2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2008-02-01 22:09:33 +00:00
|
|
|
* Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
|
|
|
|
* Copyrifht (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mostly written by Mark Lord <mlord@pobox.com>
|
|
|
|
* and Gadi Oxman <gadio@netvision.net.il>
|
|
|
|
* and Andre Hedrick <andre@linux-ide.org>
|
|
|
|
*
|
|
|
|
* See linux/MAINTAINERS for address of current maintainer.
|
|
|
|
*
|
|
|
|
* This is the multiple IDE interface driver, as evolved from hd.c.
|
|
|
|
* It supports up to MAX_HWIFS IDE interfaces, on one or more IRQs
|
|
|
|
* (usually 14 & 15).
|
|
|
|
* There can be up to two drives per interface, as per the ATA-2 spec.
|
|
|
|
*
|
|
|
|
* ...
|
|
|
|
*
|
|
|
|
* From hd.c:
|
|
|
|
* |
|
|
|
|
* | It traverses the request-list, using interrupts to jump between functions.
|
|
|
|
* | As nearly all functions can be called within interrupts, we may not sleep.
|
|
|
|
* | Special care is recommended. Have Fun!
|
|
|
|
* |
|
|
|
|
* | modified by Drew Eckhardt to check nr of hd's from the CMOS.
|
|
|
|
* |
|
|
|
|
* | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
|
|
|
|
* | in the early extended-partition checks and added DM partitions.
|
|
|
|
* |
|
|
|
|
* | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI).
|
|
|
|
* |
|
|
|
|
* | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
|
|
|
|
* | and general streamlining by Mark Lord (mlord@pobox.com).
|
|
|
|
*
|
|
|
|
* October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by:
|
|
|
|
*
|
|
|
|
* Mark Lord (mlord@pobox.com) (IDE Perf.Pkg)
|
|
|
|
* Delman Lee (delman@ieee.org) ("Mr. atdisk2")
|
|
|
|
* Scott Snyder (snyder@fnald0.fnal.gov) (ATAPI IDE cd-rom)
|
|
|
|
*
|
|
|
|
* This was a rewrite of just about everything from hd.c, though some original
|
|
|
|
* code is still sprinkled about. Think of it as a major evolution, with
|
|
|
|
* inspiration from lots of linux users, esp. hamish@zot.apana.org.au
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define _IDE_C /* Tell ide.h it's really us */
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/genhd.h>
|
|
|
|
#include <linux/blkpg.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/ide.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/cdrom.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
|
|
|
|
/* default maximum number of failures */
|
|
|
|
#define IDE_DEFAULT_MAX_FAILURES 1
|
|
|
|
|
2008-04-17 22:46:23 +00:00
|
|
|
struct class *ide_port_class;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static const u8 ide_hwif_to_major[] = { IDE0_MAJOR, IDE1_MAJOR,
|
|
|
|
IDE2_MAJOR, IDE3_MAJOR,
|
|
|
|
IDE4_MAJOR, IDE5_MAJOR,
|
|
|
|
IDE6_MAJOR, IDE7_MAJOR,
|
|
|
|
IDE8_MAJOR, IDE9_MAJOR };
|
|
|
|
|
|
|
|
static int idebus_parameter; /* holds the "idebus=" parameter */
|
|
|
|
static int system_bus_speed; /* holds what we think is VESA/PCI bus speed */
|
|
|
|
|
2007-07-09 21:17:55 +00:00
|
|
|
DEFINE_MUTEX(ide_cfg_mtx);
|
2005-04-16 22:20:36 +00:00
|
|
|
__cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock);
|
|
|
|
|
|
|
|
int noautodma = 0;
|
|
|
|
|
2007-02-07 17:19:37 +00:00
|
|
|
#ifdef CONFIG_BLK_DEV_IDEACPI
|
|
|
|
int ide_noacpi = 0;
|
|
|
|
int ide_noacpitfs = 1;
|
|
|
|
int ide_noacpionboot = 1;
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ide_hwif_t ide_hwifs[MAX_HWIFS]; /* master data repository */
|
|
|
|
|
2008-04-17 22:46:22 +00:00
|
|
|
static void ide_port_init_devices_data(ide_hwif_t *);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Do not even *think* about calling this!
|
|
|
|
*/
|
2008-01-26 19:13:06 +00:00
|
|
|
void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
/* bulk initialize hwif & drive info with zeros */
|
|
|
|
memset(hwif, 0, sizeof(ide_hwif_t));
|
|
|
|
|
|
|
|
/* fill in any non-zero initial values */
|
|
|
|
hwif->index = index;
|
|
|
|
hwif->major = ide_hwif_to_major[index];
|
|
|
|
|
|
|
|
hwif->name[0] = 'i';
|
|
|
|
hwif->name[1] = 'd';
|
|
|
|
hwif->name[2] = 'e';
|
|
|
|
hwif->name[3] = '0' + index;
|
|
|
|
|
|
|
|
hwif->bus_state = BUSSTATE_ON;
|
|
|
|
|
2006-01-09 23:59:27 +00:00
|
|
|
init_completion(&hwif->gendev_rel_comp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
default_hwif_iops(hwif);
|
|
|
|
default_hwif_transport(hwif);
|
2008-04-17 22:46:22 +00:00
|
|
|
|
|
|
|
ide_port_init_devices_data(hwif);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_init_port_data);
|
|
|
|
|
|
|
|
static void ide_port_init_devices_data(ide_hwif_t *hwif)
|
|
|
|
{
|
|
|
|
int unit;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (unit = 0; unit < MAX_DRIVES; ++unit) {
|
|
|
|
ide_drive_t *drive = &hwif->drives[unit];
|
2008-04-17 22:46:22 +00:00
|
|
|
u8 j = (hwif->index * MAX_DRIVES) + unit;
|
|
|
|
|
|
|
|
memset(drive, 0, sizeof(*drive));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
drive->media = ide_disk;
|
|
|
|
drive->select.all = (unit<<4)|0xa0;
|
|
|
|
drive->hwif = hwif;
|
|
|
|
drive->ctl = 0x08;
|
|
|
|
drive->ready_stat = READY_STAT;
|
|
|
|
drive->bad_wstat = BAD_W_STAT;
|
|
|
|
drive->special.b.recalibrate = 1;
|
|
|
|
drive->special.b.set_geometry = 1;
|
|
|
|
drive->name[0] = 'h';
|
|
|
|
drive->name[1] = 'd';
|
2008-04-17 22:46:22 +00:00
|
|
|
drive->name[2] = 'a' + j;
|
2005-04-16 22:20:36 +00:00
|
|
|
drive->max_failures = IDE_DEFAULT_MAX_FAILURES;
|
2008-04-17 22:46:22 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&drive->list);
|
2006-01-09 23:59:27 +00:00
|
|
|
init_completion(&drive->gendev_rel_comp);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2008-04-17 22:46:22 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* init_ide_data() sets reasonable default values into all fields
|
|
|
|
* of all instances of the hwifs and drives, but only on the first call.
|
|
|
|
* Subsequent calls have no effect (they don't wipe out anything).
|
|
|
|
*
|
|
|
|
* This routine is normally called at driver initialization time,
|
|
|
|
* but may also be called MUCH earlier during kernel "command-line"
|
|
|
|
* parameter processing. As such, we cannot depend on any other parts
|
|
|
|
* of the kernel (such as memory allocation) to be functioning yet.
|
|
|
|
*
|
|
|
|
* This is too bad, as otherwise we could dynamically allocate the
|
|
|
|
* ide_drive_t structs as needed, rather than always consuming memory
|
|
|
|
* for the max possible number (MAX_HWIFS * MAX_DRIVES) of them.
|
|
|
|
*
|
|
|
|
* FIXME: We should stuff the setup data into __init and copy the
|
|
|
|
* relevant hwifs/allocate them properly during boot.
|
|
|
|
*/
|
|
|
|
#define MAGIC_COOKIE 0x12345678
|
|
|
|
static void __init init_ide_data (void)
|
|
|
|
{
|
|
|
|
unsigned int index;
|
|
|
|
static unsigned long magic_cookie = MAGIC_COOKIE;
|
|
|
|
|
|
|
|
if (magic_cookie != MAGIC_COOKIE)
|
|
|
|
return; /* already initialized */
|
|
|
|
magic_cookie = 0;
|
|
|
|
|
|
|
|
/* Initialise all interface structures */
|
|
|
|
for (index = 0; index < MAX_HWIFS; ++index) {
|
2008-04-17 22:46:25 +00:00
|
|
|
ide_hwif_t *hwif = &ide_hwifs[index];
|
|
|
|
|
2008-01-26 19:13:06 +00:00
|
|
|
ide_init_port_data(hwif, index);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ide_system_bus_speed - guess bus speed
|
|
|
|
*
|
|
|
|
* ide_system_bus_speed() returns what we think is the system VESA/PCI
|
|
|
|
* bus speed (in MHz). This is used for calculating interface PIO timings.
|
|
|
|
* The default is 40 for known PCI systems, 50 otherwise.
|
|
|
|
* The "idebus=xx" parameter can be used to override this value.
|
|
|
|
* The actual value to be used is computed/displayed the first time
|
|
|
|
* through. Drivers should only use this as a last resort.
|
|
|
|
*
|
|
|
|
* Returns a guessed speed in MHz.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int ide_system_bus_speed(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
static struct pci_device_id pci_default[] = {
|
|
|
|
{ PCI_DEVICE(PCI_ANY_ID, PCI_ANY_ID) },
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
#else
|
|
|
|
#define pci_default 0
|
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
2008-02-01 22:09:35 +00:00
|
|
|
/* user supplied value */
|
|
|
|
if (idebus_parameter)
|
|
|
|
return idebus_parameter;
|
|
|
|
|
|
|
|
/* safe default value for PCI or VESA and PCI*/
|
|
|
|
return pci_dev_present(pci_default) ? 33 : 50;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-01 22:09:36 +00:00
|
|
|
void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
|
2008-02-01 22:09:35 +00:00
|
|
|
{
|
|
|
|
ide_hwgroup_t *hwgroup = hwif->hwgroup;
|
|
|
|
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
/*
|
|
|
|
* Remove us from the hwgroup, and free
|
|
|
|
* the hwgroup if we were the only member
|
|
|
|
*/
|
|
|
|
if (hwif->next == hwif) {
|
|
|
|
BUG_ON(hwgroup->hwif != hwif);
|
|
|
|
kfree(hwgroup);
|
|
|
|
} else {
|
|
|
|
/* There is another interface in hwgroup.
|
|
|
|
* Unlink us, and set hwgroup->drive and ->hwif to
|
|
|
|
* something sane.
|
|
|
|
*/
|
|
|
|
ide_hwif_t *g = hwgroup->hwif;
|
|
|
|
|
|
|
|
while (g->next != hwif)
|
|
|
|
g = g->next;
|
|
|
|
g->next = hwif->next;
|
|
|
|
if (hwgroup->hwif == hwif) {
|
|
|
|
/* Chose a random hwif for hwgroup->hwif.
|
|
|
|
* It's guaranteed that there are no drives
|
|
|
|
* left in the hwgroup.
|
|
|
|
*/
|
|
|
|
BUG_ON(hwgroup->drive != NULL);
|
|
|
|
hwgroup->hwif = g;
|
|
|
|
}
|
|
|
|
BUG_ON(hwgroup->hwif == hwif);
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
}
|
|
|
|
|
2008-04-17 22:46:22 +00:00
|
|
|
/* Called with ide_lock held. */
|
2008-04-17 22:46:23 +00:00
|
|
|
static void __ide_port_unregister_devices(ide_hwif_t *hwif)
|
2008-04-17 22:46:22 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_DRIVES; i++) {
|
|
|
|
ide_drive_t *drive = &hwif->drives[i];
|
|
|
|
|
|
|
|
if (drive->present) {
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
device_unregister(&drive->gendev);
|
|
|
|
wait_for_completion(&drive->gendev_rel_comp);
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-17 22:46:23 +00:00
|
|
|
void ide_port_unregister_devices(ide_hwif_t *hwif)
|
|
|
|
{
|
|
|
|
mutex_lock(&ide_cfg_mtx);
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
__ide_port_unregister_devices(hwif);
|
|
|
|
hwif->present = 0;
|
|
|
|
ide_port_init_devices_data(hwif);
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
mutex_unlock(&ide_cfg_mtx);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2006-10-03 08:14:13 +00:00
|
|
|
* ide_unregister - free an IDE interface
|
2005-04-16 22:20:36 +00:00
|
|
|
* @index: index of interface (will change soon to a pointer)
|
|
|
|
*
|
|
|
|
* Perform the final unregister of an IDE interface. At the moment
|
|
|
|
* we don't refcount interfaces so this will also get split up.
|
|
|
|
*
|
|
|
|
* Locking:
|
|
|
|
* The caller must not hold the IDE locks
|
|
|
|
* The drive present/vanishing is not yet properly locked
|
|
|
|
* Take care with the callbacks. These have been split to avoid
|
|
|
|
* deadlocking the IDE layer. The shutdown callback is called
|
|
|
|
* before we take the lock and free resources. It is up to the
|
|
|
|
* caller to be sure there is no pending I/O here, and that
|
2006-10-03 08:14:13 +00:00
|
|
|
* the interface will not be reopened (present/vanishing locking
|
|
|
|
* isn't yet done BTW). After we commit to the final kill we
|
2005-04-16 22:20:36 +00:00
|
|
|
* call the cleanup callback with the ide locks held.
|
|
|
|
*
|
|
|
|
* Unregister restores the hwif structures to the default state.
|
|
|
|
* This is raving bonkers.
|
|
|
|
*/
|
|
|
|
|
ide: remove broken/dangerous HDIO_[UNREGISTER,SCAN]_HWIF ioctls (take 3)
hdparm explicitely marks HDIO_[UNREGISTER,SCAN]_HWIF ioctls as DANGEROUS
and given the number of bugs we can assume that there are no real users:
* DMA has no chance of working because DMA resources are released by
ide_unregister() and they are never allocated again.
* Since ide_init_hwif_ports() is used for ->io_ports[] setup the ioctls
don't work for almost all hosts with "non-standard" (== non ISA-like)
layout of IDE taskfile registers (there is a lot of such host drivers).
* ide_port_init_devices() is not called when probing IDE devices so:
- drive->autotune is never set and IDE host/devices are not programmed
for the correct PIO/DMA transfer modes (=> possible data corruption)
- host specific I/O 32-bit and IRQ unmasking settings are not applied
(=> possible data corruption)
- host specific ->port_init_devs method is not called (=> no luck with
ht6560b, qd65xx and opti621 host drivers)
* ->rw_disk method is not preserved (=> no HPT3xxN chipsets support).
* ->serialized flag is not preserved (=> possible data corruption when
using icside, aec62xx (ATP850UF chipset), cmd640, cs5530, hpt366
(HPT3xxN chipsets), rz1000, sc1200, dtc2278 and ht6560b host drivers).
* ->ack_intr method is not preserved (=> needed by ide-cris, buddha,
gayle and macide host drivers).
* ->sata_scr[] and sata_misc[] is cleared by ide_unregister() and it
isn't initialized again (SiI3112 support needs them).
* To issue an ioctl() there need to be at least one IDE device present
in the system.
* ->cable_detect method is not preserved + it is not called when probing
IDE devices so cable detection is broken (however since DMA support is
also broken it doesn't really matter ;-).
* Some objects which may have already been freed in ide_unregister()
are restored by ide_hwif_restore() (i.e. ->hwgroup).
* ide_register_hw() may unregister unrelated IDE ports if free ide_hwifs[]
slot cannot be found.
* When IDE host drivers are modular unregistered port may be re-used by
different host driver that owned it first causing subtle bugs.
Since we now have a proper warm-plug support remove these ioctls,
then remove no longer needed:
- ide_register_hw() and ide_hwif_restore() functions
- 'init_default' and 'restore' arguments of ide_unregister()
- zeroeing of hwif->{dma,extra}_* fields in ide_unregister()
As an added bonus IDE core code size shrinks by ~3kB (x86-32).
v2:
* fix ide_unregister() arguments in cleanup_module() (Andrew Morton).
v3:
* fix ide_unregister() arguments in palm_bk3710.c.
Acked-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-04-17 22:46:24 +00:00
|
|
|
void ide_unregister(unsigned int index)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ide_hwif_t *hwif, *g;
|
|
|
|
ide_hwgroup_t *hwgroup;
|
2008-04-17 22:46:22 +00:00
|
|
|
int irq_count = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
BUG_ON(index >= MAX_HWIFS);
|
|
|
|
|
|
|
|
BUG_ON(in_interrupt());
|
|
|
|
BUG_ON(irqs_disabled());
|
2007-07-09 21:17:55 +00:00
|
|
|
mutex_lock(&ide_cfg_mtx);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
hwif = &ide_hwifs[index];
|
|
|
|
if (!hwif->present)
|
|
|
|
goto abort;
|
2008-04-17 22:46:23 +00:00
|
|
|
__ide_port_unregister_devices(hwif);
|
2005-04-16 22:20:36 +00:00
|
|
|
hwif->present = 0;
|
|
|
|
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
|
2007-05-09 22:01:11 +00:00
|
|
|
ide_proc_unregister_port(hwif);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
hwgroup = hwif->hwgroup;
|
|
|
|
/*
|
|
|
|
* free the irq if we were the only hwif using it
|
|
|
|
*/
|
|
|
|
g = hwgroup->hwif;
|
|
|
|
do {
|
|
|
|
if (g->irq == hwif->irq)
|
|
|
|
++irq_count;
|
|
|
|
g = g->next;
|
|
|
|
} while (g != hwgroup->hwif);
|
|
|
|
if (irq_count == 1)
|
|
|
|
free_irq(hwif->irq, hwgroup);
|
|
|
|
|
2008-02-01 22:09:35 +00:00
|
|
|
ide_remove_port_from_hwgroup(hwif);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-17 22:46:23 +00:00
|
|
|
device_unregister(hwif->portdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
device_unregister(&hwif->gendev);
|
2006-01-09 23:59:27 +00:00
|
|
|
wait_for_completion(&hwif->gendev_rel_comp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove us from the kernel's knowledge
|
|
|
|
*/
|
|
|
|
blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS);
|
|
|
|
kfree(hwif->sg_table);
|
|
|
|
unregister_blkdev(hwif->major, hwif->name);
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
|
ide: remove broken/dangerous HDIO_[UNREGISTER,SCAN]_HWIF ioctls (take 3)
hdparm explicitely marks HDIO_[UNREGISTER,SCAN]_HWIF ioctls as DANGEROUS
and given the number of bugs we can assume that there are no real users:
* DMA has no chance of working because DMA resources are released by
ide_unregister() and they are never allocated again.
* Since ide_init_hwif_ports() is used for ->io_ports[] setup the ioctls
don't work for almost all hosts with "non-standard" (== non ISA-like)
layout of IDE taskfile registers (there is a lot of such host drivers).
* ide_port_init_devices() is not called when probing IDE devices so:
- drive->autotune is never set and IDE host/devices are not programmed
for the correct PIO/DMA transfer modes (=> possible data corruption)
- host specific I/O 32-bit and IRQ unmasking settings are not applied
(=> possible data corruption)
- host specific ->port_init_devs method is not called (=> no luck with
ht6560b, qd65xx and opti621 host drivers)
* ->rw_disk method is not preserved (=> no HPT3xxN chipsets support).
* ->serialized flag is not preserved (=> possible data corruption when
using icside, aec62xx (ATP850UF chipset), cmd640, cs5530, hpt366
(HPT3xxN chipsets), rz1000, sc1200, dtc2278 and ht6560b host drivers).
* ->ack_intr method is not preserved (=> needed by ide-cris, buddha,
gayle and macide host drivers).
* ->sata_scr[] and sata_misc[] is cleared by ide_unregister() and it
isn't initialized again (SiI3112 support needs them).
* To issue an ioctl() there need to be at least one IDE device present
in the system.
* ->cable_detect method is not preserved + it is not called when probing
IDE devices so cable detection is broken (however since DMA support is
also broken it doesn't really matter ;-).
* Some objects which may have already been freed in ide_unregister()
are restored by ide_hwif_restore() (i.e. ->hwgroup).
* ide_register_hw() may unregister unrelated IDE ports if free ide_hwifs[]
slot cannot be found.
* When IDE host drivers are modular unregistered port may be re-used by
different host driver that owned it first causing subtle bugs.
Since we now have a proper warm-plug support remove these ioctls,
then remove no longer needed:
- ide_register_hw() and ide_hwif_restore() functions
- 'init_default' and 'restore' arguments of ide_unregister()
- zeroeing of hwif->{dma,extra}_* fields in ide_unregister()
As an added bonus IDE core code size shrinks by ~3kB (x86-32).
v2:
* fix ide_unregister() arguments in cleanup_module() (Andrew Morton).
v3:
* fix ide_unregister() arguments in palm_bk3710.c.
Acked-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-04-17 22:46:24 +00:00
|
|
|
if (hwif->dma_base)
|
2008-04-26 20:25:19 +00:00
|
|
|
ide_release_dma_engine(hwif);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* restore hwif data to pristine status */
|
2008-01-26 19:13:06 +00:00
|
|
|
ide_init_port_data(hwif, index);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
abort:
|
|
|
|
spin_unlock_irq(&ide_lock);
|
2007-07-09 21:17:55 +00:00
|
|
|
mutex_unlock(&ide_cfg_mtx);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(ide_unregister);
|
|
|
|
|
2008-01-26 19:13:05 +00:00
|
|
|
void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
|
|
|
|
{
|
|
|
|
memcpy(hwif->io_ports, hw->io_ports, sizeof(hwif->io_ports));
|
|
|
|
hwif->irq = hw->irq;
|
|
|
|
hwif->chipset = hw->chipset;
|
|
|
|
hwif->gendev.parent = hw->dev;
|
|
|
|
hwif->ack_intr = hw->ack_intr;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ide_init_port_hw);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Locks for IDE setting functionality
|
|
|
|
*/
|
|
|
|
|
2007-07-09 21:17:56 +00:00
|
|
|
DEFINE_MUTEX(ide_setting_mtx);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-09 21:17:56 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ide_setting_mtx);
|
2007-05-09 22:01:10 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* ide_spin_wait_hwgroup - wait for group
|
|
|
|
* @drive: drive in the group
|
|
|
|
*
|
|
|
|
* Wait for an IDE device group to go non busy and then return
|
|
|
|
* holding the ide_lock which guards the hwgroup->busy status
|
|
|
|
* and right to use it.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int ide_spin_wait_hwgroup (ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
ide_hwgroup_t *hwgroup = HWGROUP(drive);
|
|
|
|
unsigned long timeout = jiffies + (3 * HZ);
|
|
|
|
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
|
|
|
|
while (hwgroup->busy) {
|
|
|
|
unsigned long lflags;
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
local_irq_set(lflags);
|
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
local_irq_restore(lflags);
|
|
|
|
printk(KERN_ERR "%s: channel busy\n", drive->name);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
local_irq_restore(lflags);
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(ide_spin_wait_hwgroup);
|
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
int set_io_32bit(ide_drive_t *drive, int arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-09 22:01:10 +00:00
|
|
|
if (drive->no_io_32bit)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-12-12 22:32:00 +00:00
|
|
|
if (ide_spin_wait_hwgroup(drive))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
drive->io_32bit = arg;
|
2007-12-12 22:32:00 +00:00
|
|
|
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
static int set_ksettings(ide_drive_t *drive, int arg)
|
|
|
|
{
|
|
|
|
if (arg < 0 || arg > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (ide_spin_wait_hwgroup(drive))
|
|
|
|
return -EBUSY;
|
|
|
|
drive->keep_settings = arg;
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
int set_using_dma(ide_drive_t *drive, int arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_BLK_DEV_IDEDMA
|
2007-03-26 21:03:19 +00:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
|
|
|
int err = -EPERM;
|
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
if (arg < 0 || arg > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!drive->id || !(drive->id->capability & 1))
|
2007-03-26 21:03:19 +00:00
|
|
|
goto out;
|
|
|
|
|
2008-04-26 20:25:24 +00:00
|
|
|
if (hwif->dma_ops == NULL)
|
2007-03-26 21:03:19 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = -EBUSY;
|
|
|
|
if (ide_spin_wait_hwgroup(drive))
|
|
|
|
goto out;
|
|
|
|
/*
|
|
|
|
* set ->busy flag, unlock and let it ride
|
|
|
|
*/
|
|
|
|
hwif->hwgroup->busy = 1;
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (arg) {
|
2008-01-25 21:17:19 +00:00
|
|
|
if (ide_set_dma(drive))
|
2007-03-26 21:03:19 +00:00
|
|
|
err = -EIO;
|
2007-02-17 01:40:26 +00:00
|
|
|
} else
|
|
|
|
ide_dma_off(drive);
|
2007-03-26 21:03:19 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* lock, clear ->busy flag and unlock before leaving
|
|
|
|
*/
|
|
|
|
spin_lock_irq(&ide_lock);
|
|
|
|
hwif->hwgroup->busy = 0;
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
out:
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
2007-05-09 22:01:10 +00:00
|
|
|
if (arg < 0 || arg > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EPERM;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
int set_pio_mode(ide_drive_t *drive, int arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct request rq;
|
2008-04-26 15:36:43 +00:00
|
|
|
ide_hwif_t *hwif = drive->hwif;
|
2008-04-26 20:25:14 +00:00
|
|
|
const struct ide_port_ops *port_ops = hwif->port_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
if (arg < 0 || arg > 255)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-26 20:25:14 +00:00
|
|
|
if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
|
2008-04-26 15:36:43 +00:00
|
|
|
(hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOSYS;
|
2007-10-11 21:54:00 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (drive->special.b.set_tune)
|
|
|
|
return -EBUSY;
|
2008-01-26 19:13:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ide_init_drive_cmd(&rq);
|
2008-01-26 19:13:12 +00:00
|
|
|
rq.cmd_type = REQ_TYPE_ATA_TASKFILE;
|
2008-01-26 19:13:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
drive->tune_req = (u8) arg;
|
|
|
|
drive->special.b.set_tune = 1;
|
|
|
|
(void) ide_do_drive_cmd(drive, &rq, ide_wait);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
static int set_unmaskirq(ide_drive_t *drive, int arg)
|
|
|
|
{
|
|
|
|
if (drive->no_unmask)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (arg < 0 || arg > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (ide_spin_wait_hwgroup(drive))
|
|
|
|
return -EBUSY;
|
|
|
|
drive->unmask = arg;
|
|
|
|
spin_unlock_irq(&ide_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* system_bus_clock - clock guess
|
|
|
|
*
|
|
|
|
* External version of the bus clock guess used by very old IDE drivers
|
|
|
|
* for things like VLB timings. Should not be used.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int system_bus_clock (void)
|
|
|
|
{
|
2008-02-01 22:09:35 +00:00
|
|
|
return system_bus_speed;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(system_bus_clock);
|
|
|
|
|
2006-08-15 06:11:05 +00:00
|
|
|
static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
ide_drive_t *drive = dev->driver_data;
|
2007-02-07 17:19:37 +00:00
|
|
|
ide_hwif_t *hwif = HWIF(drive);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request rq;
|
|
|
|
struct request_pm_state rqpm;
|
|
|
|
ide_task_t args;
|
2007-10-11 21:53:58 +00:00
|
|
|
int ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-07 17:19:37 +00:00
|
|
|
/* Call ACPI _GTM only once */
|
|
|
|
if (!(drive->dn % 2))
|
|
|
|
ide_acpi_get_timing(hwif);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memset(&rq, 0, sizeof(rq));
|
|
|
|
memset(&rqpm, 0, sizeof(rqpm));
|
|
|
|
memset(&args, 0, sizeof(args));
|
2006-08-10 06:44:47 +00:00
|
|
|
rq.cmd_type = REQ_TYPE_PM_SUSPEND;
|
2005-04-16 22:20:36 +00:00
|
|
|
rq.special = &args;
|
2006-09-30 18:29:12 +00:00
|
|
|
rq.data = &rqpm;
|
2005-04-16 22:20:36 +00:00
|
|
|
rqpm.pm_step = ide_pm_state_start_suspend;
|
2006-08-15 06:11:05 +00:00
|
|
|
if (mesg.event == PM_EVENT_PRETHAW)
|
|
|
|
mesg.event = PM_EVENT_FREEZE;
|
|
|
|
rqpm.pm_state = mesg.event;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-11 21:53:58 +00:00
|
|
|
ret = ide_do_drive_cmd(drive, &rq, ide_wait);
|
|
|
|
/* only call ACPI _PS3 after both drivers are suspended */
|
|
|
|
if (!ret && (((drive->dn % 2) && hwif->drives[0].present
|
|
|
|
&& hwif->drives[1].present)
|
|
|
|
|| !hwif->drives[0].present
|
|
|
|
|| !hwif->drives[1].present))
|
|
|
|
ide_acpi_set_state(hwif, 0);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int generic_ide_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = dev->driver_data;
|
2007-02-07 17:19:37 +00:00
|
|
|
ide_hwif_t *hwif = HWIF(drive);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request rq;
|
|
|
|
struct request_pm_state rqpm;
|
|
|
|
ide_task_t args;
|
2007-06-08 13:14:30 +00:00
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-07 17:19:37 +00:00
|
|
|
/* Call ACPI _STM only once */
|
2007-10-11 21:53:58 +00:00
|
|
|
if (!(drive->dn % 2)) {
|
|
|
|
ide_acpi_set_state(hwif, 1);
|
2007-02-07 17:19:37 +00:00
|
|
|
ide_acpi_push_timing(hwif);
|
2007-10-11 21:53:58 +00:00
|
|
|
}
|
2007-02-07 17:19:37 +00:00
|
|
|
|
|
|
|
ide_acpi_exec_tfs(drive);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memset(&rq, 0, sizeof(rq));
|
|
|
|
memset(&rqpm, 0, sizeof(rqpm));
|
|
|
|
memset(&args, 0, sizeof(args));
|
2006-08-10 06:44:47 +00:00
|
|
|
rq.cmd_type = REQ_TYPE_PM_RESUME;
|
2005-04-16 22:20:36 +00:00
|
|
|
rq.special = &args;
|
2006-09-30 18:29:12 +00:00
|
|
|
rq.data = &rqpm;
|
2005-04-16 22:20:36 +00:00
|
|
|
rqpm.pm_step = ide_pm_state_start_resume;
|
2005-09-03 22:56:57 +00:00
|
|
|
rqpm.pm_state = PM_EVENT_ON;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-06-08 13:14:30 +00:00
|
|
|
err = ide_do_drive_cmd(drive, &rq, ide_head_wait);
|
|
|
|
|
2007-06-16 00:24:43 +00:00
|
|
|
if (err == 0 && dev->driver) {
|
|
|
|
ide_driver_t *drv = to_ide_driver(dev->driver);
|
|
|
|
|
|
|
|
if (drv->resume)
|
|
|
|
drv->resume(drive);
|
|
|
|
}
|
2007-06-08 13:14:30 +00:00
|
|
|
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device *bdev,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
2007-05-09 22:01:10 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
ide_driver_t *drv;
|
|
|
|
void __user *p = (void __user *)arg;
|
2007-07-17 22:57:42 +00:00
|
|
|
int err = 0, (*setfunc)(ide_drive_t *, int);
|
2007-05-09 22:01:10 +00:00
|
|
|
u8 *val;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-09 22:01:10 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case HDIO_GET_32BIT: val = &drive->io_32bit; goto read_val;
|
|
|
|
case HDIO_GET_KEEPSETTINGS: val = &drive->keep_settings; goto read_val;
|
|
|
|
case HDIO_GET_UNMASKINTR: val = &drive->unmask; goto read_val;
|
|
|
|
case HDIO_GET_DMA: val = &drive->using_dma; goto read_val;
|
|
|
|
case HDIO_SET_32BIT: setfunc = set_io_32bit; goto set_val;
|
|
|
|
case HDIO_SET_KEEPSETTINGS: setfunc = set_ksettings; goto set_val;
|
|
|
|
case HDIO_SET_PIO_MODE: setfunc = set_pio_mode; goto set_val;
|
|
|
|
case HDIO_SET_UNMASKINTR: setfunc = set_unmaskirq; goto set_val;
|
|
|
|
case HDIO_SET_DMA: setfunc = set_using_dma; goto set_val;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case HDIO_OBSOLETE_IDENTITY:
|
|
|
|
case HDIO_GET_IDENTITY:
|
|
|
|
if (bdev != bdev->bd_contains)
|
|
|
|
return -EINVAL;
|
|
|
|
if (drive->id_read == 0)
|
|
|
|
return -ENOMSG;
|
|
|
|
if (copy_to_user(p, drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case HDIO_GET_NICE:
|
|
|
|
return put_user(drive->dsc_overlap << IDE_NICE_DSC_OVERLAP |
|
|
|
|
drive->atapi_overlap << IDE_NICE_ATAPI_OVERLAP |
|
2008-02-02 18:56:45 +00:00
|
|
|
drive->nice1 << IDE_NICE_1,
|
2005-04-16 22:20:36 +00:00
|
|
|
(long __user *) arg);
|
|
|
|
#ifdef CONFIG_IDE_TASK_IOCTL
|
|
|
|
case HDIO_DRIVE_TASKFILE:
|
|
|
|
if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
|
|
|
|
return -EACCES;
|
|
|
|
switch(drive->media) {
|
|
|
|
case ide_disk:
|
|
|
|
return ide_taskfile_ioctl(drive, cmd, arg);
|
|
|
|
default:
|
|
|
|
return -ENOMSG;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_IDE_TASK_IOCTL */
|
|
|
|
|
|
|
|
case HDIO_DRIVE_CMD:
|
|
|
|
if (!capable(CAP_SYS_RAWIO))
|
|
|
|
return -EACCES;
|
|
|
|
return ide_cmd_ioctl(drive, cmd, arg);
|
|
|
|
|
|
|
|
case HDIO_DRIVE_TASK:
|
|
|
|
if (!capable(CAP_SYS_RAWIO))
|
|
|
|
return -EACCES;
|
|
|
|
return ide_task_ioctl(drive, cmd, arg);
|
|
|
|
case HDIO_SET_NICE:
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) return -EACCES;
|
|
|
|
if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP) | (1 << IDE_NICE_1))))
|
|
|
|
return -EPERM;
|
|
|
|
drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
|
|
|
|
drv = *(ide_driver_t **)bdev->bd_disk->private_data;
|
|
|
|
if (drive->dsc_overlap && !drv->supports_dsc_overlap) {
|
|
|
|
drive->dsc_overlap = 0;
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
drive->nice1 = (arg >> IDE_NICE_1) & 1;
|
|
|
|
return 0;
|
|
|
|
case HDIO_DRIVE_RESET:
|
2008-02-26 20:50:35 +00:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Abort the current command on the
|
|
|
|
* group if there is one, taking
|
|
|
|
* care not to allow anything else
|
|
|
|
* to be queued and to die on the
|
|
|
|
* spot if we miss one somehow
|
|
|
|
*/
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ide_lock, flags);
|
|
|
|
|
2006-10-03 08:14:33 +00:00
|
|
|
if (HWGROUP(drive)->resetting) {
|
|
|
|
spin_unlock_irqrestore(&ide_lock, flags);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ide_abort(drive, "drive reset");
|
|
|
|
|
2006-06-23 09:06:06 +00:00
|
|
|
BUG_ON(HWGROUP(drive)->handler);
|
2008-02-26 20:50:35 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Ensure nothing gets queued after we
|
|
|
|
drop the lock. Reset will clear the busy */
|
2008-02-26 20:50:35 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
HWGROUP(drive)->busy = 1;
|
|
|
|
spin_unlock_irqrestore(&ide_lock, flags);
|
|
|
|
(void) ide_do_reset(drive);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
case HDIO_GET_BUSSTATE:
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
if (put_user(HWIF(drive)->bus_state, (long __user *)arg))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case HDIO_SET_BUSSTATE:
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2007-05-09 22:01:10 +00:00
|
|
|
|
|
|
|
read_val:
|
2007-07-09 21:17:56 +00:00
|
|
|
mutex_lock(&ide_setting_mtx);
|
2007-05-09 22:01:10 +00:00
|
|
|
spin_lock_irqsave(&ide_lock, flags);
|
|
|
|
err = *val;
|
|
|
|
spin_unlock_irqrestore(&ide_lock, flags);
|
2007-07-09 21:17:56 +00:00
|
|
|
mutex_unlock(&ide_setting_mtx);
|
2007-05-09 22:01:10 +00:00
|
|
|
return err >= 0 ? put_user(err, (long __user *)arg) : err;
|
|
|
|
|
|
|
|
set_val:
|
|
|
|
if (bdev != bdev->bd_contains)
|
|
|
|
err = -EINVAL;
|
|
|
|
else {
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
err = -EACCES;
|
|
|
|
else {
|
2007-07-09 21:17:56 +00:00
|
|
|
mutex_lock(&ide_setting_mtx);
|
2007-05-09 22:01:10 +00:00
|
|
|
err = setfunc(drive, arg);
|
2007-07-09 21:17:56 +00:00
|
|
|
mutex_unlock(&ide_setting_mtx);
|
2007-05-09 22:01:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(generic_ide_ioctl);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* stridx() returns the offset of c within s,
|
|
|
|
* or -1 if c is '\0' or not found within s.
|
|
|
|
*/
|
|
|
|
static int __init stridx (const char *s, char c)
|
|
|
|
{
|
|
|
|
char *i = strchr(s, c);
|
|
|
|
return (i && c) ? i - s : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* match_parm() does parsing for ide_setup():
|
|
|
|
*
|
|
|
|
* 1. the first char of s must be '='.
|
|
|
|
* 2. if the remainder matches one of the supplied keywords,
|
|
|
|
* the index (1 based) of the keyword is negated and returned.
|
|
|
|
* 3. if the remainder is a series of no more than max_vals numbers
|
|
|
|
* separated by commas, the numbers are saved in vals[] and a
|
|
|
|
* count of how many were saved is returned. Base10 is assumed,
|
|
|
|
* and base16 is allowed when prefixed with "0x".
|
|
|
|
* 4. otherwise, zero is returned.
|
|
|
|
*/
|
|
|
|
static int __init match_parm (char *s, const char *keywords[], int vals[], int max_vals)
|
|
|
|
{
|
|
|
|
static const char *decimal = "0123456789";
|
|
|
|
static const char *hex = "0123456789abcdef";
|
|
|
|
int i, n;
|
|
|
|
|
|
|
|
if (*s++ == '=') {
|
|
|
|
/*
|
|
|
|
* Try matching against the supplied keywords,
|
|
|
|
* and return -(index+1) if we match one
|
|
|
|
*/
|
|
|
|
if (keywords != NULL) {
|
|
|
|
for (i = 0; *keywords != NULL; ++i) {
|
|
|
|
if (!strcmp(s, *keywords++))
|
|
|
|
return -(i+1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Look for a series of no more than "max_vals"
|
|
|
|
* numeric values separated by commas, in base10,
|
|
|
|
* or base16 when prefixed with "0x".
|
|
|
|
* Return a count of how many were found.
|
|
|
|
*/
|
|
|
|
for (n = 0; (i = stridx(decimal, *s)) >= 0;) {
|
|
|
|
vals[n] = i;
|
|
|
|
while ((i = stridx(decimal, *++s)) >= 0)
|
|
|
|
vals[n] = (vals[n] * 10) + i;
|
|
|
|
if (*s == 'x' && !vals[n]) {
|
|
|
|
while ((i = stridx(hex, *++s)) >= 0)
|
|
|
|
vals[n] = (vals[n] * 0x10) + i;
|
|
|
|
}
|
|
|
|
if (++n == max_vals)
|
|
|
|
break;
|
|
|
|
if (*s == ',' || *s == ';')
|
|
|
|
++s;
|
|
|
|
}
|
|
|
|
if (!*s)
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
return 0; /* zero = nothing matched */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ide_setup() gets called VERY EARLY during initialization,
|
|
|
|
* to handle kernel "command line" strings beginning with "hdx=" or "ide".
|
|
|
|
*
|
2008-03-07 20:53:50 +00:00
|
|
|
* Remember to update Documentation/ide/ide.txt if you change something here.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static int __init ide_setup(char *s)
|
|
|
|
{
|
|
|
|
ide_hwif_t *hwif;
|
|
|
|
ide_drive_t *drive;
|
|
|
|
unsigned int hw, unit;
|
2008-04-27 13:38:24 +00:00
|
|
|
int vals[3];
|
2005-04-16 22:20:36 +00:00
|
|
|
const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
|
|
|
|
|
|
|
|
if (strncmp(s,"hd",2) == 0 && s[2] == '=') /* hd= is for hd.c */
|
|
|
|
return 0; /* driver and not us */
|
|
|
|
|
|
|
|
if (strncmp(s,"ide",3) && strncmp(s,"idebus",6) && strncmp(s,"hd",2))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
printk(KERN_INFO "ide_setup: %s", s);
|
|
|
|
init_ide_data ();
|
|
|
|
|
|
|
|
#ifdef CONFIG_BLK_DEV_IDEDOUBLER
|
|
|
|
if (!strcmp(s, "ide=doubler")) {
|
|
|
|
extern int ide_doubler;
|
|
|
|
|
|
|
|
printk(" : Enabled support for IDE doublers\n");
|
|
|
|
ide_doubler = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_BLK_DEV_IDEDOUBLER */
|
|
|
|
|
|
|
|
if (!strcmp(s, "ide=nodma")) {
|
|
|
|
printk(" : Prevented DMA\n");
|
|
|
|
noautodma = 1;
|
2007-10-16 20:29:58 +00:00
|
|
|
goto obsolete_option;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-02-07 17:19:37 +00:00
|
|
|
#ifdef CONFIG_BLK_DEV_IDEACPI
|
|
|
|
if (!strcmp(s, "ide=noacpi")) {
|
|
|
|
//printk(" : Disable IDE ACPI support.\n");
|
|
|
|
ide_noacpi = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (!strcmp(s, "ide=acpigtf")) {
|
|
|
|
//printk(" : Enable IDE ACPI _GTF support.\n");
|
|
|
|
ide_noacpitfs = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (!strcmp(s, "ide=acpionboot")) {
|
|
|
|
//printk(" : Call IDE ACPI methods on boot.\n");
|
|
|
|
ide_noacpionboot = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_BLK_DEV_IDEACPI */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Look for drive options: "hdx="
|
|
|
|
*/
|
|
|
|
if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) {
|
|
|
|
const char *hd_words[] = {
|
2007-10-16 20:29:58 +00:00
|
|
|
"none", "noprobe", "nowerr", "cdrom", "nodma",
|
2008-04-27 13:38:24 +00:00
|
|
|
"autotune", "-7", "-8", "-9", "-10",
|
2006-07-28 06:54:59 +00:00
|
|
|
"noflush", "remap", "remap63", "scsi", NULL };
|
2005-04-16 22:20:36 +00:00
|
|
|
unit = s[2] - 'a';
|
|
|
|
hw = unit / MAX_DRIVES;
|
|
|
|
unit = unit % MAX_DRIVES;
|
|
|
|
hwif = &ide_hwifs[hw];
|
|
|
|
drive = &hwif->drives[unit];
|
|
|
|
if (strncmp(s + 4, "ide-", 4) == 0) {
|
|
|
|
strlcpy(drive->driver_req, s + 4, sizeof(drive->driver_req));
|
2008-03-22 15:40:21 +00:00
|
|
|
goto obsolete_option;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
switch (match_parm(&s[3], hd_words, vals, 3)) {
|
|
|
|
case -1: /* "none" */
|
|
|
|
case -2: /* "noprobe" */
|
|
|
|
drive->noprobe = 1;
|
|
|
|
goto done;
|
|
|
|
case -3: /* "nowerr" */
|
|
|
|
drive->bad_wstat = BAD_R_STAT;
|
|
|
|
goto done;
|
|
|
|
case -4: /* "cdrom" */
|
|
|
|
drive->present = 1;
|
|
|
|
drive->media = ide_cdrom;
|
|
|
|
/* an ATAPI device ignores DRDY */
|
|
|
|
drive->ready_stat = 0;
|
|
|
|
goto done;
|
2007-10-16 20:29:58 +00:00
|
|
|
case -5: /* nodma */
|
|
|
|
drive->nodma = 1;
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
case -6: /* "autotune" */
|
2008-04-27 13:38:24 +00:00
|
|
|
drive->autotune = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto obsolete_option;
|
2006-07-28 06:54:59 +00:00
|
|
|
case -11: /* noflush */
|
|
|
|
drive->noflush = 1;
|
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
case -12: /* "remap" */
|
|
|
|
drive->remap_0_to_1 = 1;
|
2008-03-22 15:40:22 +00:00
|
|
|
goto obsolete_option;
|
2005-04-16 22:20:36 +00:00
|
|
|
case -13: /* "remap63" */
|
|
|
|
drive->sect0 = 63;
|
2008-03-22 15:40:22 +00:00
|
|
|
goto obsolete_option;
|
2005-04-16 22:20:36 +00:00
|
|
|
case -14: /* "scsi" */
|
|
|
|
drive->scsi = 1;
|
2008-03-22 15:40:21 +00:00
|
|
|
goto obsolete_option;
|
2005-04-16 22:20:36 +00:00
|
|
|
case 3: /* cyl,head,sect */
|
|
|
|
drive->media = ide_disk;
|
|
|
|
drive->ready_stat = READY_STAT;
|
|
|
|
drive->cyl = drive->bios_cyl = vals[0];
|
|
|
|
drive->head = drive->bios_head = vals[1];
|
|
|
|
drive->sect = drive->bios_sect = vals[2];
|
|
|
|
drive->present = 1;
|
|
|
|
drive->forced_geom = 1;
|
|
|
|
goto done;
|
|
|
|
default:
|
|
|
|
goto bad_option;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s[0] != 'i' || s[1] != 'd' || s[2] != 'e')
|
|
|
|
goto bad_option;
|
|
|
|
/*
|
|
|
|
* Look for bus speed option: "idebus="
|
|
|
|
*/
|
|
|
|
if (s[3] == 'b' && s[4] == 'u' && s[5] == 's') {
|
|
|
|
if (match_parm(&s[6], NULL, vals, 1) != 1)
|
|
|
|
goto bad_option;
|
|
|
|
if (vals[0] >= 20 && vals[0] <= 66) {
|
|
|
|
idebus_parameter = vals[0];
|
|
|
|
} else
|
|
|
|
printk(" -- BAD BUS SPEED! Expected value from 20 to 66");
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
bad_option:
|
|
|
|
printk(" -- BAD OPTION\n");
|
|
|
|
return 1;
|
|
|
|
obsolete_option:
|
|
|
|
printk(" -- OBSOLETE OPTION, WILL BE REMOVED SOON!\n");
|
|
|
|
return 1;
|
|
|
|
done:
|
|
|
|
printk("\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(ide_lock);
|
|
|
|
|
2005-05-26 12:55:34 +00:00
|
|
|
static int ide_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
static char *media_string(ide_drive_t *drive)
|
|
|
|
{
|
|
|
|
switch (drive->media) {
|
|
|
|
case ide_disk:
|
|
|
|
return "disk";
|
|
|
|
case ide_cdrom:
|
|
|
|
return "cdrom";
|
|
|
|
case ide_tape:
|
|
|
|
return "tape";
|
|
|
|
case ide_floppy:
|
|
|
|
return "floppy";
|
2007-04-10 20:39:14 +00:00
|
|
|
case ide_optical:
|
|
|
|
return "optical";
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
default:
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
return sprintf(buf, "%s\n", media_string(drive));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
return sprintf(buf, "%s\n", drive->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
return sprintf(buf, "ide:m-%s\n", media_string(drive));
|
|
|
|
}
|
|
|
|
|
2007-12-12 22:31:58 +00:00
|
|
|
static ssize_t model_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
return sprintf(buf, "%s\n", drive->id->model);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
return sprintf(buf, "%s\n", drive->id->fw_rev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
return sprintf(buf, "%s\n", drive->id->serial_no);
|
|
|
|
}
|
|
|
|
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
static struct device_attribute ide_dev_attrs[] = {
|
|
|
|
__ATTR_RO(media),
|
|
|
|
__ATTR_RO(drivename),
|
|
|
|
__ATTR_RO(modalias),
|
2007-12-12 22:31:58 +00:00
|
|
|
__ATTR_RO(model),
|
|
|
|
__ATTR_RO(firmware),
|
|
|
|
__ATTR(serial, 0400, serial_show, NULL),
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
__ATTR_NULL
|
|
|
|
};
|
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
static int ide_uevent(struct device *dev, struct kobj_uevent_env *env)
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
2007-08-14 13:15:12 +00:00
|
|
|
|
|
|
|
add_uevent_var(env, "MEDIA=%s", media_string(drive));
|
|
|
|
add_uevent_var(env, "DRIVENAME=%s", drive->name);
|
|
|
|
add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive));
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-06 11:41:00 +00:00
|
|
|
static int generic_ide_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
ide_driver_t *drv = to_ide_driver(dev->driver);
|
|
|
|
|
|
|
|
return drv->probe ? drv->probe(drive) : -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int generic_ide_remove(struct device *dev)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
ide_driver_t *drv = to_ide_driver(dev->driver);
|
|
|
|
|
|
|
|
if (drv->remove)
|
|
|
|
drv->remove(drive);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void generic_ide_shutdown(struct device *dev)
|
|
|
|
{
|
|
|
|
ide_drive_t *drive = to_ide_device(dev);
|
|
|
|
ide_driver_t *drv = to_ide_driver(dev->driver);
|
|
|
|
|
|
|
|
if (dev->driver && drv->shutdown)
|
|
|
|
drv->shutdown(drive);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bus_type ide_bus_type = {
|
|
|
|
.name = "ide",
|
2005-05-26 12:55:34 +00:00
|
|
|
.match = ide_bus_match,
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
.uevent = ide_uevent,
|
2006-01-06 11:41:00 +00:00
|
|
|
.probe = generic_ide_probe,
|
|
|
|
.remove = generic_ide_remove,
|
|
|
|
.shutdown = generic_ide_shutdown,
|
[PATCH] ide: MODALIAS support for autoloading of ide-cd, ide-disk, ...
IDE: MODALIAS support for autoloading of ide-cd, ide-disk, ...
Add MODULE_ALIAS to IDE midlayer modules: ide-disk, ide-cd, ide-floppy and
ide-tape, to autoload these modules depending on the probed media type of
the IDE device.
It is used by udev and replaces the former agent shell script of the hotplug
package, which was required to lookup the media type in the proc filesystem.
Using proc was racy, cause the media file is created after the hotplug event
is sent out.
The module autoloading does not take any effect, until something like the
following udev rule is configured:
SUBSYSTEM=="ide", ACTION=="add", ENV{MODALIAS}=="?*", RUN+="/sbin/modprobe $env{MODALIAS}"
The module ide-scsi will not be autoloaded, cause it requires manual
configuration. It can't be, and never was supported for automatic setup in
the hotplug package. Adding a MODULE_ALIAS to ide-scsi for all supported
media types, would just lead to a default blacklist entry anyway.
$ modinfo ide-disk
filename: /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
description: ATA DISK Driver
alias: ide:*m-disk*
license: GPL
...
$ modprobe -vn ide:m-disk
insmod /lib/modules/2.6.15-rc4-g1b0997f5/kernel/drivers/ide/ide-disk.ko
$ cat /sys/bus/ide/devices/0.0/modalias
ide:m-disk
It also adds attributes to the IDE device:
$ tree /sys/bus/ide/devices/0.0/
/sys/bus/ide/devices/0.0/
|-- bus -> ../../../../../../../bus/ide
|-- drivename
|-- media
|-- modalias
|-- power
| |-- state
| `-- wakeup
`-- uevent
$ cat /sys/bus/ide/devices/0.0/{modalias,drivename,media}
ide:m-disk
hda
disk
Signed-off-by: Kay Sievers <kay.sievers@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-12-12 17:03:44 +00:00
|
|
|
.dev_attrs = ide_dev_attrs,
|
2005-04-16 22:20:36 +00:00
|
|
|
.suspend = generic_ide_suspend,
|
|
|
|
.resume = generic_ide_resume,
|
|
|
|
};
|
|
|
|
|
2005-05-26 12:55:34 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ide_bus_type);
|
|
|
|
|
2008-04-17 22:46:23 +00:00
|
|
|
static void ide_port_class_release(struct device *portdev)
|
|
|
|
{
|
|
|
|
ide_hwif_t *hwif = dev_get_drvdata(portdev);
|
|
|
|
|
|
|
|
put_device(&hwif->gendev);
|
|
|
|
}
|
|
|
|
|
2008-04-27 13:38:23 +00:00
|
|
|
static unsigned int ide_ignore_cable;
|
|
|
|
|
|
|
|
static int ide_set_ignore_cable(const char *s, struct kernel_param *kp)
|
|
|
|
{
|
|
|
|
int i, j = 1;
|
|
|
|
|
|
|
|
if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (i >= MAX_HWIFS || j < 0 || j > 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (j)
|
|
|
|
ide_ignore_cable |= (1 << i);
|
|
|
|
else
|
|
|
|
ide_ignore_cable &= (1 << i);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0);
|
|
|
|
MODULE_PARM_DESC(ignore_cable, "ignore cable detection");
|
|
|
|
|
|
|
|
void ide_port_apply_params(ide_hwif_t *hwif)
|
|
|
|
{
|
|
|
|
if (ide_ignore_cable & (1 << hwif->index)) {
|
|
|
|
printk(KERN_INFO "ide: ignoring cable detection for %s\n",
|
|
|
|
hwif->name);
|
|
|
|
hwif->cbl = ATA_CBL_PATA40_SHORT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* This is gets invoked once during initialization, to set *everything* up
|
|
|
|
*/
|
|
|
|
static int __init ide_init(void)
|
|
|
|
{
|
2006-10-03 08:14:23 +00:00
|
|
|
int ret;
|
|
|
|
|
2008-02-10 23:32:13 +00:00
|
|
|
printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
system_bus_speed = ide_system_bus_speed();
|
|
|
|
|
2008-02-01 22:09:35 +00:00
|
|
|
printk(KERN_INFO "ide: Assuming %dMHz system bus speed "
|
|
|
|
"for PIO modes%s\n", system_bus_speed,
|
|
|
|
idebus_parameter ? "" : "; override with idebus=xx");
|
|
|
|
|
2006-10-03 08:14:23 +00:00
|
|
|
ret = bus_register(&ide_bus_type);
|
|
|
|
if (ret < 0) {
|
|
|
|
printk(KERN_WARNING "IDE: bus_register error: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-17 22:46:23 +00:00
|
|
|
ide_port_class = class_create(THIS_MODULE, "ide_port");
|
|
|
|
if (IS_ERR(ide_port_class)) {
|
|
|
|
ret = PTR_ERR(ide_port_class);
|
|
|
|
goto out_port_class;
|
|
|
|
}
|
|
|
|
ide_port_class->dev_release = ide_port_class_release;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
init_ide_data();
|
|
|
|
|
2007-05-09 22:01:11 +00:00
|
|
|
proc_ide_create();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-04-17 22:46:23 +00:00
|
|
|
|
|
|
|
out_port_class:
|
|
|
|
bus_unregister(&ide_bus_type);
|
|
|
|
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef MODULE
|
|
|
|
static char *options = NULL;
|
|
|
|
module_param(options, charp, 0);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
static void __init parse_options (char *line)
|
|
|
|
{
|
|
|
|
char *next = line;
|
|
|
|
|
|
|
|
if (line == NULL || !*line)
|
|
|
|
return;
|
|
|
|
while ((line = next) != NULL) {
|
|
|
|
if ((next = strchr(line,' ')) != NULL)
|
|
|
|
*next++ = 0;
|
|
|
|
if (!ide_setup(line))
|
|
|
|
printk (KERN_INFO "Unknown option '%s'\n", line);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-25 11:07:11 +00:00
|
|
|
int __init init_module (void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
parse_options(options);
|
|
|
|
return ide_init();
|
|
|
|
}
|
|
|
|
|
2007-02-01 13:52:38 +00:00
|
|
|
void __exit cleanup_module (void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
for (index = 0; index < MAX_HWIFS; ++index)
|
ide: remove broken/dangerous HDIO_[UNREGISTER,SCAN]_HWIF ioctls (take 3)
hdparm explicitely marks HDIO_[UNREGISTER,SCAN]_HWIF ioctls as DANGEROUS
and given the number of bugs we can assume that there are no real users:
* DMA has no chance of working because DMA resources are released by
ide_unregister() and they are never allocated again.
* Since ide_init_hwif_ports() is used for ->io_ports[] setup the ioctls
don't work for almost all hosts with "non-standard" (== non ISA-like)
layout of IDE taskfile registers (there is a lot of such host drivers).
* ide_port_init_devices() is not called when probing IDE devices so:
- drive->autotune is never set and IDE host/devices are not programmed
for the correct PIO/DMA transfer modes (=> possible data corruption)
- host specific I/O 32-bit and IRQ unmasking settings are not applied
(=> possible data corruption)
- host specific ->port_init_devs method is not called (=> no luck with
ht6560b, qd65xx and opti621 host drivers)
* ->rw_disk method is not preserved (=> no HPT3xxN chipsets support).
* ->serialized flag is not preserved (=> possible data corruption when
using icside, aec62xx (ATP850UF chipset), cmd640, cs5530, hpt366
(HPT3xxN chipsets), rz1000, sc1200, dtc2278 and ht6560b host drivers).
* ->ack_intr method is not preserved (=> needed by ide-cris, buddha,
gayle and macide host drivers).
* ->sata_scr[] and sata_misc[] is cleared by ide_unregister() and it
isn't initialized again (SiI3112 support needs them).
* To issue an ioctl() there need to be at least one IDE device present
in the system.
* ->cable_detect method is not preserved + it is not called when probing
IDE devices so cable detection is broken (however since DMA support is
also broken it doesn't really matter ;-).
* Some objects which may have already been freed in ide_unregister()
are restored by ide_hwif_restore() (i.e. ->hwgroup).
* ide_register_hw() may unregister unrelated IDE ports if free ide_hwifs[]
slot cannot be found.
* When IDE host drivers are modular unregistered port may be re-used by
different host driver that owned it first causing subtle bugs.
Since we now have a proper warm-plug support remove these ioctls,
then remove no longer needed:
- ide_register_hw() and ide_hwif_restore() functions
- 'init_default' and 'restore' arguments of ide_unregister()
- zeroeing of hwif->{dma,extra}_* fields in ide_unregister()
As an added bonus IDE core code size shrinks by ~3kB (x86-32).
v2:
* fix ide_unregister() arguments in cleanup_module() (Andrew Morton).
v3:
* fix ide_unregister() arguments in palm_bk3710.c.
Acked-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
2008-04-17 22:46:24 +00:00
|
|
|
ide_unregister(index);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
proc_ide_destroy();
|
|
|
|
|
2008-04-17 22:46:23 +00:00
|
|
|
class_destroy(ide_port_class);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
bus_unregister(&ide_bus_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !MODULE */
|
|
|
|
|
|
|
|
__setup("", ide_setup);
|
|
|
|
|
|
|
|
module_init(ide_init);
|
|
|
|
|
|
|
|
#endif /* MODULE */
|