[PATCH] 2.5.17 IDE 70

 - Apply host chip driver cleanups by Bartomiej Zonierkiewicz.

 - Take the draft device type driver implementation from Adam Richter and make
    it actually work with some of the drivers we have at hand. Quite a lot
    of it was fixed by me as well to have the desired effects.

    We have added a attach method for the sub device type drivers to make it
    possible dor sub device type drivers to attach devices to the overall
    infrastructure. UNIX has something like this SCSI code is implementing
    something like this, just for some unknown reasons Linux block device
    operations don't have it...

 - ide_drive_t is finally gone. Please use struct ata_device instead.

    Hint the ide.h specific byte type should go over time as well, sine there
    is no need to invent something already handled by the kernel. Please use
    the unambigious u8 type instead where possible.

 - Add a bit of documentation about cabling issues. ide.txt needs a lot of
   improvement at some time still.

Documentation/ide.txt

@@ -37,9 +37,27 @@
 ***
 ***  Use of the "serialize" option is no longer necessary.
 
-This is the multiple IDE interface driver, as evolved from hd.c.  It supports
-up to 9 IDE interfaces per default, on one or more IRQs (usually 14 & 15).
-There can be up to two drives per interface, as per the ATA-6 spec.
+================================================================================
+Common pitfalls:
+
+- 40-conductor IDE cables are capable of transfering data in DMA modes up to
+  udma2, but no faster.
+
+- If possible devices should be attached to separate channels if they are
+  available. Typically the disk on the first and CD-ROM on the second.
+
+- If you mix devices on the same cable, please consider using similar devices
+  in respect of the data transfer mode they support.
+
+- Even better tru to stick to the same vendor and device type on the same
+  cable.
+
+================================================================================
+
+This is the multiple IDE interface driver, as evolved from hd.c.  
+
+It supports up to 9 IDE interfaces per default, on one or more IRQs (usually
+14 & 15).  There can be up to two drives per interface, as per the ATA-6 spec.
 
 Primary:    ide0, port 0x1f0; major=3;  hda is minor=0; hdb is minor=64
 Secondary:  ide1, port 0x170; major=22; hdc is minor=0; hdd is minor=64

arch/cris/drivers/ide.c

@@ -192,7 +192,7 @@ unsigned char IN_BYTE(ide_ioreg_t reg) {
 #define ATA_PIO0_HOLD    4
 
 static int e100_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq);
-static void e100_ideproc (ide_ide_action_t func, ide_drive_t *drive,
+static void e100_ideproc (ide_ide_action_t func, struct ata_device *drive,
 			  void *buffer, unsigned int length);
 
 /*
@@ -206,7 +206,7 @@ const char *good_dma_drives[] = {"Micropolis 2112A",
 				 "CONNER CTT8000-A",
 				 NULL};
 
-static void tune_e100_ide(ide_drive_t *drive, byte pio)
+static void tune_e100_ide(struct ata_device *drive, byte pio)
 {
 	unsigned long flags;
 	
@@ -380,7 +380,7 @@ static etrax_dma_descr mydescr;
  * extra byte allocated for the buffer.
  */
 static void
-e100_atapi_read(ide_drive_t *drive, void *buffer, unsigned int bytecount)
+e100_atapi_read(struct ata_device *drive, void *buffer, unsigned int bytecount)
 {
 	ide_ioreg_t data_reg = IDE_DATA_REG;
 
@@ -459,7 +459,7 @@ e100_atapi_read(ide_drive_t *drive, void *buffer, unsigned int bytecount)
 }
 
 static void
-e100_atapi_write(ide_drive_t *drive, void *buffer, unsigned int bytecount)
+e100_atapi_write(struct ata_device *drive, void *buffer, unsigned int bytecount)
 {
 	ide_ioreg_t data_reg = IDE_DATA_REG;
 	
@@ -546,7 +546,7 @@ e100_atapi_write(ide_drive_t *drive, void *buffer, unsigned int bytecount)
  * This is used for most PIO data transfers *from* the IDE interface
  */
 static void 
-e100_ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
+e100_ide_input_data (struct ata_device *drive, void *buffer, unsigned int wcount)
 {
 	e100_atapi_read(drive, buffer, wcount << 2);
 }
@@ -555,7 +555,7 @@ e100_ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
  * This is used for most PIO data transfers *to* the IDE interface
  */
 static void
-e100_ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
+e100_ide_output_data (struct ata_device *drive, void *buffer, unsigned int wcount)
 {
 	e100_atapi_write(drive, buffer, wcount << 2);
 }
@@ -661,7 +661,7 @@ static int e100_udma_new_table(struct ata_channel *ch, struct request *rq)
 	return 1;	/* let the PIO routines handle this weirdness */
 }
 
-static int config_drive_for_dma (ide_drive_t *drive)
+static int config_drive_for_dma (struct ata_device *drive)
 {
         const char **list;
         struct hd_driveid *id = drive->id;

drivers/ide/Config.in

@@ -131,12 +131,7 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
       bool '  IGNORE word93 Validation BITS' CONFIG_IDEDMA_IVB
    fi
    
-   if [ "$CONFIG_BLK_DEV_IDECD" != "n" -o \
-        "$CONFIG_BLK_DEV_IDETAPE" != "n" -o \
-        "$CONFIG_BLK_DEV_IDEFLOPPY" != "n" -o \
-        "$CONFIG_BLK_DEV_IDESCSI" != "n" ]; then
-	define_bool  CONFIG_ATAPI y
-   fi
+   define_bool  CONFIG_ATAPI y
 else
    bool 'Old hard disk (MFM/RLL/IDE) driver' CONFIG_BLK_DEV_HD_ONLY
    define_bool CONFIG_BLK_DEV_HD $CONFIG_BLK_DEV_HD_ONLY

drivers/ide/Makefile

@@ -21,7 +21,7 @@ obj-$(CONFIG_BLK_DEV_HD)	+= hd.o
 obj-$(CONFIG_BLK_DEV_IDE)       += ide-mod.o
 obj-$(CONFIG_BLK_DEV_IDECS)     += ide-cs.o
 obj-$(CONFIG_BLK_DEV_IDEDISK)   += ide-disk.o
-obj-$(CONFIG_ATAPI)		+= atapi.o
+# obj-$(CONFIG_ATAPI)		+= atapi.o
 obj-$(CONFIG_BLK_DEV_IDECD)     += ide-cd.o
 obj-$(CONFIG_BLK_DEV_IDETAPE)   += ide-tape.o
 obj-$(CONFIG_BLK_DEV_IDEFLOPPY) += ide-floppy.o
@@ -74,6 +74,6 @@ obj-$(CONFIG_BLK_DEV_ATARAID)		+= ataraid.o
 obj-$(CONFIG_BLK_DEV_ATARAID_PDC)	+= pdcraid.o
 obj-$(CONFIG_BLK_DEV_ATARAID_HPT)	+= hptraid.o
 
-ide-mod-objs	:= ide-taskfile.o ide.o ide-probe.o ide-geometry.o ide-features.o ata-timing.o $(ide-obj-y)
+ide-mod-objs	:= ide-taskfile.o ide.o ide-probe.o ide-geometry.o ide-features.o ata-timing.o atapi.o $(ide-obj-y)
 
 include $(TOPDIR)/Rules.make

drivers/ide/aec62xx.c

@@ -607,27 +607,7 @@ static struct ata_pci_device chipsets[] __initdata = {
 		enablebits: { {0x00,0x00,0x00},	{0x00,0x00,0x00} },
 		bootable: OFF_BOARD,
 		flags: ATA_F_IRQ | ATA_F_DMA
-	},
-	{
-		vendor: PCI_VENDOR_ID_ARTOP,
-		device: PCI_DEVICE_ID_ARTOP_ATP865,
-		init_chipset: aec62xx_init_chipset,
-		ata66_check: aec62xx_ata66_check,
-		init_channel: aec62xx_init_channel,
-		enablebits: { {0x00,0x00,0x00},	{0x00,0x00,0x00} },
-		bootable: NEVER_BOARD,
-		flags: ATA_F_IRQ | ATA_F_NOADMA | ATA_F_DMA
-	},
-	{
-		vendor: PCI_VENDOR_ID_ARTOP,
-		device: PCI_DEVICE_ID_ARTOP_ATP865R,
-		init_chipset: aec62xx_init_chipset,
-		ata66_check: aec62xx_ata66_check,
-		init_channel: aec62xx_init_channel,
-		enablebits: { {0x4a,0x02,0x02},	{0x4a,0x04,0x04} },
-		bootable: OFF_BOARD,
-		flags: ATA_F_IRQ | ATA_F_DMA
-	},
+	}
 };
 
 int __init init_aec62xx(void)

drivers/ide/amd74xx.c

@@ -226,9 +226,9 @@ static void amd_set_speed(struct pci_dev *dev, unsigned char dn, struct ata_timi
  * by upper layers.
  */
 
-static int amd_set_drive(ide_drive_t *drive, unsigned char speed)
+static int amd_set_drive(struct ata_device *drive, unsigned char speed)
 {
-	ide_drive_t *peer = drive->channel->drives + (~drive->dn & 1);
+	struct ata_device *peer = drive->channel->drives + (~drive->dn & 1);
 	struct ata_timing t, p;
 	int T, UT;
 
@@ -263,7 +263,7 @@ static int amd_set_drive(ide_drive_t *drive, unsigned char speed)
  * PIO-only tuning.
  */
 
-static void amd74xx_tune_drive(ide_drive_t *drive, unsigned char pio)
+static void amd74xx_tune_drive(struct ata_device *drive, u8 pio)
 {
 	if (!((amd_enabled >> drive->channel->unit) & 1))
 		return;

drivers/ide/cs5530.c

@@ -81,7 +81,7 @@ extern char *ide_xfer_verbose (byte xfer_rate);
 /*
  * Set a new transfer mode at the drive
  */
-int cs5530_set_xfer_mode (ide_drive_t *drive, byte mode)
+int cs5530_set_xfer_mode(struct ata_device *drive, byte mode)
 {
 	int error = 0;
 
@@ -113,7 +113,7 @@ static unsigned int cs5530_pio_timings[2][5] =
  * The ide_init_cs5530() routine guarantees that all drives
  * will have valid default PIO timings set up before we get here.
  */
-static void cs5530_tuneproc (ide_drive_t *drive, byte pio)	/* pio=255 means "autotune" */
+static void cs5530_tuneproc(struct ata_device *drive, byte pio)	/* pio=255 means "autotune" */
 {
 	struct ata_channel *hwif = drive->channel;
 	unsigned int	format, basereg = CS5530_BASEREG(hwif);
@@ -134,12 +134,12 @@ static void cs5530_tuneproc (ide_drive_t *drive, byte pio)	/* pio=255 means "aut
  * cs5530_config_dma() handles selection/setting of DMA/UDMA modes
  * for both the chipset and drive.
  */
-static int cs5530_config_dma (ide_drive_t *drive)
+static int cs5530_config_dma(struct ata_device *drive)
 {
 	int			udma_ok = 1, mode = 0;
 	struct ata_channel *hwif = drive->channel;
 	int			unit = drive->select.b.unit;
-	ide_drive_t		*mate = &hwif->drives[unit^1];
+	struct ata_device		*mate = &hwif->drives[unit^1];
 	struct hd_driveid	*id = drive->id;
 	unsigned int		basereg, reg, timings;
 

drivers/ide/cy82c693.c

@@ -183,7 +183,7 @@ static void compute_clocks (byte pio, pio_clocks_t *p_pclk)
 /*
  * set DMA mode a specific channel for CY82C693
  */
-static void cy82c693_dma_enable (ide_drive_t *drive, int mode, int single)
+static void cy82c693_dma_enable(struct ata_device *drive, int mode, int single)
 {
         byte index;
 	byte data;
@@ -270,7 +270,7 @@ static int cy82c693_dmaproc(struct ata_device *drive)
 /*
  * tune ide drive - set PIO mode
  */
-static void cy82c693_tune_drive (ide_drive_t *drive, byte pio)
+static void cy82c693_tune_drive(struct ata_device *drive, byte pio)
 {
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev = hwif->pci_dev;

drivers/ide/dtc2278.c

@@ -66,7 +66,7 @@ static void sub22 (char b, char c)
 	}
 }
 
-static void tune_dtc2278 (ide_drive_t *drive, byte pio)
+static void tune_dtc2278(struct ata_device *drive, byte pio)
 {
 	unsigned long flags;
 

drivers/ide/hpt34x.c

@@ -94,9 +94,9 @@ static int hpt34x_get_info (char *buffer, char **addr, off_t offset, int count)
 
 byte hpt34x_proc = 0;
 
-extern char *ide_xfer_verbose (byte xfer_rate);
+extern char *ide_xfer_verbose(byte xfer_rate);
 
-static void hpt34x_clear_chipset (ide_drive_t *drive)
+static void hpt34x_clear_chipset(struct ata_device *drive)
 {
 	unsigned int reg1	= 0, tmp1 = 0;
 	unsigned int reg2	= 0, tmp2 = 0;
@@ -109,7 +109,7 @@ static void hpt34x_clear_chipset (ide_drive_t *drive)
 	pci_write_config_dword(drive->channel->pci_dev, 0x48, tmp2);
 }
 
-static int hpt34x_tune_chipset (ide_drive_t *drive, byte speed)
+static int hpt34x_tune_chipset(struct ata_device *drive, byte speed)
 {
 	byte			hi_speed, lo_speed;
 	unsigned int reg1	= 0, tmp1 = 0;
@@ -145,7 +145,7 @@ static int hpt34x_tune_chipset (ide_drive_t *drive, byte speed)
 	return ide_config_drive_speed(drive, speed);
 }
 
-static void config_chipset_for_pio(ide_drive_t *drive)
+static void config_chipset_for_pio(struct ata_device *drive)
 {
 	unsigned short eide_pio_timing[6] = {960, 480, 240, 180, 120, 90};
 	unsigned short xfer_pio = drive->id->eide_pio_modes;
@@ -182,7 +182,7 @@ static void config_chipset_for_pio(ide_drive_t *drive)
 	(void) hpt34x_tune_chipset(drive, speed);
 }
 
-static void hpt34x_tune_drive (ide_drive_t *drive, byte pio)
+static void hpt34x_tune_drive(struct ata_device *drive, byte pio)
 {
 	byte speed;
 

drivers/ide/hptraid.c

@@ -230,14 +230,14 @@ static unsigned long maxsectors (int major,int minor)
 {
 	unsigned long lba = 0;
 	kdev_t dev;
-	ide_drive_t *ideinfo;
-	
+	struct ata_device *ideinfo;
+
 	dev = mk_kdev(major,minor);
 	ideinfo = get_info_ptr (dev);
 	if (ideinfo==NULL)
 		return 0;
-	
-	
+
+
 	/* first sector of the last cluster */
 	if (ideinfo->head==0) 
 		return 0;

drivers/ide/ht6560b.c

@@ -120,7 +120,7 @@
 /*
  * This routine is invoked from ide.c to prepare for access to a given drive.
  */
-static void ht6560b_selectproc (ide_drive_t *drive)
+static void ht6560b_selectproc(struct ata_device *drive)
 {
 	unsigned long flags;
 	static byte current_select = 0;
@@ -195,7 +195,7 @@ static int __init try_to_init_ht6560b(void)
 	return 1;
 }
 
-static byte ht_pio2timings(ide_drive_t *drive, byte pio)
+static byte ht_pio2timings(struct ata_device *drive, byte pio)
 {
 	int active_time, recovery_time;
 	int active_cycles, recovery_cycles;
@@ -248,7 +248,7 @@ static byte ht_pio2timings(ide_drive_t *drive, byte pio)
 /*
  *  Enable/Disable so called prefetch mode
  */
-static void ht_set_prefetch(ide_drive_t *drive, byte state)
+static void ht_set_prefetch(struct ata_device *drive, byte state)
 {
 	unsigned long flags;
 	int t = HT_PREFETCH_MODE << 8;
@@ -275,7 +275,7 @@ static void ht_set_prefetch(ide_drive_t *drive, byte state)
 #endif
 }
 
-static void tune_ht6560b (ide_drive_t *drive, byte pio)
+static void tune_ht6560b(struct ata_device *drive, byte pio)
 {
 	unsigned long flags;
 	byte timing;

drivers/ide/ide-cd.c

@@ -2925,8 +2925,11 @@ int ide_cdrom_cleanup(struct ata_device *drive)
 	return 0;
 }
 
+static void ide_cdrom_attach(struct ata_device *drive);
+
 static struct ata_operations ide_cdrom_driver = {
 	owner:			THIS_MODULE,
+	attach:			ide_cdrom_attach,
 	cleanup:		ide_cdrom_cleanup,
 	standby:		NULL,
 	do_request:		ide_cdrom_do_request,
@@ -2942,67 +2945,63 @@ static struct ata_operations ide_cdrom_driver = {
 /* options */
 static char *ignore = NULL;
 
+static void ide_cdrom_attach(struct ata_device *drive)
+{
+	struct cdrom_info *info;
+	char *req;
+	struct ata_channel *channel;
+	int unit;
+
+	if (drive->type != ATA_ROM)
+		return;
+
+	req = drive->driver_req;
+	if (req[0] != '\0' && strcmp(req, "ide-cdrom"))
+		return;
+
+	/* skip drives that we were told to ignore */
+	if (ignore && !strcmp(ignore, drive->name)) {
+		printk(KERN_INFO "%s: ignored\n", drive->name);
+		return;
+	}
+	info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
+	if (!info) {
+		printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
+		return;
+	}
+	if (ide_register_subdriver (drive, &ide_cdrom_driver)) {
+		printk(KERN_ERR "%s: Failed to register the driver with ide.c\n", drive->name);
+		kfree (info);
+		return;
+	}
+
+
+	memset(info, 0, sizeof (struct cdrom_info));
+	drive->driver_data = info;
+
+	if (ide_cdrom_setup (drive)) {
+		if (ide_cdrom_cleanup (drive))
+			printk (KERN_ERR "%s: ide_cdrom_cleanup failed in ide_cdrom_init\n", drive->name);
+		return;
+	}
+
+	channel = drive->channel;
+	unit = drive - channel->drives;
+
+	ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
+}
+
 MODULE_PARM(ignore, "s");
 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
 
 static void __exit ide_cdrom_exit(void)
 {
-	struct ata_device *drive;
-	int failed = 0;
-
-	while ((drive = ide_scan_devices(ATA_ROM, "ide-cdrom", &ide_cdrom_driver, failed)) != NULL)
-		if (ide_cdrom_cleanup (drive)) {
-			printk ("%s: cleanup_module() called while still busy\n", drive->name);
-			failed++;
-		}
+	unregister_ata_driver(&ide_cdrom_driver);
 }
 
 int ide_cdrom_init(void)
 {
-	struct ata_device *drive;
-	struct cdrom_info *info;
-	int failed = 0;
-
-	MOD_INC_USE_COUNT;
-	while ((drive = ide_scan_devices (ATA_ROM, "ide-cdrom", NULL, failed++)) != NULL) {
-		/* skip drives that we were told to ignore */
-		if (ignore != NULL) {
-			if (strstr(ignore, drive->name)) {
-				printk("ide-cd: ignoring drive %s\n", drive->name);
-				continue;
-			}
-		}
-		if (drive->scsi) {
-			printk("ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
-			continue;
-		}
-		info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
-		if (info == NULL) {
-			printk ("%s: Can't allocate a cdrom structure\n", drive->name);
-			continue;
-		}
-		if (ide_register_subdriver (drive, &ide_cdrom_driver)) {
-			printk ("%s: Failed to register the driver with ide.c\n", drive->name);
-			kfree (info);
-			continue;
-		}
-		memset(info, 0, sizeof (struct cdrom_info));
-		drive->driver_data = info;
-
-		MOD_INC_USE_COUNT;
-		if (ide_cdrom_setup (drive)) {
-			MOD_DEC_USE_COUNT;
-			if (ide_cdrom_cleanup (drive))
-				printk ("%s: ide_cdrom_cleanup failed in ide_cdrom_init\n", drive->name);
-			continue;
-		}
-		MOD_DEC_USE_COUNT;
-
-		failed--;
-	}
-	revalidate_drives();
-	MOD_DEC_USE_COUNT;
-	return 0;
+	return ata_driver_module(&ide_cdrom_driver);
 }
 
 module_init(ide_cdrom_init);

drivers/ide/ide-disk.c

@@ -911,7 +911,7 @@ static void idedisk_setup(struct ata_device *drive)
 	if ((capacity >= (drive->bios_cyl * drive->bios_sect * drive->bios_head)) &&
 	    (!drive->forced_geom) && drive->bios_sect && drive->bios_head)
 		drive->bios_cyl = (capacity / drive->bios_sect) / drive->bios_head;
-	printk(KERN_INFO "%s: %ld sectors", drive->name, capacity);
+	printk(KERN_INFO " %s: %ld sectors", drive->name, capacity);
 
 #if 0
 
@@ -1147,12 +1147,14 @@ static int idedisk_ioctl(struct ata_device *drive, struct inode *inode, struct f
 	}
 }
 
+static void idedisk_attach(struct ata_device *drive);
 
 /*
  * Subdriver functions.
  */
 static struct ata_operations idedisk_driver = {
 	owner:			THIS_MODULE,
+	attach:			idedisk_attach,
 	cleanup:		idedisk_cleanup,
 	standby:		idedisk_standby,
 	do_request:		idedisk_do_request,
@@ -1165,46 +1167,49 @@ static struct ata_operations idedisk_driver = {
 	capacity:		idedisk_capacity,
 };
 
-MODULE_DESCRIPTION("ATA DISK Driver");
-
-static void __exit idedisk_exit (void)
+static void idedisk_attach(struct ata_device *drive)
 {
-	struct ata_device *drive;
-	int failed = 0;
+	char *req;
+	struct ata_channel *channel;
+	int unit;
 
-	while ((drive = ide_scan_devices(ATA_DISK, "ide-disk", &idedisk_driver, failed)) != NULL) {
-		if (idedisk_cleanup (drive)) {
-			printk(KERN_ERR "%s: cleanup_module() called while still busy\n", drive->name);
-			++failed;
-		}
+	if (drive->type != ATA_DISK)
+		return;
+
+	req = drive->driver_req;
+	if (req[0] != '\0' && strcmp(req, "ide-disk"))
+		return;
+
+	if (ide_register_subdriver(drive, &idedisk_driver)) {
+		printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
+		return;
+	}
+
+	idedisk_setup(drive);
+	if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
+		printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", drive->name, drive->head);
+		idedisk_cleanup(drive);
+		return;
 	}
+
+	channel = drive->channel;
+	unit = drive - channel->drives;
+
+	ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
 }
 
-int idedisk_init(void)
+static void __exit idedisk_exit(void)
 {
-	struct ata_device *drive;
-	int failed = 0;
-
-	MOD_INC_USE_COUNT;
-	while ((drive = ide_scan_devices(ATA_DISK, "ide-disk", NULL, failed++)) != NULL) {
-		if (ide_register_subdriver (drive, &idedisk_driver)) {
-			printk (KERN_ERR "ide-disk: %s: Failed to register the driver with ide.c\n", drive->name);
-			continue;
-		}
-		idedisk_setup(drive);
-		if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
-			printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n", drive->name, drive->head);
-			idedisk_cleanup(drive);
-			continue;
-		}
-		--failed;
-	}
-	revalidate_drives();
-	MOD_DEC_USE_COUNT;
+	unregister_ata_driver(&idedisk_driver);
+}
 
-	return 0;
+int __init idedisk_init(void)
+{
+	return ata_driver_module(&idedisk_driver);
 }
 
 module_init(idedisk_init);
 module_exit(idedisk_exit);
+
+MODULE_DESCRIPTION("ATA DISK Driver");
 MODULE_LICENSE("GPL");

drivers/ide/ide-floppy.c

 /*
- * linux/drivers/ide/ide-floppy.c	Version 0.99	Feb 24 2002
- *
  * Copyright (C) 1996 - 1999 Gadi Oxman <gadio@netvision.net.il>
  * Copyright (C) 2000 - 2002 Paul Bristow <paul@paulbristow.net>
  */
@@ -1977,11 +1975,14 @@ static int idefloppy_cleanup(struct ata_device *drive)
 	return 0;
 }
 
+static void idefloppy_attach(struct ata_device *drive);
+
 /*
  *	IDE subdriver functions, registered with ide.c
  */
 static struct ata_operations idefloppy_driver = {
 	owner:			THIS_MODULE,
+	attach:			idefloppy_attach,
 	cleanup:		idefloppy_cleanup,
 	standby:		NULL,
 	do_request:		idefloppy_do_request,
@@ -1994,59 +1995,60 @@ static struct ata_operations idefloppy_driver = {
 	capacity:		idefloppy_capacity,
 };
 
-MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
-
-static void __exit idefloppy_exit(void)
+static void idefloppy_attach(struct ata_device *drive)
 {
-	struct ata_device *drive;
-	int failed = 0;
+	idefloppy_floppy_t *floppy;
+	char *req;
+	struct ata_channel *channel;
+	int unit;
 
-	while ((drive = ide_scan_devices(ATA_FLOPPY, "ide-floppy", &idefloppy_driver, failed)) != NULL) {
-		if (idefloppy_cleanup(drive)) {
-			printk ("%s: cleanup_module() called while still busy\n", drive->name);
-			failed++;
-		}
+	if (drive->type != ATA_FLOPPY)
+		return;
+
+	req = drive->driver_req;
+	if (req[0] != '\0' && strcmp(req, "ide-floppy"))
+		return;
+
+	if (!idefloppy_identify_device (drive, drive->id)) {
+		printk (KERN_ERR "ide-floppy: %s: not supported by this version of driver\n",
+				drive->name);
+		return;
+	}
+
+	if (drive->scsi) {
+		printk(KERN_INFO "ide-floppy: passing drive %s to ide-scsi emulation.\n",
+				drive->name);
+		return;
+	}
+	if (!(floppy = (idefloppy_floppy_t *) kmalloc (sizeof (idefloppy_floppy_t), GFP_KERNEL))) {
+		printk(KERN_ERR "ide-floppy: %s: Can't allocate a floppy structure\n",
+				drive->name);
+		return;
+	}
+	if (ide_register_subdriver(drive, &idefloppy_driver)) {
+		printk(KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.c\n", drive->name);
+		kfree (floppy);
+		return;
 	}
+
+	idefloppy_setup(drive, floppy);
+
+	channel = drive->channel;
+	unit = drive - channel->drives;
+
+	ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
 }
 
-/*
- *	idefloppy_init will register the driver for each floppy.
- */
-int idefloppy_init(void)
-{
-	struct ata_device *drive;
-	idefloppy_floppy_t *floppy;
-	int failed = 0;
+MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
 
-	printk("ide-floppy driver " IDEFLOPPY_VERSION "\n");
-	MOD_INC_USE_COUNT;
-	while ((drive = ide_scan_devices (ATA_FLOPPY, "ide-floppy", NULL, failed++)) != NULL) {
-		if (!idefloppy_identify_device (drive, drive->id)) {
-			printk (KERN_ERR "ide-floppy: %s: not supported by this version of ide-floppy\n", drive->name);
-			continue;
-		}
-		if (drive->scsi) {
-			printk("ide-floppy: passing drive %s to ide-scsi emulation.\n", drive->name);
-			continue;
-		}
-		if ((floppy = (idefloppy_floppy_t *) kmalloc (sizeof (idefloppy_floppy_t), GFP_KERNEL)) == NULL) {
-			printk (KERN_ERR "ide-floppy: %s: Can't allocate a floppy structure\n", drive->name);
-			continue;
-		}
-		if (ide_register_subdriver (drive, &idefloppy_driver)) {
-			printk (KERN_ERR "ide-floppy: %s: Failed to register the driver with ide.c\n", drive->name);
-			kfree (floppy);
-			continue;
-		}
-		MOD_INC_USE_COUNT;
-		idefloppy_setup (drive, floppy);
-		MOD_DEC_USE_COUNT;
+static void __exit idefloppy_exit(void)
+{
+	unregister_ata_driver(&idefloppy_driver);
+}
 
-		failed--;
-	}
-	revalidate_drives();
-	MOD_DEC_USE_COUNT;
-	return 0;
+int __init idefloppy_init(void)
+{
+	return ata_driver_module(&idefloppy_driver);
 }
 
 module_init(idefloppy_init);

drivers/ide/ide-m8xx.c

@@ -51,7 +51,7 @@ static void print_funcid (int func);
 static int check_ide_device (unsigned long base);
 
 static void ide_interrupt_ack (void *dev);
-static void m8xx_ide_tuneproc(ide_drive_t *drive, byte pio);
+static void m8xx_ide_tuneproc(struct ata_device *drive, byte pio);
 
 typedef	struct ide_ioport_desc {
 	unsigned long	base_off;		/* Offset to PCMCIA memory	*/
@@ -437,7 +437,7 @@ void m8xx_ide_init_hwif_ports (hw_regs_t *hw,
 
 /* Calculate PIO timings */
 static void
-m8xx_ide_tuneproc(ide_drive_t *drive, byte pio)
+m8xx_ide_tuneproc(struct ata_device *drive, byte pio)
 {
 #if defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_DIRECT)
 	volatile pcmconf8xx_t	*pcmp;

drivers/ide/ide-pci.c

@@ -207,7 +207,8 @@ static unsigned long __init get_dma_base(struct ata_channel *hwif, int extra, co
 
 	if ((dev->vendor == PCI_VENDOR_ID_AL && dev->device == PCI_DEVICE_ID_AL_M5219) ||
 			(dev->vendor == PCI_VENDOR_ID_AMD && dev->device == PCI_DEVICE_ID_AMD_VIPER_7409) ||
-			(dev->vendor == PCI_VENDOR_ID_CMD && dev->device == PCI_DEVICE_ID_CMD_643)) {
+			(dev->vendor == PCI_VENDOR_ID_CMD && dev->device == PCI_DEVICE_ID_CMD_643) ||
+			(dev->vendor == PCI_VENDOR_ID_SERVERWORKS && dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE)) {
 		outb(inb(dma_base + 2) & 0x60, dma_base+2);
 		if (inb(dma_base + 2) & 0x80)
 			printk(KERN_INFO "%s: simplex device: DMA forced\n", name);
@@ -553,14 +554,14 @@ static void __init pdc20270_device_order_fixup (struct pci_dev *dev, struct ata_
 			}
 		}
 	}
-	printk(KERN_INFO "ATA: %s: controller on PCI slot %s dev %02x\n",
-			dev->name, dev->slot_name, dev->devfn);
+	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+			dev->name, dev->slot_name);
 	setup_pci_device(dev, d);
 	if (!dev2)
 		return;
 	d2 = d;
-	printk(KERN_INFO "ATA: %s: controller on PCI slot %s dev %02x\n",
-			dev2->name, dev2->slot_name, dev2->devfn);
+	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+			dev2->name, dev2->slot_name);
 	setup_pci_device(dev2, d2);
 }
 
@@ -583,8 +584,8 @@ static void __init hpt374_device_order_fixup (struct pci_dev *dev, struct ata_pc
 		}
 	}
 
-	printk(KERN_INFO "ATA: %s: controller on PCI slot %s dev %02x\n",
-		dev->name, dev->slot_name, dev->devfn);
+	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+		dev->name, dev->slot_name);
 	setup_pci_device(dev, d);
 	if (!dev2) {
 		return;
@@ -600,8 +601,8 @@ static void __init hpt374_device_order_fixup (struct pci_dev *dev, struct ata_pc
 		}
 	}
 	d2 = d;
-	printk(KERN_INFO "ATA: %s: controller on PCI slot %s dev %02x\n",
-		dev2->name, dev2->slot_name, dev2->devfn);
+	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+		dev2->name, dev2->slot_name);
 	setup_pci_device(dev2, d2);
 
 }
@@ -622,7 +623,8 @@ static void __init hpt366_device_order_fixup (struct pci_dev *dev, struct ata_pc
 	switch(class_rev) {
 		case 5:
 		case 4:
-		case 3:	printk(KERN_INFO "ATA: %s: controller on PCI slot %s\n", dev->name, dev->slot_name);
+		case 3:	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+					dev->name, dev->slot_name);
 			setup_pci_device(dev, d);
 			return;
 		default:	break;
@@ -643,12 +645,14 @@ static void __init hpt366_device_order_fixup (struct pci_dev *dev, struct ata_pc
 			break;
 		}
 	}
-	printk(KERN_INFO "ATA: %s: controller on PCI slot %s\n", dev->name, dev->slot_name);
+	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+			dev->name, dev->slot_name);
 	setup_pci_device(dev, d);
 	if (!dev2)
 		return;
 	d2 = d;
-	printk(KERN_INFO "ATA: %s: controller on PCI slot %s\n", dev2->name, dev2->slot_name);
+	printk(KERN_INFO "ATA: %s: controller, PCI slot %s\n",
+			dev2->name, dev2->slot_name);
 	setup_pci_device(dev2, d2);
 }
 
@@ -683,7 +687,7 @@ static void __init scan_pcidev(struct pci_dev *dev)
 		 * beeing grabbed by generic drivers.
 		 */
 		if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
-			printk(KERN_INFO "ATA: unknown interface: %s, on PCI slot %s\n",
+			printk(KERN_INFO "ATA: unknown interface: %s, PCI slot %s\n",
 					dev->name, dev->slot_name);
 		}
 		return;
@@ -707,8 +711,8 @@ static void __init scan_pcidev(struct pci_dev *dev)
 	} else if (d->vendor == PCI_VENDOR_ID_PROMISE && d->device == PCI_DEVICE_ID_PROMISE_20268R)
 		pdc20270_device_order_fixup(dev, d);
 	else {
-		printk(KERN_INFO "ATA: %s (%04x:%04x) on PCI slot %s\n",
-				dev->name, vendor, device, dev->slot_name);
+		printk(KERN_INFO "ATA: %s, PCI slot %s\n",
+				dev->name, dev->slot_name);
 		setup_pci_device(dev, d);
 	}
 }

drivers/ide/ide-tape.c

 /*
- * linux/drivers/ide/ide-tape.c		Version 1.17a	Jan, 2001
- *
  * Copyright (C) 1995 - 1999 Gadi Oxman <gadio@netvision.net.il>
  *
- * $Header$
- *
  * This driver was constructed as a student project in the software laboratory
  * of the faculty of electrical engineering in the Technion - Israel's
  * Institute Of Technology, with the guide of Avner Lottem and Dr. Ilana David.
@@ -5849,7 +5845,7 @@ static void idetape_get_mode_sense_results(struct ata_device *drive)
 	printk (KERN_INFO "ide-tape: Medium Type - %d\n",header->medium_type);
 	printk (KERN_INFO "ide-tape: Device Specific Parameter - %d\n",header->dsp);
 	printk (KERN_INFO "ide-tape: Block Descriptor Length - %d\n",header->bdl);
-	
+
 	printk (KERN_INFO "ide-tape: Capabilities and Mechanical Status Page:\n");
 	printk (KERN_INFO "ide-tape: Page code - %d\n",capabilities->page_code);
 	printk (KERN_INFO "ide-tape: Page length - %d\n",capabilities->page_length);
@@ -5955,7 +5951,7 @@ static void idetape_setup(struct ata_device *drive, idetape_tape_t *tape, int mi
 		set_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags);
 
 	tape->min_pipeline = tape->max_pipeline = tape->max_stages = 10;
-	
+
 	idetape_get_inquiry_results(drive);
 	idetape_get_mode_sense_results(drive);
 	idetape_get_blocksize_from_block_descriptor(drive);
@@ -6054,11 +6050,11 @@ static void idetape_revalidate(struct ata_device *_dummy)
 	 */
 }
 
-/*
- *	IDE subdriver functions, registered with ide.c
- */
+static void idetape_attach(struct ata_device *);
+
 static struct ata_operations idetape_driver = {
 	owner:			THIS_MODULE,
+	attach:			idetape_attach,
 	cleanup:		idetape_cleanup,
 	standby:		NULL,
 	do_request:		idetape_do_request,
@@ -6070,6 +6066,8 @@ static struct ata_operations idetape_driver = {
 	revalidate:		idetape_revalidate,
 };
 
+
+
 /*
  *	Our character device supporting functions, passed to register_chrdev.
  */
@@ -6082,104 +6080,93 @@ static struct file_operations idetape_fops = {
 	release:	idetape_chrdev_release,
 };
 
-MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
-MODULE_LICENSE("GPL");
-
-static void __exit idetape_exit(void)
+static void idetape_attach(struct ata_device *drive)
 {
-	struct ata_device *drive;
-	int minor;
+	idetape_tape_t *tape;
+	int minor, supported = 0;
+	char *req;
+	struct ata_channel *channel;
+	int unit;
 
-	for (minor = 0; minor < MAX_HWIFS * MAX_DRIVES; minor++) {
-		drive = idetape_chrdevs[minor].drive;
-		if (drive != NULL && idetape_cleanup (drive))
-		printk (KERN_ERR "ide-tape: %s: cleanup_module() called while still busy\n", drive->name);
-	}
-}
+	if (drive->type != ATA_TAPE)
+		return;
+
+	req = drive->driver_req;
+	if (req[0] != '\0' && strcmp(req, "ide-tape"))
+		return;
 
-/*
- *	idetape_init will register the driver for each tape.
- */
-int idetape_init(void)
-{
-	struct ata_device *drive;
-	idetape_tape_t *tape;
-	int minor, failed = 0, supported = 0;
-/* DRIVER(drive)->busy++; */
-	MOD_INC_USE_COUNT;
-#if ONSTREAM_DEBUG
-        printk(KERN_INFO "ide-tape: MOD_INC_USE_COUNT in idetape_init\n");
-#endif
 	if (!idetape_chrdev_present)
 		for (minor = 0; minor < MAX_HWIFS * MAX_DRIVES; minor++ )
 			idetape_chrdevs[minor].drive = NULL;
 
-	if ((drive = ide_scan_devices(ATA_TAPE, "ide-tape", NULL, failed++)) == NULL) {
-		revalidate_drives();
-		MOD_DEC_USE_COUNT;
-#if ONSTREAM_DEBUG
-		printk(KERN_INFO "ide-tape: MOD_DEC_USE_COUNT in idetape_init\n");
-#endif
-		return 0;
-	}
 	if (!idetape_chrdev_present &&
 	    devfs_register_chrdev (IDETAPE_MAJOR, "ht", &idetape_fops)) {
-		printk (KERN_ERR "ide-tape: Failed to register character device interface\n");
-		MOD_DEC_USE_COUNT;
-#if ONSTREAM_DEBUG
-		printk(KERN_INFO "ide-tape: MOD_DEC_USE_COUNT in idetape_init\n");
-#endif
-		return -EBUSY;
+		printk(KERN_ERR "ide-tape: Failed to register character device interface\n");
+		return;
 	}
-	do {
-		if (!idetape_identify_device (drive, drive->id)) {
-			printk (KERN_ERR "ide-tape: %s: not supported by this version of ide-tape\n", drive->name);
-			continue;
-		}
-		if (drive->scsi) {
-			if (strstr(drive->id->model, "OnStream DI-")) {
-				printk("ide-tape: ide-scsi emulation is not supported for %s.\n", drive->id->model);
-			} else {
-				printk("ide-tape: passing drive %s to ide-scsi emulation.\n", drive->name);
-				continue;
-			}
-		}
-		tape = (idetape_tape_t *) kmalloc (sizeof (idetape_tape_t), GFP_KERNEL);
-		if (tape == NULL) {
-			printk (KERN_ERR "ide-tape: %s: Can't allocate a tape structure\n", drive->name);
-			continue;
-		}
-		if (ide_register_subdriver (drive, &idetape_driver)) {
-			printk (KERN_ERR "ide-tape: %s: Failed to register the driver with ide.c\n", drive->name);
-			kfree (tape);
-			continue;
+
+	if (!idetape_identify_device (drive, drive->id)) {
+		printk(KERN_ERR "ide-tape: %s: not supported by this version of ide-tape\n", drive->name);
+		return;
+	}
+	if (drive->scsi) {
+		if (strstr(drive->id->model, "OnStream DI-")) {
+			printk(KERN_INFO "ide-tape: ide-scsi emulation is not supported for %s.\n", drive->id->model);
+		} else {
+			printk(KERN_INFO "ide-tape: passing drive %s to ide-scsi emulation.\n", drive->name);
+			return;
 		}
-		for (minor = 0; idetape_chrdevs[minor].drive != NULL; minor++);
-		idetape_setup (drive, tape, minor);
-		idetape_chrdevs[minor].drive = drive;
-		tape->de_r =
-		    devfs_register (drive->de, "mt", DEVFS_FL_DEFAULT,
-				    drive->channel->major, minor,
-				    S_IFCHR | S_IRUGO | S_IWUGO,
-				    &idetape_fops, NULL);
-		tape->de_n =
-		    devfs_register (drive->de, "mtn", DEVFS_FL_DEFAULT,
-				    drive->channel->major, minor + 128,
-				    S_IFCHR | S_IRUGO | S_IWUGO,
-				    &idetape_fops, NULL);
-		devfs_register_tape (tape->de_r);
-		supported++; failed--;
-	} while ((drive = ide_scan_devices(ATA_TAPE, "ide-tape", NULL, failed++)) != NULL);
+	}
+	tape = (idetape_tape_t *) kmalloc (sizeof (idetape_tape_t), GFP_KERNEL);
+	if (!tape) {
+		printk (KERN_ERR "ide-tape: %s: Can't allocate a tape structure\n", drive->name);
+		return;
+	}
+	if (ide_register_subdriver (drive, &idetape_driver)) {
+		printk (KERN_ERR "ide-tape: %s: Failed to register the driver with ide.c\n", drive->name);
+		kfree (tape);
+		return;
+	}
+	for (minor = 0; idetape_chrdevs[minor].drive != NULL; minor++);
+	idetape_setup (drive, tape, minor);
+	idetape_chrdevs[minor].drive = drive;
+	tape->de_r =
+		devfs_register (drive->de, "mt", DEVFS_FL_DEFAULT,
+				drive->channel->major, minor,
+				S_IFCHR | S_IRUGO | S_IWUGO,
+				&idetape_fops, NULL);
+	tape->de_n =
+		devfs_register (drive->de, "mtn", DEVFS_FL_DEFAULT,
+				drive->channel->major, minor + 128,
+				S_IFCHR | S_IRUGO | S_IWUGO,
+				&idetape_fops, NULL);
+	devfs_register_tape (tape->de_r);
+	supported++;
+
 	if (!idetape_chrdev_present && !supported) {
 		devfs_unregister_chrdev (IDETAPE_MAJOR, "ht");
 	} else
 		idetape_chrdev_present = 1;
-	revalidate_drives();
-	MOD_DEC_USE_COUNT;
-#if ONSTREAM_DEBUG
-	printk(KERN_INFO "ide-tape: MOD_DEC_USE_COUNT in idetape_init\n");
-#endif
-	return 0;
+
+	/* Feel free to use partitions even on tapes... */
+
+	channel = drive->channel;
+	unit = drive - channel->drives;
+
+	ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
+}
+
+MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
+MODULE_LICENSE("GPL");
+
+static void __exit idetape_exit(void)
+{
+	unregister_ata_driver(&idetape_driver);
+}
+
+int __init idetape_init(void)
+{
+	return ata_driver_module(&idetape_driver);
 }
 
 module_init(idetape_init);

drivers/ide/it8172.c

@@ -48,17 +48,17 @@
 /*
  * Prototypes
  */
-static void it8172_tune_drive (ide_drive_t *drive, byte pio);
+static void it8172_tune_drive (struct ata_device *drive, byte pio);
 #if defined(CONFIG_BLK_DEV_IDEDMA) && defined(CONFIG_IT8172_TUNING)
 static byte it8172_dma_2_pio (byte xfer_rate);
-static int it8172_tune_chipset (ide_drive_t *drive, byte speed);
-static int it8172_config_chipset_for_dma (ide_drive_t *drive);
-static int it8172_dmaproc(ide_dma_action_t func, ide_drive_t *drive);
+static int it8172_tune_chipset (struct ata_device *drive, byte speed);
+static int it8172_config_chipset_for_dma (struct ata_device *drive);
+static int it8172_dmaproc(ide_dma_action_t func, struct ata_device *drive);
 #endif
 void __init ide_init_it8172(struct ata_channel *channel);
 
 
-static void it8172_tune_drive (ide_drive_t *drive, byte pio)
+static void it8172_tune_drive (struct ata_device *drive, byte pio)
 {
     unsigned long flags;
     u16 drive_enables;
@@ -139,7 +139,7 @@ static byte it8172_dma_2_pio (byte xfer_rate)
     }
 }
 
-static int it8172_tune_chipset (ide_drive_t *drive, byte speed)
+static int it8172_tune_chipset (struct ata_device *drive, byte speed)
 {
     struct ata_channel *hwif = drive->channel;
     struct pci_dev *dev	= hwif->pci_dev;
@@ -194,7 +194,7 @@ static int it8172_tune_chipset (ide_drive_t *drive, byte speed)
     return err;
 }
 
-static int it8172_config_chipset_for_dma(ide_drive_t *drive)
+static int it8172_config_chipset_for_dma(struct ata_device *drive)
 {
     struct hd_driveid *id = drive->id;
     byte speed;
@@ -210,7 +210,7 @@ static int it8172_config_chipset_for_dma(ide_drive_t *drive)
 	    ide_dma_off_quietly);
 }
 
-static int it8172_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
+static int it8172_dmaproc(ide_dma_action_t func, struct ata_device *drive)
 {
     switch (func) {
     case ide_dma_check:

drivers/ide/macide.c

@@ -119,7 +119,7 @@ void macide_init(void)
 			/* hardware ID, and we cna't get that without	*/
 			/* probing the drive which freezes a 190.	*/
 
-			ide_drive_t *drive = &ide_hwifs[index].drives[0];
+			struct ata_device *drive = &ide_hwifs[index].drives[0];
         		drive->capacity = drive->cyl*drive->head*drive->sect;
 
 #ifdef CONFIG_BLK_DEV_MAC_MEDIABAY

drivers/ide/ns87415.c

@@ -33,7 +33,7 @@ static unsigned int ns87415_count = 0, ns87415_control[MAX_HWIFS] = { 0 };
  * the IRQ associated with the port (drive->channel),
  * and selects either PIO or DMA handshaking for the next I/O operation.
  */
-static void ns87415_prepare_drive (ide_drive_t *drive, unsigned int use_dma)
+static void ns87415_prepare_drive(struct ata_device *drive, unsigned int use_dma)
 {
 	struct ata_channel *hwif = drive->channel;
 	unsigned int bit, other, new, *old = (unsigned int *) hwif->select_data;
@@ -78,7 +78,7 @@ static void ns87415_prepare_drive (ide_drive_t *drive, unsigned int use_dma)
 	__restore_flags(flags);	/* local CPU only */
 }
 
-static void ns87415_selectproc (ide_drive_t *drive)
+static void ns87415_selectproc(struct ata_device *drive)
 {
 	ns87415_prepare_drive (drive, drive->using_dma);
 }

drivers/ide/opti621.c

@@ -137,7 +137,7 @@ int reg_base;
 
 /* there are stored pio numbers from other calls of opti621_tune_drive */
 
-static void compute_pios(ide_drive_t *drive, byte pio)
+static void compute_pios(struct ata_device *drive, byte pio)
 /* Store values into drive->drive_data
  *	second_contr - 0 for primary controller, 1 for secondary
  *	slave_drive - 0 -> pio is for master, 1 -> pio is for slave
@@ -245,7 +245,7 @@ static void compute_clocks(int pio, pio_clocks_t *clks)
 }
 
 /* Main tune procedure, called from tuneproc. */
-static void opti621_tune_drive (ide_drive_t *drive, byte pio)
+static void opti621_tune_drive(struct ata_device *drive, byte pio)
 {
 	/* primary and secondary drives share some registers,
 	 * so we have to program both drives

drivers/ide/pdcraid.c

@@ -377,7 +377,7 @@ static int pdcraid1_make_request (request_queue_t *q, int rw, struct buffer_head
 static unsigned long calc_pdcblock_offset(struct block_device *bdev)
 {
 	unsigned long lba = 0;
-	ide_drive_t *ideinfo = get_info_ptr(to_kdev_t(bdev->bd_dev));
+	struct ata_device *ideinfo = get_info_ptr(to_kdev_t(bdev->bd_dev));
 
 	if (ideinfo==NULL)
 		return 0;

drivers/ide/qd65xx.c

@@ -112,7 +112,7 @@ byte __init qd_read_reg (byte reg)
  * This routine is invoked from ide.c to prepare for access to a given drive.
  */
 
-static void qd_select (ide_drive_t *drive)
+static void qd_select(struct ata_device *drive)
 {
 	byte index = (( (QD_TIMREG(drive)) & 0x80 ) >> 7) |
 			(QD_TIMREG(drive) & 0x02);
@@ -164,7 +164,7 @@ static byte qd6580_compute_timing (int active_time, int recovery_time)
  * tries to find timing from dos driver's table
  */
 
-static int qd_find_disk_type (ide_drive_t *drive,
+static int qd_find_disk_type(struct ata_device *drive,
 		int *active_time, int *recovery_time)
 {
 	struct qd65xx_timing_s *p;
@@ -192,7 +192,7 @@ static int qd_find_disk_type (ide_drive_t *drive,
  * check whether timings don't conflict
  */
 
-static int qd_timing_ok (ide_drive_t drives[])
+static int qd_timing_ok(struct ata_device drives[])
 {
 	return (IDE_IMPLY(drives[0].present && drives[1].present,
 			IDE_IMPLY(QD_TIMREG(drives) == QD_TIMREG(drives+1),
@@ -206,7 +206,7 @@ static int qd_timing_ok (ide_drive_t drives[])
  * records the timing, and enables selectproc as needed
  */
 
-static void qd_set_timing (ide_drive_t *drive, byte timing)
+static void qd_set_timing(struct ata_device *drive, byte timing)
 {
 	struct ata_channel *hwif = drive->channel;
 
@@ -225,7 +225,7 @@ static void qd_set_timing (ide_drive_t *drive, byte timing)
  * qd6500_tune_drive
  */
 
-static void qd6500_tune_drive (ide_drive_t *drive, byte pio)
+static void qd6500_tune_drive(struct ata_device *drive, byte pio)
 {
 	int active_time   = 175;
 	int recovery_time = 415; /* worst case values from the dos driver */
@@ -247,7 +247,7 @@ static void qd6500_tune_drive (ide_drive_t *drive, byte pio)
  * qd6580_tune_drive
  */
 
-static void qd6580_tune_drive (ide_drive_t *drive, byte pio)
+static void qd6580_tune_drive(struct ata_device *drive, byte pio)
 {
 	struct ata_timing *t;
 	int base = drive->channel->select_data;

drivers/ide/serverworks.c

@@ -240,6 +240,26 @@ extern char *ide_xfer_verbose (byte xfer_rate);
 
 static struct pci_dev *isa_dev;
 
+static int svwks_ratemask(struct ata_device *drive)
+{
+	struct pci_dev *dev = drive->channel->pci_dev;
+	int map = 0;
+
+	if (!eighty_ninty_three(drive))
+		return XFER_UDMA;
+
+	switch(dev->device) {
+		case PCI_DEVICE_ID_SERVERWORKS_CSB5IDE:
+			if (svwks_revision >= SVWKS_CSB5_REVISION_NEW)
+				map |= XFER_UDMA_100;
+			map |= XFER_UDMA_66;
+		case PCI_DEVICE_ID_SERVERWORKS_OSB4IDE:
+			map |= XFER_UDMA;
+			break;
+	}
+	return map;
+}
+
 static int svwks_tune_chipset(struct ata_device *drive, byte speed)
 {
 	static u8 udma_modes[]	= { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
@@ -251,11 +271,6 @@ static int svwks_tune_chipset(struct ata_device *drive, byte speed)
 	byte unit		= (drive->select.b.unit & 0x01);
 	byte csb5		= (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE) ? 1 : 0;
 
-#ifdef CONFIG_BLK_DEV_IDEDMA
-	unsigned long dma_base	= hwif->dma_base;
-#endif
-	int err;
-
 	byte drive_pci		= 0x00;
 	byte drive_pci2		= 0x00;
 	byte drive_pci3		= hwif->unit ? 0x57 : 0x56;
@@ -338,9 +353,6 @@ static int svwks_tune_chipset(struct ata_device *drive, byte speed)
 	printk("%s: %s drive%d\n", drive->name, ide_xfer_verbose(speed), drive->dn);
 #endif /* SVWKS_DEBUG_DRIVE_INFO */
 
-	if (!drive->init_speed)
-		drive->init_speed = speed;
-
 	pci_write_config_byte(dev, drive_pci, pio_timing);
 	if (csb5)
 		pci_write_config_word(dev, 0x4A, csb5_pio);
@@ -349,16 +361,12 @@ static int svwks_tune_chipset(struct ata_device *drive, byte speed)
 	pci_write_config_byte(dev, drive_pci2, dma_timing);
 	pci_write_config_byte(dev, drive_pci3, ultra_timing);
 	pci_write_config_byte(dev, 0x54, ultra_enable);
-
-	if (speed > XFER_PIO_4)
-		outb(inb(dma_base+2)|(1<<(5+unit)), dma_base+2);
-	else
-		outb(inb(dma_base+2) & ~(1<<(5+unit)), dma_base+2);
-#endif /* CONFIG_BLK_DEV_IDEDMA */
-
-	err = ide_config_drive_speed(drive, speed);
+#endif
+	if (!drive->init_speed)
+		drive->init_speed = speed;
 	drive->current_speed = speed;
-	return err;
+
+	return ide_config_drive_speed(drive, speed);
 }
 
 static void config_chipset_for_pio(struct ata_device *drive)
@@ -415,23 +423,14 @@ static void svwks_tune_drive(struct ata_device *drive, byte pio)
 #ifdef CONFIG_BLK_DEV_IDEDMA
 static int config_chipset_for_dma(struct ata_device *drive)
 {
-	struct hd_driveid *id	= drive->id;
-	struct pci_dev *dev	= drive->channel->pci_dev;
-	byte udma_66	= eighty_ninty_three(drive);
-	int ultra66	= (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE) ? 1 : 0;
-	int ultra100	= (ultra66 && svwks_revision >= SVWKS_CSB5_REVISION_NEW) ? 1 : 0;
-
-	byte speed = ata_timing_mode(drive, XFER_PIO | XFER_EPIO | XFER_SWDMA | XFER_MWDMA | XFER_UDMA
-				| ((udma_66 && ultra66) ? XFER_UDMA_66 : 0)
-				| ((udma_66 && ultra100) ? XFER_UDMA_100 : 0));
+	int map;
+	byte mode;
 
-	(void) svwks_tune_chipset(drive, speed);
+	/* FIXME: check SWDMA modes --bkz */
+	map = XFER_MWDMA | svwks_ratemask(drive);
+	mode = ata_timing_mode(drive, map);
 
-	return ((int)	((id->dma_ultra >> 11) & 7) ? 1 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
+	return !svwks_tune_chipset(drive, mode);
 }
 
 static int config_drive_xfer_rate(struct ata_device *drive)

drivers/ide/sl82c105.c

@@ -71,7 +71,7 @@ static unsigned int get_timing_sl82c105(struct ata_timing *t)
 /*
  * Configure the drive and chipset for PIO
  */
-static void config_for_pio(ide_drive_t *drive, int pio, int report)
+static void config_for_pio(struct ata_device *drive, int pio, int report)
 {
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev = hwif->pci_dev;
@@ -109,7 +109,7 @@ static void config_for_pio(ide_drive_t *drive, int pio, int report)
 /*
  * Configure the drive and the chipset for DMA
  */
-static int config_for_dma(ide_drive_t *drive)
+static int config_for_dma(struct ata_device *drive)
 {
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev = hwif->pci_dev;
@@ -131,7 +131,7 @@ static int config_for_dma(ide_drive_t *drive)
  * Check to see if the drive and
  * chipset is capable of DMA mode
  */
-static int sl82c105_check_drive(ide_drive_t *drive)
+static int sl82c105_check_drive(struct ata_device *drive)
 {
 	int on = 0;
 
@@ -240,7 +240,7 @@ static void sl82c105_timeout(struct ata_device *drive)
  * This function is called when the IDE timer expires, the drive
  * indicates that it is READY, and we were waiting for DMA to complete.
  */
-static void sl82c105_lostirq(ide_drive_t *drive)
+static void sl82c105_lostirq(struct ata_device *drive)
 {
 	struct ata_channel *ch = drive->channel;
 	struct pci_dev *dev = ch->pci_dev;
@@ -273,7 +273,7 @@ static void sl82c105_lostirq(ide_drive_t *drive)
  * We only deal with PIO mode here - DMA mode 'using_dma' is not
  * initialised at the point that this function is called.
  */
-static void tune_sl82c105(ide_drive_t *drive, byte pio)
+static void tune_sl82c105(struct ata_device *drive, byte pio)
 {
 	config_for_pio(drive, pio, 1);
 

drivers/scsi/ide-scsi.c

@@ -502,11 +502,14 @@ static void idescsi_revalidate(struct ata_device *_dummy)
 	 */
 }
 
+static void idescsi_attach(struct ata_device *drive);
+
 /*
  *	IDE subdriver functions, registered with ide.c
  */
 static struct ata_operations idescsi_driver = {
 	owner:			THIS_MODULE,
+	attach:			idescsi_attach,
 	cleanup:		idescsi_cleanup,
 	standby:		NULL,
 	do_request:		idescsi_do_request,
@@ -519,45 +522,40 @@ static struct ata_operations idescsi_driver = {
 	capacity:		NULL,
 };
 
-/*
- *	idescsi_init will register the driver for each scsi.
- */
-int idescsi_init(void)
+static void idescsi_attach(struct ata_device *drive)
 {
-	struct ata_device *drive;
 	idescsi_scsi_t *scsi;
-	/* FIXME: The following is just plain wrong, since those are definitely *not* the
-	 * media types supported by the ATA layer */
-	byte media[] = {TYPE_DISK, TYPE_TAPE, TYPE_PROCESSOR, TYPE_WORM, TYPE_ROM, TYPE_SCANNER, TYPE_MOD, 255};
-	int i, failed, id;
+	int i, id;
+	char *req;
+	struct ata_channel *channel;
+	int unit;
 
 	if (idescsi_initialized)
-		return 0;
+		return;
 	idescsi_initialized = 1;
 	for (i = 0; i < MAX_HWIFS * MAX_DRIVES; i++)
 		idescsi_drives[i] = NULL;
-	MOD_INC_USE_COUNT;
-	for (i = 0; media[i] != 255; i++) {
-		failed = 0;
-		while ((drive = ide_scan_devices (media[i], "ide-scsi", NULL, failed++)) != NULL) {
 
-			if ((scsi = (idescsi_scsi_t *) kmalloc (sizeof (idescsi_scsi_t), GFP_KERNEL)) == NULL) {
-				printk (KERN_ERR "ide-scsi: %s: Can't allocate a scsi structure\n", drive->name);
-				continue;
-			}
-			if (ide_register_subdriver (drive, &idescsi_driver)) {
-				printk (KERN_ERR "ide-scsi: %s: Failed to register the driver with ide.c\n", drive->name);
-				kfree (scsi);
-				continue;
-			}
-			for (id = 0; id < MAX_HWIFS * MAX_DRIVES && idescsi_drives[id]; id++);
-				idescsi_setup (drive, scsi, id);
-			failed--;
-		}
+	req = drive->driver_req;
+	if (req[0] != '\0' && strcmp(req, "ide-scsi"))
+		return;
+
+	if ((scsi = (idescsi_scsi_t *) kmalloc (sizeof (idescsi_scsi_t), GFP_KERNEL)) == NULL) {
+		printk(KERN_ERR "ide-scsi: %s: Can't allocate a scsi structure\n", drive->name);
+		return;
 	}
-	revalidate_drives();
-	MOD_DEC_USE_COUNT;
-	return 0;
+	if (ide_register_subdriver (drive, &idescsi_driver)) {
+		printk(KERN_ERR "ide-scsi: %s: Failed to register the driver with ide.c\n", drive->name);
+		kfree (scsi);
+		return;
+	}
+	for (id = 0; id < MAX_HWIFS * MAX_DRIVES && idescsi_drives[id]; id++);
+	idescsi_setup (drive, scsi, id);
+
+	channel = drive->channel;
+	unit = drive - channel->drives;
+
+	ide_revalidate_disk(mk_kdev(channel->major, unit << PARTN_BITS));
 }
 
 int idescsi_detect (Scsi_Host_Template *host_template)
@@ -805,38 +803,31 @@ static Scsi_Host_Template idescsi_template = {
 	emulated:	1,
 };
 
-static int __init init_idescsi_module(void)
+
+static int __init idescsi_init(void)
 {
-	idescsi_init();
+	int ret;
+	ret = ata_driver_module(&idescsi_driver);
 	scsi_register_host(&idescsi_template);
 	return 0;
 }
 
 static void __exit exit_idescsi_module(void)
 {
-	struct ata_device *drive;
-	byte media[] = {TYPE_DISK, TYPE_TAPE, TYPE_PROCESSOR, TYPE_WORM, TYPE_ROM, TYPE_SCANNER, TYPE_MOD, 255};
-	int i, failed;
-
 	scsi_unregister_host(&idescsi_template);
 
-	/* FIXME: The media types scanned here have literally nothing to do
-	 * with the media types used by the overall ATA code!
-	 *
-	 * This is basically showing us, that there is something wrong with the
-	 * ide_scan_devices function.
-	 */
+#if 0
+	/* FIXME: what about this cleanup stuff here? This all should be done
+	 * on close time perhaps? */
 
-	for (i = 0; media[i] != 255; i++) {
-		failed = 0;
-		while ((drive = ide_scan_devices (media[i], "ide-scsi", &idescsi_driver, failed)) != NULL)
-			if (idescsi_cleanup (drive)) {
-				printk ("%s: exit_idescsi_module() called while still busy\n", drive->name);
-				failed++;
-			}
+	if (idescsi_cleanup (drive)) {
+		printk ("%s: exit_idescsi_module() called while still busy\n", drive->name);
 	}
+#endif
+
+	unregister_ata_driver(&idescsi_driver);
 }
 
-module_init(init_idescsi_module);
+module_init(idescsi_init);
 module_exit(exit_idescsi_module);
 MODULE_LICENSE("GPL");

include/linux/ide.h

@@ -317,7 +317,6 @@ typedef union {
 /*
  * ATA/ATAPI device structure :
  */
-typedef
 struct ata_device {
 	struct ata_channel *	channel;
 	char			name[6];	/* device name */
@@ -409,7 +408,7 @@ struct ata_device {
 	unsigned long	immed_comp;
 	int		max_last_depth;
 	int		max_depth;
-} ide_drive_t;
+};
 
 /*
  * Status returned by various functions.
@@ -590,6 +589,7 @@ static inline int ata_can_queue(struct ata_device *drive)
 
 struct ata_operations {
 	struct module *owner;
+	void (*attach) (struct ata_device *);
 	int (*cleanup)(struct ata_device *);
 	int (*standby)(struct ata_device *);
 	ide_startstop_t	(*do_request)(struct ata_device *, struct request *, sector_t);
@@ -602,6 +602,9 @@ struct ata_operations {
 	void (*revalidate)(struct ata_device *);
 
 	sector_t (*capacity)(struct ata_device *);
+
+	/* linked list of rgistered device type drivers */
+	struct ata_operations *next;
 };
 
 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
@@ -618,11 +621,20 @@ do {	\
 
 extern sector_t ata_capacity(struct ata_device *drive);
 
-/* FIXME: Actually implement and use them as soon as possible!  to make the
- * ide_scan_devices() go away! */
-
-extern int unregister_ata_driver(unsigned int type, struct ata_operations *driver);
-extern int register_ata_driver(unsigned int type, struct ata_operations *driver);
+extern void unregister_ata_driver(struct ata_operations *driver);
+extern int register_ata_driver(struct ata_operations *driver);
+static inline int ata_driver_module(struct ata_operations *driver)
+{
+#ifdef MODULE
+	if (register_ata_driver(driver) <= 0) {
+		unregister_ata_driver(driver);
+		return -ENODEV;
+	}
+#else
+	register_ata_driver(driver);
+#endif
+	return 0;
+}
 
 #define ata_ops(drive)		((drive)->driver)
 
@@ -797,9 +809,9 @@ extern int idefloppy_init (void);
 extern int idescsi_init (void);
 #endif
 
-extern struct ata_device *ide_scan_devices(byte, const char *, struct ata_operations *, int);
 extern int ide_register_subdriver(struct ata_device *, struct ata_operations *);
 extern int ide_unregister_subdriver(struct ata_device *drive);
+extern int ide_revalidate_disk(kdev_t i_rdev);
 
 #ifdef CONFIG_PCI
 # define ON_BOARD		0
@@ -890,6 +902,5 @@ extern spinlock_t ide_lock;
 #define DRIVE_LOCK(drive)		((drive)->queue.queue_lock)
 
 extern int drive_is_ready(struct ata_device *drive);
-extern void revalidate_drives(void);
 
 #endif