70 files changed, 1938 insertions, 2369 deletions

diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index e6857e01d1ba..3f9503867e6b 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -62,6 +62,9 @@ config IDE_TIMINGS
 config IDE_ATAPI
         bool
 
+config IDE_LEGACY
+        bool
+
 config BLK_DEV_IDE_SATA
         bool "Support for SATA (deprecated; conflicts with libata SATA driver)"
         default n
@@ -134,6 +137,7 @@ config BLK_DEV_DELKIN
 
 config BLK_DEV_IDECD
         tristate "Include IDE/ATAPI CDROM support"
+        select IDE_ATAPI
         ---help---
           If you have a CD-ROM drive using the ATAPI protocol, say Y. ATAPI is
           a newer protocol used by IDE CD-ROM and TAPE drives, similar to the
@@ -182,23 +186,6 @@ config BLK_DEV_IDETAPE
           To compile this driver as a module, choose M here: the
           module will be called ide-tape.
 
-config BLK_DEV_IDESCSI
-        tristate "SCSI emulation support (DEPRECATED)"
-        depends on SCSI
-        select IDE_ATAPI
-        ---help---
-          WARNING: ide-scsi is no longer needed for cd writing applications!
-          The 2.6 kernel supports direct writing to ide-cd, which eliminates
-          the need for ide-scsi + the entire scsi stack just for writing a
-          cd. The new method is more efficient in every way.
-
-          This will provide SCSI host adapter emulation for IDE ATAPI devices,
-          and will allow you to use a SCSI device driver instead of a native
-          ATAPI driver.
-
-          If both this SCSI emulation and native ATAPI support are compiled
-          into the kernel, the native support will be used.
-
 config BLK_DEV_IDEACPI
         bool "IDE ACPI support"
         depends on ACPI
@@ -524,6 +511,13 @@ config BLK_DEV_PIIX
           This allows the kernel to change PIO, DMA and UDMA speeds and to
           configure the chip to optimum performance.
 
+config BLK_DEV_IT8172
+        tristate "IT8172 IDE support"
+        select BLK_DEV_IDEDMA_PCI
+        help
+          This driver adds support for the IDE controller on the
+          IT8172 System Controller.
+
 config BLK_DEV_IT8213
         tristate "IT8213 IDE support"
         select BLK_DEV_IDEDMA_PCI
@@ -724,7 +718,7 @@ config BLK_DEV_IDE_TX4939
 
 config IDE_ARM
         tristate "ARM IDE support"
-        depends on ARM && (ARCH_CLPS7500 || ARCH_RPC || ARCH_SHARK)
+        depends on ARM && (ARCH_RPC || ARCH_SHARK)
         default y
 
 config BLK_DEV_IDE_ICSIDE
@@ -856,6 +850,7 @@ config BLK_DEV_4DRIVES
 config BLK_DEV_ALI14XX
         tristate "ALI M14xx support"
         select IDE_TIMINGS
+        select IDE_LEGACY
         help
           This driver is enabled at runtime using the "ali14xx.probe" kernel
           boot parameter.  It enables support for the secondary IDE interface
@@ -866,6 +861,7 @@ config BLK_DEV_ALI14XX
 
 config BLK_DEV_DTC2278
         tristate "DTC-2278 support"
+        select IDE_LEGACY
         help
           This driver is enabled at runtime using the "dtc2278.probe" kernel
           boot parameter. It enables support for the secondary IDE interface
@@ -876,6 +872,7 @@ config BLK_DEV_DTC2278
 config BLK_DEV_HT6560B
         tristate "Holtek HT6560B support"
         select IDE_TIMINGS
+        select IDE_LEGACY
         help
           This driver is enabled at runtime using the "ht6560b.probe" kernel
           boot parameter. It enables support for the secondary IDE interface
@@ -886,6 +883,7 @@ config BLK_DEV_HT6560B
 config BLK_DEV_QD65XX
         tristate "QDI QD65xx support"
         select IDE_TIMINGS
+        select IDE_LEGACY
         help
           This driver is enabled at runtime using the "qd65xx.probe" kernel
           boot parameter.  It permits faster I/O speeds to be set.  See the
@@ -894,6 +892,7 @@ config BLK_DEV_QD65XX
 
 config BLK_DEV_UMC8672
         tristate "UMC-8672 support"
+        select IDE_LEGACY
         help
           This driver is enabled at runtime using the "umc8672.probe" kernel
           boot parameter. It enables support for the secondary IDE interface
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile
index 7818d402b188..c2b9c93f0095 100644
--- a/drivers/ide/Makefile
+++ b/drivers/ide/Makefile
@@ -5,7 +5,7 @@
 EXTRA_CFLAGS                            += -Idrivers/ide
 
 ide-core-y += ide.o ide-ioctls.o ide-io.o ide-iops.o ide-lib.o ide-probe.o \
-              ide-taskfile.o ide-park.o ide-pio-blacklist.o
+              ide-taskfile.o ide-pm.o ide-park.o ide-pio-blacklist.o ide-sysfs.o
 
 # core IDE code
 ide-core-$(CONFIG_IDE_TIMINGS)          += ide-timings.o
@@ -15,6 +15,7 @@ ide-core-$(CONFIG_BLK_DEV_IDEDMA)	+= ide-dma.o
 ide-core-$(CONFIG_BLK_DEV_IDEDMA_SFF)   += ide-dma-sff.o
 ide-core-$(CONFIG_IDE_PROC_FS)          += ide-proc.o
 ide-core-$(CONFIG_BLK_DEV_IDEACPI)      += ide-acpi.o
+ide-core-$(CONFIG_IDE_LEGACY)           += ide-legacy.o
 
 obj-$(CONFIG_IDE)                       += ide-core.o
 
@@ -46,6 +47,7 @@ obj-$(CONFIG_BLK_DEV_SC1200)		+= sc1200.o
 obj-$(CONFIG_BLK_DEV_CY82C693)          += cy82c693.o
 obj-$(CONFIG_BLK_DEV_DELKIN)            += delkin_cb.o
 obj-$(CONFIG_BLK_DEV_HPT366)            += hpt366.o
+obj-$(CONFIG_BLK_DEV_IT8172)            += it8172.o
 obj-$(CONFIG_BLK_DEV_IT8213)            += it8213.o
 obj-$(CONFIG_BLK_DEV_IT821X)            += it821x.o
 obj-$(CONFIG_BLK_DEV_JMICRON)           += jmicron.o
diff --git a/drivers/ide/aec62xx.c b/drivers/ide/aec62xx.c
index 4142c698e0d3..4485b9c6f0e6 100644
--- a/drivers/ide/aec62xx.c
+++ b/drivers/ide/aec62xx.c
@@ -83,7 +83,7 @@ static u8 pci_bus_clock_list_ultra (u8 speed, struct chipset_bus_clock_list_entr
 
 static void aec6210_set_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         struct ide_host *host   = pci_get_drvdata(dev);
         struct chipset_bus_clock_list_entry *bus_clock = host->host_priv;
@@ -111,7 +111,7 @@ static void aec6210_set_mode(ide_drive_t *drive, const u8 speed)
 
 static void aec6260_set_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         struct ide_host *host   = pci_get_drvdata(dev);
         struct chipset_bus_clock_list_entry *bus_clock = host->host_priv;
diff --git a/drivers/ide/alim15x3.c b/drivers/ide/alim15x3.c
index 45d2356bb725..66f43083408b 100644
--- a/drivers/ide/alim15x3.c
+++ b/drivers/ide/alim15x3.c
@@ -68,7 +68,7 @@ static struct pci_dev *isa_dev;
 
 static void ali_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         struct ide_timing *t = ide_timing_find_mode(XFER_PIO_0 + pio);
         int s_time = t->setup, a_time = t->active, c_time = t->cycle;
@@ -150,7 +150,7 @@ static u8 ali_udma_filter(ide_drive_t *drive)
 
 static void ali_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 speed1               = speed;
         u8 unit                 = drive->dn & 1;
@@ -198,7 +198,7 @@ static void ali_set_dma_mode(ide_drive_t *drive, const u8 speed)
 static int ali15x3_dma_setup(ide_drive_t *drive)
 {
         if (m5229_revision < 0xC2 && drive->media != ide_disk) {
-                if (rq_data_dir(drive->hwif->hwgroup->rq))
+                if (rq_data_dir(drive->hwif->rq))
                         return 1;       /* try PIO instead of DMA */
         }
         return ide_dma_setup(drive);
@@ -490,8 +490,6 @@ static int __devinit init_dma_ali15x3(ide_hwif_t *hwif,
         if (ide_allocate_dma_engine(hwif))
                 return -1;
 
-        hwif->dma_ops = &sff_dma_ops;
-
         return 0;
 }
 
@@ -511,6 +509,7 @@ static const struct ide_dma_ops ali_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info ali15x3_chipset __devinitdata = {
@@ -519,6 +518,7 @@ static const struct ide_port_info ali15x3_chipset __devinitdata = {
         .init_hwif      = init_hwif_ali15x3,
         .init_dma       = init_dma_ali15x3,
         .port_ops       = &ali_port_ops,
+        .dma_ops        = &sff_dma_ops,
         .pio_mask       = ATA_PIO5,
         .swdma_mask     = ATA_SWDMA2,
         .mwdma_mask     = ATA_MWDMA2,
diff --git a/drivers/ide/amd74xx.c b/drivers/ide/amd74xx.c
index c6bcd3014a29..69660a431cd9 100644
--- a/drivers/ide/amd74xx.c
+++ b/drivers/ide/amd74xx.c
@@ -82,7 +82,7 @@ static void amd_set_drive(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
-        ide_drive_t *peer = hwif->drives + (~drive->dn & 1);
+        ide_drive_t *peer = ide_get_pair_dev(drive);
         struct ide_timing t, p;
         int T, UT;
         u8 udma_mask = hwif->ultra_mask;
@@ -92,7 +92,7 @@ static void amd_set_drive(ide_drive_t *drive, const u8 speed)
 
         ide_timing_compute(drive, speed, &t, T, UT);
 
-        if (peer->dev_flags & IDE_DFLAG_PRESENT) {
+        if (peer) {
                 ide_timing_compute(peer, peer->current_speed, &p, T, UT);
                 ide_timing_merge(&p, &t, &t, IDE_TIMING_8BIT);
         }
diff --git a/drivers/ide/au1xxx-ide.c b/drivers/ide/au1xxx-ide.c
index 0ec8fd1e4dcb..79a2dfed8eb7 100644
--- a/drivers/ide/au1xxx-ide.c
+++ b/drivers/ide/au1xxx-ide.c
@@ -212,8 +212,8 @@ static void auide_set_dma_mode(ide_drive_t *drive, const u8 speed)
 static int auide_build_dmatable(ide_drive_t *drive)
 {
         int i, iswrite, count = 0;
-        ide_hwif_t *hwif = HWIF(drive);
-        struct request *rq = HWGROUP(drive)->rq;
+        ide_hwif_t *hwif = drive->hwif;
+        struct request *rq = hwif->rq;
         _auide_hwif *ahwif = &auide_hwif;
         struct scatterlist *sg;
 
@@ -286,7 +286,7 @@ static int auide_build_dmatable(ide_drive_t *drive)
 
 static int auide_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
 
         if (hwif->sg_nents) {
                 ide_destroy_dmatable(drive);
@@ -309,8 +309,8 @@ static void auide_dma_exec_cmd(ide_drive_t *drive, u8 command)
 }
 
 static int auide_dma_setup(ide_drive_t *drive)
-{               
-        struct request *rq = HWGROUP(drive)->rq;
+{
+        struct request *rq = drive->hwif->rq;
 
         if (!auide_build_dmatable(drive)) {
                 ide_map_sg(drive, rq);
@@ -502,7 +502,6 @@ static const struct ide_tp_ops au1xxx_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
diff --git a/drivers/ide/cmd640.c b/drivers/ide/cmd640.c
index e4306647d00d..8890276fef7f 100644
--- a/drivers/ide/cmd640.c
+++ b/drivers/ide/cmd640.c
@@ -467,11 +467,10 @@ static void program_drive_counts(ide_drive_t *drive, unsigned int index)
          * so we merge the timings, using the slowest value for each timing.
          */
         if (index > 1) {
-                ide_hwif_t *hwif = drive->hwif;
-                ide_drive_t *peer = &hwif->drives[!(drive->dn & 1)];
+                ide_drive_t *peer = ide_get_pair_dev(drive);
                 unsigned int mate = index ^ 1;
 
-                if (peer->dev_flags & IDE_DFLAG_PRESENT) {
+                if (peer) {
                         if (setup_count < setup_counts[mate])
                                 setup_count = setup_counts[mate];
                         if (active_count < active_counts[mate])
diff --git a/drivers/ide/cmd64x.c b/drivers/ide/cmd64x.c
index 935385c77e06..2f9688d87ecd 100644
--- a/drivers/ide/cmd64x.c
+++ b/drivers/ide/cmd64x.c
@@ -115,7 +115,7 @@ static void program_cycle_times (ide_drive_t *drive, int cycle_time, int active_
  */
 static void cmd64x_tune_pio(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         struct ide_timing *t    = ide_timing_find_mode(XFER_PIO_0 + pio);
         unsigned int cycle_time;
@@ -138,10 +138,12 @@ static void cmd64x_tune_pio(ide_drive_t *drive, const u8 pio)
          * the slowest address setup timing ourselves.
          */
         if (hwif->channel) {
-                ide_drive_t *drives = hwif->drives;
+                ide_drive_t *pair = ide_get_pair_dev(drive);
 
                 drive->drive_data = setup_count;
-                setup_count = max(drives[0].drive_data, drives[1].drive_data);
+
+                if (pair)
+                        setup_count = max_t(u8, setup_count, pair->drive_data);
         }
 
         if (setup_count > 5)            /* shouldn't actually happen... */
@@ -180,7 +182,7 @@ static void cmd64x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 static void cmd64x_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 unit                 = drive->dn & 0x01;
         u8 regU = 0, pciU       = hwif->channel ? UDIDETCR1 : UDIDETCR0;
@@ -226,7 +228,7 @@ static void cmd64x_set_dma_mode(ide_drive_t *drive, const u8 speed)
 
 static int cmd648_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long base      = hwif->dma_base - (hwif->channel * 8);
         int err                 = ide_dma_end(drive);
         u8  irq_mask            = hwif->channel ? MRDMODE_INTR_CH1 :
@@ -242,7 +244,7 @@ static int cmd648_dma_end(ide_drive_t *drive)
 
 static int cmd64x_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int irq_reg             = hwif->channel ? ARTTIM23 : CFR;
         u8  irq_mask            = hwif->channel ? ARTTIM23_INTR_CH1 :
@@ -259,7 +261,7 @@ static int cmd64x_dma_end(ide_drive_t *drive)
 
 static int cmd648_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long base      = hwif->dma_base - (hwif->channel * 8);
         u8 irq_mask             = hwif->channel ? MRDMODE_INTR_CH1 :
                                                   MRDMODE_INTR_CH0;
@@ -282,7 +284,7 @@ static int cmd648_dma_test_irq(ide_drive_t *drive)
 
 static int cmd64x_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int irq_reg             = hwif->channel ? ARTTIM23 : CFR;
         u8  irq_mask            = hwif->channel ? ARTTIM23_INTR_CH1 :
@@ -313,7 +315,7 @@ static int cmd64x_dma_test_irq(ide_drive_t *drive)
 
 static int cmd646_1_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         u8 dma_stat = 0, dma_cmd = 0;
 
         drive->waiting_for_dma = 0;
@@ -383,6 +385,7 @@ static const struct ide_dma_ops cmd64x_dma_ops = {
         .dma_test_irq           = cmd64x_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_dma_ops cmd646_rev1_dma_ops = {
@@ -394,6 +397,7 @@ static const struct ide_dma_ops cmd646_rev1_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_dma_ops cmd648_dma_ops = {
@@ -405,6 +409,7 @@ static const struct ide_dma_ops cmd648_dma_ops = {
         .dma_test_irq           = cmd648_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
@@ -424,10 +429,10 @@ static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
                 .name           = DRV_NAME,
                 .init_chipset   = init_chipset_cmd64x,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
-                .chipset        = ide_cmd646,
                 .port_ops       = &cmd64x_port_ops,
                 .dma_ops        = &cmd648_dma_ops,
-                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
+                .host_flags     = IDE_HFLAG_SERIALIZE |
+                                  IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA2,
diff --git a/drivers/ide/cs5520.c b/drivers/ide/cs5520.c
index 5efb467f8fa0..d003bec56ff9 100644
--- a/drivers/ide/cs5520.c
+++ b/drivers/ide/cs5520.c
@@ -59,7 +59,7 @@ static struct pio_clocks cs5520_pio_clocks[]={
 
 static void cs5520_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *pdev = to_pci_dev(hwif->dev);
         int controller = drive->dn > 1 ? 1 : 0;
 
diff --git a/drivers/ide/cy82c693.c b/drivers/ide/cy82c693.c
index 5297f07d2933..74fc5401f407 100644
--- a/drivers/ide/cy82c693.c
+++ b/drivers/ide/cy82c693.c
@@ -203,7 +203,7 @@ static void cy82c693_set_dma_mode(ide_drive_t *drive, const u8 mode)
 
 static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         pio_clocks_t pclk;
         unsigned int addrCtrl;
@@ -292,7 +292,6 @@ static const struct ide_port_info cy82c693_chipset __devinitdata = {
         .name           = DRV_NAME,
         .init_iops      = init_iops_cy82c693,
         .port_ops       = &cy82c693_port_ops,
-        .chipset        = ide_cy82c693,
         .host_flags     = IDE_HFLAG_SINGLE,
         .pio_mask       = ATA_PIO4,
         .swdma_mask     = ATA_SWDMA2,
diff --git a/drivers/ide/falconide.c b/drivers/ide/falconide.c
index 39d500d84b07..a5ba820d69bb 100644
--- a/drivers/ide/falconide.c
+++ b/drivers/ide/falconide.c
@@ -70,7 +70,6 @@ static const struct ide_tp_ops falconide_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
diff --git a/drivers/ide/gayle.c b/drivers/ide/gayle.c
index 691506886561..59bd0be9dcb3 100644
--- a/drivers/ide/gayle.c
+++ b/drivers/ide/gayle.c
@@ -117,6 +117,10 @@ static void __init gayle_setup_ports(hw_regs_t *hw, unsigned long base,
         hw->chipset = ide_generic;
 }
 
+static const struct ide_port_info gayle_port_info = {
+        .host_flags             = IDE_HFLAG_SERIALIZE | IDE_HFLAG_NO_DMA,
+};
+
     /*
      *  Probe for a Gayle IDE interface (and optionally for an IDE doubler)
      */
@@ -178,7 +182,7 @@ found:
         hws[i] = &hw[i];
     }
 
-    rc = ide_host_add(NULL, hws, NULL);
+    rc = ide_host_add(&gayle_port_info, hws, NULL);
     if (rc)
         release_mem_region(res_start, res_n);
 
diff --git a/drivers/ide/hpt366.c b/drivers/ide/hpt366.c
index f5afd46ed51c..3eb9b5c63a0f 100644
--- a/drivers/ide/hpt366.c
+++ b/drivers/ide/hpt366.c
@@ -135,7 +135,6 @@
 /* various tuning parameters */
 #define HPT_RESET_STATE_ENGINE
 #undef  HPT_DELAY_INTERRUPT
-#define HPT_SERIALIZE_IO        0
 
 static const char *quirk_drives[] = {
         "QUANTUM FIREBALLlct08 08",
@@ -627,7 +626,7 @@ static struct hpt_info *hpt3xx_get_info(struct device *dev)
 
 static u8 hpt3xx_udma_filter(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
         u8 mask                 = hwif->ultra_mask;
 
@@ -666,7 +665,7 @@ static u8 hpt3xx_udma_filter(ide_drive_t *drive)
 
 static u8 hpt3xx_mdma_filter(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
 
         switch (info->chip_type) {
@@ -744,7 +743,7 @@ static void hpt3xx_quirkproc(ide_drive_t *drive)
 
 static void hpt3xx_maskproc(ide_drive_t *drive, int mask)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev  *dev    = to_pci_dev(hwif->dev);
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
 
@@ -789,7 +788,7 @@ static void hpt366_dma_lost_irq(ide_drive_t *drive)
 
 static void hpt370_clear_engine(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
 
         pci_write_config_byte(dev, hwif->select_data, 0x37);
@@ -798,7 +797,7 @@ static void hpt370_clear_engine(ide_drive_t *drive)
 
 static void hpt370_irq_timeout(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u16 bfifo               = 0;
         u8  dma_cmd;
@@ -823,7 +822,7 @@ static void hpt370_dma_start(ide_drive_t *drive)
 
 static int hpt370_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         u8  dma_stat            = inb(hwif->dma_base + ATA_DMA_STATUS);
 
         if (dma_stat & 0x01) {
@@ -845,7 +844,7 @@ static void hpt370_dma_timeout(ide_drive_t *drive)
 /* returns 1 if DMA IRQ issued, 0 otherwise */
 static int hpt374_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u16 bfifo               = 0;
         u8  dma_stat;
@@ -866,7 +865,7 @@ static int hpt374_dma_test_irq(ide_drive_t *drive)
 
 static int hpt374_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 mcr  = 0, mcr_addr   = hwif->select_data;
         u8 bwsr = 0, mask       = hwif->channel ? 0x02 : 0x01;
@@ -928,7 +927,7 @@ static void hpt3xxn_set_clock(ide_hwif_t *hwif, u8 mode)
 
 static void hpt3xxn_rw_disk(ide_drive_t *drive, struct request *rq)
 {
-        hpt3xxn_set_clock(HWIF(drive), rq_data_dir(rq) ? 0x23 : 0x21);
+        hpt3xxn_set_clock(drive->hwif, rq_data_dir(rq) ? 0x23 : 0x21);
 }
 
 /**
@@ -1288,7 +1287,6 @@ static u8 hpt3xx_cable_detect(ide_hwif_t *hwif)
 static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
 {
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
-        int serialize           = HPT_SERIALIZE_IO;
         u8  chip_type           = info->chip_type;
 
         /* Cache the channel's MISC. control registers' offset */
@@ -1305,13 +1303,9 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
                  * Clock is shared between the channels,
                  * so we'll have to serialize them... :-(
                  */
-                serialize = 1;
+                hwif->host->host_flags |= IDE_HFLAG_SERIALIZE;
                 hwif->rw_disk = &hpt3xxn_rw_disk;
         }
-
-        /* Serialize access to this device if needed */
-        if (serialize && hwif->mate)
-                hwif->serialized = hwif->mate->serialized = 1;
 }
 
 static int __devinit init_dma_hpt366(ide_hwif_t *hwif,
@@ -1355,8 +1349,6 @@ static int __devinit init_dma_hpt366(ide_hwif_t *hwif,
         if (ide_allocate_dma_engine(hwif))
                 return -1;
 
-        hwif->dma_ops = &sff_dma_ops;
-
         return 0;
 }
 
@@ -1432,6 +1424,7 @@ static const struct ide_dma_ops hpt37x_dma_ops = {
         .dma_test_irq           = hpt374_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_dma_ops hpt370_dma_ops = {
@@ -1443,6 +1436,7 @@ static const struct ide_dma_ops hpt370_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = hpt370_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_dma_ops hpt36x_dma_ops = {
@@ -1454,6 +1448,7 @@ static const struct ide_dma_ops hpt36x_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = hpt366_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
diff --git a/drivers/ide/icside.c b/drivers/ide/icside.c
index 81f70caeb40f..97a35c667aee 100644
--- a/drivers/ide/icside.c
+++ b/drivers/ide/icside.c
@@ -166,7 +166,7 @@ static const expansioncard_ops_t icside_ops_arcin_v6 = {
  */
 static void icside_maskproc(ide_drive_t *drive, int mask)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct expansion_card *ec = ECARD_DEV(hwif->dev);
         struct icside_state *state = ecard_get_drvdata(ec);
         unsigned long flags;
@@ -284,7 +284,7 @@ static void icside_dma_host_set(ide_drive_t *drive, int on)
 
 static int icside_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct expansion_card *ec = ECARD_DEV(hwif->dev);
 
         drive->waiting_for_dma = 0;
@@ -299,7 +299,7 @@ static int icside_dma_end(ide_drive_t *drive)
 
 static void icside_dma_start(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct expansion_card *ec = ECARD_DEV(hwif->dev);
 
         /* We can not enable DMA on both channels simultaneously. */
@@ -309,10 +309,10 @@ static void icside_dma_start(ide_drive_t *drive)
 
 static int icside_dma_setup(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct expansion_card *ec = ECARD_DEV(hwif->dev);
         struct icside_state *state = ecard_get_drvdata(ec);
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         unsigned int dma_mode;
 
         if (rq_data_dir(rq))
@@ -362,7 +362,7 @@ static void icside_dma_exec_cmd(ide_drive_t *drive, u8 cmd)
 
 static int icside_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct expansion_card *ec = ECARD_DEV(hwif->dev);
         struct icside_state *state = ecard_get_drvdata(ec);
 
diff --git a/drivers/ide/ide-acpi.c b/drivers/ide/ide-acpi.c
index 9e8d52a4f306..d8f295bdad76 100644
--- a/drivers/ide/ide-acpi.c
+++ b/drivers/ide/ide-acpi.c
@@ -212,7 +212,7 @@ static acpi_handle ide_acpi_hwif_get_handle(ide_hwif_t *hwif)
  */
 static acpi_handle ide_acpi_drive_get_handle(ide_drive_t *drive)
 {
-        ide_hwif_t      *hwif = HWIF(drive);
+        ide_hwif_t      *hwif = drive->hwif;
         int              port;
         acpi_handle      drive_handle;
 
@@ -257,7 +257,7 @@ static int do_drive_get_GTF(ide_drive_t *drive,
         acpi_status                     status;
         struct acpi_buffer              output;
         union acpi_object               *out_obj;
-        ide_hwif_t                      *hwif = HWIF(drive);
+        ide_hwif_t                      *hwif = drive->hwif;
         struct device                   *dev = hwif->gendev.parent;
         int                             err = -ENODEV;
         int                             port;
@@ -609,10 +609,10 @@ void ide_acpi_push_timing(ide_hwif_t *hwif)
         in_params[0].buffer.length = sizeof(struct GTM_buffer);
         in_params[0].buffer.pointer = (u8 *)&hwif->acpidata->gtm;
         in_params[1].type = ACPI_TYPE_BUFFER;
-        in_params[1].buffer.length = sizeof(ATA_ID_WORDS * 2);
+        in_params[1].buffer.length = ATA_ID_WORDS * 2;
         in_params[1].buffer.pointer = (u8 *)&master->idbuff;
         in_params[2].type = ACPI_TYPE_BUFFER;
-        in_params[2].buffer.length = sizeof(ATA_ID_WORDS * 2);
+        in_params[2].buffer.length = ATA_ID_WORDS * 2;
         in_params[2].buffer.pointer = (u8 *)&slave->idbuff;
         /* Output buffer: _STM has no output */
 
@@ -635,7 +635,8 @@ void ide_acpi_push_timing(ide_hwif_t *hwif)
  */
 void ide_acpi_set_state(ide_hwif_t *hwif, int on)
 {
-        int unit;
+        ide_drive_t *drive;
+        int i;
 
         if (ide_noacpi || ide_noacpi_psx)
                 return;
@@ -649,9 +650,8 @@ void ide_acpi_set_state(ide_hwif_t *hwif, int on)
         /* channel first and then drives for power on and verse versa for power off */
         if (on)
                 acpi_bus_set_power(hwif->acpidata->obj_handle, ACPI_STATE_D0);
-        for (unit = 0; unit < MAX_DRIVES; ++unit) {
-                ide_drive_t *drive = &hwif->drives[unit];
 
+        ide_port_for_each_dev(i, drive, hwif) {
                 if (!drive->acpidata->obj_handle)
                         drive->acpidata->obj_handle = ide_acpi_drive_get_handle(drive);
 
@@ -705,15 +705,13 @@ void ide_acpi_port_init_devices(ide_hwif_t *hwif)
          * for both drives, regardless whether they are connected
          * or not.
          */
-        hwif->drives[0].acpidata = &hwif->acpidata->master;
-        hwif->drives[1].acpidata = &hwif->acpidata->slave;
+        hwif->devices[0]->acpidata = &hwif->acpidata->master;
+        hwif->devices[1]->acpidata = &hwif->acpidata->slave;
 
         /*
          * Send IDENTIFY for each drive
          */
-        for (i = 0; i < MAX_DRIVES; i++) {
-                drive = &hwif->drives[i];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 memset(drive->acpidata, 0, sizeof(*drive->acpidata));
 
                 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
@@ -738,9 +736,7 @@ void ide_acpi_port_init_devices(ide_hwif_t *hwif)
         ide_acpi_get_timing(hwif);
         ide_acpi_push_timing(hwif);
 
-        for (i = 0; i < MAX_DRIVES; i++) {
-                drive = &hwif->drives[i];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 if (drive->dev_flags & IDE_DFLAG_PRESENT)
                         /* Execute ACPI startup code */
                         ide_acpi_exec_tfs(drive);
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 4e58b9e7a58a..e96c01260598 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -3,6 +3,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/cdrom.h>
 #include <linux/delay.h>
 #include <linux/ide.h>
 #include <scsi/scsi.h>
@@ -14,6 +15,13 @@
 #define debug_log(fmt, args...) do {} while (0)
 #endif
 
+#define ATAPI_MIN_CDB_BYTES     12
+
+static inline int dev_is_idecd(ide_drive_t *drive)
+{
+        return drive->media == ide_cdrom || drive->media == ide_optical;
+}
+
 /*
  * Check whether we can support a device,
  * based on the ATAPI IDENTIFY command results.
@@ -233,18 +241,49 @@ void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk)
 }
 EXPORT_SYMBOL_GPL(ide_retry_pc);
 
-int ide_scsi_expiry(ide_drive_t *drive)
+int ide_cd_expiry(ide_drive_t *drive)
 {
-        struct ide_atapi_pc *pc = drive->pc;
+        struct request *rq = drive->hwif->rq;
+        unsigned long wait = 0;
 
-        debug_log("%s called for %lu at %lu\n", __func__,
-                  pc->scsi_cmd->serial_number, jiffies);
+        debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]);
 
-        pc->flags |= PC_FLAG_TIMEDOUT;
+        /*
+         * Some commands are *slow* and normally take a long time to complete.
+         * Usually we can use the ATAPI "disconnect" to bypass this, but not all
+         * commands/drives support that. Let ide_timer_expiry keep polling us
+         * for these.
+         */
+        switch (rq->cmd[0]) {
+        case GPCMD_BLANK:
+        case GPCMD_FORMAT_UNIT:
+        case GPCMD_RESERVE_RZONE_TRACK:
+        case GPCMD_CLOSE_TRACK:
+        case GPCMD_FLUSH_CACHE:
+                wait = ATAPI_WAIT_PC;
+                break;
+        default:
+                if (!(rq->cmd_flags & REQ_QUIET))
+                        printk(KERN_INFO "cmd 0x%x timed out\n",
+                                         rq->cmd[0]);
+                wait = 0;
+                break;
+        }
+        return wait;
+}
+EXPORT_SYMBOL_GPL(ide_cd_expiry);
 
-        return 0; /* we do not want the IDE subsystem to retry */
+int ide_cd_get_xferlen(struct request *rq)
+{
+        if (blk_fs_request(rq))
+                return 32768;
+        else if (blk_sense_request(rq) || blk_pc_request(rq) ||
+                         rq->cmd_type == REQ_TYPE_ATA_PC)
+                return rq->data_len;
+        else
+                return 0;
 }
-EXPORT_SYMBOL_GPL(ide_scsi_expiry);
+EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
 
 /*
  * This is the usual interrupt handler which will be called during a packet
@@ -255,24 +294,17 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
 {
         struct ide_atapi_pc *pc = drive->pc;
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         xfer_func_t *xferfunc;
-        ide_expiry_t *expiry;
         unsigned int timeout, temp;
         u16 bcount;
-        u8 stat, ireason, scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI), dsc = 0;
+        u8 stat, ireason, dsc = 0;
 
         debug_log("Enter %s - interrupt handler\n", __func__);
 
-        if (scsi) {
-                timeout = ide_scsi_get_timeout(pc);
-                expiry = ide_scsi_expiry;
-        } else {
-                timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
-                                                       : WAIT_TAPE_CMD;
-                expiry = NULL;
-        }
+        timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
+                                               : WAIT_TAPE_CMD;
 
         if (pc->flags & PC_FLAG_TIMEDOUT) {
                 drive->pc_callback(drive, 0);
@@ -284,8 +316,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
 
         if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
                 if (hwif->dma_ops->dma_end(drive) ||
-                    (drive->media == ide_tape && !scsi && (stat & ATA_ERR))) {
-                        if (drive->media == ide_floppy && !scsi)
+                    (drive->media == ide_tape && (stat & ATA_ERR))) {
+                        if (drive->media == ide_floppy)
                                 printk(KERN_ERR "%s: DMA %s error\n",
                                         drive->name, rq_data_dir(pc->rq)
                                                      ? "write" : "read");
@@ -307,7 +339,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
 
                 local_irq_enable_in_hardirq();
 
-                if (drive->media == ide_tape && !scsi &&
+                if (drive->media == ide_tape &&
                     (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
                         stat &= ~ATA_ERR;
 
@@ -315,11 +347,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                         /* Error detected */
                         debug_log("%s: I/O error\n", drive->name);
 
-                        if (drive->media != ide_tape || scsi) {
+                        if (drive->media != ide_tape)
                                 pc->rq->errors++;
-                                if (scsi)
-                                        goto cmd_finished;
-                        }
 
                         if (rq->cmd[0] == REQUEST_SENSE) {
                                 printk(KERN_ERR "%s: I/O error in request sense"
@@ -335,7 +364,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                         /* queued, but not started */
                         return ide_stopped;
                 }
-cmd_finished:
                 pc->error = 0;
 
                 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
@@ -382,25 +410,8 @@ cmd_finished:
                                                 "us more data than expected - "
                                                 "discarding data\n",
                                                 drive->name);
-                                if (scsi)
-                                        temp = pc->buf_size - pc->xferred;
-                                else
-                                        temp = 0;
-                                if (temp) {
-                                        if (pc->sg)
-                                                drive->pc_io_buffers(drive, pc,
-                                                                     temp, 0);
-                                        else
-                                                tp_ops->input_data(drive, NULL,
-                                                        pc->cur_pos, temp);
-                                        printk(KERN_ERR "%s: transferred %d of "
-                                                        "%d bytes\n",
-                                                        drive->name,
-                                                        temp, bcount);
-                                }
-                                pc->xferred += temp;
-                                pc->cur_pos += temp;
-                                ide_pad_transfer(drive, 0, bcount - temp);
+
+                                ide_pad_transfer(drive, 0, bcount);
                                 goto next_irq;
                         }
                         debug_log("The device wants to send us more data than "
@@ -410,14 +421,13 @@ cmd_finished:
         } else
                 xferfunc = tp_ops->output_data;
 
-        if ((drive->media == ide_floppy && !scsi && !pc->buf) ||
-            (drive->media == ide_tape && !scsi && pc->bh) ||
-            (scsi && pc->sg)) {
+        if ((drive->media == ide_floppy && !pc->buf) ||
+            (drive->media == ide_tape && pc->bh)) {
                 int done = drive->pc_io_buffers(drive, pc, bcount,
                                   !!(pc->flags & PC_FLAG_WRITING));
 
                 /* FIXME: don't do partial completions */
-                if (drive->media == ide_floppy && !scsi)
+                if (drive->media == ide_floppy)
                         ide_end_request(drive, 1, done >> 9);
         } else
                 xferfunc(drive, NULL, pc->cur_pos, bcount);
@@ -430,7 +440,7 @@ cmd_finished:
                   rq->cmd[0], bcount);
 next_irq:
         /* And set the interrupt handler again */
-        ide_set_handler(drive, ide_pc_intr, timeout, expiry);
+        ide_set_handler(drive, ide_pc_intr, timeout, NULL);
         return ide_started;
 }
 
@@ -479,11 +489,12 @@ static int ide_delayed_transfer_pc(ide_drive_t *drive)
 
 static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
 {
-        struct ide_atapi_pc *pc = drive->pc;
+        struct ide_atapi_pc *uninitialized_var(pc);
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         ide_expiry_t *expiry;
         unsigned int timeout;
+        int cmd_len;
         ide_startstop_t startstop;
         u8 ireason;
 
@@ -493,101 +504,127 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
                 return startstop;
         }
 
-        ireason = ide_read_ireason(drive);
-        if (drive->media == ide_tape &&
-            (drive->dev_flags & IDE_DFLAG_SCSI) == 0)
-                ireason = ide_wait_ireason(drive, ireason);
-
-        if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
-                printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
-                                "a packet command\n", drive->name);
-                return ide_do_reset(drive);
+        if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
+                if (drive->dma)
+                        drive->waiting_for_dma = 1;
         }
 
-        /*
-         * If necessary schedule the packet transfer to occur 'timeout'
-         * miliseconds later in ide_delayed_transfer_pc() after the device
-         * says it's ready for a packet.
-         */
-        if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
-                timeout = drive->pc_delay;
-                expiry = &ide_delayed_transfer_pc;
+        if (dev_is_idecd(drive)) {
+                /* ATAPI commands get padded out to 12 bytes minimum */
+                cmd_len = COMMAND_SIZE(rq->cmd[0]);
+                if (cmd_len < ATAPI_MIN_CDB_BYTES)
+                        cmd_len = ATAPI_MIN_CDB_BYTES;
+
+                timeout = rq->timeout;
+                expiry  = ide_cd_expiry;
         } else {
-                if (drive->dev_flags & IDE_DFLAG_SCSI) {
-                        timeout = ide_scsi_get_timeout(pc);
-                        expiry = ide_scsi_expiry;
+                pc = drive->pc;
+
+                cmd_len = ATAPI_MIN_CDB_BYTES;
+
+                /*
+                 * If necessary schedule the packet transfer to occur 'timeout'
+                 * miliseconds later in ide_delayed_transfer_pc() after the
+                 * device says it's ready for a packet.
+                 */
+                if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
+                        timeout = drive->pc_delay;
+                        expiry = &ide_delayed_transfer_pc;
                 } else {
                         timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
                                                                : WAIT_TAPE_CMD;
                         expiry = NULL;
                 }
+
+                ireason = ide_read_ireason(drive);
+                if (drive->media == ide_tape)
+                        ireason = ide_wait_ireason(drive, ireason);
+
+                if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
+                        printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
+                                        "a packet command\n", drive->name);
+
+                        return ide_do_reset(drive);
+                }
         }
 
         /* Set the interrupt routine */
-        ide_set_handler(drive, ide_pc_intr, timeout, expiry);
+        ide_set_handler(drive,
+                        (dev_is_idecd(drive) ? drive->irq_handler
+                                             : ide_pc_intr),
+                        timeout, expiry);
 
         /* Begin DMA, if necessary */
-        if (pc->flags & PC_FLAG_DMA_OK) {
-                pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
-                hwif->dma_ops->dma_start(drive);
+        if (dev_is_idecd(drive)) {
+                if (drive->dma)
+                        hwif->dma_ops->dma_start(drive);
+        } else {
+                if (pc->flags & PC_FLAG_DMA_OK) {
+                        pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
+                        hwif->dma_ops->dma_start(drive);
+                }
         }
 
         /* Send the actual packet */
         if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
-                hwif->tp_ops->output_data(drive, NULL, rq->cmd, 12);
+                hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
 
         return ide_started;
 }
 
-ide_startstop_t ide_issue_pc(ide_drive_t *drive, unsigned int timeout,
-                             ide_expiry_t *expiry)
+ide_startstop_t ide_issue_pc(ide_drive_t *drive)
 {
-        struct ide_atapi_pc *pc = drive->pc;
+        struct ide_atapi_pc *pc;
         ide_hwif_t *hwif = drive->hwif;
+        ide_expiry_t *expiry = NULL;
+        unsigned int timeout;
         u32 tf_flags;
         u16 bcount;
-        u8 scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI);
 
-        /* We haven't transferred any data yet */
-        pc->xferred = 0;
-        pc->cur_pos = pc->buf;
+        if (dev_is_idecd(drive)) {
+                tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;
+                bcount = ide_cd_get_xferlen(hwif->rq);
+                expiry = ide_cd_expiry;
+                timeout = ATAPI_WAIT_PC;
 
-        /* Request to transfer the entire buffer at once */
-        if (drive->media == ide_tape && scsi == 0)
-                bcount = pc->req_xfer;
-        else
-                bcount = min(pc->req_xfer, 63 * 1024);
+                if (drive->dma)
+                        drive->dma = !hwif->dma_ops->dma_setup(drive);
+        } else {
+                pc = drive->pc;
 
-        if (pc->flags & PC_FLAG_DMA_ERROR) {
-                pc->flags &= ~PC_FLAG_DMA_ERROR;
-                ide_dma_off(drive);
-        }
+                /* We haven't transferred any data yet */
+                pc->xferred = 0;
+                pc->cur_pos = pc->buf;
 
-        if ((pc->flags & PC_FLAG_DMA_OK) &&
-            (drive->dev_flags & IDE_DFLAG_USING_DMA)) {
-                if (scsi)
-                        hwif->sg_mapped = 1;
-                drive->dma = !hwif->dma_ops->dma_setup(drive);
-                if (scsi)
-                        hwif->sg_mapped = 0;
-        }
+                tf_flags = IDE_TFLAG_OUT_DEVICE;
+                bcount = ((drive->media == ide_tape) ?
+                                pc->req_xfer :
+                                min(pc->req_xfer, 63 * 1024));
 
-        if (!drive->dma)
-                pc->flags &= ~PC_FLAG_DMA_OK;
+                if (pc->flags & PC_FLAG_DMA_ERROR) {
+                        pc->flags &= ~PC_FLAG_DMA_ERROR;
+                        ide_dma_off(drive);
+                }
 
-        if (scsi)
-                tf_flags = 0;
-        else if (drive->media == ide_cdrom || drive->media == ide_optical)
-                tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;
-        else
-                tf_flags = IDE_TFLAG_OUT_DEVICE;
+                if ((pc->flags & PC_FLAG_DMA_OK) &&
+                     (drive->dev_flags & IDE_DFLAG_USING_DMA))
+                        drive->dma = !hwif->dma_ops->dma_setup(drive);
+
+                if (!drive->dma)
+                        pc->flags &= ~PC_FLAG_DMA_OK;
+
+                timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
+                                                       : WAIT_TAPE_CMD;
+        }
 
         ide_pktcmd_tf_load(drive, tf_flags, bcount, drive->dma);
 
         /* Issue the packet command */
         if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
+                if (drive->dma)
+                        drive->waiting_for_dma = 0;
                 ide_execute_command(drive, ATA_CMD_PACKET, ide_transfer_pc,
-                                    timeout, NULL);
+                                    timeout, expiry);
                 return ide_started;
         } else {
                 ide_execute_pkt_cmd(drive);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 42ab6d8715f2..cae69372cf45 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -53,14 +53,6 @@
 
 #include "ide-cd.h"
 
-#define IDECD_DEBUG_LOG         1
-
-#if IDECD_DEBUG_LOG
-#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
-#else
-#define ide_debug_log(lvl, fmt, args...) do {} while (0)
-#endif
-
 static DEFINE_MUTEX(idecd_ref_mutex);
 
 static void ide_cd_release(struct kref *);
@@ -247,7 +239,7 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
 
 static void cdrom_end_request(ide_drive_t *drive, int uptodate)
 {
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = drive->hwif->rq;
         int nsectors = rq->hard_cur_sectors;
 
         ide_debug_log(IDE_DBG_FUNC, "Call %s, cmd: 0x%x, uptodate: 0x%x, "
@@ -262,7 +254,6 @@ static void cdrom_end_request(ide_drive_t *drive, int uptodate)
                 struct request *failed = (struct request *) rq->buffer;
                 struct cdrom_info *info = drive->driver_data;
                 void *sense = &info->sense_data;
-                unsigned long flags;
 
                 if (failed) {
                         if (failed->sense) {
@@ -278,11 +269,9 @@ static void cdrom_end_request(ide_drive_t *drive, int uptodate)
                                                 failed->hard_nr_sectors))
                                         BUG();
                         } else {
-                                spin_lock_irqsave(&ide_lock, flags);
-                                if (__blk_end_request(failed, -EIO,
-                                                      failed->data_len))
+                                if (blk_end_request(failed, -EIO,
+                                                    failed->data_len))
                                         BUG();
-                                spin_unlock_irqrestore(&ide_lock, flags);
                         }
                 } else
                         cdrom_analyze_sense_data(drive, NULL, sense);
@@ -317,7 +306,7 @@ static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 st)
 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         int stat, err, sense_key;
 
         /* check for errors */
@@ -426,16 +415,17 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                                 if (time_after(jiffies, info->write_timeout))
                                         do_end_request = 1;
                                 else {
+                                        struct request_queue *q = drive->queue;
                                         unsigned long flags;
 
                                         /*
                                          * take a breather relying on the unplug
                                          * timer to kick us again
                                          */
-                                        spin_lock_irqsave(&ide_lock, flags);
-                                        blk_plug_device(drive->queue);
-                                        spin_unlock_irqrestore(&ide_lock,
-                                                                flags);
+                                        spin_lock_irqsave(q->queue_lock, flags);
+                                        blk_plug_device(q);
+                                        spin_unlock_irqrestore(q->queue_lock, flags);
+
                                         return 1;
                                 }
                         }
@@ -504,12 +494,14 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
 
 end_request:
         if (stat & ATA_ERR) {
+                struct request_queue *q = drive->queue;
                 unsigned long flags;
 
-                spin_lock_irqsave(&ide_lock, flags);
+                spin_lock_irqsave(q->queue_lock, flags);
                 blkdev_dequeue_request(rq);
-                HWGROUP(drive)->rq = NULL;
-                spin_unlock_irqrestore(&ide_lock, flags);
+                spin_unlock_irqrestore(q->queue_lock, flags);
+
+                hwif->rq = NULL;
 
                 cdrom_queue_request_sense(drive, rq->sense, rq);
         } else
@@ -518,133 +510,6 @@ end_request:
         return 1;
 }
 
-static int cdrom_timer_expiry(ide_drive_t *drive)
-{
-        struct request *rq = HWGROUP(drive)->rq;
-        unsigned long wait = 0;
-
-        ide_debug_log(IDE_DBG_RQ, "Call %s: rq->cmd[0]: 0x%x\n", __func__,
-                      rq->cmd[0]);
-
-        /*
-         * Some commands are *slow* and normally take a long time to complete.
-         * Usually we can use the ATAPI "disconnect" to bypass this, but not all
-         * commands/drives support that. Let ide_timer_expiry keep polling us
-         * for these.
-         */
-        switch (rq->cmd[0]) {
-        case GPCMD_BLANK:
-        case GPCMD_FORMAT_UNIT:
-        case GPCMD_RESERVE_RZONE_TRACK:
-        case GPCMD_CLOSE_TRACK:
-        case GPCMD_FLUSH_CACHE:
-                wait = ATAPI_WAIT_PC;
-                break;
-        default:
-                if (!(rq->cmd_flags & REQ_QUIET))
-                        printk(KERN_INFO PFX "cmd 0x%x timed out\n",
-                                         rq->cmd[0]);
-                wait = 0;
-                break;
-        }
-        return wait;
-}
-
-/*
- * Set up the device registers for transferring a packet command on DEV,
- * expecting to later transfer XFERLEN bytes.  HANDLER is the routine
- * which actually transfers the command to the drive.  If this is a
- * drq_interrupt device, this routine will arrange for HANDLER to be
- * called when the interrupt from the drive arrives.  Otherwise, HANDLER
- * will be called immediately after the drive is prepared for the transfer.
- */
-static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
-                                                  int xferlen,
-                                                  ide_handler_t *handler)
-{
-        ide_hwif_t *hwif = drive->hwif;
-
-        ide_debug_log(IDE_DBG_PC, "Call %s, xferlen: %d\n", __func__, xferlen);
-
-        /* FIXME: for Virtual DMA we must check harder */
-        if (drive->dma)
-                drive->dma = !hwif->dma_ops->dma_setup(drive);
-
-        /* set up the controller registers */
-        ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL,
-                           xferlen, drive->dma);
-
-        if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
-                /* waiting for CDB interrupt, not DMA yet. */
-                if (drive->dma)
-                        drive->waiting_for_dma = 0;
-
-                /* packet command */
-                ide_execute_command(drive, ATA_CMD_PACKET, handler,
-                                    ATAPI_WAIT_PC, cdrom_timer_expiry);
-                return ide_started;
-        } else {
-                ide_execute_pkt_cmd(drive);
-
-                return (*handler) (drive);
-        }
-}
-
-/*
- * Send a packet command to DRIVE described by CMD_BUF and CMD_LEN. The device
- * registers must have already been prepared by cdrom_start_packet_command.
- * HANDLER is the interrupt handler to call when the command completes or
- * there's data ready.
- */
-#define ATAPI_MIN_CDB_BYTES 12
-static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
-                                          struct request *rq,
-                                          ide_handler_t *handler)
-{
-        ide_hwif_t *hwif = drive->hwif;
-        int cmd_len;
-        ide_startstop_t startstop;
-
-        ide_debug_log(IDE_DBG_PC, "Call %s\n", __func__);
-
-        if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
-                /*
-                 * Here we should have been called after receiving an interrupt
-                 * from the device.  DRQ should how be set.
-                 */
-
-                /* check for errors */
-                if (cdrom_decode_status(drive, ATA_DRQ, NULL))
-                        return ide_stopped;
-
-                /* ok, next interrupt will be DMA interrupt */
-                if (drive->dma)
-                        drive->waiting_for_dma = 1;
-        } else {
-                /* otherwise, we must wait for DRQ to get set */
-                if (ide_wait_stat(&startstop, drive, ATA_DRQ,
-                                  ATA_BUSY, WAIT_READY))
-                        return startstop;
-        }
-
-        /* arm the interrupt handler */
-        ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
-
-        /* ATAPI commands get padded out to 12 bytes minimum */
-        cmd_len = COMMAND_SIZE(rq->cmd[0]);
-        if (cmd_len < ATAPI_MIN_CDB_BYTES)
-                cmd_len = ATAPI_MIN_CDB_BYTES;
-
-        /* send the command to the device */
-        hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
-
-        /* start the DMA if need be */
-        if (drive->dma)
-                hwif->dma_ops->dma_start(drive);
-
-        return ide_started;
-}
-
 /*
  * Check the contents of the interrupt reason register from the cdrom
  * and attempt to recover if there are problems.  Returns  0 if everything's
@@ -716,8 +581,6 @@ static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
         return 1;
 }
 
-static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
-
 static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
                                                  struct request *rq)
 {
@@ -760,66 +623,6 @@ static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
 }
 
 /*
- * Routine to send a read/write packet command to the drive. This is usually
- * called directly from cdrom_start_{read,write}(). However, for drq_interrupt
- * devices, it is called from an interrupt when the drive is ready to accept
- * the command.
- */
-static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
-{
-        struct request *rq = drive->hwif->hwgroup->rq;
-
-        /* send the command to the drive and return */
-        return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
-}
-
-#define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
-#define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
-#define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
-
-static ide_startstop_t cdrom_seek_intr(ide_drive_t *drive)
-{
-        struct cdrom_info *info = drive->driver_data;
-        int stat;
-        static int retry = 10;
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
-
-        if (cdrom_decode_status(drive, 0, &stat))
-                return ide_stopped;
-
-        drive->atapi_flags |= IDE_AFLAG_SEEKING;
-
-        if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
-                if (--retry == 0)
-                        drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
-        }
-        return ide_stopped;
-}
-
-static void ide_cd_prepare_seek_request(ide_drive_t *drive, struct request *rq)
-{
-        sector_t frame = rq->sector;
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
-
-        sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
-
-        memset(rq->cmd, 0, BLK_MAX_CDB);
-        rq->cmd[0] = GPCMD_SEEK;
-        put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
-
-        rq->timeout = ATAPI_WAIT_PC;
-}
-
-static ide_startstop_t cdrom_start_seek_continuation(ide_drive_t *drive)
-{
-        struct request *rq = drive->hwif->hwgroup->rq;
-
-        return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
-}
-
-/*
  * Fix up a possibly partially-processed request so that we can start it over
  * entirely, or even put it back on the request queue.
  */
@@ -950,7 +753,7 @@ static int cdrom_newpc_intr_dummy_cb(struct request *rq)
 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = hwif->rq;
         xfer_func_t *xferfunc;
         ide_expiry_t *expiry = NULL;
         int dma_error = 0, dma, stat, thislen, uptodate = 0;
@@ -1140,7 +943,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
         } else {
                 timeout = ATAPI_WAIT_PC;
                 if (!blk_fs_request(rq))
-                        expiry = cdrom_timer_expiry;
+                        expiry = ide_cd_expiry;
         }
 
         ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
@@ -1148,17 +951,15 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
 
 end_request:
         if (blk_pc_request(rq)) {
-                unsigned long flags;
                 unsigned int dlen = rq->data_len;
 
                 if (dma)
                         rq->data_len = 0;
 
-                spin_lock_irqsave(&ide_lock, flags);
-                if (__blk_end_request(rq, 0, dlen))
+                if (blk_end_request(rq, 0, dlen))
                         BUG();
-                HWGROUP(drive)->rq = NULL;
-                spin_unlock_irqrestore(&ide_lock, flags);
+
+                hwif->rq = NULL;
         } else {
                 if (!uptodate)
                         rq->cmd_flags |= REQ_FAILED;
@@ -1209,13 +1010,6 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         return ide_started;
 }
 
-static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
-{
-        struct request *rq = HWGROUP(drive)->rq;
-
-        return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
-}
-
 static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 {
 
@@ -1260,59 +1054,19 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
                                         sector_t block)
 {
-        struct cdrom_info *info = drive->driver_data;
-        ide_handler_t *fn;
-        int xferlen;
-
         ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, "
                       "rq->cmd_type: 0x%x, block: %llu\n",
                       __func__, rq->cmd[0], rq->cmd_type,
                       (unsigned long long)block);
 
         if (blk_fs_request(rq)) {
-                if (drive->atapi_flags & IDE_AFLAG_SEEKING) {
-                        ide_hwif_t *hwif = drive->hwif;
-                        unsigned long elapsed = jiffies - info->start_seek;
-                        int stat = hwif->tp_ops->read_status(hwif);
-
-                        if ((stat & ATA_DSC) != ATA_DSC) {
-                                if (elapsed < IDECD_SEEK_TIMEOUT) {
-                                        ide_stall_queue(drive,
-                                                        IDECD_SEEK_TIMER);
-                                        return ide_stopped;
-                                }
-                                printk(KERN_ERR PFX "%s: DSC timeout\n",
-                                                drive->name);
-                        }
-                        drive->atapi_flags &= ~IDE_AFLAG_SEEKING;
-                }
-                if (rq_data_dir(rq) == READ &&
-                    IDE_LARGE_SEEK(info->last_block, block,
-                            IDECD_SEEK_THRESHOLD) &&
-                    (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP)) {
-                        xferlen = 0;
-                        fn = cdrom_start_seek_continuation;
-
-                        drive->dma = 0;
-                        info->start_seek = jiffies;
-
-                        ide_cd_prepare_seek_request(drive, rq);
-                } else {
-                        xferlen = 32768;
-                        fn = cdrom_start_rw_cont;
-
-                        if (cdrom_start_rw(drive, rq) == ide_stopped)
-                                return ide_stopped;
+                if (cdrom_start_rw(drive, rq) == ide_stopped)
+                        return ide_stopped;
 
-                        if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
-                                return ide_stopped;
-                }
-                info->last_block = block;
+                if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
+                        return ide_stopped;
         } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
                    rq->cmd_type == REQ_TYPE_ATA_PC) {
-                xferlen = rq->data_len;
-                fn = cdrom_do_newpc_cont;
-
                 if (!rq->timeout)
                         rq->timeout = ATAPI_WAIT_PC;
 
@@ -1327,7 +1081,7 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
                 return ide_stopped;
         }
 
-        return cdrom_start_packet_command(drive, xferlen, fn);
+        return ide_issue_pc(drive);
 }
 
 /*
@@ -1908,13 +1662,6 @@ static ide_proc_entry_t idecd_proc[] = {
         { NULL, 0, NULL, NULL }
 };
 
-ide_devset_rw_flag(dsc_overlap, IDE_DFLAG_DSC_OVERLAP);
-
-static const struct ide_proc_devset idecd_settings[] = {
-        IDE_PROC_DEVSET(dsc_overlap, 0, 1),
-        { 0 },
-};
-
 static ide_proc_entry_t *ide_cd_proc_entries(ide_drive_t *drive)
 {
         return idecd_proc;
@@ -1922,7 +1669,7 @@ static ide_proc_entry_t *ide_cd_proc_entries(ide_drive_t *drive)
 
 static const struct ide_proc_devset *ide_cd_proc_devsets(ide_drive_t *drive)
 {
-        return idecd_settings;
+        return NULL;
 }
 #endif
 
@@ -2022,11 +1769,6 @@ static int ide_cdrom_setup(ide_drive_t *drive)
         /* set correct block size */
         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
 
-        if (drive->next != drive)
-                drive->dev_flags |= IDE_DFLAG_DSC_OVERLAP;
-        else
-                drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
-
         if (ide_cdrom_register(drive, nslots)) {
                 printk(KERN_ERR PFX "%s: %s failed to register device with the"
                                 " cdrom driver.\n", drive->name, __func__);
@@ -2063,7 +1805,6 @@ static void ide_cd_release(struct kref *kref)
         kfree(info->toc);
         if (devinfo->handle == drive)
                 unregister_cdrom(devinfo);
-        drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
         drive->driver_data = NULL;
         blk_queue_prep_rq(drive->queue, NULL);
         g->private_data = NULL;
@@ -2073,7 +1814,7 @@ static void ide_cd_release(struct kref *kref)
 
 static int ide_cd_probe(ide_drive_t *);
 
-static ide_driver_t ide_cdrom_driver = {
+static struct ide_driver ide_cdrom_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-cdrom",
@@ -2084,7 +1825,6 @@ static ide_driver_t ide_cdrom_driver = {
         .version                = IDECD_VERSION,
         .do_request             = ide_cd_do_request,
         .end_request            = ide_end_request,
-        .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
         .proc_entries           = ide_cd_proc_entries,
         .proc_devsets           = ide_cd_proc_devsets,
@@ -2239,6 +1979,7 @@ static int ide_cd_probe(ide_drive_t *drive)
         }
 
         drive->debug_mask = debug_mask;
+        drive->irq_handler = cdrom_newpc_intr;
 
         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
         if (info == NULL) {
diff --git a/drivers/ide/ide-cd.h b/drivers/ide/ide-cd.h
index 5882b9a9ea8b..ac40d6cb90a2 100644
--- a/drivers/ide/ide-cd.h
+++ b/drivers/ide/ide-cd.h
@@ -8,10 +8,14 @@
 #include <linux/cdrom.h>
 #include <asm/byteorder.h>
 
-/*
- * typical timeout for packet command
- */
-#define ATAPI_WAIT_PC           (60 * HZ)
+#define IDECD_DEBUG_LOG         0
+
+#if IDECD_DEBUG_LOG
+#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
+#else
+#define ide_debug_log(lvl, fmt, args...) do {} while (0)
+#endif
+
 #define ATAPI_WAIT_WRITE_BUSY   (10 * HZ)
 
 /************************************************************************/
@@ -29,33 +33,33 @@
 
 /* Structure of a MSF cdrom address. */
 struct atapi_msf {
-        byte reserved;
-        byte minute;
-        byte second;
-        byte frame;
+        u8 reserved;
+        u8 minute;
+        u8 second;
+        u8 frame;
 };
 
 /* Space to hold the disk TOC. */
 #define MAX_TRACKS 99
 struct atapi_toc_header {
         unsigned short toc_length;
-        byte first_track;
-        byte last_track;
+        u8 first_track;
+        u8 last_track;
 };
 
 struct atapi_toc_entry {
-        byte reserved1;
+        u8 reserved1;
 #if defined(__BIG_ENDIAN_BITFIELD)
-        __u8 adr     : 4;
-        __u8 control : 4;
+        u8 adr     : 4;
+        u8 control : 4;
 #elif defined(__LITTLE_ENDIAN_BITFIELD)
-        __u8 control : 4;
-        __u8 adr     : 4;
+        u8 control : 4;
+        u8 adr     : 4;
 #else
 #error "Please fix <asm/byteorder.h>"
 #endif
-        byte track;
-        byte reserved2;
+        u8 track;
+        u8 reserved2;
         union {
                 unsigned lba;
                 struct atapi_msf msf;
@@ -73,10 +77,10 @@ struct atapi_toc {
 
 /* Extra per-device info for cdrom drives. */
 struct cdrom_info {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
+        ide_drive_t             *drive;
+        struct ide_driver       *driver;
+        struct gendisk          *disk;
+        struct kref             kref;
 
         /* Buffer for table of contents.  NULL if we haven't allocated
            a TOC buffer for this device yet. */
@@ -88,8 +92,6 @@ struct cdrom_info {
         struct request_sense sense_data;
 
         struct request request_sense_request;
-        unsigned long last_block;
-        unsigned long start_seek;
 
         u8 max_speed;           /* Max speed of the drive. */
         u8 current_speed;       /* Current speed of the drive. */
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index eb9fac4d0f0c..4088a622873e 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -89,7 +89,7 @@ static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                                         sector_t block)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         u16 nsectors            = (u16)rq->nr_sectors;
         u8 lba48                = !!(drive->dev_flags & IDE_DFLAG_LBA48);
         u8 dma                  = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
@@ -187,7 +187,7 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                                       sector_t block)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
 
         BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
 
diff --git a/drivers/ide/ide-dma-sff.c b/drivers/ide/ide-dma-sff.c
index cac431f0df17..123d393658af 100644
--- a/drivers/ide/ide-dma-sff.c
+++ b/drivers/ide/ide-dma-sff.c
@@ -50,6 +50,27 @@ int config_drive_for_dma(ide_drive_t *drive)
         return 0;
 }
 
+u8 ide_dma_sff_read_status(ide_hwif_t *hwif)
+{
+        unsigned long addr = hwif->dma_base + ATA_DMA_STATUS;
+
+        if (hwif->host_flags & IDE_HFLAG_MMIO)
+                return readb((void __iomem *)addr);
+        else
+                return inb(addr);
+}
+EXPORT_SYMBOL_GPL(ide_dma_sff_read_status);
+
+static void ide_dma_sff_write_status(ide_hwif_t *hwif, u8 val)
+{
+        unsigned long addr = hwif->dma_base + ATA_DMA_STATUS;
+
+        if (hwif->host_flags & IDE_HFLAG_MMIO)
+                writeb(val, (void __iomem *)addr);
+        else
+                outb(val, addr);
+}
+
 /**
  *      ide_dma_host_set        -       Enable/disable DMA on a host
  *      @drive: drive to control
@@ -62,18 +83,14 @@ void ide_dma_host_set(ide_drive_t *drive, int on)
 {
         ide_hwif_t *hwif = drive->hwif;
         u8 unit = drive->dn & 1;
-        u8 dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        u8 dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
 
         if (on)
                 dma_stat |= (1 << (5 + unit));
         else
                 dma_stat &= ~(1 << (5 + unit));
 
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
-                writeb(dma_stat,
-                       (void __iomem *)(hwif->dma_base + ATA_DMA_STATUS));
-        else
-                outb(dma_stat, hwif->dma_base + ATA_DMA_STATUS);
+        ide_dma_sff_write_status(hwif, dma_stat);
 }
 EXPORT_SYMBOL_GPL(ide_dma_host_set);
 
@@ -98,10 +115,10 @@ int ide_build_dmatable(ide_drive_t *drive, struct request *rq)
 {
         ide_hwif_t *hwif = drive->hwif;
         __le32 *table = (__le32 *)hwif->dmatable_cpu;
-        unsigned int is_trm290  = (hwif->chipset == ide_trm290) ? 1 : 0;
         unsigned int count = 0;
         int i;
         struct scatterlist *sg;
+        u8 is_trm290 = !!(hwif->host_flags & IDE_HFLAG_TRM290);
 
         hwif->sg_nents = ide_build_sglist(drive, rq);
         if (hwif->sg_nents == 0)
@@ -175,16 +192,11 @@ EXPORT_SYMBOL_GPL(ide_build_dmatable);
 int ide_dma_setup(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = hwif->hwgroup->rq;
-        unsigned int reading;
+        struct request *rq = hwif->rq;
+        unsigned int reading = rq_data_dir(rq) ? 0 : ATA_DMA_WR;
         u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
         u8 dma_stat;
 
-        if (rq_data_dir(rq))
-                reading = 0;
-        else
-                reading = 1 << 3;
-
         /* fall back to pio! */
         if (!ide_build_dmatable(drive, rq)) {
                 ide_map_sg(drive, rq);
@@ -192,7 +204,7 @@ int ide_dma_setup(ide_drive_t *drive)
         }
 
         /* PRD table */
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
+        if (mmio)
                 writel(hwif->dmatable_dma,
                        (void __iomem *)(hwif->dma_base + ATA_DMA_TABLE_OFS));
         else
@@ -205,14 +217,10 @@ int ide_dma_setup(ide_drive_t *drive)
                 outb(reading, hwif->dma_base + ATA_DMA_CMD);
 
         /* read DMA status for INTR & ERROR flags */
-        dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
 
         /* clear INTR & ERROR flags */
-        if (mmio)
-                writeb(dma_stat | 6,
-                       (void __iomem *)(hwif->dma_base + ATA_DMA_STATUS));
-        else
-                outb(dma_stat | 6, hwif->dma_base + ATA_DMA_STATUS);
+        ide_dma_sff_write_status(hwif, dma_stat | ATA_DMA_ERR | ATA_DMA_INTR);
 
         drive->waiting_for_dma = 1;
         return 0;
@@ -236,7 +244,7 @@ EXPORT_SYMBOL_GPL(ide_dma_setup);
 static int dma_timer_expiry(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        u8 dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        u8 dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
 
         printk(KERN_WARNING "%s: %s: DMA status (0x%02x)\n",
                 drive->name, __func__, dma_stat);
@@ -244,16 +252,15 @@ static int dma_timer_expiry(ide_drive_t *drive)
         if ((dma_stat & 0x18) == 0x18)  /* BUSY Stupid Early Timer !! */
                 return WAIT_CMD;
 
-        hwif->hwgroup->expiry = NULL;   /* one free ride for now */
+        hwif->expiry = NULL;    /* one free ride for now */
 
-        /* 1 dmaing, 2 error, 4 intr */
-        if (dma_stat & 2)       /* ERROR */
+        if (dma_stat & ATA_DMA_ERR)     /* ERROR */
                 return -1;
 
-        if (dma_stat & 1)       /* DMAing */
+        if (dma_stat & ATA_DMA_ACTIVE)  /* DMAing */
                 return WAIT_CMD;
 
-        if (dma_stat & 4)       /* Got an Interrupt */
+        if (dma_stat & ATA_DMA_INTR)    /* Got an Interrupt */
                 return WAIT_CMD;
 
         return 0;       /* Status is unknown -- reset the bus */
@@ -279,12 +286,11 @@ void ide_dma_start(ide_drive_t *drive)
          */
         if (hwif->host_flags & IDE_HFLAG_MMIO) {
                 dma_cmd = readb((void __iomem *)(hwif->dma_base + ATA_DMA_CMD));
-                /* start DMA */
-                writeb(dma_cmd | 1,
+                writeb(dma_cmd | ATA_DMA_START,
                        (void __iomem *)(hwif->dma_base + ATA_DMA_CMD));
         } else {
                 dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD);
-                outb(dma_cmd | 1, hwif->dma_base + ATA_DMA_CMD);
+                outb(dma_cmd | ATA_DMA_START, hwif->dma_base + ATA_DMA_CMD);
         }
 
         wmb();
@@ -295,37 +301,35 @@ EXPORT_SYMBOL_GPL(ide_dma_start);
 int ide_dma_end(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
-        u8 dma_stat = 0, dma_cmd = 0;
+        u8 dma_stat = 0, dma_cmd = 0, mask;
 
         drive->waiting_for_dma = 0;
 
-        if (mmio) {
-                /* get DMA command mode */
+        /* stop DMA */
+        if (hwif->host_flags & IDE_HFLAG_MMIO) {
                 dma_cmd = readb((void __iomem *)(hwif->dma_base + ATA_DMA_CMD));
-                /* stop DMA */
-                writeb(dma_cmd & ~1,
+                writeb(dma_cmd & ~ATA_DMA_START,
                        (void __iomem *)(hwif->dma_base + ATA_DMA_CMD));
         } else {
                 dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD);
-                outb(dma_cmd & ~1, hwif->dma_base + ATA_DMA_CMD);
+                outb(dma_cmd & ~ATA_DMA_START, hwif->dma_base + ATA_DMA_CMD);
         }
 
         /* get DMA status */
-        dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
 
-        if (mmio)
-                /* clear the INTR & ERROR bits */
-                writeb(dma_stat | 6,
-                       (void __iomem *)(hwif->dma_base + ATA_DMA_STATUS));
-        else
-                outb(dma_stat | 6, hwif->dma_base + ATA_DMA_STATUS);
+        /* clear INTR & ERROR bits */
+        ide_dma_sff_write_status(hwif, dma_stat | ATA_DMA_ERR | ATA_DMA_INTR);
 
         /* purge DMA mappings */
         ide_destroy_dmatable(drive);
-        /* verify good DMA status */
         wmb();
-        return (dma_stat & 7) != 4 ? (0x10 | dma_stat) : 0;
+
+        /* verify good DMA status */
+        mask = ATA_DMA_ACTIVE | ATA_DMA_ERR | ATA_DMA_INTR;
+        if ((dma_stat & mask) != ATA_DMA_INTR)
+                return 0x10 | dma_stat;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(ide_dma_end);
 
@@ -333,13 +337,9 @@ EXPORT_SYMBOL_GPL(ide_dma_end);
 int ide_dma_test_irq(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        u8 dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        u8 dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
 
-        /* return 1 if INTR asserted */
-        if ((dma_stat & 4) == 4)
-                return 1;
-
-        return 0;
+        return (dma_stat & ATA_DMA_INTR) ? 1 : 0;
 }
 EXPORT_SYMBOL_GPL(ide_dma_test_irq);
 
@@ -352,5 +352,6 @@ const struct ide_dma_ops sff_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_timeout            = ide_dma_timeout,
         .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 EXPORT_SYMBOL_GPL(sff_dma_ops);
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index fffd11717b2d..72ebab0bc755 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -96,7 +96,7 @@ ide_startstop_t ide_dma_intr(ide_drive_t *drive)
 
         if (OK_STAT(stat, DRIVE_READY, drive->bad_wstat | ATA_DRQ)) {
                 if (!dma_stat) {
-                        struct request *rq = hwif->hwgroup->rq;
+                        struct request *rq = hwif->rq;
 
                         task_end_request(drive, rq, stat);
                         return ide_stopped;
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index aeb1ad782f54..3eab1c6c9b31 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -71,7 +71,7 @@
 static int ide_floppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
 {
         struct ide_disk_obj *floppy = drive->driver_data;
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = drive->hwif->rq;
         int error;
 
         ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
@@ -197,7 +197,7 @@ static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
 
         pc->retries++;
 
-        return ide_issue_pc(drive, WAIT_FLOPPY_CMD, NULL);
+        return ide_issue_pc(drive);
 }
 
 void ide_floppy_create_read_capacity_cmd(struct ide_atapi_pc *pc)
@@ -342,38 +342,38 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
  * Look at the flexible disk page parameters. We ignore the CHS capacity
  * parameters and use the LBA parameters instead.
  */
-static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
+static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive,
+                                             struct ide_atapi_pc *pc)
 {
         struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
-        struct ide_atapi_pc pc;
         u8 *page;
         int capacity, lba_capacity;
         u16 transfer_rate, sector_size, cyls, rpm;
         u8 heads, sectors;
 
-        ide_floppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);
+        ide_floppy_create_mode_sense_cmd(pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);
 
-        if (ide_queue_pc_tail(drive, disk, &pc)) {
+        if (ide_queue_pc_tail(drive, disk, pc)) {
                 printk(KERN_ERR PFX "Can't get flexible disk page params\n");
                 return 1;
         }
 
-        if (pc.buf[3] & 0x80)
+        if (pc->buf[3] & 0x80)
                 drive->dev_flags |= IDE_DFLAG_WP;
         else
                 drive->dev_flags &= ~IDE_DFLAG_WP;
 
         set_disk_ro(disk, !!(drive->dev_flags & IDE_DFLAG_WP));
 
-        page = &pc.buf[8];
+        page = &pc->buf[8];
 
-        transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);
-        sector_size   = be16_to_cpup((__be16 *)&pc.buf[8 + 6]);
-        cyls          = be16_to_cpup((__be16 *)&pc.buf[8 + 8]);
-        rpm           = be16_to_cpup((__be16 *)&pc.buf[8 + 28]);
-        heads         = pc.buf[8 + 4];
-        sectors       = pc.buf[8 + 5];
+        transfer_rate = be16_to_cpup((__be16 *)&pc->buf[8 + 2]);
+        sector_size   = be16_to_cpup((__be16 *)&pc->buf[8 + 6]);
+        cyls          = be16_to_cpup((__be16 *)&pc->buf[8 + 8]);
+        rpm           = be16_to_cpup((__be16 *)&pc->buf[8 + 28]);
+        heads         = pc->buf[8 + 4];
+        sectors       = pc->buf[8 + 5];
 
         capacity = cyls * heads * sectors * sector_size;
 
@@ -499,7 +499,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
 
         /* Clik! disk does not support get_flexible_disk_page */
         if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
-                (void) ide_floppy_get_flexible_disk_page(drive);
+                (void) ide_floppy_get_flexible_disk_page(drive, &pc);
 
         return rc;
 }
diff --git a/drivers/ide/ide-floppy_ioctl.c b/drivers/ide/ide-floppy_ioctl.c
index 2bc51ff73fee..8f8be8546038 100644
--- a/drivers/ide/ide-floppy_ioctl.c
+++ b/drivers/ide/ide-floppy_ioctl.c
@@ -31,10 +31,11 @@
  * On exit we set nformats to the number of records we've actually initialized.
  */
 
-static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
+static int ide_floppy_get_format_capacities(ide_drive_t *drive,
+                                            struct ide_atapi_pc *pc,
+                                            int __user *arg)
 {
         struct ide_disk_obj *floppy = drive->driver_data;
-        struct ide_atapi_pc pc;
         u8 header_len, desc_cnt;
         int i, blocks, length, u_array_size, u_index;
         int __user *argp;
@@ -45,13 +46,13 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
         if (u_array_size <= 0)
                 return -EINVAL;
 
-        ide_floppy_create_read_capacity_cmd(&pc);
-        if (ide_queue_pc_tail(drive, floppy->disk, &pc)) {
+        ide_floppy_create_read_capacity_cmd(pc);
+        if (ide_queue_pc_tail(drive, floppy->disk, pc)) {
                 printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
                 return -EIO;
         }
 
-        header_len = pc.buf[3];
+        header_len = pc->buf[3];
         desc_cnt = header_len / 8; /* capacity descriptor of 8 bytes */
 
         u_index = 0;
@@ -68,8 +69,8 @@ static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
                 if (u_index >= u_array_size)
                         break;  /* User-supplied buffer too small */
 
-                blocks = be32_to_cpup((__be32 *)&pc.buf[desc_start]);
-                length = be16_to_cpup((__be16 *)&pc.buf[desc_start + 6]);
+                blocks = be32_to_cpup((__be32 *)&pc->buf[desc_start]);
+                length = be16_to_cpup((__be16 *)&pc->buf[desc_start + 6]);
 
                 if (put_user(blocks, argp))
                         return -EFAULT;
@@ -111,29 +112,28 @@ static void ide_floppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b,
         pc->flags |= PC_FLAG_WRITING;
 }
 
-static int ide_floppy_get_sfrp_bit(ide_drive_t *drive)
+static int ide_floppy_get_sfrp_bit(ide_drive_t *drive, struct ide_atapi_pc *pc)
 {
         struct ide_disk_obj *floppy = drive->driver_data;
-        struct ide_atapi_pc pc;
 
         drive->atapi_flags &= ~IDE_AFLAG_SRFP;
 
-        ide_floppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE);
-        pc.flags |= PC_FLAG_SUPPRESS_ERROR;
+        ide_floppy_create_mode_sense_cmd(pc, IDEFLOPPY_CAPABILITIES_PAGE);
+        pc->flags |= PC_FLAG_SUPPRESS_ERROR;
 
-        if (ide_queue_pc_tail(drive, floppy->disk, &pc))
+        if (ide_queue_pc_tail(drive, floppy->disk, pc))
                 return 1;
 
-        if (pc.buf[8 + 2] & 0x40)
+        if (pc->buf[8 + 2] & 0x40)
                 drive->atapi_flags |= IDE_AFLAG_SRFP;
 
         return 0;
 }
 
-static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
+static int ide_floppy_format_unit(ide_drive_t *drive, struct ide_atapi_pc *pc,
+                                  int __user *arg)
 {
         struct ide_disk_obj *floppy = drive->driver_data;
-        struct ide_atapi_pc pc;
         int blocks, length, flags, err = 0;
 
         if (floppy->openers > 1) {
@@ -166,10 +166,10 @@ static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
                 goto out;
         }
 
-        (void)ide_floppy_get_sfrp_bit(drive);
-        ide_floppy_create_format_unit_cmd(&pc, blocks, length, flags);
+        ide_floppy_get_sfrp_bit(drive, pc);
+        ide_floppy_create_format_unit_cmd(pc, blocks, length, flags);
 
-        if (ide_queue_pc_tail(drive, floppy->disk, &pc))
+        if (ide_queue_pc_tail(drive, floppy->disk, pc))
                 err = -EIO;
 
 out:
@@ -188,15 +188,16 @@ out:
  * the dsc bit, and return either 0 or 65536.
  */
 
-static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)
+static int ide_floppy_get_format_progress(ide_drive_t *drive,
+                                          struct ide_atapi_pc *pc,
+                                          int __user *arg)
 {
         struct ide_disk_obj *floppy = drive->driver_data;
-        struct ide_atapi_pc pc;
         int progress_indication = 0x10000;
 
         if (drive->atapi_flags & IDE_AFLAG_SRFP) {
-                ide_create_request_sense_cmd(drive, &pc);
-                if (ide_queue_pc_tail(drive, floppy->disk, &pc))
+                ide_create_request_sense_cmd(drive, pc);
+                if (ide_queue_pc_tail(drive, floppy->disk, pc))
                         return -EIO;
 
                 if (floppy->sense_key == 2 &&
@@ -241,20 +242,21 @@ static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc,
         return 0;
 }
 
-static int ide_floppy_format_ioctl(ide_drive_t *drive, fmode_t mode,
-                                   unsigned int cmd, void __user *argp)
+static int ide_floppy_format_ioctl(ide_drive_t *drive, struct ide_atapi_pc *pc,
+                                   fmode_t mode, unsigned int cmd,
+                                   void __user *argp)
 {
         switch (cmd) {
         case IDEFLOPPY_IOCTL_FORMAT_SUPPORTED:
                 return 0;
         case IDEFLOPPY_IOCTL_FORMAT_GET_CAPACITY:
-                return ide_floppy_get_format_capacities(drive, argp);
+                return ide_floppy_get_format_capacities(drive, pc, argp);
         case IDEFLOPPY_IOCTL_FORMAT_START:
                 if (!(mode & FMODE_WRITE))
                         return -EPERM;
-                return ide_floppy_format_unit(drive, (int __user *)argp);
+                return ide_floppy_format_unit(drive, pc, (int __user *)argp);
         case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:
-                return ide_floppy_get_format_progress(drive, argp);
+                return ide_floppy_get_format_progress(drive, pc, argp);
         default:
                 return -ENOTTY;
         }
@@ -270,7 +272,7 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
         if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR)
                 return ide_floppy_lockdoor(drive, &pc, arg, cmd);
 
-        err = ide_floppy_format_ioctl(drive, mode, cmd, argp);
+        err = ide_floppy_format_ioctl(drive, &pc, mode, cmd, argp);
         if (err != -ENOTTY)
                 return err;
 
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c
index b8078b3231f7..7857b209c6df 100644
--- a/drivers/ide/ide-gd.c
+++ b/drivers/ide/ide-gd.c
@@ -149,7 +149,7 @@ static int ide_gd_end_request(ide_drive_t *drive, int uptodate, int nrsecs)
         return drive->disk_ops->end_request(drive, uptodate, nrsecs);
 }
 
-static ide_driver_t ide_gd_driver = {
+static struct ide_driver ide_gd_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-gd",
@@ -162,7 +162,6 @@ static ide_driver_t ide_gd_driver = {
         .version                = IDE_GD_VERSION,
         .do_request             = ide_gd_do_request,
         .end_request            = ide_gd_end_request,
-        .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
         .proc_entries           = ide_disk_proc_entries,
         .proc_devsets           = ide_disk_proc_devsets,
diff --git a/drivers/ide/ide-gd.h b/drivers/ide/ide-gd.h
index 7d3d101713e0..a86779f0756b 100644
--- a/drivers/ide/ide-gd.h
+++ b/drivers/ide/ide-gd.h
@@ -14,11 +14,11 @@
 #endif
 
 struct ide_disk_obj {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
-        unsigned int    openers;        /* protected by BKL for now */
+        ide_drive_t             *drive;
+        struct ide_driver       *driver;
+        struct gendisk          *disk;
+        struct kref             kref;
+        unsigned int            openers;        /* protected by BKL for now */
 
         /* Last failed packet command */
         struct ide_atapi_pc *failed_pc;
diff --git a/drivers/ide/ide-h8300.c b/drivers/ide/ide-h8300.c
index e2cdd2e9cdec..9270d3255ee0 100644
--- a/drivers/ide/ide-h8300.c
+++ b/drivers/ide/ide-h8300.c
@@ -159,7 +159,6 @@ static const struct ide_tp_ops h8300_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index cc35d6dbd410..cc163319dfbd 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -84,11 +84,11 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
                 ide_dma_on(drive);
         }
 
-        if (!__blk_end_request(rq, error, nr_bytes)) {
-                if (dequeue)
-                        HWGROUP(drive)->rq = NULL;
+        if (!blk_end_request(rq, error, nr_bytes))
                 ret = 0;
-        }
+
+        if (ret == 0 && dequeue)
+                drive->hwif->rq = NULL;
 
         return ret;
 }
@@ -107,16 +107,7 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
 int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors)
 {
         unsigned int nr_bytes = nr_sectors << 9;
-        struct request *rq;
-        unsigned long flags;
-        int ret = 1;
-
-        /*
-         * room for locking improvements here, the calls below don't
-         * need the queue lock held at all
-         */
-        spin_lock_irqsave(&ide_lock, flags);
-        rq = HWGROUP(drive)->rq;
+        struct request *rq = drive->hwif->rq;
 
         if (!nr_bytes) {
                 if (blk_pc_request(rq))
@@ -125,105 +116,10 @@ int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors)
                         nr_bytes = rq->hard_cur_sectors << 9;
         }
 
-        ret = __ide_end_request(drive, rq, uptodate, nr_bytes, 1);
-
-        spin_unlock_irqrestore(&ide_lock, flags);
-        return ret;
+        return __ide_end_request(drive, rq, uptodate, nr_bytes, 1);
 }
 EXPORT_SYMBOL(ide_end_request);
 
-static void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
-{
-        struct request_pm_state *pm = rq->data;
-
-#ifdef DEBUG_PM
-        printk(KERN_INFO "%s: complete_power_step(step: %d)\n",
-                drive->name, pm->pm_step);
-#endif
-        if (drive->media != ide_disk)
-                return;
-
-        switch (pm->pm_step) {
-        case IDE_PM_FLUSH_CACHE:        /* Suspend step 1 (flush cache) */
-                if (pm->pm_state == PM_EVENT_FREEZE)
-                        pm->pm_step = IDE_PM_COMPLETED;
-                else
-                        pm->pm_step = IDE_PM_STANDBY;
-                break;
-        case IDE_PM_STANDBY:            /* Suspend step 2 (standby) */
-                pm->pm_step = IDE_PM_COMPLETED;
-                break;
-        case IDE_PM_RESTORE_PIO:        /* Resume step 1 (restore PIO) */
-                pm->pm_step = IDE_PM_IDLE;
-                break;
-        case IDE_PM_IDLE:               /* Resume step 2 (idle)*/
-                pm->pm_step = IDE_PM_RESTORE_DMA;
-                break;
-        }
-}
-
-static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
-{
-        struct request_pm_state *pm = rq->data;
-        ide_task_t *args = rq->special;
-
-        memset(args, 0, sizeof(*args));
-
-        switch (pm->pm_step) {
-        case IDE_PM_FLUSH_CACHE:        /* Suspend step 1 (flush cache) */
-                if (drive->media != ide_disk)
-                        break;
-                /* Not supported? Switch to next step now. */
-                if (ata_id_flush_enabled(drive->id) == 0 ||
-                    (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) {
-                        ide_complete_power_step(drive, rq);
-                        return ide_stopped;
-                }
-                if (ata_id_flush_ext_enabled(drive->id))
-                        args->tf.command = ATA_CMD_FLUSH_EXT;
-                else
-                        args->tf.command = ATA_CMD_FLUSH;
-                goto out_do_tf;
-        case IDE_PM_STANDBY:            /* Suspend step 2 (standby) */
-                args->tf.command = ATA_CMD_STANDBYNOW1;
-                goto out_do_tf;
-        case IDE_PM_RESTORE_PIO:        /* Resume step 1 (restore PIO) */
-                ide_set_max_pio(drive);
-                /*
-                 * skip IDE_PM_IDLE for ATAPI devices
-                 */
-                if (drive->media != ide_disk)
-                        pm->pm_step = IDE_PM_RESTORE_DMA;
-                else
-                        ide_complete_power_step(drive, rq);
-                return ide_stopped;
-        case IDE_PM_IDLE:               /* Resume step 2 (idle) */
-                args->tf.command = ATA_CMD_IDLEIMMEDIATE;
-                goto out_do_tf;
-        case IDE_PM_RESTORE_DMA:        /* Resume step 3 (restore DMA) */
-                /*
-                 * Right now, all we do is call ide_set_dma(drive),
-                 * we could be smarter and check for current xfer_speed
-                 * in struct drive etc...
-                 */
-                if (drive->hwif->dma_ops == NULL)
-                        break;
-                /*
-                 * TODO: respect IDE_DFLAG_USING_DMA
-                 */
-                ide_set_dma(drive);
-                break;
-        }
-
-        pm->pm_step = IDE_PM_COMPLETED;
-        return ide_stopped;
-
-out_do_tf:
-        args->tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
-        args->data_phase = TASKFILE_NO_DATA;
-        return do_rw_taskfile(drive, args);
-}
-
 /**
  *      ide_end_dequeued_request        -       complete an IDE I/O
  *      @drive: IDE device for the I/O
@@ -242,48 +138,12 @@ out_do_tf:
 int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
                              int uptodate, int nr_sectors)
 {
-        unsigned long flags;
-        int ret;
-
-        spin_lock_irqsave(&ide_lock, flags);
         BUG_ON(!blk_rq_started(rq));
-        ret = __ide_end_request(drive, rq, uptodate, nr_sectors << 9, 0);
-        spin_unlock_irqrestore(&ide_lock, flags);
 
-        return ret;
+        return __ide_end_request(drive, rq, uptodate, nr_sectors << 9, 0);
 }
 EXPORT_SYMBOL_GPL(ide_end_dequeued_request);
 
-
-/**
- *      ide_complete_pm_request - end the current Power Management request
- *      @drive: target drive
- *      @rq: request
- *
- *      This function cleans up the current PM request and stops the queue
- *      if necessary.
- */
-static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq)
-{
-        unsigned long flags;
-
-#ifdef DEBUG_PM
-        printk("%s: completing PM request, %s\n", drive->name,
-               blk_pm_suspend_request(rq) ? "suspend" : "resume");
-#endif
-        spin_lock_irqsave(&ide_lock, flags);
-        if (blk_pm_suspend_request(rq)) {
-                blk_stop_queue(drive->queue);
-        } else {
-                drive->dev_flags &= ~IDE_DFLAG_BLOCKED;
-                blk_start_queue(drive->queue);
-        }
-        HWGROUP(drive)->rq = NULL;
-        if (__blk_end_request(rq, 0, 0))
-                BUG();
-        spin_unlock_irqrestore(&ide_lock, flags);
-}
-
 /**
  *      ide_end_drive_cmd       -       end an explicit drive command
  *      @drive: command 
@@ -300,19 +160,12 @@ static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq)
  
 void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
 {
-        unsigned long flags;
-        struct request *rq;
-
-        spin_lock_irqsave(&ide_lock, flags);
-        rq = HWGROUP(drive)->rq;
-        spin_unlock_irqrestore(&ide_lock, flags);
+        ide_hwif_t *hwif = drive->hwif;
+        struct request *rq = hwif->rq;
 
         if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *task = (ide_task_t *)rq->special;
 
-                if (rq->errors == 0)
-                        rq->errors = !OK_STAT(stat, ATA_DRDY, BAD_STAT);
-
                 if (task) {
                         struct ide_taskfile *tf = &task->tf;
 
@@ -333,23 +186,22 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
                 return;
         }
 
-        spin_lock_irqsave(&ide_lock, flags);
-        HWGROUP(drive)->rq = NULL;
+        hwif->rq = NULL;
+
         rq->errors = err;
-        if (unlikely(__blk_end_request(rq, (rq->errors ? -EIO : 0),
-                                       blk_rq_bytes(rq))))
+
+        if (unlikely(blk_end_request(rq, (rq->errors ? -EIO : 0),
+                                     blk_rq_bytes(rq))))
                 BUG();
-        spin_unlock_irqrestore(&ide_lock, flags);
 }
-
 EXPORT_SYMBOL(ide_end_drive_cmd);
 
 static void ide_kill_rq(ide_drive_t *drive, struct request *rq)
 {
         if (rq->rq_disk) {
-                ide_driver_t *drv;
+                struct ide_driver *drv;
 
-                drv = *(ide_driver_t **)rq->rq_disk->private_data;
+                drv = *(struct ide_driver **)rq->rq_disk->private_data;
                 drv->end_request(drive, 0, 0);
         } else
                 ide_end_request(drive, 0, 0);
@@ -439,7 +291,7 @@ static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u
         return ide_stopped;
 }
 
-ide_startstop_t
+static ide_startstop_t
 __ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
 {
         if (drive->media == ide_disk)
@@ -447,8 +299,6 @@ __ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err)
         return ide_atapi_error(drive, rq, stat, err);
 }
 
-EXPORT_SYMBOL_GPL(__ide_error);
-
 /**
  *      ide_error       -       handle an error on the IDE
  *      @drive: drive the error occurred on
@@ -469,7 +319,8 @@ ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat)
 
         err = ide_dump_status(drive, msg, stat);
 
-        if ((rq = HWGROUP(drive)->rq) == NULL)
+        rq = drive->hwif->rq;
+        if (rq == NULL)
                 return ide_stopped;
 
         /* retry only "normal" I/O: */
@@ -479,15 +330,8 @@ ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat)
                 return ide_stopped;
         }
 
-        if (rq->rq_disk) {
-                ide_driver_t *drv;
-
-                drv = *(ide_driver_t **)rq->rq_disk->private_data;
-                return drv->error(drive, rq, stat, err);
-        } else
-                return __ide_error(drive, rq, stat, err);
+        return __ide_error(drive, rq, stat, err);
 }
-
 EXPORT_SYMBOL_GPL(ide_error);
 
 static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf)
@@ -574,9 +418,6 @@ void ide_map_sg(ide_drive_t *drive, struct request *rq)
         ide_hwif_t *hwif = drive->hwif;
         struct scatterlist *sg = hwif->sg_table;
 
-        if (hwif->sg_mapped)    /* needed by ide-scsi */
-                return;
-
         if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) {
                 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
         } else {
@@ -613,7 +454,7 @@ EXPORT_SYMBOL_GPL(ide_init_sg_cmd);
 static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 struct request *rq)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         ide_task_t *task = rq->special;
 
         if (task) {
@@ -720,40 +561,6 @@ static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq)
         }
 }
 
-static void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
-{
-        struct request_pm_state *pm = rq->data;
-
-        if (blk_pm_suspend_request(rq) &&
-            pm->pm_step == IDE_PM_START_SUSPEND)
-                /* Mark drive blocked when starting the suspend sequence. */
-                drive->dev_flags |= IDE_DFLAG_BLOCKED;
-        else if (blk_pm_resume_request(rq) &&
-                 pm->pm_step == IDE_PM_START_RESUME) {
-                /* 
-                 * The first thing we do on wakeup is to wait for BSY bit to
-                 * go away (with a looong timeout) as a drive on this hwif may
-                 * just be POSTing itself.
-                 * We do that before even selecting as the "other" device on
-                 * the bus may be broken enough to walk on our toes at this
-                 * point.
-                 */
-                ide_hwif_t *hwif = drive->hwif;
-                int rc;
-#ifdef DEBUG_PM
-                printk("%s: Wakeup request inited, waiting for !BSY...\n", drive->name);
-#endif
-                rc = ide_wait_not_busy(hwif, 35000);
-                if (rc)
-                        printk(KERN_WARNING "%s: bus not ready on wakeup\n", drive->name);
-                SELECT_DRIVE(drive);
-                hwif->tp_ops->set_irq(hwif, 1);
-                rc = ide_wait_not_busy(hwif, 100000);
-                if (rc)
-                        printk(KERN_WARNING "%s: drive not ready on wakeup\n", drive->name);
-        }
-}
-
 /**
  *      start_request   -       start of I/O and command issuing for IDE
  *
@@ -771,7 +578,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
 
 #ifdef DEBUG
         printk("%s: start_request: current=0x%08lx\n",
-                HWIF(drive)->name, (unsigned long) rq);
+                drive->hwif->name, (unsigned long) rq);
 #endif
 
         /* bail early if we've exceeded max_failures */
@@ -790,7 +597,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
                 return startstop;
         }
         if (!drive->special.all) {
-                ide_driver_t *drv;
+                struct ide_driver *drv;
 
                 /*
                  * We reset the drive so we need to issue a SETFEATURES.
@@ -823,7 +630,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
                          */
                         return ide_special_rq(drive, rq);
 
-                drv = *(ide_driver_t **)rq->rq_disk->private_data;
+                drv = *(struct ide_driver **)rq->rq_disk->private_data;
 
                 return drv->do_request(drive, rq, rq->sector);
         }
@@ -839,7 +646,7 @@ kill_rq:
  *      @timeout: time to stall for (jiffies)
  *
  *      ide_stall_queue() can be used by a drive to give excess bandwidth back
- *      to the hwgroup by sleeping for timeout jiffies.
+ *      to the port by sleeping for timeout jiffies.
  */
  
 void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
@@ -849,206 +656,117 @@ void ide_stall_queue (ide_drive_t *drive, unsigned long timeout)
         drive->sleep = timeout + jiffies;
         drive->dev_flags |= IDE_DFLAG_SLEEPING;
 }
-
 EXPORT_SYMBOL(ide_stall_queue);
 
-#define WAKEUP(drive)   ((drive)->service_start + 2 * (drive)->service_time)
+static inline int ide_lock_port(ide_hwif_t *hwif)
+{
+        if (hwif->busy)
+                return 1;
 
-/**
- *      choose_drive            -       select a drive to service
- *      @hwgroup: hardware group to select on
- *
- *      choose_drive() selects the next drive which will be serviced.
- *      This is necessary because the IDE layer can't issue commands
- *      to both drives on the same cable, unlike SCSI.
- */
- 
-static inline ide_drive_t *choose_drive (ide_hwgroup_t *hwgroup)
+        hwif->busy = 1;
+
+        return 0;
+}
+
+static inline void ide_unlock_port(ide_hwif_t *hwif)
+{
+        hwif->busy = 0;
+}
+
+static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif)
 {
-        ide_drive_t *drive, *best;
+        int rc = 0;
 
-repeat: 
-        best = NULL;
-        drive = hwgroup->drive;
+        if (host->host_flags & IDE_HFLAG_SERIALIZE) {
+                rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy);
+                if (rc == 0) {
+                        /* for atari only */
+                        ide_get_lock(ide_intr, hwif);
+                }
+        }
+        return rc;
+}
+
+static inline void ide_unlock_host(struct ide_host *host)
+{
+        if (host->host_flags & IDE_HFLAG_SERIALIZE) {
+                /* for atari only */
+                ide_release_lock();
+                clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy);
+        }
+}
+
+/*
+ * Issue a new request to a device.
+ */
+void do_ide_request(struct request_queue *q)
+{
+        ide_drive_t     *drive = q->queuedata;
+        ide_hwif_t      *hwif = drive->hwif;
+        struct ide_host *host = hwif->host;
+        struct request  *rq = NULL;
+        ide_startstop_t startstop;
 
         /*
          * drive is doing pre-flush, ordered write, post-flush sequence. even
          * though that is 3 requests, it must be seen as a single transaction.
          * we must not preempt this drive until that is complete
          */
-        if (blk_queue_flushing(drive->queue)) {
+        if (blk_queue_flushing(q))
                 /*
                  * small race where queue could get replugged during
                  * the 3-request flush cycle, just yank the plug since
                  * we want it to finish asap
                  */
-                blk_remove_plug(drive->queue);
-                return drive;
-        }
+                blk_remove_plug(q);
 
-        do {
-                u8 dev_s = !!(drive->dev_flags & IDE_DFLAG_SLEEPING);
-                u8 best_s = (best && !!(best->dev_flags & IDE_DFLAG_SLEEPING));
-
-                if ((dev_s == 0 || time_after_eq(jiffies, drive->sleep)) &&
-                    !elv_queue_empty(drive->queue)) {
-                        if (best == NULL ||
-                            (dev_s && (best_s == 0 || time_before(drive->sleep, best->sleep))) ||
-                            (best_s == 0 && time_before(WAKEUP(drive), WAKEUP(best)))) {
-                                if (!blk_queue_plugged(drive->queue))
-                                        best = drive;
-                        }
-                }
-        } while ((drive = drive->next) != hwgroup->drive);
+        spin_unlock_irq(q->queue_lock);
 
-        if (best && (best->dev_flags & IDE_DFLAG_NICE1) &&
-            (best->dev_flags & IDE_DFLAG_SLEEPING) == 0 &&
-            best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) {
-                long t = (signed long)(WAKEUP(best) - jiffies);
-                if (t >= WAIT_MIN_SLEEP) {
-                /*
-                 * We *may* have some time to spare, but first let's see if
-                 * someone can potentially benefit from our nice mood today..
-                 */
-                        drive = best->next;
-                        do {
-                                if ((drive->dev_flags & IDE_DFLAG_SLEEPING) == 0
-                                 && time_before(jiffies - best->service_time, WAKEUP(drive))
-                                 && time_before(WAKEUP(drive), jiffies + t))
-                                {
-                                        ide_stall_queue(best, min_t(long, t, 10 * WAIT_MIN_SLEEP));
-                                        goto repeat;
-                                }
-                        } while ((drive = drive->next) != best);
-                }
-        }
-        return best;
-}
+        if (ide_lock_host(host, hwif))
+                goto plug_device_2;
 
-/*
- * Issue a new request to a drive from hwgroup
- * Caller must have already done spin_lock_irqsave(&ide_lock, ..);
- *
- * A hwgroup is a serialized group of IDE interfaces.  Usually there is
- * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640)
- * may have both interfaces in a single hwgroup to "serialize" access.
- * Or possibly multiple ISA interfaces can share a common IRQ by being grouped
- * together into one hwgroup for serialized access.
- *
- * Note also that several hwgroups can end up sharing a single IRQ,
- * possibly along with many other devices.  This is especially common in
- * PCI-based systems with off-board IDE controller cards.
- *
- * The IDE driver uses the single global ide_lock spinlock to protect
- * access to the request queues, and to protect the hwgroup->busy flag.
- *
- * The first thread into the driver for a particular hwgroup sets the
- * hwgroup->busy flag to indicate that this hwgroup is now active,
- * and then initiates processing of the top request from the request queue.
- *
- * Other threads attempting entry notice the busy setting, and will simply
- * queue their new requests and exit immediately.  Note that hwgroup->busy
- * remains set even when the driver is merely awaiting the next interrupt.
- * Thus, the meaning is "this hwgroup is busy processing a request".
- *
- * When processing of a request completes, the completing thread or IRQ-handler
- * will start the next request from the queue.  If no more work remains,
- * the driver will clear the hwgroup->busy flag and exit.
- *
- * The ide_lock (spinlock) is used to protect all access to the
- * hwgroup->busy flag, but is otherwise not needed for most processing in
- * the driver.  This makes the driver much more friendlier to shared IRQs
- * than previous designs, while remaining 100% (?) SMP safe and capable.
- */
-static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
-{
-        ide_drive_t     *drive;
-        ide_hwif_t      *hwif;
-        struct request  *rq;
-        ide_startstop_t startstop;
-        int             loops = 0;
+        spin_lock_irq(&hwif->lock);
 
-        /* caller must own ide_lock */
-        BUG_ON(!irqs_disabled());
+        if (!ide_lock_port(hwif)) {
+                ide_hwif_t *prev_port;
+repeat:
+                prev_port = hwif->host->cur_port;
+                hwif->rq = NULL;
 
-        while (!hwgroup->busy) {
-                hwgroup->busy = 1;
-                /* for atari only */
-                ide_get_lock(ide_intr, hwgroup);
-                drive = choose_drive(hwgroup);
-                if (drive == NULL) {
-                        int sleeping = 0;
-                        unsigned long sleep = 0; /* shut up, gcc */
-                        hwgroup->rq = NULL;
-                        drive = hwgroup->drive;
-                        do {
-                                if ((drive->dev_flags & IDE_DFLAG_SLEEPING) &&
-                                    (sleeping == 0 ||
-                                     time_before(drive->sleep, sleep))) {
-                                        sleeping = 1;
-                                        sleep = drive->sleep;
-                                }
-                        } while ((drive = drive->next) != hwgroup->drive);
-                        if (sleeping) {
-                /*
-                 * Take a short snooze, and then wake up this hwgroup again.
-                 * This gives other hwgroups on the same a chance to
-                 * play fairly with us, just in case there are big differences
-                 * in relative throughputs.. don't want to hog the cpu too much.
-                 */
-                                if (time_before(sleep, jiffies + WAIT_MIN_SLEEP))
-                                        sleep = jiffies + WAIT_MIN_SLEEP;
-#if 1
-                                if (timer_pending(&hwgroup->timer))
-                                        printk(KERN_CRIT "ide_set_handler: timer already active\n");
-#endif
-                                /* so that ide_timer_expiry knows what to do */
-                                hwgroup->sleeping = 1;
-                                hwgroup->req_gen_timer = hwgroup->req_gen;
-                                mod_timer(&hwgroup->timer, sleep);
-                                /* we purposely leave hwgroup->busy==1
-                                 * while sleeping */
-                        } else {
-                                /* Ugly, but how can we sleep for the lock
-                                 * otherwise? perhaps from tq_disk?
-                                 */
-
-                                /* for atari only */
-                                ide_release_lock();
-                                hwgroup->busy = 0;
+                if (drive->dev_flags & IDE_DFLAG_SLEEPING) {
+                        if (time_before(drive->sleep, jiffies)) {
+                                ide_unlock_port(hwif);
+                                goto plug_device;
                         }
-
-                        /* no more work for this hwgroup (for now) */
-                        return;
                 }
-        again:
-                hwif = HWIF(drive);
-                if (hwgroup->hwif->sharing_irq && hwif != hwgroup->hwif) {
+
+                if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) &&
+                    hwif != prev_port) {
                         /*
-                         * set nIEN for previous hwif, drives in the
+                         * set nIEN for previous port, drives in the
                          * quirk_list may not like intr setups/cleanups
                          */
-                        if (drive->quirk_list != 1)
-                                hwif->tp_ops->set_irq(hwif, 0);
-                }
-                hwgroup->hwif = hwif;
-                hwgroup->drive = drive;
-                drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
-                drive->service_start = jiffies;
+                        if (prev_port && prev_port->cur_dev->quirk_list == 0)
+                                prev_port->tp_ops->set_irq(prev_port, 0);
 
-                if (blk_queue_plugged(drive->queue)) {
-                        printk(KERN_ERR "ide: huh? queue was plugged!\n");
-                        break;
+                        hwif->host->cur_port = hwif;
                 }
+                hwif->cur_dev = drive;
+                drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
 
+                spin_unlock_irq(&hwif->lock);
+                spin_lock_irq(q->queue_lock);
                 /*
                  * we know that the queue isn't empty, but this can happen
                  * if the q->prep_rq_fn() decides to kill a request
                  */
                 rq = elv_next_request(drive->queue);
+                spin_unlock_irq(q->queue_lock);
+                spin_lock_irq(&hwif->lock);
+
                 if (!rq) {
-                        hwgroup->busy = 0;
-                        break;
+                        ide_unlock_port(hwif);
+                        goto out;
                 }
 
                 /*
@@ -1063,63 +781,50 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                  * though. I hope that doesn't happen too much, hopefully not
                  * unless the subdriver triggers such a thing in its own PM
                  * state machine.
-                 *
-                 * We count how many times we loop here to make sure we service
-                 * all drives in the hwgroup without looping for ever
                  */
                 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
                     blk_pm_request(rq) == 0 &&
                     (rq->cmd_flags & REQ_PREEMPT) == 0) {
-                        drive = drive->next ? drive->next : hwgroup->drive;
-                        if (loops++ < 4 && !blk_queue_plugged(drive->queue))
-                                goto again;
-                        /* We clear busy, there should be no pending ATA command at this point. */
-                        hwgroup->busy = 0;
-                        break;
+                        /* there should be no pending command at this point */
+                        ide_unlock_port(hwif);
+                        goto plug_device;
                 }
 
-                hwgroup->rq = rq;
+                hwif->rq = rq;
 
-                /*
-                 * Some systems have trouble with IDE IRQs arriving while
-                 * the driver is still setting things up.  So, here we disable
-                 * the IRQ used by this interface while the request is being started.
-                 * This may look bad at first, but pretty much the same thing
-                 * happens anyway when any interrupt comes in, IDE or otherwise
-                 *  -- the kernel masks the IRQ while it is being handled.
-                 */
-                if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq)
-                        disable_irq_nosync(hwif->irq);
-                spin_unlock(&ide_lock);
-                local_irq_enable_in_hardirq();
-                        /* allow other IRQs while we start this request */
+                spin_unlock_irq(&hwif->lock);
                 startstop = start_request(drive, rq);
-                spin_lock_irq(&ide_lock);
-                if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq)
-                        enable_irq(hwif->irq);
-                if (startstop == ide_stopped)
-                        hwgroup->busy = 0;
-        }
-}
+                spin_lock_irq(&hwif->lock);
 
-/*
- * Passes the stuff to ide_do_request
- */
-void do_ide_request(struct request_queue *q)
-{
-        ide_drive_t *drive = q->queuedata;
-
-        ide_do_request(HWGROUP(drive), IDE_NO_IRQ);
+                if (startstop == ide_stopped)
+                        goto repeat;
+        } else
+                goto plug_device;
+out:
+        spin_unlock_irq(&hwif->lock);
+        if (rq == NULL)
+                ide_unlock_host(host);
+        spin_lock_irq(q->queue_lock);
+        return;
+
+plug_device:
+        spin_unlock_irq(&hwif->lock);
+        ide_unlock_host(host);
+plug_device_2:
+        spin_lock_irq(q->queue_lock);
+
+        if (!elv_queue_empty(q))
+                blk_plug_device(q);
 }
 
 /*
- * un-busy the hwgroup etc, and clear any pending DMA status. we want to
+ * un-busy the port etc, and clear any pending DMA status. we want to
  * retry the current request in pio mode instead of risking tossing it
  * all away
  */
 static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct request *rq;
         ide_startstop_t ret = ide_stopped;
 
@@ -1147,15 +852,14 @@ static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
         ide_dma_off_quietly(drive);
 
         /*
-         * un-busy drive etc (hwgroup->busy is cleared on return) and
-         * make sure request is sane
+         * un-busy drive etc and make sure request is sane
          */
-        rq = HWGROUP(drive)->rq;
 
+        rq = hwif->rq;
         if (!rq)
                 goto out;
 
-        HWGROUP(drive)->rq = NULL;
+        hwif->rq = NULL;
 
         rq->errors = 0;
 
@@ -1170,9 +874,20 @@ out:
         return ret;
 }
 
+static void ide_plug_device(ide_drive_t *drive)
+{
+        struct request_queue *q = drive->queue;
+        unsigned long flags;
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (!elv_queue_empty(q))
+                blk_plug_device(q);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+}
+
 /**
  *      ide_timer_expiry        -       handle lack of an IDE interrupt
- *      @data: timer callback magic (hwgroup)
+ *      @data: timer callback magic (hwif)
  *
  *      An IDE command has timed out before the expected drive return
  *      occurred. At this point we attempt to clean up the current
@@ -1186,93 +901,87 @@ out:
  
 void ide_timer_expiry (unsigned long data)
 {
-        ide_hwgroup_t   *hwgroup = (ide_hwgroup_t *) data;
+        ide_hwif_t      *hwif = (ide_hwif_t *)data;
+        ide_drive_t     *uninitialized_var(drive);
         ide_handler_t   *handler;
-        ide_expiry_t    *expiry;
         unsigned long   flags;
         unsigned long   wait = -1;
+        int             plug_device = 0;
 
-        spin_lock_irqsave(&ide_lock, flags);
+        spin_lock_irqsave(&hwif->lock, flags);
 
-        if (((handler = hwgroup->handler) == NULL) ||
-            (hwgroup->req_gen != hwgroup->req_gen_timer)) {
+        handler = hwif->handler;
+
+        if (handler == NULL || hwif->req_gen != hwif->req_gen_timer) {
                 /*
                  * Either a marginal timeout occurred
                  * (got the interrupt just as timer expired),
                  * or we were "sleeping" to give other devices a chance.
                  * Either way, we don't really want to complain about anything.
                  */
-                if (hwgroup->sleeping) {
-                        hwgroup->sleeping = 0;
-                        hwgroup->busy = 0;
-                }
         } else {
-                ide_drive_t *drive = hwgroup->drive;
-                if (!drive) {
-                        printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n");
-                        hwgroup->handler = NULL;
-                } else {
-                        ide_hwif_t *hwif;
-                        ide_startstop_t startstop = ide_stopped;
-                        if (!hwgroup->busy) {
-                                hwgroup->busy = 1;      /* paranoia */
-                                printk(KERN_ERR "%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name);
-                        }
-                        if ((expiry = hwgroup->expiry) != NULL) {
-                                /* continue */
-                                if ((wait = expiry(drive)) > 0) {
-                                        /* reset timer */
-                                        hwgroup->timer.expires  = jiffies + wait;
-                                        hwgroup->req_gen_timer = hwgroup->req_gen;
-                                        add_timer(&hwgroup->timer);
-                                        spin_unlock_irqrestore(&ide_lock, flags);
-                                        return;
-                                }
+                ide_expiry_t *expiry = hwif->expiry;
+                ide_startstop_t startstop = ide_stopped;
+
+                drive = hwif->cur_dev;
+
+                if (expiry) {
+                        wait = expiry(drive);
+                        if (wait > 0) { /* continue */
+                                /* reset timer */
+                                hwif->timer.expires = jiffies + wait;
+                                hwif->req_gen_timer = hwif->req_gen;
+                                add_timer(&hwif->timer);
+                                spin_unlock_irqrestore(&hwif->lock, flags);
+                                return;
                         }
-                        hwgroup->handler = NULL;
-                        /*
-                         * We need to simulate a real interrupt when invoking
-                         * the handler() function, which means we need to
-                         * globally mask the specific IRQ:
-                         */
-                        spin_unlock(&ide_lock);
-                        hwif  = HWIF(drive);
-                        /* disable_irq_nosync ?? */
-                        disable_irq(hwif->irq);
-                        /* local CPU only,
-                         * as if we were handling an interrupt */
-                        local_irq_disable();
-                        if (hwgroup->polling) {
-                                startstop = handler(drive);
-                        } else if (drive_is_ready(drive)) {
-                                if (drive->waiting_for_dma)
-                                        hwif->dma_ops->dma_lost_irq(drive);
-                                (void)ide_ack_intr(hwif);
-                                printk(KERN_WARNING "%s: lost interrupt\n", drive->name);
-                                startstop = handler(drive);
-                        } else {
-                                if (drive->waiting_for_dma) {
-                                        startstop = ide_dma_timeout_retry(drive, wait);
-                                } else
-                                        startstop =
-                                        ide_error(drive, "irq timeout",
-                                                  hwif->tp_ops->read_status(hwif));
-                        }
-                        drive->service_time = jiffies - drive->service_start;
-                        spin_lock_irq(&ide_lock);
-                        enable_irq(hwif->irq);
-                        if (startstop == ide_stopped)
-                                hwgroup->busy = 0;
                 }
+                hwif->handler = NULL;
+                /*
+                 * We need to simulate a real interrupt when invoking
+                 * the handler() function, which means we need to
+                 * globally mask the specific IRQ:
+                 */
+                spin_unlock(&hwif->lock);
+                /* disable_irq_nosync ?? */
+                disable_irq(hwif->irq);
+                /* local CPU only, as if we were handling an interrupt */
+                local_irq_disable();
+                if (hwif->polling) {
+                        startstop = handler(drive);
+                } else if (drive_is_ready(drive)) {
+                        if (drive->waiting_for_dma)
+                                hwif->dma_ops->dma_lost_irq(drive);
+                        (void)ide_ack_intr(hwif);
+                        printk(KERN_WARNING "%s: lost interrupt\n",
+                                drive->name);
+                        startstop = handler(drive);
+                } else {
+                        if (drive->waiting_for_dma)
+                                startstop = ide_dma_timeout_retry(drive, wait);
+                        else
+                                startstop = ide_error(drive, "irq timeout",
+                                        hwif->tp_ops->read_status(hwif));
+                }
+                spin_lock_irq(&hwif->lock);
+                enable_irq(hwif->irq);
+                if (startstop == ide_stopped) {
+                        ide_unlock_port(hwif);
+                        plug_device = 1;
+                }
+        }
+        spin_unlock_irqrestore(&hwif->lock, flags);
+
+        if (plug_device) {
+                ide_unlock_host(hwif->host);
+                ide_plug_device(drive);
         }
-        ide_do_request(hwgroup, IDE_NO_IRQ);
-        spin_unlock_irqrestore(&ide_lock, flags);
 }
 
 /**
  *      unexpected_intr         -       handle an unexpected IDE interrupt
  *      @irq: interrupt line
- *      @hwgroup: hwgroup being processed
+ *      @hwif: port being processed
  *
  *      There's nothing really useful we can do with an unexpected interrupt,
  *      other than reading the status register (to clear it), and logging it.
@@ -1296,52 +1005,38 @@ void ide_timer_expiry (unsigned long data)
  *      before completing the issuance of any new drive command, so we will not
  *      be accidentally invoked as a result of any valid command completion
  *      interrupt.
- *
- *      Note that we must walk the entire hwgroup here. We know which hwif
- *      is doing the current command, but we don't know which hwif burped
- *      mysteriously.
  */
- 
-static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup)
-{
-        u8 stat;
-        ide_hwif_t *hwif = hwgroup->hwif;
 
-        /*
-         * handle the unexpected interrupt
-         */
-        do {
-                if (hwif->irq == irq) {
-                        stat = hwif->tp_ops->read_status(hwif);
-
-                        if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) {
-                                /* Try to not flood the console with msgs */
-                                static unsigned long last_msgtime, count;
-                                ++count;
-                                if (time_after(jiffies, last_msgtime + HZ)) {
-                                        last_msgtime = jiffies;
-                                        printk(KERN_ERR "%s%s: unexpected interrupt, "
-                                                "status=0x%02x, count=%ld\n",
-                                                hwif->name,
-                                                (hwif->next==hwgroup->hwif) ? "" : "(?)", stat, count);
-                                }
-                        }
+static void unexpected_intr(int irq, ide_hwif_t *hwif)
+{
+        u8 stat = hwif->tp_ops->read_status(hwif);
+
+        if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) {
+                /* Try to not flood the console with msgs */
+                static unsigned long last_msgtime, count;
+                ++count;
+
+                if (time_after(jiffies, last_msgtime + HZ)) {
+                        last_msgtime = jiffies;
+                        printk(KERN_ERR "%s: unexpected interrupt, "
+                                "status=0x%02x, count=%ld\n",
+                                hwif->name, stat, count);
                 }
-        } while ((hwif = hwif->next) != hwgroup->hwif);
+        }
 }
 
 /**
  *      ide_intr        -       default IDE interrupt handler
  *      @irq: interrupt number
- *      @dev_id: hwif group
+ *      @dev_id: hwif
  *      @regs: unused weirdness from the kernel irq layer
  *
  *      This is the default IRQ handler for the IDE layer. You should
  *      not need to override it. If you do be aware it is subtle in
  *      places
  *
- *      hwgroup->hwif is the interface in the group currently performing
- *      a command. hwgroup->drive is the drive and hwgroup->handler is
+ *      hwif is the interface in the group currently performing
+ *      a command. hwif->cur_dev is the drive and hwif->handler is
  *      the IRQ handler to call. As we issue a command the handlers
  *      step through multiple states, reassigning the handler to the
  *      next step in the process. Unlike a smart SCSI controller IDE
@@ -1352,27 +1047,32 @@ static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup)
  *
  *      The handler eventually returns ide_stopped to indicate the
  *      request completed. At this point we issue the next request
- *      on the hwgroup and the process begins again.
+ *      on the port and the process begins again.
  */
- 
+
 irqreturn_t ide_intr (int irq, void *dev_id)
 {
-        unsigned long flags;
-        ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id;
-        ide_hwif_t *hwif;
-        ide_drive_t *drive;
+        ide_hwif_t *hwif = (ide_hwif_t *)dev_id;
+        ide_drive_t *uninitialized_var(drive);
         ide_handler_t *handler;
+        unsigned long flags;
         ide_startstop_t startstop;
+        irqreturn_t irq_ret = IRQ_NONE;
+        int plug_device = 0;
 
-        spin_lock_irqsave(&ide_lock, flags);
-        hwif = hwgroup->hwif;
-
-        if (!ide_ack_intr(hwif)) {
-                spin_unlock_irqrestore(&ide_lock, flags);
-                return IRQ_NONE;
+        if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE) {
+                if (hwif != hwif->host->cur_port)
+                        goto out_early;
         }
 
-        if ((handler = hwgroup->handler) == NULL || hwgroup->polling) {
+        spin_lock_irqsave(&hwif->lock, flags);
+
+        if (!ide_ack_intr(hwif))
+                goto out;
+
+        handler = hwif->handler;
+
+        if (handler == NULL || hwif->polling) {
                 /*
                  * Not expecting an interrupt from this drive.
                  * That means this could be:
@@ -1396,7 +1096,7 @@ irqreturn_t ide_intr (int irq, void *dev_id)
                          * Probably not a shared PCI interrupt,
                          * so we can safely try to do something about it:
                          */
-                        unexpected_intr(irq, hwgroup);
+                        unexpected_intr(irq, hwif);
 #ifdef CONFIG_BLK_DEV_IDEPCI
                 } else {
                         /*
@@ -1406,21 +1106,12 @@ irqreturn_t ide_intr (int irq, void *dev_id)
                         (void)hwif->tp_ops->read_status(hwif);
 #endif /* CONFIG_BLK_DEV_IDEPCI */
                 }
-                spin_unlock_irqrestore(&ide_lock, flags);
-                return IRQ_NONE;
-        }
-        drive = hwgroup->drive;
-        if (!drive) {
-                /*
-                 * This should NEVER happen, and there isn't much
-                 * we could do about it here.
-                 *
-                 * [Note - this can occur if the drive is hot unplugged]
-                 */
-                spin_unlock_irqrestore(&ide_lock, flags);
-                return IRQ_HANDLED;
+                goto out;
         }
-        if (!drive_is_ready(drive)) {
+
+        drive = hwif->cur_dev;
+
+        if (!drive_is_ready(drive))
                 /*
                  * This happens regularly when we share a PCI IRQ with
                  * another device.  Unfortunately, it can also happen
@@ -1428,17 +1119,12 @@ irqreturn_t ide_intr (int irq, void *dev_id)
                  * their status register is up to date.  Hopefully we have
                  * enough advance overhead that the latter isn't a problem.
                  */
-                spin_unlock_irqrestore(&ide_lock, flags);
-                return IRQ_NONE;
-        }
-        if (!hwgroup->busy) {
-                hwgroup->busy = 1;      /* paranoia */
-                printk(KERN_ERR "%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name);
-        }
-        hwgroup->handler = NULL;
-        hwgroup->req_gen++;
-        del_timer(&hwgroup->timer);
-        spin_unlock(&ide_lock);
+                goto out;
+
+        hwif->handler = NULL;
+        hwif->req_gen++;
+        del_timer(&hwif->timer);
+        spin_unlock(&hwif->lock);
 
         if (hwif->port_ops && hwif->port_ops->clear_irq)
                 hwif->port_ops->clear_irq(drive);
@@ -1449,7 +1135,7 @@ irqreturn_t ide_intr (int irq, void *dev_id)
         /* service this interrupt, may set handler for next interrupt */
         startstop = handler(drive);
 
-        spin_lock_irq(&ide_lock);
+        spin_lock_irq(&hwif->lock);
         /*
          * Note that handler() may have set things up for another
          * interrupt to occur soon, but it cannot happen until
@@ -1457,18 +1143,21 @@ irqreturn_t ide_intr (int irq, void *dev_id)
          * same irq as is currently being serviced here, and Linux
          * won't allow another of the same (on any CPU) until we return.
          */
-        drive->service_time = jiffies - drive->service_start;
         if (startstop == ide_stopped) {
-                if (hwgroup->handler == NULL) { /* paranoia */
-                        hwgroup->busy = 0;
-                        ide_do_request(hwgroup, hwif->irq);
-                } else {
-                        printk(KERN_ERR "%s: ide_intr: huh? expected NULL handler "
-                                "on exit\n", drive->name);
-                }
+                BUG_ON(hwif->handler);
+                ide_unlock_port(hwif);
+                plug_device = 1;
         }
-        spin_unlock_irqrestore(&ide_lock, flags);
-        return IRQ_HANDLED;
+        irq_ret = IRQ_HANDLED;
+out:
+        spin_unlock_irqrestore(&hwif->lock, flags);
+out_early:
+        if (plug_device) {
+                ide_unlock_host(hwif->host);
+                ide_plug_device(drive);
+        }
+
+        return irq_ret;
 }
 
 /**
@@ -1488,16 +1177,15 @@ irqreturn_t ide_intr (int irq, void *dev_id)
 
 void ide_do_drive_cmd(ide_drive_t *drive, struct request *rq)
 {
+        struct request_queue *q = drive->queue;
         unsigned long flags;
-        ide_hwgroup_t *hwgroup = HWGROUP(drive);
 
-        spin_lock_irqsave(&ide_lock, flags);
-        hwgroup->rq = NULL;
-        __elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
-        blk_start_queueing(drive->queue);
-        spin_unlock_irqrestore(&ide_lock, flags);
-}
+        drive->hwif->rq = NULL;
 
+        spin_lock_irqsave(q->queue_lock, flags);
+        __elv_add_request(q, rq, ELEVATOR_INSERT_FRONT, 0);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+}
 EXPORT_SYMBOL(ide_do_drive_cmd);
 
 void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount, u8 dma)
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index fcde16bb53a7..1be263eb9c07 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -19,7 +19,6 @@ int ide_setting_ioctl(ide_drive_t *drive, struct block_device *bdev,
                       const struct ide_ioctl_devset *s)
 {
         const struct ide_devset *ds;
-        unsigned long flags;
         int err = -EOPNOTSUPP;
 
         for (; (ds = s->setting); s++) {
@@ -33,9 +32,7 @@ int ide_setting_ioctl(ide_drive_t *drive, struct block_device *bdev,
 
 read_val:
         mutex_lock(&ide_setting_mtx);
-        spin_lock_irqsave(&ide_lock, flags);
         err = ds->get(drive);
-        spin_unlock_irqrestore(&ide_lock, flags);
         mutex_unlock(&ide_setting_mtx);
         return err >= 0 ? put_user(err, (long __user *)arg) : err;
 
@@ -98,8 +95,7 @@ static int ide_set_nice_ioctl(ide_drive_t *drive, unsigned long arg)
                 return -EPERM;
 
         if (((arg >> IDE_NICE_DSC_OVERLAP) & 1) &&
-            (drive->media == ide_disk || drive->media == ide_floppy ||
-             (drive->dev_flags & IDE_DFLAG_SCSI)))
+            (drive->media != ide_tape))
                 return -EPERM;
 
         if ((arg >> IDE_NICE_DSC_OVERLAP) & 1)
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index c41c3b9b6f02..e728cfe7273f 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -105,15 +105,6 @@ u8 ide_read_altstatus(ide_hwif_t *hwif)
 }
 EXPORT_SYMBOL_GPL(ide_read_altstatus);
 
-u8 ide_read_sff_dma_status(ide_hwif_t *hwif)
-{
-        if (hwif->host_flags & IDE_HFLAG_MMIO)
-                return readb((void __iomem *)(hwif->dma_base + ATA_DMA_STATUS));
-        else
-                return inb(hwif->dma_base + ATA_DMA_STATUS);
-}
-EXPORT_SYMBOL_GPL(ide_read_sff_dma_status);
-
 void ide_set_irq(ide_hwif_t *hwif, int on)
 {
         u8 ctl = ATA_DEVCTL_OBS;
@@ -388,7 +379,6 @@ const struct ide_tp_ops default_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
@@ -451,7 +441,7 @@ EXPORT_SYMBOL(ide_fixstring);
  */
 int drive_is_ready (ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         u8 stat                 = 0;
 
         if (drive->waiting_for_dma)
@@ -503,7 +493,8 @@ static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long ti
         stat = tp_ops->read_status(hwif);
 
         if (stat & ATA_BUSY) {
-                local_irq_set(flags);
+                local_irq_save(flags);
+                local_irq_enable_in_hardirq();
                 timeout += jiffies;
                 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
                         if (time_after(jiffies, timeout)) {
@@ -822,23 +813,25 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 static void __ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
                       unsigned int timeout, ide_expiry_t *expiry)
 {
-        ide_hwgroup_t *hwgroup = HWGROUP(drive);
-
-        BUG_ON(hwgroup->handler);
-        hwgroup->handler        = handler;
-        hwgroup->expiry         = expiry;
-        hwgroup->timer.expires  = jiffies + timeout;
-        hwgroup->req_gen_timer  = hwgroup->req_gen;
-        add_timer(&hwgroup->timer);
+        ide_hwif_t *hwif = drive->hwif;
+
+        BUG_ON(hwif->handler);
+        hwif->handler           = handler;
+        hwif->expiry            = expiry;
+        hwif->timer.expires     = jiffies + timeout;
+        hwif->req_gen_timer     = hwif->req_gen;
+        add_timer(&hwif->timer);
 }
 
 void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
                       unsigned int timeout, ide_expiry_t *expiry)
 {
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long flags;
-        spin_lock_irqsave(&ide_lock, flags);
+
+        spin_lock_irqsave(&hwif->lock, flags);
         __ide_set_handler(drive, handler, timeout, expiry);
-        spin_unlock_irqrestore(&ide_lock, flags);
+        spin_unlock_irqrestore(&hwif->lock, flags);
 }
 
 EXPORT_SYMBOL(ide_set_handler);
@@ -860,10 +853,10 @@ EXPORT_SYMBOL(ide_set_handler);
 void ide_execute_command(ide_drive_t *drive, u8 cmd, ide_handler_t *handler,
                          unsigned timeout, ide_expiry_t *expiry)
 {
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long flags;
-        ide_hwif_t *hwif = HWIF(drive);
 
-        spin_lock_irqsave(&ide_lock, flags);
+        spin_lock_irqsave(&hwif->lock, flags);
         __ide_set_handler(drive, handler, timeout, expiry);
         hwif->tp_ops->exec_command(hwif, cmd);
         /*
@@ -873,7 +866,7 @@ void ide_execute_command(ide_drive_t *drive, u8 cmd, ide_handler_t *handler,
          * FIXME: we could skip this delay with care on non shared devices
          */
         ndelay(400);
-        spin_unlock_irqrestore(&ide_lock, flags);
+        spin_unlock_irqrestore(&hwif->lock, flags);
 }
 EXPORT_SYMBOL(ide_execute_command);
 
@@ -882,16 +875,16 @@ void ide_execute_pkt_cmd(ide_drive_t *drive)
         ide_hwif_t *hwif = drive->hwif;
         unsigned long flags;
 
-        spin_lock_irqsave(&ide_lock, flags);
+        spin_lock_irqsave(&hwif->lock, flags);
         hwif->tp_ops->exec_command(hwif, ATA_CMD_PACKET);
         ndelay(400);
-        spin_unlock_irqrestore(&ide_lock, flags);
+        spin_unlock_irqrestore(&hwif->lock, flags);
 }
 EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd);
 
 static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
 {
-        struct request *rq = drive->hwif->hwgroup->rq;
+        struct request *rq = drive->hwif->rq;
 
         if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET)
                 ide_end_request(drive, err ? err : 1, 0);
@@ -909,7 +902,6 @@ static ide_startstop_t do_reset1 (ide_drive_t *, int);
 static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        ide_hwgroup_t *hwgroup = hwif->hwgroup;
         u8 stat;
 
         SELECT_DRIVE(drive);
@@ -919,20 +911,20 @@ static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
         if (OK_STAT(stat, 0, ATA_BUSY))
                 printk("%s: ATAPI reset complete\n", drive->name);
         else {
-                if (time_before(jiffies, hwgroup->poll_timeout)) {
+                if (time_before(jiffies, hwif->poll_timeout)) {
                         ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
                         /* continue polling */
                         return ide_started;
                 }
                 /* end of polling */
-                hwgroup->polling = 0;
+                hwif->polling = 0;
                 printk("%s: ATAPI reset timed-out, status=0x%02x\n",
                                 drive->name, stat);
                 /* do it the old fashioned way */
                 return do_reset1(drive, 1);
         }
         /* done polling */
-        hwgroup->polling = 0;
+        hwif->polling = 0;
         ide_complete_drive_reset(drive, 0);
         return ide_stopped;
 }
@@ -964,8 +956,7 @@ static void ide_reset_report_error(ide_hwif_t *hwif, u8 err)
  */
 static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
 {
-        ide_hwgroup_t *hwgroup  = HWGROUP(drive);
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         const struct ide_port_ops *port_ops = hwif->port_ops;
         u8 tmp;
         int err = 0;
@@ -982,7 +973,7 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
         tmp = hwif->tp_ops->read_status(hwif);
 
         if (!OK_STAT(tmp, 0, ATA_BUSY)) {
-                if (time_before(jiffies, hwgroup->poll_timeout)) {
+                if (time_before(jiffies, hwif->poll_timeout)) {
                         ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
                         /* continue polling */
                         return ide_started;
@@ -1003,7 +994,7 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
                 }
         }
 out:
-        hwgroup->polling = 0;   /* done polling */
+        hwif->polling = 0;      /* done polling */
         ide_complete_drive_reset(drive, err);
         return ide_stopped;
 }
@@ -1076,25 +1067,19 @@ static void pre_reset(ide_drive_t *drive)
  */
 static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
 {
-        unsigned int unit;
-        unsigned long flags, timeout;
-        ide_hwif_t *hwif;
-        ide_hwgroup_t *hwgroup;
-        struct ide_io_ports *io_ports;
-        const struct ide_tp_ops *tp_ops;
+        ide_hwif_t *hwif = drive->hwif;
+        struct ide_io_ports *io_ports = &hwif->io_ports;
+        const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         const struct ide_port_ops *port_ops;
+        ide_drive_t *tdrive;
+        unsigned long flags, timeout;
+        int i;
         DEFINE_WAIT(wait);
 
-        spin_lock_irqsave(&ide_lock, flags);
-        hwif = HWIF(drive);
-        hwgroup = HWGROUP(drive);
-
-        io_ports = &hwif->io_ports;
-
-        tp_ops = hwif->tp_ops;
+        spin_lock_irqsave(&hwif->lock, flags);
 
         /* We must not reset with running handlers */
-        BUG_ON(hwgroup->handler != NULL);
+        BUG_ON(hwif->handler != NULL);
 
         /* For an ATAPI device, first try an ATAPI SRST. */
         if (drive->media != ide_disk && !do_not_try_atapi) {
@@ -1103,10 +1088,10 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
                 udelay (20);
                 tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
                 ndelay(400);
-                hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
-                hwgroup->polling = 1;
+                hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
+                hwif->polling = 1;
                 __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL);
-                spin_unlock_irqrestore(&ide_lock, flags);
+                spin_unlock_irqrestore(&hwif->lock, flags);
                 return ide_started;
         }
 
@@ -1116,9 +1101,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
 
                 prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE);
                 timeout = jiffies;
-                for (unit = 0; unit < MAX_DRIVES; unit++) {
-                        ide_drive_t *tdrive = &hwif->drives[unit];
-
+                ide_port_for_each_dev(i, tdrive, hwif) {
                         if (tdrive->dev_flags & IDE_DFLAG_PRESENT &&
                             tdrive->dev_flags & IDE_DFLAG_PARKED &&
                             time_after(tdrive->sleep, timeout))
@@ -1129,9 +1112,9 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
                 if (time_before_eq(timeout, now))
                         break;
 
-                spin_unlock_irqrestore(&ide_lock, flags);
+                spin_unlock_irqrestore(&hwif->lock, flags);
                 timeout = schedule_timeout_uninterruptible(timeout - now);
-                spin_lock_irqsave(&ide_lock, flags);
+                spin_lock_irqsave(&hwif->lock, flags);
         } while (timeout);
         finish_wait(&ide_park_wq, &wait);
 
@@ -1139,11 +1122,11 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
          * First, reset any device state data we were maintaining
          * for any of the drives on this interface.
          */
-        for (unit = 0; unit < MAX_DRIVES; ++unit)
-                pre_reset(&hwif->drives[unit]);
+        ide_port_for_each_dev(i, tdrive, hwif)
+                pre_reset(tdrive);
 
         if (io_ports->ctl_addr == 0) {
-                spin_unlock_irqrestore(&ide_lock, flags);
+                spin_unlock_irqrestore(&hwif->lock, flags);
                 ide_complete_drive_reset(drive, -ENXIO);
                 return ide_stopped;
         }
@@ -1166,8 +1149,8 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
         tp_ops->set_irq(hwif, drive->quirk_list == 2);
         /* more than enough time */
         udelay(10);
-        hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
-        hwgroup->polling = 1;
+        hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
+        hwif->polling = 1;
         __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
 
         /*
@@ -1179,7 +1162,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
         if (port_ops && port_ops->resetproc)
                 port_ops->resetproc(drive);
 
-        spin_unlock_irqrestore(&ide_lock, flags);
+        spin_unlock_irqrestore(&hwif->lock, flags);
         return ide_started;
 }
 
@@ -1223,6 +1206,3 @@ int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
         }
         return -EBUSY;
 }
-
-EXPORT_SYMBOL_GPL(ide_wait_not_busy);
-
diff --git a/drivers/ide/ide-legacy.c b/drivers/ide/ide-legacy.c
new file mode 100644
index 000000000000..8c5dcbf22547
--- /dev/null
+++ b/drivers/ide/ide-legacy.c
@@ -0,0 +1,58 @@
+#include <linux/kernel.h>
+#include <linux/ide.h>
+
+static void ide_legacy_init_one(hw_regs_t **hws, hw_regs_t *hw,
+                                u8 port_no, const struct ide_port_info *d,
+                                unsigned long config)
+{
+        unsigned long base, ctl;
+        int irq;
+
+        if (port_no == 0) {
+                base = 0x1f0;
+                ctl  = 0x3f6;
+                irq  = 14;
+        } else {
+                base = 0x170;
+                ctl  = 0x376;
+                irq  = 15;
+        }
+
+        if (!request_region(base, 8, d->name)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
+                                d->name, base, base + 7);
+                return;
+        }
+
+        if (!request_region(ctl, 1, d->name)) {
+                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
+                                d->name, ctl);
+                release_region(base, 8);
+                return;
+        }
+
+        ide_std_init_ports(hw, base, ctl);
+        hw->irq = irq;
+        hw->chipset = d->chipset;
+        hw->config = config;
+
+        hws[port_no] = hw;
+}
+
+int ide_legacy_device_add(const struct ide_port_info *d, unsigned long config)
+{
+        hw_regs_t hw[2], *hws[] = { NULL, NULL, NULL, NULL };
+
+        memset(&hw, 0, sizeof(hw));
+
+        if ((d->host_flags & IDE_HFLAG_QD_2ND_PORT) == 0)
+                ide_legacy_init_one(hws, &hw[0], 0, d, config);
+        ide_legacy_init_one(hws, &hw[1], 1, d, config);
+
+        if (hws[0] == NULL && hws[1] == NULL &&
+            (d->host_flags & IDE_HFLAG_SINGLE))
+                return -ENOENT;
+
+        return ide_host_add(d, hws, NULL);
+}
+EXPORT_SYMBOL_GPL(ide_legacy_device_add);
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 9fc4cfb2a272..09526a0de734 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -43,7 +43,6 @@ const char *ide_xfer_verbose(u8 mode)
 
         return s;
 }
-
 EXPORT_SYMBOL(ide_xfer_verbose);
 
 /**
@@ -87,7 +86,7 @@ static u8 ide_rate_filter(ide_drive_t *drive, u8 speed)
  *      This is used by most chipset support modules when "auto-tuning".
  */
 
-u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
+u8 ide_get_best_pio_mode(ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
 {
         u16 *id = drive->id;
         int pio_mode = -1, overridden = 0;
@@ -131,7 +130,6 @@ u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
 
         return pio_mode;
 }
-
 EXPORT_SYMBOL_GPL(ide_get_best_pio_mode);
 
 /* req_pio == "255" for auto-tune */
@@ -162,7 +160,6 @@ void ide_set_pio(ide_drive_t *drive, u8 req_pio)
 
         (void)ide_set_pio_mode(drive, XFER_PIO_0 + pio);
 }
-
 EXPORT_SYMBOL_GPL(ide_set_pio);
 
 /**
@@ -173,7 +170,7 @@ EXPORT_SYMBOL_GPL(ide_set_pio);
  *      Enable or disable bounce buffering for the device. Drives move
  *      between PIO and DMA and that changes the rules we need.
  */
- 
+
 void ide_toggle_bounce(ide_drive_t *drive, int on)
 {
         u64 addr = BLK_BOUNCE_HIGH;     /* dma64_addr_t */
@@ -243,14 +240,13 @@ int ide_set_dma_mode(ide_drive_t *drive, const u8 mode)
                 return ide_config_drive_speed(drive, mode);
         }
 }
-
 EXPORT_SYMBOL_GPL(ide_set_dma_mode);
 
 /**
  *      ide_set_xfer_rate       -       set transfer rate
  *      @drive: drive to set
  *      @rate: speed to attempt to set
- *      
+ *
  *      General helper for setting the speed of an IDE device. This
  *      function knows about user enforced limits from the configuration
  *      which ->set_pio_mode/->set_dma_mode does not.
@@ -277,21 +273,16 @@ int ide_set_xfer_rate(ide_drive_t *drive, u8 rate)
 
 static void ide_dump_opcode(ide_drive_t *drive)
 {
-        struct request *rq;
+        struct request *rq = drive->hwif->rq;
         ide_task_t *task = NULL;
 
-        spin_lock(&ide_lock);
-        rq = NULL;
-        if (HWGROUP(drive))
-                rq = HWGROUP(drive)->rq;
-        spin_unlock(&ide_lock);
         if (!rq)
                 return;
 
         if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
                 task = rq->special;
 
-        printk("ide: failed opcode was: ");
+        printk(KERN_ERR "ide: failed opcode was: ");
         if (task == NULL)
                 printk(KERN_CONT "unknown\n");
         else
@@ -329,44 +320,58 @@ static void ide_dump_sector(ide_drive_t *drive)
         drive->hwif->tp_ops->tf_read(drive, &task);
 
         if (lba48 || (tf->device & ATA_LBA))
-                printk(", LBAsect=%llu",
+                printk(KERN_CONT ", LBAsect=%llu",
                         (unsigned long long)ide_get_lba_addr(tf, lba48));
         else
-                printk(", CHS=%d/%d/%d", (tf->lbah << 8) + tf->lbam,
-                                         tf->device & 0xf, tf->lbal);
+                printk(KERN_CONT ", CHS=%d/%d/%d", (tf->lbah << 8) + tf->lbam,
+                        tf->device & 0xf, tf->lbal);
 }
 
 static void ide_dump_ata_error(ide_drive_t *drive, u8 err)
 {
-        printk("{ ");
-        if (err & ATA_ABORTED)  printk("DriveStatusError ");
+        printk(KERN_ERR "{ ");
+        if (err & ATA_ABORTED)
+                printk(KERN_CONT "DriveStatusError ");
         if (err & ATA_ICRC)
-                printk((err & ATA_ABORTED) ? "BadCRC " : "BadSector ");
-        if (err & ATA_UNC)      printk("UncorrectableError ");
-        if (err & ATA_IDNF)     printk("SectorIdNotFound ");
-        if (err & ATA_TRK0NF)   printk("TrackZeroNotFound ");
-        if (err & ATA_AMNF)     printk("AddrMarkNotFound ");
-        printk("}");
+                printk(KERN_CONT "%s",
+                        (err & ATA_ABORTED) ? "BadCRC " : "BadSector ");
+        if (err & ATA_UNC)
+                printk(KERN_CONT "UncorrectableError ");
+        if (err & ATA_IDNF)
+                printk(KERN_CONT "SectorIdNotFound ");
+        if (err & ATA_TRK0NF)
+                printk(KERN_CONT "TrackZeroNotFound ");
+        if (err & ATA_AMNF)
+                printk(KERN_CONT "AddrMarkNotFound ");
+        printk(KERN_CONT "}");
         if ((err & (ATA_BBK | ATA_ABORTED)) == ATA_BBK ||
             (err & (ATA_UNC | ATA_IDNF | ATA_AMNF))) {
+                struct request *rq = drive->hwif->rq;
+
                 ide_dump_sector(drive);
-                if (HWGROUP(drive) && HWGROUP(drive)->rq)
-                        printk(", sector=%llu",
-                               (unsigned long long)HWGROUP(drive)->rq->sector);
+
+                if (rq)
+                        printk(KERN_CONT ", sector=%llu",
+                               (unsigned long long)rq->sector);
         }
-        printk("\n");
+        printk(KERN_CONT "\n");
 }
 
 static void ide_dump_atapi_error(ide_drive_t *drive, u8 err)
 {
-        printk("{ ");
-        if (err & ATAPI_ILI)    printk("IllegalLengthIndication ");
-        if (err & ATAPI_EOM)    printk("EndOfMedia ");
-        if (err & ATA_ABORTED)  printk("AbortedCommand ");
-        if (err & ATA_MCR)      printk("MediaChangeRequested ");
-        if (err & ATAPI_LFS)    printk("LastFailedSense=0x%02x ",
-                                       (err & ATAPI_LFS) >> 4);
-        printk("}\n");
+        printk(KERN_ERR "{ ");
+        if (err & ATAPI_ILI)
+                printk(KERN_CONT "IllegalLengthIndication ");
+        if (err & ATAPI_EOM)
+                printk(KERN_CONT "EndOfMedia ");
+        if (err & ATA_ABORTED)
+                printk(KERN_CONT "AbortedCommand ");
+        if (err & ATA_MCR)
+                printk(KERN_CONT "MediaChangeRequested ");
+        if (err & ATAPI_LFS)
+                printk(KERN_CONT "LastFailedSense=0x%02x ",
+                        (err & ATAPI_LFS) >> 4);
+        printk(KERN_CONT "}\n");
 }
 
 /**
@@ -382,34 +387,37 @@ static void ide_dump_atapi_error(ide_drive_t *drive, u8 err)
 
 u8 ide_dump_status(ide_drive_t *drive, const char *msg, u8 stat)
 {
-        unsigned long flags;
         u8 err = 0;
 
-        local_irq_save(flags);
-        printk("%s: %s: status=0x%02x { ", drive->name, msg, stat);
+        printk(KERN_ERR "%s: %s: status=0x%02x { ", drive->name, msg, stat);
         if (stat & ATA_BUSY)
-                printk("Busy ");
+                printk(KERN_CONT "Busy ");
         else {
-                if (stat & ATA_DRDY)    printk("DriveReady ");
-                if (stat & ATA_DF)      printk("DeviceFault ");
-                if (stat & ATA_DSC)     printk("SeekComplete ");
-                if (stat & ATA_DRQ)     printk("DataRequest ");
-                if (stat & ATA_CORR)    printk("CorrectedError ");
-                if (stat & ATA_IDX)     printk("Index ");
-                if (stat & ATA_ERR)     printk("Error ");
+                if (stat & ATA_DRDY)
+                        printk(KERN_CONT "DriveReady ");
+                if (stat & ATA_DF)
+                        printk(KERN_CONT "DeviceFault ");
+                if (stat & ATA_DSC)
+                        printk(KERN_CONT "SeekComplete ");
+                if (stat & ATA_DRQ)
+                        printk(KERN_CONT "DataRequest ");
+                if (stat & ATA_CORR)
+                        printk(KERN_CONT "CorrectedError ");
+                if (stat & ATA_IDX)
+                        printk(KERN_CONT "Index ");
+                if (stat & ATA_ERR)
+                        printk(KERN_CONT "Error ");
         }
-        printk("}\n");
+        printk(KERN_CONT "}\n");
         if ((stat & (ATA_BUSY | ATA_ERR)) == ATA_ERR) {
                 err = ide_read_error(drive);
-                printk("%s: %s: error=0x%02x ", drive->name, msg, err);
+                printk(KERN_ERR "%s: %s: error=0x%02x ", drive->name, msg, err);
                 if (drive->media == ide_disk)
                         ide_dump_ata_error(drive, err);
                 else
                         ide_dump_atapi_error(drive, err);
         }
         ide_dump_opcode(drive);
-        local_irq_restore(flags);
         return err;
 }
-
 EXPORT_SYMBOL(ide_dump_status);
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index 03b00e57e93f..c875a957596c 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -7,29 +7,31 @@ DECLARE_WAIT_QUEUE_HEAD(ide_park_wq);
 
 static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
 {
+        ide_hwif_t *hwif = drive->hwif;
         struct request_queue *q = drive->queue;
         struct request *rq;
         int rc;
 
         timeout += jiffies;
-        spin_lock_irq(&ide_lock);
+        spin_lock_irq(&hwif->lock);
         if (drive->dev_flags & IDE_DFLAG_PARKED) {
-                ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;
-                int reset_timer;
+                int reset_timer = time_before(timeout, drive->sleep);
+                int start_queue = 0;
 
-                reset_timer = time_before(timeout, drive->sleep);
                 drive->sleep = timeout;
                 wake_up_all(&ide_park_wq);
-                if (reset_timer && hwgroup->sleeping &&
-                    del_timer(&hwgroup->timer)) {
-                        hwgroup->sleeping = 0;
-                        hwgroup->busy = 0;
+                if (reset_timer && del_timer(&hwif->timer))
+                        start_queue = 1;
+                spin_unlock_irq(&hwif->lock);
+
+                if (start_queue) {
+                        spin_lock_irq(q->queue_lock);
                         blk_start_queueing(q);
+                        spin_unlock_irq(q->queue_lock);
                 }
-                spin_unlock_irq(&ide_lock);
                 return;
         }
-        spin_unlock_irq(&ide_lock);
+        spin_unlock_irq(&hwif->lock);
 
         rq = blk_get_request(q, READ, __GFP_WAIT);
         rq->cmd[0] = REQ_PARK_HEADS;
@@ -62,20 +64,21 @@ ssize_t ide_park_show(struct device *dev, struct device_attribute *attr,
                       char *buf)
 {
         ide_drive_t *drive = to_ide_device(dev);
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long now;
         unsigned int msecs;
 
         if (drive->dev_flags & IDE_DFLAG_NO_UNLOAD)
                 return -EOPNOTSUPP;
 
-        spin_lock_irq(&ide_lock);
+        spin_lock_irq(&hwif->lock);
         now = jiffies;
         if (drive->dev_flags & IDE_DFLAG_PARKED &&
             time_after(drive->sleep, now))
                 msecs = jiffies_to_msecs(drive->sleep - now);
         else
                 msecs = 0;
-        spin_unlock_irq(&ide_lock);
+        spin_unlock_irq(&hwif->lock);
 
         return snprintf(buf, 20, "%u\n", msecs);
 }
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
new file mode 100644
index 000000000000..4b3bf6a06b70
--- /dev/null
+++ b/drivers/ide/ide-pm.c
@@ -0,0 +1,235 @@
+#include <linux/kernel.h>
+#include <linux/ide.h>
+#include <linux/hdreg.h>
+
+int generic_ide_suspend(struct device *dev, pm_message_t mesg)
+{
+        ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
+        ide_hwif_t *hwif = drive->hwif;
+        struct request *rq;
+        struct request_pm_state rqpm;
+        ide_task_t args;
+        int ret;
+
+        /* call ACPI _GTM only once */
+        if ((drive->dn & 1) == 0 || pair == NULL)
+                ide_acpi_get_timing(hwif);
+
+        memset(&rqpm, 0, sizeof(rqpm));
+        memset(&args, 0, sizeof(args));
+        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
+        rq->cmd_type = REQ_TYPE_PM_SUSPEND;
+        rq->special = &args;
+        rq->data = &rqpm;
+        rqpm.pm_step = IDE_PM_START_SUSPEND;
+        if (mesg.event == PM_EVENT_PRETHAW)
+                mesg.event = PM_EVENT_FREEZE;
+        rqpm.pm_state = mesg.event;
+
+        ret = blk_execute_rq(drive->queue, NULL, rq, 0);
+        blk_put_request(rq);
+
+        /* call ACPI _PS3 only after both devices are suspended */
+        if (ret == 0 && ((drive->dn & 1) || pair == NULL))
+                ide_acpi_set_state(hwif, 0);
+
+        return ret;
+}
+
+int generic_ide_resume(struct device *dev)
+{
+        ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
+        ide_hwif_t *hwif = drive->hwif;
+        struct request *rq;
+        struct request_pm_state rqpm;
+        ide_task_t args;
+        int err;
+
+        /* call ACPI _PS0 / _STM only once */
+        if ((drive->dn & 1) == 0 || pair == NULL) {
+                ide_acpi_set_state(hwif, 1);
+                ide_acpi_push_timing(hwif);
+        }
+
+        ide_acpi_exec_tfs(drive);
+
+        memset(&rqpm, 0, sizeof(rqpm));
+        memset(&args, 0, sizeof(args));
+        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
+        rq->cmd_type = REQ_TYPE_PM_RESUME;
+        rq->cmd_flags |= REQ_PREEMPT;
+        rq->special = &args;
+        rq->data = &rqpm;
+        rqpm.pm_step = IDE_PM_START_RESUME;
+        rqpm.pm_state = PM_EVENT_ON;
+
+        err = blk_execute_rq(drive->queue, NULL, rq, 1);
+        blk_put_request(rq);
+
+        if (err == 0 && dev->driver) {
+                struct ide_driver *drv = to_ide_driver(dev->driver);
+
+                if (drv->resume)
+                        drv->resume(drive);
+        }
+
+        return err;
+}
+
+void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
+{
+        struct request_pm_state *pm = rq->data;
+
+#ifdef DEBUG_PM
+        printk(KERN_INFO "%s: complete_power_step(step: %d)\n",
+                drive->name, pm->pm_step);
+#endif
+        if (drive->media != ide_disk)
+                return;
+
+        switch (pm->pm_step) {
+        case IDE_PM_FLUSH_CACHE:        /* Suspend step 1 (flush cache) */
+                if (pm->pm_state == PM_EVENT_FREEZE)
+                        pm->pm_step = IDE_PM_COMPLETED;
+                else
+                        pm->pm_step = IDE_PM_STANDBY;
+                break;
+        case IDE_PM_STANDBY:            /* Suspend step 2 (standby) */
+                pm->pm_step = IDE_PM_COMPLETED;
+                break;
+        case IDE_PM_RESTORE_PIO:        /* Resume step 1 (restore PIO) */
+                pm->pm_step = IDE_PM_IDLE;
+                break;
+        case IDE_PM_IDLE:               /* Resume step 2 (idle)*/
+                pm->pm_step = IDE_PM_RESTORE_DMA;
+                break;
+        }
+}
+
+ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
+{
+        struct request_pm_state *pm = rq->data;
+        ide_task_t *args = rq->special;
+
+        memset(args, 0, sizeof(*args));
+
+        switch (pm->pm_step) {
+        case IDE_PM_FLUSH_CACHE:        /* Suspend step 1 (flush cache) */
+                if (drive->media != ide_disk)
+                        break;
+                /* Not supported? Switch to next step now. */
+                if (ata_id_flush_enabled(drive->id) == 0 ||
+                    (drive->dev_flags & IDE_DFLAG_WCACHE) == 0) {
+                        ide_complete_power_step(drive, rq);
+                        return ide_stopped;
+                }
+                if (ata_id_flush_ext_enabled(drive->id))
+                        args->tf.command = ATA_CMD_FLUSH_EXT;
+                else
+                        args->tf.command = ATA_CMD_FLUSH;
+                goto out_do_tf;
+        case IDE_PM_STANDBY:            /* Suspend step 2 (standby) */
+                args->tf.command = ATA_CMD_STANDBYNOW1;
+                goto out_do_tf;
+        case IDE_PM_RESTORE_PIO:        /* Resume step 1 (restore PIO) */
+                ide_set_max_pio(drive);
+                /*
+                 * skip IDE_PM_IDLE for ATAPI devices
+                 */
+                if (drive->media != ide_disk)
+                        pm->pm_step = IDE_PM_RESTORE_DMA;
+                else
+                        ide_complete_power_step(drive, rq);
+                return ide_stopped;
+        case IDE_PM_IDLE:               /* Resume step 2 (idle) */
+                args->tf.command = ATA_CMD_IDLEIMMEDIATE;
+                goto out_do_tf;
+        case IDE_PM_RESTORE_DMA:        /* Resume step 3 (restore DMA) */
+                /*
+                 * Right now, all we do is call ide_set_dma(drive),
+                 * we could be smarter and check for current xfer_speed
+                 * in struct drive etc...
+                 */
+                if (drive->hwif->dma_ops == NULL)
+                        break;
+                /*
+                 * TODO: respect IDE_DFLAG_USING_DMA
+                 */
+                ide_set_dma(drive);
+                break;
+        }
+
+        pm->pm_step = IDE_PM_COMPLETED;
+        return ide_stopped;
+
+out_do_tf:
+        args->tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
+        args->data_phase = TASKFILE_NO_DATA;
+        return do_rw_taskfile(drive, args);
+}
+
+/**
+ *      ide_complete_pm_request - end the current Power Management request
+ *      @drive: target drive
+ *      @rq: request
+ *
+ *      This function cleans up the current PM request and stops the queue
+ *      if necessary.
+ */
+void ide_complete_pm_request(ide_drive_t *drive, struct request *rq)
+{
+        struct request_queue *q = drive->queue;
+        unsigned long flags;
+
+#ifdef DEBUG_PM
+        printk("%s: completing PM request, %s\n", drive->name,
+               blk_pm_suspend_request(rq) ? "suspend" : "resume");
+#endif
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (blk_pm_suspend_request(rq)) {
+                blk_stop_queue(q);
+        } else {
+                drive->dev_flags &= ~IDE_DFLAG_BLOCKED;
+                blk_start_queue(q);
+        }
+        spin_unlock_irqrestore(q->queue_lock, flags);
+
+        drive->hwif->rq = NULL;
+
+        if (blk_end_request(rq, 0, 0))
+                BUG();
+}
+
+void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
+{
+        struct request_pm_state *pm = rq->data;
+
+        if (blk_pm_suspend_request(rq) &&
+            pm->pm_step == IDE_PM_START_SUSPEND)
+                /* Mark drive blocked when starting the suspend sequence. */
+                drive->dev_flags |= IDE_DFLAG_BLOCKED;
+        else if (blk_pm_resume_request(rq) &&
+                 pm->pm_step == IDE_PM_START_RESUME) {
+                /*
+                 * The first thing we do on wakeup is to wait for BSY bit to
+                 * go away (with a looong timeout) as a drive on this hwif may
+                 * just be POSTing itself.
+                 * We do that before even selecting as the "other" device on
+                 * the bus may be broken enough to walk on our toes at this
+                 * point.
+                 */
+                ide_hwif_t *hwif = drive->hwif;
+                int rc;
+#ifdef DEBUG_PM
+                printk("%s: Wakeup request inited, waiting for !BSY...\n", drive->name);
+#endif
+                rc = ide_wait_not_busy(hwif, 35000);
+                if (rc)
+                        printk(KERN_WARNING "%s: bus not ready on wakeup\n", drive->name);
+                SELECT_DRIVE(drive);
+                hwif->tp_ops->set_irq(hwif, 1);
+                rc = ide_wait_not_busy(hwif, 100000);
+                if (rc)
+                        printk(KERN_WARNING "%s: drive not ready on wakeup\n", drive->name);
+        }
+}
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index c55bdbd22314..0ccbb4459fb9 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -101,6 +101,82 @@ static void ide_disk_init_mult_count(ide_drive_t *drive)
         }
 }
 
+static void ide_classify_ata_dev(ide_drive_t *drive)
+{
+        u16 *id = drive->id;
+        char *m = (char *)&id[ATA_ID_PROD];
+        int is_cfa = ata_id_is_cfa(id);
+
+        /* CF devices are *not* removable in Linux definition of the term */
+        if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
+                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
+
+        drive->media = ide_disk;
+
+        if (!ata_id_has_unload(drive->id))
+                drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
+
+        printk(KERN_INFO "%s: %s, %s DISK drive\n", drive->name, m,
+                is_cfa ? "CFA" : "ATA");
+}
+
+static void ide_classify_atapi_dev(ide_drive_t *drive)
+{
+        u16 *id = drive->id;
+        char *m = (char *)&id[ATA_ID_PROD];
+        u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
+
+        printk(KERN_INFO "%s: %s, ATAPI ", drive->name, m);
+        switch (type) {
+        case ide_floppy:
+                if (!strstr(m, "CD-ROM")) {
+                        if (!strstr(m, "oppy") &&
+                            !strstr(m, "poyp") &&
+                            !strstr(m, "ZIP"))
+                                printk(KERN_CONT "cdrom or floppy?, assuming ");
+                        if (drive->media != ide_cdrom) {
+                                printk(KERN_CONT "FLOPPY");
+                                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
+                                break;
+                        }
+                }
+                /* Early cdrom models used zero */
+                type = ide_cdrom;
+        case ide_cdrom:
+                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
+#ifdef CONFIG_PPC
+                /* kludge for Apple PowerBook internal zip */
+                if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
+                        printk(KERN_CONT "FLOPPY");
+                        type = ide_floppy;
+                        break;
+                }
+#endif
+                printk(KERN_CONT "CD/DVD-ROM");
+                break;
+        case ide_tape:
+                printk(KERN_CONT "TAPE");
+                break;
+        case ide_optical:
+                printk(KERN_CONT "OPTICAL");
+                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
+                break;
+        default:
+                printk(KERN_CONT "UNKNOWN (type %d)", type);
+                break;
+        }
+
+        printk(KERN_CONT " drive\n");
+        drive->media = type;
+        /* an ATAPI device ignores DRDY */
+        drive->ready_stat = 0;
+        if (ata_id_cdb_intr(id))
+                drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
+        drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
+        /* we don't do head unloading on ATAPI devices */
+        drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
+}
+
 /**
  *      do_identify     -       identify a drive
  *      @drive: drive to identify 
@@ -110,20 +186,22 @@ static void ide_disk_init_mult_count(ide_drive_t *drive)
  *      read and parse the results. This function is run with
  *      interrupts disabled. 
  */
- 
-static inline void do_identify (ide_drive_t *drive, u8 cmd)
+
+static void do_identify(ide_drive_t *drive, u8 cmd)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         u16 *id = drive->id;
         char *m = (char *)&id[ATA_ID_PROD];
-        int bswap = 1, is_cfa;
+        unsigned long flags;
+        int bswap = 1;
 
+        /* local CPU only; some systems need this */
+        local_irq_save(flags);
         /* read 512 bytes of id info */
         hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
+        local_irq_restore(flags);
 
         drive->dev_flags |= IDE_DFLAG_ID_READ;
-
-        local_irq_enable();
 #ifdef DEBUG
         printk(KERN_INFO "%s: dumping identify data\n", drive->name);
         ide_dump_identify((u8 *)id);
@@ -152,91 +230,23 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
         if (strstr(m, "E X A B Y T E N E S T"))
                 goto err_misc;
 
-        printk(KERN_INFO "%s: %s, ", drive->name, m);
-
         drive->dev_flags |= IDE_DFLAG_PRESENT;
         drive->dev_flags &= ~IDE_DFLAG_DEAD;
 
         /*
          * Check for an ATAPI device
          */
-        if (cmd == ATA_CMD_ID_ATAPI) {
-                u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
-
-                printk(KERN_CONT "ATAPI ");
-                switch (type) {
-                        case ide_floppy:
-                                if (!strstr(m, "CD-ROM")) {
-                                        if (!strstr(m, "oppy") &&
-                                            !strstr(m, "poyp") &&
-                                            !strstr(m, "ZIP"))
-                                                printk(KERN_CONT "cdrom or floppy?, assuming ");
-                                        if (drive->media != ide_cdrom) {
-                                                printk(KERN_CONT "FLOPPY");
-                                                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
-                                                break;
-                                        }
-                                }
-                                /* Early cdrom models used zero */
-                                type = ide_cdrom;
-                        case ide_cdrom:
-                                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
-#ifdef CONFIG_PPC
-                                /* kludge for Apple PowerBook internal zip */
-                                if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
-                                        printk(KERN_CONT "FLOPPY");
-                                        type = ide_floppy;
-                                        break;
-                                }
-#endif
-                                printk(KERN_CONT "CD/DVD-ROM");
-                                break;
-                        case ide_tape:
-                                printk(KERN_CONT "TAPE");
-                                break;
-                        case ide_optical:
-                                printk(KERN_CONT "OPTICAL");
-                                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
-                                break;
-                        default:
-                                printk(KERN_CONT "UNKNOWN (type %d)", type);
-                                break;
-                }
-                printk(KERN_CONT " drive\n");
-                drive->media = type;
-                /* an ATAPI device ignores DRDY */
-                drive->ready_stat = 0;
-                if (ata_id_cdb_intr(id))
-                        drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
-                drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
-                /* we don't do head unloading on ATAPI devices */
-                drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
-                return;
-        }
-
+        if (cmd == ATA_CMD_ID_ATAPI)
+                ide_classify_atapi_dev(drive);
+        else
         /*
          * Not an ATAPI device: looks like a "regular" hard disk
          */
-
-        is_cfa = ata_id_is_cfa(id);
-
-        /* CF devices are *not* removable in Linux definition of the term */
-        if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
-                drive->dev_flags |= IDE_DFLAG_REMOVABLE;
-
-        drive->media = ide_disk;
-
-        if (!ata_id_has_unload(drive->id))
-                drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
-
-        printk(KERN_CONT "%s DISK drive\n", is_cfa ? "CFA" : "ATA");
-
+                ide_classify_ata_dev(drive);
         return;
-
 err_misc:
         kfree(id);
         drive->dev_flags &= ~IDE_DFLAG_PRESENT;
-        return;
 }
 
 /**
@@ -256,7 +266,7 @@ err_misc:
 
 static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct ide_io_ports *io_ports = &hwif->io_ports;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         int use_altstatus = 0, rc;
@@ -306,17 +316,12 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
         s = tp_ops->read_status(hwif);
 
         if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
-                unsigned long flags;
-
-                /* local CPU only; some systems need this */
-                local_irq_save(flags);
                 /* drive returned ID */
                 do_identify(drive, cmd);
                 /* drive responded with ID */
                 rc = 0;
                 /* clear drive IRQ */
                 (void)tp_ops->read_status(hwif);
-                local_irq_restore(flags);
         } else {
                 /* drive refused ID */
                 rc = 2;
@@ -336,7 +341,7 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
  
 static int try_to_identify (ide_drive_t *drive, u8 cmd)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         int retval;
         int autoprobe = 0;
@@ -433,7 +438,7 @@ static u8 ide_read_device(ide_drive_t *drive)
 
 static int do_probe (ide_drive_t *drive, u8 cmd)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         int rc;
         u8 present = !!(drive->dev_flags & IDE_DFLAG_PRESENT), stat;
@@ -458,7 +463,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
         if (ide_read_device(drive) != drive->select && present == 0) {
                 if (drive->dn & 1) {
                         /* exit with drive0 selected */
-                        SELECT_DRIVE(&hwif->drives[0]);
+                        SELECT_DRIVE(hwif->devices[0]);
                         /* allow ATA_BUSY to assert & clear */
                         msleep(50);
                 }
@@ -504,7 +509,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
         }
         if (drive->dn & 1) {
                 /* exit with drive0 selected */
-                SELECT_DRIVE(&hwif->drives[0]);
+                SELECT_DRIVE(hwif->devices[0]);
                 msleep(50);
                 /* ensure drive irq is clear */
                 (void)tp_ops->read_status(hwif);
@@ -517,7 +522,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
  */
 static void enable_nest (ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         u8 stat;
 
@@ -554,8 +559,8 @@ static void enable_nest (ide_drive_t *drive)
  *                      1  device was found
  *                         (note: IDE_DFLAG_PRESENT might still be not set)
  */
- 
-static inline u8 probe_for_drive (ide_drive_t *drive)
+
+static u8 probe_for_drive(ide_drive_t *drive)
 {
         char *m;
 
@@ -642,16 +647,11 @@ static int ide_register_port(ide_hwif_t *hwif)
         int ret;
 
         /* register with global device tree */
-        strlcpy(hwif->gendev.bus_id,hwif->name,BUS_ID_SIZE);
+        dev_set_name(&hwif->gendev, hwif->name);
         hwif->gendev.driver_data = hwif;
-        if (hwif->gendev.parent == NULL) {
-                if (hwif->dev)
-                        hwif->gendev.parent = hwif->dev;
-                else
-                        /* Would like to do = &device_legacy */
-                        hwif->gendev.parent = NULL;
-        }
+        hwif->gendev.parent = hwif->dev;
         hwif->gendev.release = hwif_release_dev;
+
         ret = device_register(&hwif->gendev);
         if (ret < 0) {
                 printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
@@ -697,7 +697,8 @@ out:
 
 static int ide_port_wait_ready(ide_hwif_t *hwif)
 {
-        int unit, rc;
+        ide_drive_t *drive;
+        int i, rc;
 
         printk(KERN_DEBUG "Probing IDE interface %s...\n", hwif->name);
 
@@ -714,9 +715,7 @@ static int ide_port_wait_ready(ide_hwif_t *hwif)
                 return rc;
 
         /* Now make sure both master & slave are ready */
-        for (unit = 0; unit < MAX_DRIVES; unit++) {
-                ide_drive_t *drive = &hwif->drives[unit];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 /* Ignore disks that we will not probe for later. */
                 if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
                     (drive->dev_flags & IDE_DFLAG_PRESENT)) {
@@ -732,8 +731,8 @@ static int ide_port_wait_ready(ide_hwif_t *hwif)
         }
 out:
         /* Exit function with master reselected (let's be sane) */
-        if (unit)
-                SELECT_DRIVE(&hwif->drives[0]);
+        if (i)
+                SELECT_DRIVE(hwif->devices[0]);
 
         return rc;
 }
@@ -749,7 +748,7 @@ out:
 
 void ide_undecoded_slave(ide_drive_t *dev1)
 {
-        ide_drive_t *dev0 = &dev1->hwif->drives[0];
+        ide_drive_t *dev0 = dev1->hwif->devices[0];
 
         if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
                 return;
@@ -778,14 +777,15 @@ EXPORT_SYMBOL_GPL(ide_undecoded_slave);
 
 static int ide_probe_port(ide_hwif_t *hwif)
 {
+        ide_drive_t *drive;
         unsigned long flags;
         unsigned int irqd;
-        int unit, rc = -ENODEV;
+        int i, rc = -ENODEV;
 
         BUG_ON(hwif->present);
 
-        if ((hwif->drives[0].dev_flags & IDE_DFLAG_NOPROBE) &&
-            (hwif->drives[1].dev_flags & IDE_DFLAG_NOPROBE))
+        if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
+            (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
                 return -EACCES;
 
         /*
@@ -796,7 +796,8 @@ static int ide_probe_port(ide_hwif_t *hwif)
         if (irqd)
                 disable_irq(hwif->irq);
 
-        local_irq_set(flags);
+        local_irq_save(flags);
+        local_irq_enable_in_hardirq();
 
         if (ide_port_wait_ready(hwif) == -EBUSY)
                 printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);
@@ -805,9 +806,7 @@ static int ide_probe_port(ide_hwif_t *hwif)
          * Second drive should only exist if first drive was found,
          * but a lot of cdrom drives are configured as single slaves.
          */
-        for (unit = 0; unit < MAX_DRIVES; ++unit) {
-                ide_drive_t *drive = &hwif->drives[unit];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 (void) probe_for_drive(drive);
                 if (drive->dev_flags & IDE_DFLAG_PRESENT)
                         rc = 0;
@@ -828,20 +827,17 @@ static int ide_probe_port(ide_hwif_t *hwif)
 static void ide_port_tune_devices(ide_hwif_t *hwif)
 {
         const struct ide_port_ops *port_ops = hwif->port_ops;
-        int unit;
-
-        for (unit = 0; unit < MAX_DRIVES; unit++) {
-                ide_drive_t *drive = &hwif->drives[unit];
+        ide_drive_t *drive;
+        int i;
 
+        ide_port_for_each_dev(i, drive, hwif) {
                 if (drive->dev_flags & IDE_DFLAG_PRESENT) {
                         if (port_ops && port_ops->quirkproc)
                                 port_ops->quirkproc(drive);
                 }
         }
 
-        for (unit = 0; unit < MAX_DRIVES; ++unit) {
-                ide_drive_t *drive = &hwif->drives[unit];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 if (drive->dev_flags & IDE_DFLAG_PRESENT) {
                         ide_set_max_pio(drive);
 
@@ -852,11 +848,8 @@ static void ide_port_tune_devices(ide_hwif_t *hwif)
                 }
         }
 
-        for (unit = 0; unit < MAX_DRIVES; ++unit) {
-                ide_drive_t *drive = &hwif->drives[unit];
-
-                if ((hwif->host_flags & IDE_HFLAG_NO_IO_32BIT) ||
-                    drive->id[ATA_ID_DWORD_IO])
+        ide_port_for_each_dev(i, drive, hwif) {
+                if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
                         drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
                 else
                         drive->dev_flags &= ~IDE_DFLAG_NO_IO_32BIT;
@@ -864,37 +857,12 @@ static void ide_port_tune_devices(ide_hwif_t *hwif)
 }
 
 /*
- * save_match() is used to simplify logic in init_irq() below.
- *
- * A loophole here is that we may not know about a particular
- * hwif's irq until after that hwif is actually probed/initialized..
- * This could be a problem for the case where an hwif is on a
- * dual interface that requires serialization (eg. cmd640) and another
- * hwif using one of the same irqs is initialized beforehand.
- *
- * This routine detects and reports such situations, but does not fix them.
- */
-static void save_match(ide_hwif_t *hwif, ide_hwif_t *new, ide_hwif_t **match)
-{
-        ide_hwif_t *m = *match;
-
-        if (m && m->hwgroup && m->hwgroup != new->hwgroup) {
-                if (!new->hwgroup)
-                        return;
-                printk(KERN_WARNING "%s: potential IRQ problem with %s and %s\n",
-                        hwif->name, new->name, m->name);
-        }
-        if (!m || m->irq != hwif->irq) /* don't undo a prior perfect match */
-                *match = new;
-}
-
-/*
  * init request queue
  */
 static int ide_init_queue(ide_drive_t *drive)
 {
         struct request_queue *q;
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         int max_sectors = 256;
         int max_sg_entries = PRD_ENTRIES;
 
@@ -906,7 +874,7 @@ static int ide_init_queue(ide_drive_t *drive)
          *      do not.
          */
 
-        q = blk_init_queue_node(do_ide_request, &ide_lock, hwif_to_node(hwif));
+        q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
         if (!q)
                 return 1;
 
@@ -943,36 +911,19 @@ static int ide_init_queue(ide_drive_t *drive)
         return 0;
 }
 
-static void ide_add_drive_to_hwgroup(ide_drive_t *drive)
-{
-        ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;
-
-        spin_lock_irq(&ide_lock);
-        if (!hwgroup->drive) {
-                /* first drive for hwgroup. */
-                drive->next = drive;
-                hwgroup->drive = drive;
-                hwgroup->hwif = HWIF(hwgroup->drive);
-        } else {
-                drive->next = hwgroup->drive->next;
-                hwgroup->drive->next = drive;
-        }
-        spin_unlock_irq(&ide_lock);
-}
+static DEFINE_MUTEX(ide_cfg_mtx);
 
 /*
  * For any present drive:
  * - allocate the block device queue
- * - link drive into the hwgroup
  */
 static int ide_port_setup_devices(ide_hwif_t *hwif)
 {
+        ide_drive_t *drive;
         int i, j = 0;
 
         mutex_lock(&ide_cfg_mtx);
-        for (i = 0; i < MAX_DRIVES; i++) {
-                ide_drive_t *drive = &hwif->drives[i];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
                         continue;
 
@@ -986,152 +937,39 @@ static int ide_port_setup_devices(ide_hwif_t *hwif)
                 }
 
                 j++;
-
-                ide_add_drive_to_hwgroup(drive);
         }
         mutex_unlock(&ide_cfg_mtx);
 
         return j;
 }
 
-static ide_hwif_t *ide_ports[MAX_HWIFS];
-
-void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
-{
-        ide_hwgroup_t *hwgroup = hwif->hwgroup;
-
-        ide_ports[hwif->index] = NULL;
-
-        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);
-}
-
 /*
- * This routine sets up the irq for an ide interface, and creates a new
- * hwgroup for the irq/hwif if none was previously assigned.
- *
- * Much of the code is for correctly detecting/handling irq sharing
- * and irq serialization situations.  This is somewhat complex because
- * it handles static as well as dynamic (PCMCIA) IDE interfaces.
+ * This routine sets up the IRQ for an IDE interface.
  */
 static int init_irq (ide_hwif_t *hwif)
 {
         struct ide_io_ports *io_ports = &hwif->io_ports;
-        unsigned int index;
-        ide_hwgroup_t *hwgroup;
-        ide_hwif_t *match = NULL;
+        int sa = 0;
 
         mutex_lock(&ide_cfg_mtx);
-        hwif->hwgroup = NULL;
+        spin_lock_init(&hwif->lock);
 
-        /*
-         * Group up with any other hwifs that share our irq(s).
-         */
-        for (index = 0; index < MAX_HWIFS; index++) {
-                ide_hwif_t *h = ide_ports[index];
-
-                if (h && h->hwgroup) {  /* scan only initialized ports */
-                        if (hwif->irq == h->irq) {
-                                hwif->sharing_irq = h->sharing_irq = 1;
-                                if (hwif->chipset != ide_pci ||
-                                    h->chipset != ide_pci) {
-                                        save_match(hwif, h, &match);
-                                }
-                        }
-                        if (hwif->serialized) {
-                                if (hwif->mate && hwif->mate->irq == h->irq)
-                                        save_match(hwif, h, &match);
-                        }
-                        if (h->serialized) {
-                                if (h->mate && hwif->irq == h->mate->irq)
-                                        save_match(hwif, h, &match);
-                        }
-                }
-        }
-
-        /*
-         * If we are still without a hwgroup, then form a new one
-         */
-        if (match) {
-                hwgroup = match->hwgroup;
-                hwif->hwgroup = hwgroup;
-                /*
-                 * Link us into the hwgroup.
-                 * This must be done early, do ensure that unexpected_intr
-                 * can find the hwif and prevent irq storms.
-                 * No drives are attached to the new hwif, choose_drive
-                 * can't do anything stupid (yet).
-                 * Add ourself as the 2nd entry to the hwgroup->hwif
-                 * linked list, the first entry is the hwif that owns
-                 * hwgroup->handler - do not change that.
-                 */
-                spin_lock_irq(&ide_lock);
-                hwif->next = hwgroup->hwif->next;
-                hwgroup->hwif->next = hwif;
-                BUG_ON(hwif->next == hwif);
-                spin_unlock_irq(&ide_lock);
-        } else {
-                hwgroup = kmalloc_node(sizeof(*hwgroup), GFP_KERNEL|__GFP_ZERO,
-                                       hwif_to_node(hwif));
-                if (hwgroup == NULL)
-                        goto out_up;
-
-                hwif->hwgroup = hwgroup;
-                hwgroup->hwif = hwif->next = hwif;
+        init_timer(&hwif->timer);
+        hwif->timer.function = &ide_timer_expiry;
+        hwif->timer.data = (unsigned long)hwif;
 
-                init_timer(&hwgroup->timer);
-                hwgroup->timer.function = &ide_timer_expiry;
-                hwgroup->timer.data = (unsigned long) hwgroup;
-        }
-
-        ide_ports[hwif->index] = hwif;
-
-        /*
-         * Allocate the irq, if not already obtained for another hwif
-         */
-        if (!match || match->irq != hwif->irq) {
-                int sa = 0;
 #if defined(__mc68000__)
-                sa = IRQF_SHARED;
+        sa = IRQF_SHARED;
 #endif /* __mc68000__ */
 
-                if (hwif->chipset == ide_pci || hwif->chipset == ide_cmd646 ||
-                    hwif->chipset == ide_ali14xx)
-                        sa = IRQF_SHARED;
+        if (hwif->chipset == ide_pci)
+                sa = IRQF_SHARED;
 
-                if (io_ports->ctl_addr)
-                        hwif->tp_ops->set_irq(hwif, 1);
+        if (io_ports->ctl_addr)
+                hwif->tp_ops->set_irq(hwif, 1);
 
-                if (request_irq(hwif->irq,&ide_intr,sa,hwif->name,hwgroup))
-                        goto out_unlink;
-        }
+        if (request_irq(hwif->irq, &ide_intr, sa, hwif->name, hwif))
+                goto out_up;
 
         if (!hwif->rqsize) {
                 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
@@ -1149,15 +987,12 @@ static int init_irq (ide_hwif_t *hwif)
         printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
                 io_ports->data_addr, hwif->irq);
 #endif /* __mc68000__ */
-        if (match)
-                printk(KERN_CONT " (%sed with %s)",
-                        hwif->sharing_irq ? "shar" : "serializ", match->name);
+        if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
+                printk(KERN_CONT " (serialized)");
         printk(KERN_CONT "\n");
 
         mutex_unlock(&ide_cfg_mtx);
         return 0;
-out_unlink:
-        ide_remove_port_from_hwgroup(hwif);
 out_up:
         mutex_unlock(&ide_cfg_mtx);
         return 1;
@@ -1173,15 +1008,13 @@ static struct kobject *ata_probe(dev_t dev, int *part, void *data)
 {
         ide_hwif_t *hwif = data;
         int unit = *part >> PARTN_BITS;
-        ide_drive_t *drive = &hwif->drives[unit];
+        ide_drive_t *drive = hwif->devices[unit];
 
         if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
                 return NULL;
 
         if (drive->media == ide_disk)
                 request_module("ide-disk");
-        if (drive->dev_flags & IDE_DFLAG_SCSI)
-                request_module("ide-scsi");
         if (drive->media == ide_cdrom || drive->media == ide_optical)
                 request_module("ide-cd");
         if (drive->media == ide_tape)
@@ -1237,46 +1070,23 @@ void ide_init_disk(struct gendisk *disk, ide_drive_t *drive)
 
 EXPORT_SYMBOL_GPL(ide_init_disk);
 
-static void ide_remove_drive_from_hwgroup(ide_drive_t *drive)
-{
-        ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;
-
-        if (drive == drive->next) {
-                /* special case: last drive from hwgroup. */
-                BUG_ON(hwgroup->drive != drive);
-                hwgroup->drive = NULL;
-        } else {
-                ide_drive_t *walk;
-
-                walk = hwgroup->drive;
-                while (walk->next != drive)
-                        walk = walk->next;
-                walk->next = drive->next;
-                if (hwgroup->drive == drive) {
-                        hwgroup->drive = drive->next;
-                        hwgroup->hwif = hwgroup->drive->hwif;
-                }
-        }
-        BUG_ON(hwgroup->drive == drive);
-}
-
 static void drive_release_dev (struct device *dev)
 {
         ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
+        ide_hwif_t *hwif = drive->hwif;
 
         ide_proc_unregister_device(drive);
 
-        spin_lock_irq(&ide_lock);
-        ide_remove_drive_from_hwgroup(drive);
+        spin_lock_irq(&hwif->lock);
         kfree(drive->id);
         drive->id = NULL;
         drive->dev_flags &= ~IDE_DFLAG_PRESENT;
         /* Messed up locking ... */
-        spin_unlock_irq(&ide_lock);
+        spin_unlock_irq(&hwif->lock);
         blk_cleanup_queue(drive->queue);
-        spin_lock_irq(&ide_lock);
+        spin_lock_irq(&hwif->lock);
         drive->queue = NULL;
-        spin_unlock_irq(&ide_lock);
+        spin_unlock_irq(&hwif->lock);
 
         complete(&drive->gendev_rel_comp);
 }
@@ -1342,17 +1152,17 @@ out:
 
 static void hwif_register_devices(ide_hwif_t *hwif)
 {
+        ide_drive_t *drive;
         unsigned int i;
 
-        for (i = 0; i < MAX_DRIVES; i++) {
-                ide_drive_t *drive = &hwif->drives[i];
+        ide_port_for_each_dev(i, drive, hwif) {
                 struct device *dev = &drive->gendev;
                 int ret;
 
                 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
                         continue;
 
-                snprintf(dev->bus_id, BUS_ID_SIZE, "%u.%u", hwif->index, i);
+                dev_set_name(dev, "%u.%u", hwif->index, i);
                 dev->parent = &hwif->gendev;
                 dev->bus = &ide_bus_type;
                 dev->driver_data = drive;
@@ -1368,11 +1178,10 @@ static void hwif_register_devices(ide_hwif_t *hwif)
 static void ide_port_init_devices(ide_hwif_t *hwif)
 {
         const struct ide_port_ops *port_ops = hwif->port_ops;
+        ide_drive_t *drive;
         int i;
 
-        for (i = 0; i < MAX_DRIVES; i++) {
-                ide_drive_t *drive = &hwif->drives[i];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 drive->dn = i + hwif->channel * 2;
 
                 if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
@@ -1420,6 +1229,8 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
         if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
                 int rc;
 
+                hwif->dma_ops = d->dma_ops;
+
                 if (d->init_dma)
                         rc = d->init_dma(hwif, d);
                 else
@@ -1427,22 +1238,21 @@ static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
 
                 if (rc < 0) {
                         printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
+
+                        hwif->dma_ops = NULL;
                         hwif->dma_base = 0;
                         hwif->swdma_mask = 0;
                         hwif->mwdma_mask = 0;
                         hwif->ultra_mask = 0;
-                } else if (d->dma_ops)
-                        hwif->dma_ops = d->dma_ops;
+                }
         }
 
         if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
-            ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base)) {
-                if (hwif->mate)
-                        hwif->mate->serialized = hwif->serialized = 1;
-        }
+            ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base))
+                hwif->host->host_flags |= IDE_HFLAG_SERIALIZE;
 
-        if (d->host_flags & IDE_HFLAG_RQSIZE_256)
-                hwif->rqsize = 256;
+        if (d->max_sectors)
+                hwif->rqsize = d->max_sectors;
 
         /* call chipset specific routine for each enabled port */
         if (d->init_hwif)
@@ -1459,56 +1269,64 @@ static void ide_port_cable_detect(ide_hwif_t *hwif)
         }
 }
 
-static ssize_t store_delete_devices(struct device *portdev,
-                                    struct device_attribute *attr,
-                                    const char *buf, size_t n)
-{
-        ide_hwif_t *hwif = dev_get_drvdata(portdev);
-
-        if (strncmp(buf, "1", n))
-                return -EINVAL;
+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 };
 
-        ide_port_unregister_devices(hwif);
-
-        return n;
-};
+static void ide_port_init_devices_data(ide_hwif_t *hwif)
+{
+        ide_drive_t *drive;
+        int i;
 
-static DEVICE_ATTR(delete_devices, S_IWUSR, NULL, store_delete_devices);
+        ide_port_for_each_dev(i, drive, hwif) {
+                u8 j = (hwif->index * MAX_DRIVES) + i;
+
+                memset(drive, 0, sizeof(*drive));
+
+                drive->media                    = ide_disk;
+                drive->select                   = (i << 4) | ATA_DEVICE_OBS;
+                drive->hwif                     = hwif;
+                drive->ready_stat               = ATA_DRDY;
+                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';
+                drive->name[2]                  = 'a' + j;
+                drive->max_failures             = IDE_DEFAULT_MAX_FAILURES;
+
+                INIT_LIST_HEAD(&drive->list);
+                init_completion(&drive->gendev_rel_comp);
+        }
+}
 
-static ssize_t store_scan(struct device *portdev,
-                          struct device_attribute *attr,
-                          const char *buf, size_t n)
+static void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
 {
-        ide_hwif_t *hwif = dev_get_drvdata(portdev);
-
-        if (strncmp(buf, "1", n))
-                return -EINVAL;
+        /* fill in any non-zero initial values */
+        hwif->index     = index;
+        hwif->major     = ide_hwif_to_major[index];
 
-        ide_port_unregister_devices(hwif);
-        ide_port_scan(hwif);
+        hwif->name[0]   = 'i';
+        hwif->name[1]   = 'd';
+        hwif->name[2]   = 'e';
+        hwif->name[3]   = '0' + index;
 
-        return n;
-};
+        init_completion(&hwif->gendev_rel_comp);
 
-static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
+        hwif->tp_ops = &default_tp_ops;
 
-static struct device_attribute *ide_port_attrs[] = {
-        &dev_attr_delete_devices,
-        &dev_attr_scan,
-        NULL
-};
+        ide_port_init_devices_data(hwif);
+}
 
-static int ide_sysfs_register_port(ide_hwif_t *hwif)
+static void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
 {
-        int i, uninitialized_var(rc);
-
-        for (i = 0; ide_port_attrs[i]; i++) {
-                rc = device_create_file(hwif->portdev, ide_port_attrs[i]);
-                if (rc)
-                        break;
-        }
-
-        return rc;
+        memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
+        hwif->irq = hw->irq;
+        hwif->chipset = hw->chipset;
+        hwif->dev = hw->dev;
+        hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
+        hwif->ack_intr = hw->ack_intr;
+        hwif->config_data = hw->config;
 }
 
 static unsigned int ide_indexes;
@@ -1560,12 +1378,43 @@ static void ide_free_port_slot(int idx)
         mutex_unlock(&ide_cfg_mtx);
 }
 
+static void ide_port_free_devices(ide_hwif_t *hwif)
+{
+        ide_drive_t *drive;
+        int i;
+
+        ide_port_for_each_dev(i, drive, hwif)
+                kfree(drive);
+}
+
+static int ide_port_alloc_devices(ide_hwif_t *hwif, int node)
+{
+        int i;
+
+        for (i = 0; i < MAX_DRIVES; i++) {
+                ide_drive_t *drive;
+
+                drive = kzalloc_node(sizeof(*drive), GFP_KERNEL, node);
+                if (drive == NULL)
+                        goto out_nomem;
+
+                hwif->devices[i] = drive;
+        }
+        return 0;
+
+out_nomem:
+        ide_port_free_devices(hwif);
+        return -ENOMEM;
+}
+
 struct ide_host *ide_host_alloc(const struct ide_port_info *d, hw_regs_t **hws)
 {
         struct ide_host *host;
+        struct device *dev = hws[0] ? hws[0]->dev : NULL;
+        int node = dev ? dev_to_node(dev) : -1;
         int i;
 
-        host = kzalloc(sizeof(*host), GFP_KERNEL);
+        host = kzalloc_node(sizeof(*host), GFP_KERNEL, node);
         if (host == NULL)
                 return NULL;
 
@@ -1576,10 +1425,15 @@ struct ide_host *ide_host_alloc(const struct ide_port_info *d, hw_regs_t **hws)
                 if (hws[i] == NULL)
                         continue;
 
-                hwif = kzalloc(sizeof(*hwif), GFP_KERNEL);
+                hwif = kzalloc_node(sizeof(*hwif), GFP_KERNEL, node);
                 if (hwif == NULL)
                         continue;
 
+                if (ide_port_alloc_devices(hwif, node) < 0) {
+                        kfree(hwif);
+                        continue;
+                }
+
                 idx = ide_find_port_slot(d);
                 if (idx < 0) {
                         printk(KERN_ERR "%s: no free slot for interface\n",
@@ -1601,8 +1455,7 @@ struct ide_host *ide_host_alloc(const struct ide_port_info *d, hw_regs_t **hws)
                 return NULL;
         }
 
-        if (hws[0])
-                host->dev[0] = hws[0]->dev;
+        host->dev[0] = dev;
 
         if (d) {
                 host->init_chipset = d->init_chipset;
@@ -1619,9 +1472,7 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
         ide_hwif_t *hwif, *mate = NULL;
         int i, j = 0;
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                hwif = host->ports[i];
-
+        ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL) {
                         mate = NULL;
                         continue;
@@ -1647,9 +1498,7 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                 ide_port_init_devices(hwif);
         }
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                hwif = host->ports[i];
-
+        ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
 
@@ -1664,9 +1513,7 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                         ide_port_tune_devices(hwif);
         }
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                hwif = host->ports[i];
-
+        ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
 
@@ -1691,22 +1538,15 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                         ide_acpi_port_init_devices(hwif);
         }
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                hwif = host->ports[i];
-
+        ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
 
-                if (hwif->chipset == ide_unknown)
-                        hwif->chipset = ide_generic;
-
                 if (hwif->present)
                         hwif_register_devices(hwif);
         }
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                hwif = host->ports[i];
-
+        ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
 
@@ -1744,17 +1584,85 @@ int ide_host_add(const struct ide_port_info *d, hw_regs_t **hws,
 }
 EXPORT_SYMBOL_GPL(ide_host_add);
 
+static void __ide_port_unregister_devices(ide_hwif_t *hwif)
+{
+        ide_drive_t *drive;
+        int i;
+
+        ide_port_for_each_dev(i, drive, hwif) {
+                if (drive->dev_flags & IDE_DFLAG_PRESENT) {
+                        device_unregister(&drive->gendev);
+                        wait_for_completion(&drive->gendev_rel_comp);
+                }
+        }
+}
+
+void ide_port_unregister_devices(ide_hwif_t *hwif)
+{
+        mutex_lock(&ide_cfg_mtx);
+        __ide_port_unregister_devices(hwif);
+        hwif->present = 0;
+        ide_port_init_devices_data(hwif);
+        mutex_unlock(&ide_cfg_mtx);
+}
+EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
+
+/**
+ *      ide_unregister          -       free an IDE interface
+ *      @hwif: IDE interface
+ *
+ *      Perform the final unregister of an IDE interface.
+ *
+ *      Locking:
+ *      The caller must not hold the IDE locks.
+ *
+ *      It is up to the caller to be sure there is no pending I/O here,
+ *      and that the interface will not be reopened (present/vanishing
+ *      locking isn't yet done BTW).
+ */
+
+static void ide_unregister(ide_hwif_t *hwif)
+{
+        BUG_ON(in_interrupt());
+        BUG_ON(irqs_disabled());
+
+        mutex_lock(&ide_cfg_mtx);
+
+        if (hwif->present) {
+                __ide_port_unregister_devices(hwif);
+                hwif->present = 0;
+        }
+
+        ide_proc_unregister_port(hwif);
+
+        free_irq(hwif->irq, hwif);
+
+        device_unregister(hwif->portdev);
+        device_unregister(&hwif->gendev);
+        wait_for_completion(&hwif->gendev_rel_comp);
+
+        /*
+         * 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);
+
+        ide_release_dma_engine(hwif);
+
+        mutex_unlock(&ide_cfg_mtx);
+}
+
 void ide_host_free(struct ide_host *host)
 {
         ide_hwif_t *hwif;
         int i;
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                hwif = host->ports[i];
-
+        ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
 
+                ide_port_free_devices(hwif);
                 ide_free_port_slot(hwif->index);
                 kfree(hwif);
         }
@@ -1765,11 +1673,12 @@ EXPORT_SYMBOL_GPL(ide_host_free);
 
 void ide_host_remove(struct ide_host *host)
 {
+        ide_hwif_t *hwif;
         int i;
 
-        for (i = 0; i < MAX_HOST_PORTS; i++) {
-                if (host->ports[i])
-                        ide_unregister(host->ports[i]);
+        ide_host_for_each_port(i, hwif, host) {
+                if (hwif)
+                        ide_unregister(hwif);
         }
 
         ide_host_free(host);
@@ -1788,65 +1697,9 @@ void ide_port_scan(ide_hwif_t *hwif)
         hwif->present = 1;
 
         ide_port_tune_devices(hwif);
-        ide_acpi_port_init_devices(hwif);
         ide_port_setup_devices(hwif);
+        ide_acpi_port_init_devices(hwif);
         hwif_register_devices(hwif);
         ide_proc_port_register_devices(hwif);
 }
 EXPORT_SYMBOL_GPL(ide_port_scan);
-
-static void ide_legacy_init_one(hw_regs_t **hws, hw_regs_t *hw,
-                                u8 port_no, const struct ide_port_info *d,
-                                unsigned long config)
-{
-        unsigned long base, ctl;
-        int irq;
-
-        if (port_no == 0) {
-                base = 0x1f0;
-                ctl  = 0x3f6;
-                irq  = 14;
-        } else {
-                base = 0x170;
-                ctl  = 0x376;
-                irq  = 15;
-        }
-
-        if (!request_region(base, 8, d->name)) {
-                printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
-                                d->name, base, base + 7);
-                return;
-        }
-
-        if (!request_region(ctl, 1, d->name)) {
-                printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
-                                d->name, ctl);
-                release_region(base, 8);
-                return;
-        }
-
-        ide_std_init_ports(hw, base, ctl);
-        hw->irq = irq;
-        hw->chipset = d->chipset;
-        hw->config = config;
-
-        hws[port_no] = hw;
-}
-
-int ide_legacy_device_add(const struct ide_port_info *d, unsigned long config)
-{
-        hw_regs_t hw[2], *hws[] = { NULL, NULL, NULL, NULL };
-
-        memset(&hw, 0, sizeof(hw));
-
-        if ((d->host_flags & IDE_HFLAG_QD_2ND_PORT) == 0)
-                ide_legacy_init_one(hws, &hw[0], 0, d, config);
-        ide_legacy_init_one(hws, &hw[1], 1, d, config);
-
-        if (hws[0] == NULL && hws[1] == NULL &&
-            (d->host_flags & IDE_HFLAG_SINGLE))
-                return -ENOENT;
-
-        return ide_host_add(d, hws, NULL);
-}
-EXPORT_SYMBOL_GPL(ide_legacy_device_add);
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index f3cddd1b2f8f..1d8978b3314a 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -46,10 +46,6 @@ static int proc_ide_read_imodel
         case ide_qd65xx:        name = "qd65xx";        break;
         case ide_umc8672:       name = "umc8672";       break;
         case ide_ht6560b:       name = "ht6560b";       break;
-        case ide_rz1000:        name = "rz1000";        break;
-        case ide_trm290:        name = "trm290";        break;
-        case ide_cmd646:        name = "cmd646";        break;
-        case ide_cy82c693:      name = "cy82c693";      break;
         case ide_4drives:       name = "4drives";       break;
         case ide_pmac:          name = "mac-io";        break;
         case ide_au1xxx:        name = "au1xxx";        break;
@@ -155,13 +151,8 @@ static int ide_read_setting(ide_drive_t *drive,
         const struct ide_devset *ds = setting->setting;
         int val = -EINVAL;
 
-        if (ds->get) {
-                unsigned long flags;
-
-                spin_lock_irqsave(&ide_lock, flags);
+        if (ds->get)
                 val = ds->get(drive);
-                spin_unlock_irqrestore(&ide_lock, flags);
-        }
 
         return val;
 }
@@ -448,13 +439,13 @@ static int proc_ide_read_dmodel
 static int proc_ide_read_driver
         (char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        ide_drive_t     *drive = (ide_drive_t *) data;
-        struct device   *dev = &drive->gendev;
-        ide_driver_t    *ide_drv;
-        int             len;
+        ide_drive_t             *drive = (ide_drive_t *)data;
+        struct device           *dev = &drive->gendev;
+        struct ide_driver       *ide_drv;
+        int                     len;
 
         if (dev->driver) {
-                ide_drv = container_of(dev->driver, ide_driver_t, gen_driver);
+                ide_drv = to_ide_driver(dev->driver);
                 len = sprintf(page, "%s version %s\n",
                                 dev->driver->name, ide_drv->version);
         } else
@@ -564,7 +555,7 @@ static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t
         }
 }
 
-void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver)
+void ide_proc_register_driver(ide_drive_t *drive, struct ide_driver *driver)
 {
         mutex_lock(&ide_setting_mtx);
         drive->settings = driver->proc_devsets(drive);
@@ -583,45 +574,32 @@ EXPORT_SYMBOL(ide_proc_register_driver);
  *      Clean up the driver specific /proc files and IDE settings
  *      for a given drive.
  *
- *      Takes ide_setting_mtx and ide_lock.
- *      Caller must hold none of the locks.
+ *      Takes ide_setting_mtx.
  */
 
-void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver)
+void ide_proc_unregister_driver(ide_drive_t *drive, struct ide_driver *driver)
 {
-        unsigned long flags;
-
         ide_remove_proc_entries(drive->proc, driver->proc_entries(drive));
 
         mutex_lock(&ide_setting_mtx);
-        spin_lock_irqsave(&ide_lock, flags);
         /*
-         * ide_setting_mtx protects the settings list
-         * ide_lock protects the use of settings
-         *
-         * so we need to hold both, ide_settings_sem because we want to
-         * modify the settings list, and ide_lock because we cannot take
-         * a setting out that is being used.
-         *
-         * OTOH both ide_{read,write}_setting are only ever used under
-         * ide_setting_mtx.
+         * ide_setting_mtx protects both the settings list and the use
+         * of settings (we cannot take a setting out that is being used).
          */
         drive->settings = NULL;
-        spin_unlock_irqrestore(&ide_lock, flags);
         mutex_unlock(&ide_setting_mtx);
 }
 EXPORT_SYMBOL(ide_proc_unregister_driver);
 
 void ide_proc_port_register_devices(ide_hwif_t *hwif)
 {
-        int     d;
         struct proc_dir_entry *ent;
         struct proc_dir_entry *parent = hwif->proc;
+        ide_drive_t *drive;
         char name[64];
+        int i;
 
-        for (d = 0; d < MAX_DRIVES; d++) {
-                ide_drive_t *drive = &hwif->drives[d];
-
+        ide_port_for_each_dev(i, drive, hwif) {
                 if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0 || drive->proc)
                         continue;
 
@@ -674,7 +652,7 @@ void ide_proc_unregister_port(ide_hwif_t *hwif)
 
 static int proc_print_driver(struct device_driver *drv, void *data)
 {
-        ide_driver_t *ide_drv = container_of(drv, ide_driver_t, gen_driver);
+        struct ide_driver *ide_drv = to_ide_driver(drv);
         struct seq_file *s = data;
 
         seq_printf(s, "%s version %s\n", drv->name, ide_drv->version);
diff --git a/drivers/ide/ide-sysfs.c b/drivers/ide/ide-sysfs.c
new file mode 100644
index 000000000000..883ffacaf45a
--- /dev/null
+++ b/drivers/ide/ide-sysfs.c
@@ -0,0 +1,125 @@
+#include <linux/kernel.h>
+#include <linux/ide.h>
+
+char *ide_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";
+        case ide_optical:
+                return "optical";
+        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", ide_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", ide_media_string(drive));
+}
+
+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", (char *)&drive->id[ATA_ID_PROD]);
+}
+
+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", (char *)&drive->id[ATA_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", (char *)&drive->id[ATA_ID_SERNO]);
+}
+
+struct device_attribute ide_dev_attrs[] = {
+        __ATTR_RO(media),
+        __ATTR_RO(drivename),
+        __ATTR_RO(modalias),
+        __ATTR_RO(model),
+        __ATTR_RO(firmware),
+        __ATTR(serial, 0400, serial_show, NULL),
+        __ATTR(unload_heads, 0644, ide_park_show, ide_park_store),
+        __ATTR_NULL
+};
+
+static ssize_t store_delete_devices(struct device *portdev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t n)
+{
+        ide_hwif_t *hwif = dev_get_drvdata(portdev);
+
+        if (strncmp(buf, "1", n))
+                return -EINVAL;
+
+        ide_port_unregister_devices(hwif);
+
+        return n;
+};
+
+static DEVICE_ATTR(delete_devices, S_IWUSR, NULL, store_delete_devices);
+
+static ssize_t store_scan(struct device *portdev,
+                          struct device_attribute *attr,
+                          const char *buf, size_t n)
+{
+        ide_hwif_t *hwif = dev_get_drvdata(portdev);
+
+        if (strncmp(buf, "1", n))
+                return -EINVAL;
+
+        ide_port_unregister_devices(hwif);
+        ide_port_scan(hwif);
+
+        return n;
+};
+
+static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
+
+static struct device_attribute *ide_port_attrs[] = {
+        &dev_attr_delete_devices,
+        &dev_attr_scan,
+        NULL
+};
+
+int ide_sysfs_register_port(ide_hwif_t *hwif)
+{
+        int i, uninitialized_var(rc);
+
+        for (i = 0; ide_port_attrs[i]; i++) {
+                rc = device_create_file(hwif->portdev, ide_port_attrs[i]);
+                if (rc)
+                        break;
+        }
+
+        return rc;
+}
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index a2d470eb2b55..d7ecd3c79757 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -166,10 +166,10 @@ struct idetape_bh {
  * to an interrupt or a timer event is stored in the struct defined below.
  */
 typedef struct ide_tape_obj {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
+        ide_drive_t             *drive;
+        struct ide_driver       *driver;
+        struct gendisk          *disk;
+        struct kref             kref;
 
         /*
          *      failed_pc points to the last failed packet command, or contains
@@ -479,7 +479,7 @@ static void ide_tape_kfree_buffer(idetape_tape_t *tape)
 
 static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects)
 {
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = drive->hwif->rq;
         idetape_tape_t *tape = drive->driver_data;
         unsigned long flags;
         int error;
@@ -531,7 +531,7 @@ static void ide_tape_callback(ide_drive_t *drive, int dsc)
                         printk(KERN_ERR "ide-tape: Error in REQUEST SENSE "
                                         "itself - Aborting request!\n");
         } else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
-                struct request *rq = drive->hwif->hwgroup->rq;
+                struct request *rq = drive->hwif->rq;
                 int blocks = pc->xferred / tape->blk_size;
 
                 tape->avg_size += blocks * tape->blk_size;
@@ -576,7 +576,7 @@ static void ide_tape_callback(ide_drive_t *drive, int dsc)
 
 /*
  * Postpone the current request so that ide.c will be able to service requests
- * from another device on the same hwgroup while we are polling for DSC.
+ * from another device on the same port while we are polling for DSC.
  */
 static void idetape_postpone_request(ide_drive_t *drive)
 {
@@ -584,7 +584,8 @@ static void idetape_postpone_request(ide_drive_t *drive)
 
         debug_log(DBG_PROCS, "Enter %s\n", __func__);
 
-        tape->postponed_rq = HWGROUP(drive)->rq;
+        tape->postponed_rq = drive->hwif->rq;
+
         ide_stall_queue(drive, tape->dsc_poll_freq);
 }
 
@@ -694,7 +695,7 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive,
 
         pc->retries++;
 
-        return ide_issue_pc(drive, WAIT_TAPE_CMD, NULL);
+        return ide_issue_pc(drive);
 }
 
 /* A mode sense command is used to "sense" tape parameters. */
@@ -2312,7 +2313,7 @@ static const struct ide_proc_devset *ide_tape_proc_devsets(ide_drive_t *drive)
 
 static int ide_tape_probe(ide_drive_t *);
 
-static ide_driver_t idetape_driver = {
+static struct ide_driver idetape_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
                 .name           = "ide-tape",
@@ -2323,7 +2324,6 @@ static ide_driver_t idetape_driver = {
         .version                = IDETAPE_VERSION,
         .do_request             = idetape_do_request,
         .end_request            = idetape_end_request,
-        .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
         .proc_entries           = ide_tape_proc_entries,
         .proc_devsets           = ide_tape_proc_devsets,
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index bf4fb9d8d176..16138bce84a7 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -58,7 +58,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *);
 
 ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct ide_taskfile *tf = &task->tf;
         ide_handler_t *handler = NULL;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
@@ -309,9 +309,9 @@ static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq,
                 }
 
                 if (sectors > 0) {
-                        ide_driver_t *drv;
+                        struct ide_driver *drv;
 
-                        drv = *(ide_driver_t **)rq->rq_disk->private_data;
+                        drv = *(struct ide_driver **)rq->rq_disk->private_data;
                         drv->end_request(drive, 1, sectors);
                 }
         }
@@ -328,9 +328,9 @@ void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat)
         }
 
         if (rq->rq_disk) {
-                ide_driver_t *drv;
+                struct ide_driver *drv;
 
-                drv = *(ide_driver_t **)rq->rq_disk->private_data;;
+                drv = *(struct ide_driver **)rq->rq_disk->private_data;;
                 drv->end_request(drive, 1, rq->nr_sectors);
         } else
                 ide_end_request(drive, 1, rq->nr_sectors);
@@ -361,7 +361,7 @@ static ide_startstop_t task_in_unexpected(ide_drive_t *drive, struct request *rq
 static ide_startstop_t task_in_intr(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         u8 stat = hwif->tp_ops->read_status(hwif);
 
         /* Error? */
@@ -395,7 +395,7 @@ static ide_startstop_t task_in_intr(ide_drive_t *drive)
 static ide_startstop_t task_out_intr (ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = hwif->rq;
         u8 stat = hwif->tp_ops->read_status(hwif);
 
         if (!OK_STAT(stat, DRIVE_READY, drive->bad_wstat))
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 04f8f13cb9d7..258805da15c3 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -60,189 +60,8 @@
 #include <linux/completion.h>
 #include <linux/device.h>
 
-
-/* default maximum number of failures */
-#define IDE_DEFAULT_MAX_FAILURES        1
-
 struct class *ide_port_class;
 
-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 };
-
-DEFINE_MUTEX(ide_cfg_mtx);
-
-__cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock);
-EXPORT_SYMBOL(ide_lock);
-
-static void ide_port_init_devices_data(ide_hwif_t *);
-
-/*
- * Do not even *think* about calling this!
- */
-void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
-{
-        /* 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;
-
-        init_completion(&hwif->gendev_rel_comp);
-
-        hwif->tp_ops = &default_tp_ops;
-
-        ide_port_init_devices_data(hwif);
-}
-
-static void ide_port_init_devices_data(ide_hwif_t *hwif)
-{
-        int unit;
-
-        for (unit = 0; unit < MAX_DRIVES; ++unit) {
-                ide_drive_t *drive = &hwif->drives[unit];
-                u8 j = (hwif->index * MAX_DRIVES) + unit;
-
-                memset(drive, 0, sizeof(*drive));
-
-                drive->media                    = ide_disk;
-                drive->select                   = (unit << 4) | ATA_DEVICE_OBS;
-                drive->hwif                     = hwif;
-                drive->ready_stat               = ATA_DRDY;
-                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';
-                drive->name[2]                  = 'a' + j;
-                drive->max_failures             = IDE_DEFAULT_MAX_FAILURES;
-
-                INIT_LIST_HEAD(&drive->list);
-                init_completion(&drive->gendev_rel_comp);
-        }
-}
-
-/* Called with ide_lock held. */
-static void __ide_port_unregister_devices(ide_hwif_t *hwif)
-{
-        int i;
-
-        for (i = 0; i < MAX_DRIVES; i++) {
-                ide_drive_t *drive = &hwif->drives[i];
-
-                if (drive->dev_flags & IDE_DFLAG_PRESENT) {
-                        spin_unlock_irq(&ide_lock);
-                        device_unregister(&drive->gendev);
-                        wait_for_completion(&drive->gendev_rel_comp);
-                        spin_lock_irq(&ide_lock);
-                }
-        }
-}
-
-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);
-
-/**
- *      ide_unregister          -       free an IDE interface
- *      @hwif: IDE interface
- *
- *      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
- *      the interface will not be reopened (present/vanishing locking
- *      isn't yet done BTW). After we commit to the final kill we
- *      call the cleanup callback with the ide locks held.
- *
- *      Unregister restores the hwif structures to the default state.
- *      This is raving bonkers.
- */
-
-void ide_unregister(ide_hwif_t *hwif)
-{
-        ide_hwif_t *g;
-        ide_hwgroup_t *hwgroup;
-        int irq_count = 0;
-
-        BUG_ON(in_interrupt());
-        BUG_ON(irqs_disabled());
-
-        mutex_lock(&ide_cfg_mtx);
-
-        spin_lock_irq(&ide_lock);
-        if (hwif->present) {
-                __ide_port_unregister_devices(hwif);
-                hwif->present = 0;
-        }
-        spin_unlock_irq(&ide_lock);
-
-        ide_proc_unregister_port(hwif);
-
-        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);
-
-        ide_remove_port_from_hwgroup(hwif);
-
-        device_unregister(hwif->portdev);
-        device_unregister(&hwif->gendev);
-        wait_for_completion(&hwif->gendev_rel_comp);
-
-        /*
-         * 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);
-
-        ide_release_dma_engine(hwif);
-
-        mutex_unlock(&ide_cfg_mtx);
-}
-
-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->dev = hw->dev;
-        hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
-        hwif->ack_intr = hw->ack_intr;
-        hwif->config_data = hw->config;
-}
-
 /*
  *      Locks for IDE setting functionality
  */
@@ -354,9 +173,9 @@ static int set_pio_mode(ide_drive_t *drive, int arg)
                         unsigned long flags;
 
                         /* take lock for IDE_DFLAG_[NO_]UNMASK/[NO_]IO_32BIT */
-                        spin_lock_irqsave(&ide_lock, flags);
+                        spin_lock_irqsave(&hwif->lock, flags);
                         port_ops->set_pio_mode(drive, arg);
-                        spin_unlock_irqrestore(&ide_lock, flags);
+                        spin_unlock_irqrestore(&hwif->lock, flags);
                 } else
                         port_ops->set_pio_mode(drive, arg);
         } else {
@@ -397,80 +216,6 @@ ide_ext_devset_rw_sync(unmaskirq, unmaskirq);
 ide_ext_devset_rw_sync(using_dma, using_dma);
 __IDE_DEVSET(pio_mode, DS_SYNC, NULL, set_pio_mode);
 
-static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
-{
-        ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
-        ide_hwif_t *hwif = HWIF(drive);
-        struct request *rq;
-        struct request_pm_state rqpm;
-        ide_task_t args;
-        int ret;
-
-        /* call ACPI _GTM only once */
-        if ((drive->dn & 1) == 0 || pair == NULL)
-                ide_acpi_get_timing(hwif);
-
-        memset(&rqpm, 0, sizeof(rqpm));
-        memset(&args, 0, sizeof(args));
-        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_PM_SUSPEND;
-        rq->special = &args;
-        rq->data = &rqpm;
-        rqpm.pm_step = IDE_PM_START_SUSPEND;
-        if (mesg.event == PM_EVENT_PRETHAW)
-                mesg.event = PM_EVENT_FREEZE;
-        rqpm.pm_state = mesg.event;
-
-        ret = blk_execute_rq(drive->queue, NULL, rq, 0);
-        blk_put_request(rq);
-
-        /* call ACPI _PS3 only after both devices are suspended */
-        if (ret == 0 && ((drive->dn & 1) || pair == NULL))
-                ide_acpi_set_state(hwif, 0);
-
-        return ret;
-}
-
-static int generic_ide_resume(struct device *dev)
-{
-        ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
-        ide_hwif_t *hwif = HWIF(drive);
-        struct request *rq;
-        struct request_pm_state rqpm;
-        ide_task_t args;
-        int err;
-
-        /* call ACPI _PS0 / _STM only once */
-        if ((drive->dn & 1) == 0 || pair == NULL) {
-                ide_acpi_set_state(hwif, 1);
-                ide_acpi_push_timing(hwif);
-        }
-
-        ide_acpi_exec_tfs(drive);
-
-        memset(&rqpm, 0, sizeof(rqpm));
-        memset(&args, 0, sizeof(args));
-        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_PM_RESUME;
-        rq->cmd_flags |= REQ_PREEMPT;
-        rq->special = &args;
-        rq->data = &rqpm;
-        rqpm.pm_step = IDE_PM_START_RESUME;
-        rqpm.pm_state = PM_EVENT_ON;
-
-        err = blk_execute_rq(drive->queue, NULL, rq, 1);
-        blk_put_request(rq);
-
-        if (err == 0 && dev->driver) {
-                ide_driver_t *drv = to_ide_driver(dev->driver);
-
-                if (drv->resume)
-                        drv->resume(drive);
-        }
-
-        return err;
-}
-
 /**
  * ide_device_get       -       get an additional reference to a ide_drive_t
  * @drive:      device to get a reference to
@@ -523,88 +268,20 @@ static int ide_bus_match(struct device *dev, struct device_driver *drv)
         return 1;
 }
 
-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";
-        case ide_optical:
-                return "optical";
-        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));
-}
-
-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", (char *)&drive->id[ATA_ID_PROD]);
-}
-
-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", (char *)&drive->id[ATA_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", (char *)&drive->id[ATA_ID_SERNO]);
-}
-
-static struct device_attribute ide_dev_attrs[] = {
-        __ATTR_RO(media),
-        __ATTR_RO(drivename),
-        __ATTR_RO(modalias),
-        __ATTR_RO(model),
-        __ATTR_RO(firmware),
-        __ATTR(serial, 0400, serial_show, NULL),
-        __ATTR(unload_heads, 0644, ide_park_show, ide_park_store),
-        __ATTR_NULL
-};
-
 static int ide_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         ide_drive_t *drive = to_ide_device(dev);
 
-        add_uevent_var(env, "MEDIA=%s", media_string(drive));
+        add_uevent_var(env, "MEDIA=%s", ide_media_string(drive));
         add_uevent_var(env, "DRIVENAME=%s", drive->name);
-        add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive));
+        add_uevent_var(env, "MODALIAS=ide:m-%s", ide_media_string(drive));
         return 0;
 }
 
 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);
+        struct ide_driver *drv = to_ide_driver(dev->driver);
 
         return drv->probe ? drv->probe(drive) : -ENODEV;
 }
@@ -612,7 +289,7 @@ static int generic_ide_probe(struct device *dev)
 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);
+        struct ide_driver *drv = to_ide_driver(dev->driver);
 
         if (drv->remove)
                 drv->remove(drive);
@@ -623,7 +300,7 @@ static int generic_ide_remove(struct device *dev)
 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);
+        struct ide_driver *drv = to_ide_driver(dev->driver);
 
         if (dev->driver && drv->shutdown)
                 drv->shutdown(drive);
@@ -811,6 +488,7 @@ MODULE_PARM_DESC(ignore_cable, "ignore cable detection");
 
 void ide_port_apply_params(ide_hwif_t *hwif)
 {
+        ide_drive_t *drive;
         int i;
 
         if (ide_ignore_cable & (1 << hwif->index)) {
@@ -819,8 +497,8 @@ void ide_port_apply_params(ide_hwif_t *hwif)
                 hwif->cbl = ATA_CBL_PATA40_SHORT;
         }
 
-        for (i = 0; i < MAX_DRIVES; i++)
-                ide_dev_apply_params(&hwif->drives[i], i);
+        ide_port_for_each_dev(i, drive, hwif)
+                ide_dev_apply_params(drive, i);
 }
 
 /*
diff --git a/drivers/ide/ide_arm.c b/drivers/ide/ide_arm.c
index f728f2927b5a..bdcac94d7c1f 100644
--- a/drivers/ide/ide_arm.c
+++ b/drivers/ide/ide_arm.c
@@ -15,15 +15,8 @@
 
 #define DRV_NAME "ide_arm"
 
-#ifdef CONFIG_ARCH_CLPS7500
-# include <mach/hardware.h>
-#
-# define IDE_ARM_IO     (ISASLOT_IO + 0x1f0)
-# define IDE_ARM_IRQ    IRQ_ISA_14
-#else
-# define IDE_ARM_IO     0x1f0
-# define IDE_ARM_IRQ    IRQ_HARDDISK
-#endif
+#define IDE_ARM_IO      0x1f0
+#define IDE_ARM_IRQ     IRQ_HARDDISK
 
 static int __init ide_arm_init(void)
 {
diff --git a/drivers/ide/it8172.c b/drivers/ide/it8172.c
new file mode 100644
index 000000000000..e021078cd06b
--- /dev/null
+++ b/drivers/ide/it8172.c
@@ -0,0 +1,166 @@
+/*
+ *
+ * BRIEF MODULE DESCRIPTION
+ *      IT8172 IDE controller support
+ *
+ * Copyright (C) 2000 MontaVista Software Inc.
+ * Copyright (C) 2008 Shane McDonald
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/ioport.h>
+#include <linux/pci.h>
+#include <linux/ide.h>
+#include <linux/init.h>
+
+#define DRV_NAME "IT8172"
+
+static void it8172_set_pio_mode(ide_drive_t *drive, const u8 pio)
+{
+        ide_hwif_t *hwif        = drive->hwif;
+        struct pci_dev *dev     = to_pci_dev(hwif->dev);
+        u16 drive_enables;
+        u32 drive_timing;
+
+        /*
+         * The highest value of DIOR/DIOW pulse width and recovery time
+         * that can be set in the IT8172 is 8 PCI clock cycles.  As a result,
+         * it cannot be configured for PIO mode 0.  This table sets these
+         * parameters to the maximum supported by the IT8172.
+         */
+        static const u8 timings[] = { 0x3f, 0x3c, 0x1b, 0x12, 0x0a };
+
+        pci_read_config_word(dev, 0x40, &drive_enables);
+        pci_read_config_dword(dev, 0x44, &drive_timing);
+
+        /*
+         * Enable port 0x44. The IT8172 spec is confused; it calls
+         * this register the "Slave IDE Timing Register", but in fact,
+         * it controls timing for both master and slave drives.
+         */
+        drive_enables |= 0x4000;
+
+        drive_enables &= drive->dn ? 0xc006 : 0xc060;
+        if (drive->media == ide_disk)
+                /* enable prefetch */
+                drive_enables |= 0x0004 << (drive->dn * 4);
+        if (ata_id_has_iordy(drive->id))
+                /* enable IORDY sample-point */
+                drive_enables |= 0x0002 << (drive->dn * 4);
+
+        drive_timing &= drive->dn ? 0x00003f00 : 0x000fc000;
+        drive_timing |= timings[pio] << (drive->dn * 6 + 8);
+
+        pci_write_config_word(dev, 0x40, drive_enables);
+        pci_write_config_dword(dev, 0x44, drive_timing);
+}
+
+static void it8172_set_dma_mode(ide_drive_t *drive, const u8 speed)
+{
+        ide_hwif_t *hwif        = drive->hwif;
+        struct pci_dev *dev     = to_pci_dev(hwif->dev);
+        int a_speed             = 3 << (drive->dn * 4);
+        int u_flag              = 1 << drive->dn;
+        int u_speed             = 0;
+        u8 reg48, reg4a;
+
+        pci_read_config_byte(dev, 0x48, &reg48);
+        pci_read_config_byte(dev, 0x4a, &reg4a);
+
+        if (speed >= XFER_UDMA_0) {
+                u8 udma = speed - XFER_UDMA_0;
+                u_speed = udma << (drive->dn * 4);
+
+                pci_write_config_byte(dev, 0x48, reg48 | u_flag);
+                reg4a &= ~a_speed;
+                pci_write_config_byte(dev, 0x4a, reg4a | u_speed);
+        } else {
+                const u8 mwdma_to_pio[] = { 0, 3, 4 };
+                u8 pio;
+
+                pci_write_config_byte(dev, 0x48, reg48 & ~u_flag);
+                pci_write_config_byte(dev, 0x4a, reg4a & ~a_speed);
+
+                pio = mwdma_to_pio[speed - XFER_MW_DMA_0];
+
+                it8172_set_pio_mode(drive, pio);
+        }
+}
+
+
+static const struct ide_port_ops it8172_port_ops = {
+        .set_pio_mode   = it8172_set_pio_mode,
+        .set_dma_mode   = it8172_set_dma_mode,
+};
+
+static const struct ide_port_info it8172_port_info __devinitdata = {
+        .name           = DRV_NAME,
+        .port_ops       = &it8172_port_ops,
+        .enablebits     = { {0x41, 0x80, 0x80}, {0x00, 0x00, 0x00} },
+        .host_flags     = IDE_HFLAG_SINGLE,
+        .pio_mask       = ATA_PIO4 & ~ATA_PIO0,
+        .mwdma_mask     = ATA_MWDMA2,
+        .udma_mask      = ATA_UDMA2,
+};
+
+static int __devinit it8172_init_one(struct pci_dev *dev,
+                                        const struct pci_device_id *id)
+{
+        if ((dev->class >> 8) != PCI_CLASS_STORAGE_IDE)
+                return -ENODEV; /* IT8172 is more than an IDE controller */
+        return ide_pci_init_one(dev, &it8172_port_info, NULL);
+}
+
+static struct pci_device_id it8172_pci_tbl[] = {
+        { PCI_VDEVICE(ITE, PCI_DEVICE_ID_ITE_8172), 0 },
+        { 0, },
+};
+MODULE_DEVICE_TABLE(pci, it8172_pci_tbl);
+
+static struct pci_driver it8172_pci_driver = {
+        .name           = "IT8172_IDE",
+        .id_table       = it8172_pci_tbl,
+        .probe          = it8172_init_one,
+        .remove         = ide_pci_remove,
+        .suspend        = ide_pci_suspend,
+        .resume         = ide_pci_resume,
+};
+
+static int __init it8172_ide_init(void)
+{
+        return ide_pci_register_driver(&it8172_pci_driver);
+}
+
+static void __exit it8172_ide_exit(void)
+{
+        pci_unregister_driver(&it8172_pci_driver);
+}
+
+module_init(it8172_ide_init);
+module_exit(it8172_ide_exit);
+
+MODULE_AUTHOR("Steve Longerbeam");
+MODULE_DESCRIPTION("PCI driver module for ITE 8172 IDE");
+MODULE_LICENSE("GPL");
diff --git a/drivers/ide/it8213.c b/drivers/ide/it8213.c
index 7c2feeb3c5ec..d7969b6d139e 100644
--- a/drivers/ide/it8213.c
+++ b/drivers/ide/it8213.c
@@ -25,7 +25,7 @@
 
 static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int is_slave            = drive->dn & 1;
         int master_port         = 0x40;
@@ -82,7 +82,7 @@ static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 static void it8213_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 maslave              = 0x40;
         int a_speed             = 3 << (drive->dn * 4);
diff --git a/drivers/ide/it821x.c b/drivers/ide/it821x.c
index ef004089761b..0be27ac1f077 100644
--- a/drivers/ide/it821x.c
+++ b/drivers/ide/it821x.c
@@ -167,12 +167,10 @@ static void it821x_clock_strategy(ide_drive_t *drive)
         ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         struct it821x_dev *itdev = ide_get_hwifdata(hwif);
-        ide_drive_t *pair;
+        ide_drive_t *pair = ide_get_pair_dev(drive);
         int clock, altclock, sel = 0;
         u8 unit = drive->dn & 1, v;
 
-        pair = &hwif->drives[1 - unit];
-
         if(itdev->want[0][0] > itdev->want[1][0]) {
                 clock = itdev->want[0][1];
                 altclock = itdev->want[1][1];
@@ -239,15 +237,13 @@ static void it821x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif = drive->hwif;
         struct it821x_dev *itdev = ide_get_hwifdata(hwif);
-        ide_drive_t *pair;
+        ide_drive_t *pair = ide_get_pair_dev(drive);
         u8 unit = drive->dn & 1, set_pio = pio;
 
         /* Spec says 89 ref driver uses 88 */
         static u16 pio_timings[]= { 0xAA88, 0xA382, 0xA181, 0x3332, 0x3121 };
         static u8 pio_want[]    = { ATA_66, ATA_66, ATA_66, ATA_66, ATA_ANY };
 
-        pair = &hwif->drives[1 - unit];
-
         /*
          * Compute the best PIO mode we can for a given device. We must
          * pick a speed that does not cause problems with the other device
@@ -279,7 +275,7 @@ static void it821x_set_pio_mode(ide_drive_t *drive, const u8 pio)
  *      the shared MWDMA/PIO timing register.
  */
 
-static void it821x_tune_mwdma (ide_drive_t *drive, byte mode_wanted)
+static void it821x_tune_mwdma(ide_drive_t *drive, u8 mode_wanted)
 {
         ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
@@ -316,7 +312,7 @@ static void it821x_tune_mwdma (ide_drive_t *drive, byte mode_wanted)
  *      controller when doing UDMA modes in pass through.
  */
 
-static void it821x_tune_udma (ide_drive_t *drive, byte mode_wanted)
+static void it821x_tune_udma(ide_drive_t *drive, u8 mode_wanted)
 {
         ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
@@ -516,6 +512,7 @@ static struct ide_dma_ops it821x_pass_through_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_timeout            = ide_dma_timeout,
         .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 /**
diff --git a/drivers/ide/macide.c b/drivers/ide/macide.c
index 43f97cc1d30e..3c60064f1d4f 100644
--- a/drivers/ide/macide.c
+++ b/drivers/ide/macide.c
@@ -18,7 +18,6 @@
 #include <linux/delay.h>
 #include <linux/ide.h>
 
-#include <asm/machw.h>
 #include <asm/macintosh.h>
 #include <asm/macints.h>
 #include <asm/mac_baboon.h>
diff --git a/drivers/ide/ns87415.c b/drivers/ide/ns87415.c
index 13789060f407..83643ed9a426 100644
--- a/drivers/ide/ns87415.c
+++ b/drivers/ide/ns87415.c
@@ -56,7 +56,7 @@ static u8 superio_read_status(ide_hwif_t *hwif)
         return superio_ide_inb(hwif->io_ports.status_addr);
 }
 
-static u8 superio_read_sff_dma_status(ide_hwif_t *hwif)
+static u8 superio_dma_sff_read_status(ide_hwif_t *hwif)
 {
         return superio_ide_inb(hwif->dma_base + ATA_DMA_STATUS);
 }
@@ -109,7 +109,6 @@ static const struct ide_tp_ops superio_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = superio_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = superio_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
@@ -132,18 +131,20 @@ static void __devinit superio_init_iops(struct hwif_s *hwif)
         tmp = superio_ide_inb(dma_stat);
         outb(tmp | 0x66, dma_stat);
 }
+#else
+#define superio_dma_sff_read_status ide_dma_sff_read_status
 #endif
 
 static unsigned int ns87415_count = 0, ns87415_control[MAX_HWIFS] = { 0 };
 
 /*
  * This routine either enables/disables (according to IDE_DFLAG_PRESENT)
- * the IRQ associated with the port (HWIF(drive)),
+ * the IRQ associated with the port,
  * 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)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         unsigned int bit, other, new, *old = (unsigned int *) hwif->select_data;
         unsigned long flags;
@@ -197,11 +198,11 @@ static void ns87415_selectproc (ide_drive_t *drive)
 
 static int ns87415_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t      *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         u8 dma_stat = 0, dma_cmd = 0;
 
         drive->waiting_for_dma = 0;
-        dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
         /* get DMA command mode */
         dma_cmd = inb(hwif->dma_base + ATA_DMA_CMD);
         /* stop DMA */
@@ -308,6 +309,7 @@ static const struct ide_dma_ops ns87415_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = superio_dma_sff_read_status,
 };
 
 static const struct ide_port_info ns87415_chipset __devinitdata = {
diff --git a/drivers/ide/palm_bk3710.c b/drivers/ide/palm_bk3710.c
index 122ed3c072fd..a7ac490c9ae3 100644
--- a/drivers/ide/palm_bk3710.c
+++ b/drivers/ide/palm_bk3710.c
@@ -324,8 +324,6 @@ static int __devinit palm_bk3710_init_dma(ide_hwif_t *hwif,
 
         hwif->dma_base = hwif->io_ports.data_addr - IDE_PALM_ATA_PRI_REG_OFFSET;
 
-        hwif->dma_ops = &sff_dma_ops;
-
         return 0;
 }
 
@@ -338,6 +336,7 @@ static const struct ide_port_ops palm_bk3710_ports_ops = {
 static struct ide_port_info __devinitdata palm_bk3710_port_info = {
         .init_dma               = palm_bk3710_init_dma,
         .port_ops               = &palm_bk3710_ports_ops,
+        .dma_ops                = &sff_dma_ops,
         .host_flags             = IDE_HFLAG_MMIO,
         .pio_mask               = ATA_PIO4,
         .mwdma_mask             = ATA_MWDMA2,
diff --git a/drivers/ide/pdc202xx_new.c b/drivers/ide/pdc202xx_new.c
index 211ae46e3e0c..f21290c4b447 100644
--- a/drivers/ide/pdc202xx_new.c
+++ b/drivers/ide/pdc202xx_new.c
@@ -143,7 +143,7 @@ static struct udma_timing {
 
 static void pdcnew_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 adj                  = (drive->dn & 1) ? 0x08 : 0x00;
 
@@ -219,7 +219,7 @@ static void pdcnew_reset(ide_drive_t *drive)
          * Deleted this because it is redundant from the caller.
          */
         printk(KERN_WARNING "pdc202xx_new: %s channel reset.\n",
-                HWIF(drive)->channel ? "Secondary" : "Primary");
+                drive->hwif->channel ? "Secondary" : "Primary");
 }
 
 /**
diff --git a/drivers/ide/pdc202xx_old.c b/drivers/ide/pdc202xx_old.c
index 799557c25eef..97193323aebf 100644
--- a/drivers/ide/pdc202xx_old.c
+++ b/drivers/ide/pdc202xx_old.c
@@ -39,7 +39,7 @@ static void pdc_old_disable_66MHz_clock(ide_hwif_t *);
 
 static void pdc202xx_set_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 drive_pci            = 0x60 + (drive->dn << 2);
 
@@ -169,8 +169,8 @@ static void pdc202xx_dma_start(ide_drive_t *drive)
         if (drive->current_speed > XFER_UDMA_2)
                 pdc_old_enable_66MHz_clock(drive->hwif);
         if (drive->media != ide_disk || (drive->dev_flags & IDE_DFLAG_LBA48)) {
-                struct request *rq      = HWGROUP(drive)->rq;
-                ide_hwif_t *hwif        = HWIF(drive);
+                ide_hwif_t *hwif        = drive->hwif;
+                struct request *rq      = hwif->rq;
                 unsigned long high_16   = hwif->extra_base - 16;
                 unsigned long atapi_reg = high_16 + (hwif->channel ? 0x24 : 0x20);
                 u32 word_count  = 0;
@@ -189,7 +189,7 @@ static void pdc202xx_dma_start(ide_drive_t *drive)
 static int pdc202xx_dma_end(ide_drive_t *drive)
 {
         if (drive->media != ide_disk || (drive->dev_flags & IDE_DFLAG_LBA48)) {
-                ide_hwif_t *hwif        = HWIF(drive);
+                ide_hwif_t *hwif        = drive->hwif;
                 unsigned long high_16   = hwif->extra_base - 16;
                 unsigned long atapi_reg = high_16 + (hwif->channel ? 0x24 : 0x20);
                 u8 clock                = 0;
@@ -205,7 +205,7 @@ static int pdc202xx_dma_end(ide_drive_t *drive)
 
 static int pdc202xx_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long high_16   = hwif->extra_base - 16;
         u8 dma_stat             = inb(hwif->dma_base + ATA_DMA_STATUS);
         u8 sc1d                 = inb(high_16 + 0x001d);
@@ -243,7 +243,7 @@ static void pdc202xx_reset_host (ide_hwif_t *hwif)
 
 static void pdc202xx_reset (ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         ide_hwif_t *mate        = hwif->mate;
 
         pdc202xx_reset_host(hwif);
@@ -337,6 +337,7 @@ static const struct ide_dma_ops pdc20246_dma_ops = {
         .dma_test_irq           = pdc202xx_dma_test_irq,
         .dma_lost_irq           = pdc202xx_dma_lost_irq,
         .dma_timeout            = pdc202xx_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_dma_ops pdc2026x_dma_ops = {
@@ -348,18 +349,20 @@ static const struct ide_dma_ops pdc2026x_dma_ops = {
         .dma_test_irq           = pdc202xx_dma_test_irq,
         .dma_lost_irq           = pdc202xx_dma_lost_irq,
         .dma_timeout            = pdc202xx_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-#define DECLARE_PDC2026X_DEV(udma, extra_flags) \
+#define DECLARE_PDC2026X_DEV(udma, sectors) \
         { \
                 .name           = DRV_NAME, \
                 .init_chipset   = init_chipset_pdc202xx, \
                 .port_ops       = &pdc2026x_port_ops, \
                 .dma_ops        = &pdc2026x_dma_ops, \
-                .host_flags     = IDE_HFLAGS_PDC202XX | extra_flags, \
+                .host_flags     = IDE_HFLAGS_PDC202XX, \
                 .pio_mask       = ATA_PIO4, \
                 .mwdma_mask     = ATA_MWDMA2, \
                 .udma_mask      = udma, \
+                .max_sectors    = sectors, \
         }
 
 static const struct ide_port_info pdc202xx_chipsets[] __devinitdata = {
@@ -376,8 +379,8 @@ static const struct ide_port_info pdc202xx_chipsets[] __devinitdata = {
 
         /* 1: PDC2026{2,3} */
         DECLARE_PDC2026X_DEV(ATA_UDMA4, 0),
-        /* 2: PDC2026{5,7} */
-        DECLARE_PDC2026X_DEV(ATA_UDMA5, IDE_HFLAG_RQSIZE_256),
+        /* 2: PDC2026{5,7}: UDMA5, limit LBA48 requests to 256 sectors */
+        DECLARE_PDC2026X_DEV(ATA_UDMA5, 256),
 };
 
 /**
diff --git a/drivers/ide/piix.c b/drivers/ide/piix.c
index 61d2d920a5cd..f1e2e4ef0d71 100644
--- a/drivers/ide/piix.c
+++ b/drivers/ide/piix.c
@@ -67,7 +67,7 @@ static int no_piix_dma;
 
 static void piix_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int is_slave            = drive->dn & 1;
         int master_port         = hwif->channel ? 0x42 : 0x40;
@@ -136,7 +136,7 @@ static void piix_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 static void piix_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 maslave              = hwif->channel ? 0x42 : 0x40;
         int a_speed             = 3 << (drive->dn * 4);
@@ -224,7 +224,7 @@ static unsigned int init_chipset_ich(struct pci_dev *dev)
  */
 static void ich_clear_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         u8 dma_stat;
 
         /*
@@ -260,6 +260,8 @@ static const struct ich_laptop ich_laptop[] = {
         { 0x27DF, 0x103C, 0x30A1 },     /* ICH7 on HP Compaq nc2400 */
         { 0x27DF, 0x1071, 0xD221 },     /* ICH7 on Hercules EC-900 */
         { 0x24CA, 0x1025, 0x0061 },     /* ICH4 on Acer Aspire 2023WLMi */
+        { 0x24CA, 0x1025, 0x003d },     /* ICH4 on ACER TM290 */
+        { 0x266F, 0x1025, 0x0066 },     /* ICH6 on ACER Aspire 1694WLMi */
         { 0x2653, 0x1043, 0x82D8 },     /* ICH6M on Asus Eee 701 */
         /* end marker */
         { 0, }
diff --git a/drivers/ide/pmac.c b/drivers/ide/pmac.c
index 7c481bb56fab..74625e821a43 100644
--- a/drivers/ide/pmac.c
+++ b/drivers/ide/pmac.c
@@ -955,7 +955,6 @@ static const struct ide_tp_ops pmac_tp_ops = {
         .exec_command           = pmac_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = pmac_set_irq,
 
@@ -1513,10 +1512,10 @@ use_pio_instead:
 static int
 pmac_ide_dma_setup(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         pmac_ide_hwif_t *pmif =
                 (pmac_ide_hwif_t *)dev_get_drvdata(hwif->gendev.parent);
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = hwif->rq;
         u8 unit = drive->dn & 1, ata4 = (pmif->kind == controller_kl_ata4);
 
         if (!pmac_ide_build_dmatable(drive, rq)) {
@@ -1637,7 +1636,7 @@ pmac_ide_dma_test_irq (ide_drive_t *drive)
                         break;
                 if (++timeout > 100) {
                         printk(KERN_WARNING "ide%d, ide_dma_test_irq \
-                        timeout flushing channel\n", HWIF(drive)->index);
+                        timeout flushing channel\n", hwif->index);
                         break;
                 }
         }       
diff --git a/drivers/ide/q40ide.c b/drivers/ide/q40ide.c
index 4af4a8ce4cdf..9f9c0b3cc3a3 100644
--- a/drivers/ide/q40ide.c
+++ b/drivers/ide/q40ide.c
@@ -99,7 +99,6 @@ static const struct ide_tp_ops q40ide_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
diff --git a/drivers/ide/qd65xx.c b/drivers/ide/qd65xx.c
index bc27c7aba936..5b2e3af43c4b 100644
--- a/drivers/ide/qd65xx.c
+++ b/drivers/ide/qd65xx.c
@@ -202,7 +202,8 @@ static void qd6500_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 recovery_time = drive->id[ATA_ID_EIDE_PIO] - 120;
         }
 
-        qd_set_timing(drive, qd6500_compute_timing(HWIF(drive), active_time, recovery_time));
+        qd_set_timing(drive, qd6500_compute_timing(drive->hwif,
+                                active_time, recovery_time));
 }
 
 static void qd6580_set_pio_mode(ide_drive_t *drive, const u8 pio)
@@ -245,11 +246,11 @@ static void qd6580_set_pio_mode(ide_drive_t *drive, const u8 pio)
                 printk(KERN_INFO "%s: PIO mode%d\n", drive->name,pio);
         }
 
-        if (!HWIF(drive)->channel && drive->media != ide_disk) {
+        if (!hwif->channel && drive->media != ide_disk) {
                 outb(0x5f, QD_CONTROL_PORT);
                 printk(KERN_WARNING "%s: ATAPI: disabled read-ahead FIFO "
                         "and post-write buffer on %s.\n",
-                        drive->name, HWIF(drive)->name);
+                        drive->name, hwif->name);
         }
 
         qd_set_timing(drive, qd6580_compute_timing(active_time, recovery_time));
diff --git a/drivers/ide/qd65xx.h b/drivers/ide/qd65xx.h
index c83dea85e621..6636f9665d16 100644
--- a/drivers/ide/qd65xx.h
+++ b/drivers/ide/qd65xx.h
@@ -31,8 +31,8 @@
 
 #define QD_CONFIG(hwif)         ((hwif)->config_data & 0x00ff)
 
-#define QD_TIMING(drive)        (byte)(((drive)->drive_data) & 0x00ff)
-#define QD_TIMREG(drive)        (byte)((((drive)->drive_data) & 0xff00) >> 8)
+#define QD_TIMING(drive)        (u8)(((drive)->drive_data) & 0x00ff)
+#define QD_TIMREG(drive)        (u8)((((drive)->drive_data) & 0xff00) >> 8)
 
 #define QD6500_DEF_DATA         ((QD_TIM1_PORT<<8) | (QD_ID3 ? 0x0c : 0x08))
 #define QD6580_DEF_DATA         ((QD_TIM1_PORT<<8) | (QD_ID3 ? 0x0a : 0x00))
diff --git a/drivers/ide/rz1000.c b/drivers/ide/rz1000.c
index 7daf0135cbac..a6414a884eb1 100644
--- a/drivers/ide/rz1000.c
+++ b/drivers/ide/rz1000.c
@@ -22,34 +22,48 @@
 
 #define DRV_NAME "rz1000"
 
-static void __devinit init_hwif_rz1000 (ide_hwif_t *hwif)
+static int __devinit rz1000_disable_readahead(struct pci_dev *dev)
 {
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
         u16 reg;
 
         if (!pci_read_config_word (dev, 0x40, &reg) &&
             !pci_write_config_word(dev, 0x40, reg & 0xdfff)) {
                 printk(KERN_INFO "%s: disabled chipset read-ahead "
-                        "(buggy RZ1000/RZ1001)\n", hwif->name);
+                        "(buggy RZ1000/RZ1001)\n", pci_name(dev));
+                return 0;
         } else {
-                if (hwif->mate)
-                        hwif->mate->serialized = hwif->serialized = 1;
-                hwif->host_flags |= IDE_HFLAG_NO_UNMASK_IRQS;
                 printk(KERN_INFO "%s: serialized, disabled unmasking "
-                        "(buggy RZ1000/RZ1001)\n", hwif->name);
+                        "(buggy RZ1000/RZ1001)\n", pci_name(dev));
+                return 1;
         }
 }
 
 static const struct ide_port_info rz1000_chipset __devinitdata = {
         .name           = DRV_NAME,
-        .init_hwif      = init_hwif_rz1000,
-        .chipset        = ide_rz1000,
         .host_flags     = IDE_HFLAG_NO_DMA,
 };
 
 static int __devinit rz1000_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
-        return ide_pci_init_one(dev, &rz1000_chipset, NULL);
+        struct ide_port_info d = rz1000_chipset;
+        int rc;
+
+        rc = pci_enable_device(dev);
+        if (rc)
+                return rc;
+
+        if (rz1000_disable_readahead(dev)) {
+                d.host_flags |= IDE_HFLAG_SERIALIZE;
+                d.host_flags |= IDE_HFLAG_NO_UNMASK_IRQS;
+        }
+
+        return ide_pci_init_one(dev, &d, NULL);
+}
+
+static void rz1000_remove(struct pci_dev *dev)
+{
+        ide_pci_remove(dev);
+        pci_disable_device(dev);
 }
 
 static const struct pci_device_id rz1000_pci_tbl[] = {
@@ -63,7 +77,7 @@ static struct pci_driver rz1000_pci_driver = {
         .name           = "RZ1000_IDE",
         .id_table       = rz1000_pci_tbl,
         .probe          = rz1000_init_one,
-        .remove         = ide_pci_remove,
+        .remove         = rz1000_remove,
 };
 
 static int __init rz1000_ide_init(void)
diff --git a/drivers/ide/sc1200.c b/drivers/ide/sc1200.c
index ec7f766ef5e4..dbdd2985a0d8 100644
--- a/drivers/ide/sc1200.c
+++ b/drivers/ide/sc1200.c
@@ -125,7 +125,7 @@ out:
 
 static void sc1200_set_dma_mode(ide_drive_t *drive, const u8 mode)
 {
-        ide_hwif_t              *hwif = HWIF(drive);
+        ide_hwif_t              *hwif = drive->hwif;
         struct pci_dev          *dev = to_pci_dev(hwif->dev);
         unsigned int            reg, timings;
         unsigned short          pci_clock;
@@ -170,9 +170,9 @@ static void sc1200_set_dma_mode(ide_drive_t *drive, const u8 mode)
  */
 static int sc1200_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long dma_base = hwif->dma_base;
-        byte dma_stat;
+        u8 dma_stat;
 
         dma_stat = inb(dma_base+2);             /* get DMA status */
 
@@ -199,7 +199,7 @@ static int sc1200_dma_end(ide_drive_t *drive)
 
 static void sc1200_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t      *hwif = HWIF(drive);
+        ide_hwif_t      *hwif = drive->hwif;
         int             mode = -1;
 
         /*
@@ -292,6 +292,7 @@ static const struct ide_dma_ops sc1200_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info sc1200_chipset __devinitdata = {
diff --git a/drivers/ide/scc_pata.c b/drivers/ide/scc_pata.c
index 0f48f9dacfa5..8d2314b6327c 100644
--- a/drivers/ide/scc_pata.c
+++ b/drivers/ide/scc_pata.c
@@ -143,7 +143,7 @@ static u8 scc_read_altstatus(ide_hwif_t *hwif)
         return (u8)in_be32((void *)hwif->io_ports.ctl_addr);
 }
 
-static u8 scc_read_sff_dma_status(ide_hwif_t *hwif)
+static u8 scc_dma_sff_read_status(ide_hwif_t *hwif)
 {
         return (u8)in_be32((void *)(hwif->dma_base + 4));
 }
@@ -217,7 +217,7 @@ scc_ide_outsl(unsigned long port, void *addr, u32 count)
 
 static void scc_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct scc_ports *ports = ide_get_hwifdata(hwif);
         unsigned long ctl_base = ports->ctl;
         unsigned long cckctrl_port = ctl_base + 0xff0;
@@ -249,7 +249,7 @@ static void scc_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 static void scc_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct scc_ports *ports = ide_get_hwifdata(hwif);
         unsigned long ctl_base = ports->ctl;
         unsigned long cckctrl_port = ctl_base + 0xff0;
@@ -259,7 +259,7 @@ static void scc_set_dma_mode(ide_drive_t *drive, const u8 speed)
         unsigned long scrcst_port = ctl_base + 0x014;
         unsigned long udenvt_port = ctl_base + 0x018;
         unsigned long tdvhsel_port   = ctl_base + 0x020;
-        int is_slave = (&hwif->drives[1] == drive);
+        int is_slave = drive->dn & 1;
         int offset, idx;
         unsigned long reg;
         unsigned long jcactsel;
@@ -292,7 +292,7 @@ static void scc_dma_host_set(ide_drive_t *drive, int on)
 {
         ide_hwif_t *hwif = drive->hwif;
         u8 unit = drive->dn & 1;
-        u8 dma_stat = scc_ide_inb(hwif->dma_base + 4);
+        u8 dma_stat = scc_dma_sff_read_status(hwif);
 
         if (on)
                 dma_stat |= (1 << (5 + unit));
@@ -316,7 +316,7 @@ static void scc_dma_host_set(ide_drive_t *drive, int on)
 static int scc_dma_setup(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = hwif->rq;
         unsigned int reading;
         u8 dma_stat;
 
@@ -338,7 +338,7 @@ static int scc_dma_setup(ide_drive_t *drive)
         out_be32((void __iomem *)hwif->dma_base, reading);
 
         /* read DMA status for INTR & ERROR flags */
-        dma_stat = in_be32((void __iomem *)(hwif->dma_base + 4));
+        dma_stat = scc_dma_sff_read_status(hwif);
 
         /* clear INTR & ERROR flags */
         out_be32((void __iomem *)(hwif->dma_base + 4), dma_stat | 6);
@@ -367,7 +367,7 @@ static int __scc_dma_end(ide_drive_t *drive)
         /* stop DMA */
         scc_ide_outb(dma_cmd & ~1, hwif->dma_base);
         /* get DMA status */
-        dma_stat = scc_ide_inb(hwif->dma_base + 4);
+        dma_stat = scc_dma_sff_read_status(hwif);
         /* clear the INTR & ERROR bits */
         scc_ide_outb(dma_stat | 6, hwif->dma_base + 4);
         /* purge DMA mappings */
@@ -387,7 +387,7 @@ static int __scc_dma_end(ide_drive_t *drive)
 
 static int scc_dma_end(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         void __iomem *dma_base = (void __iomem *)hwif->dma_base;
         unsigned long intsts_port = hwif->dma_base + 0x014;
         u32 reg;
@@ -405,17 +405,18 @@ static int scc_dma_end(ide_drive_t *drive)
                                drive->name);
                         data_loss = 1;
                         if (retry++) {
-                                struct request *rq = HWGROUP(drive)->rq;
-                                int unit;
+                                struct request *rq = hwif->rq;
+                                ide_drive_t *drive;
+                                int i;
+
                                 /* ERROR_RESET and drive->crc_count are needed
                                  * to reduce DMA transfer mode in retry process.
                                  */
                                 if (rq)
                                         rq->errors |= ERROR_RESET;
-                                for (unit = 0; unit < MAX_DRIVES; unit++) {
-                                        ide_drive_t *drive = &hwif->drives[unit];
+
+                                ide_port_for_each_dev(i, drive, hwif)
                                         drive->crc_count++;
-                                }
                         }
                 }
         }
@@ -496,7 +497,7 @@ static int scc_dma_end(ide_drive_t *drive)
 /* returns 1 if dma irq issued, 0 otherwise */
 static int scc_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         u32 int_stat = in_be32((void __iomem *)hwif->dma_base + 0x014);
 
         /* SCC errata A252,A308 workaround: Step4 */
@@ -852,7 +853,6 @@ static const struct ide_tp_ops scc_tp_ops = {
         .exec_command           = scc_exec_command,
         .read_status            = scc_read_status,
         .read_altstatus         = scc_read_altstatus,
-        .read_sff_dma_status    = scc_read_sff_dma_status,
 
         .set_irq                = scc_set_irq,
 
@@ -879,6 +879,7 @@ static const struct ide_dma_ops scc_dma_ops = {
         .dma_test_irq           = scc_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = scc_dma_sff_read_status,
 };
 
 #define DECLARE_SCC_DEV(name_str)                       \
diff --git a/drivers/ide/serverworks.c b/drivers/ide/serverworks.c
index 437bc919dafd..382102ba467b 100644
--- a/drivers/ide/serverworks.c
+++ b/drivers/ide/serverworks.c
@@ -151,7 +151,7 @@ static void svwks_set_dma_mode(ide_drive_t *drive, const u8 speed)
         static const u8 dma_modes[]             = { 0x77, 0x21, 0x20 };
         static const u8 drive_pci2[]            = { 0x45, 0x44, 0x47, 0x46 };
 
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 unit                 = drive->dn & 1;
 
diff --git a/drivers/ide/setup-pci.c b/drivers/ide/setup-pci.c
index 9f1f9163a136..e85d1ed29c2a 100644
--- a/drivers/ide/setup-pci.c
+++ b/drivers/ide/setup-pci.c
@@ -130,7 +130,7 @@ int ide_pci_check_simplex(ide_hwif_t *hwif, const struct ide_port_info *d)
          * we tune the drive then try to grab DMA ownership if we want to be
          * the DMA end.  This has to be become dynamic to handle hot-plug.
          */
-        dma_stat = hwif->tp_ops->read_sff_dma_status(hwif);
+        dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
         if ((dma_stat & 0x80) && hwif->mate && hwif->mate->dma_base) {
                 printk(KERN_INFO "%s %s: simplex device: DMA disabled\n",
                         d->name, pci_name(dev));
@@ -377,6 +377,9 @@ int ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
 
                 hwif->dma_base = base;
 
+                if (hwif->dma_ops == NULL)
+                        hwif->dma_ops = &sff_dma_ops;
+
                 if (ide_pci_check_simplex(hwif, d) < 0)
                         return -1;
 
@@ -393,8 +396,6 @@ int ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
 
                 if (ide_allocate_dma_engine(hwif))
                         return -1;
-
-                hwif->dma_ops = &sff_dma_ops;
         }
 
         return 0;
@@ -471,7 +472,7 @@ void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d,
          */
 
         for (port = 0; port < channels; ++port) {
-                const ide_pci_enablebit_t *e = &(d->enablebits[port]);
+                const struct ide_pci_enablebit *e = &d->enablebits[port];
 
                 if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
                     (tmp & e->mask) != e->val)) {
@@ -519,8 +520,7 @@ static int do_ide_setup_pci_device(struct pci_dev *dev,
         if (ret < 0)
                 goto out;
 
-        /* Is it an "IDE storage" device in non-PCI mode? */
-        if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE && (dev->class & 5) != 5) {
+        if (ide_pci_is_in_compatibility_mode(dev)) {
                 if (noisy)
                         printk(KERN_INFO "%s %s: not 100%% native mode: will "
                                 "probe irqs later\n", d->name, pci_name(dev));
diff --git a/drivers/ide/sgiioc4.c b/drivers/ide/sgiioc4.c
index a687a7dfea6f..fdb9d7037694 100644
--- a/drivers/ide/sgiioc4.c
+++ b/drivers/ide/sgiioc4.c
@@ -123,7 +123,7 @@ static int
 sgiioc4_clearirq(ide_drive_t * drive)
 {
         u32 intr_reg;
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct ide_io_ports *io_ports = &hwif->io_ports;
         unsigned long other_ir = io_ports->irq_addr + (IOC4_INTR_REG << 2);
 
@@ -181,7 +181,7 @@ sgiioc4_clearirq(ide_drive_t * drive)
 
 static void sgiioc4_dma_start(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long ioc4_dma_addr = hwif->dma_base + IOC4_DMA_CTRL * 4;
         unsigned int reg = readl((void __iomem *)ioc4_dma_addr);
         unsigned int temp_reg = reg | IOC4_S_DMA_START;
@@ -209,7 +209,7 @@ sgiioc4_ide_dma_stop(ide_hwif_t *hwif, u64 dma_base)
 static int sgiioc4_dma_end(ide_drive_t *drive)
 {
         u32 ioc4_dma, bc_dev, bc_mem, num, valid = 0, cnt = 0;
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long dma_base = hwif->dma_base;
         int dma_stat = 0;
         unsigned long *ending_dma = ide_get_hwifdata(hwif);
@@ -271,7 +271,7 @@ static void sgiioc4_set_dma_mode(ide_drive_t *drive, const u8 speed)
 /* returns 1 if dma irq issued, 0 otherwise */
 static int sgiioc4_dma_test_irq(ide_drive_t *drive)
 {
-        return sgiioc4_checkirq(HWIF(drive));
+        return sgiioc4_checkirq(drive->hwif);
 }
 
 static void sgiioc4_dma_host_set(ide_drive_t *drive, int on)
@@ -367,7 +367,7 @@ static void
 sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
 {
         u32 ioc4_dma;
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         unsigned long dma_base = hwif->dma_base;
         unsigned long ioc4_dma_addr = dma_base + IOC4_DMA_CTRL * 4;
         u32 dma_addr, ending_dma_addr;
@@ -427,7 +427,7 @@ sgiioc4_configure_for_dma(int dma_direction, ide_drive_t * drive)
 static unsigned int
 sgiioc4_build_dma_table(ide_drive_t * drive, struct request *rq, int ddir)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         unsigned int *table = hwif->dmatable_cpu;
         unsigned int count = 0, i = 1;
         struct scatterlist *sg;
@@ -492,7 +492,7 @@ use_pio_instead:
 
 static int sgiioc4_dma_setup(ide_drive_t *drive)
 {
-        struct request *rq = HWGROUP(drive)->rq;
+        struct request *rq = drive->hwif->rq;
         unsigned int count = 0;
         int ddir;
 
@@ -523,7 +523,6 @@ static const struct ide_tp_ops sgiioc4_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = sgiioc4_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
diff --git a/drivers/ide/siimage.c b/drivers/ide/siimage.c
index 7d622d20bc4c..cb2b352b876b 100644
--- a/drivers/ide/siimage.c
+++ b/drivers/ide/siimage.c
@@ -114,7 +114,7 @@ static unsigned long siimage_selreg(ide_hwif_t *hwif, int r)
 
 static inline unsigned long siimage_seldev(ide_drive_t *drive, int r)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long base      = (unsigned long)hwif->hwif_data;
         u8 unit                 = drive->dn & 1;
 
@@ -243,7 +243,7 @@ static void sil_set_pio_mode(ide_drive_t *drive, u8 pio)
         static const u16 tf_speed[]   = { 0x328a, 0x2283, 0x1281, 0x10c3, 0x10c1 };
         static const u16 data_speed[] = { 0x328a, 0x2283, 0x1104, 0x10c3, 0x10c1 };
 
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         ide_drive_t *pair       = ide_get_pair_dev(drive);
         u32 speedt              = 0;
@@ -300,7 +300,7 @@ static void sil_set_dma_mode(ide_drive_t *drive, const u8 speed)
         static const u8 ultra5[] = { 0x0C, 0x07, 0x05, 0x04, 0x02, 0x01 };
         static const u16 dma[]   = { 0x2208, 0x10C2, 0x10C1 };
 
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         unsigned long base      = (unsigned long)hwif->hwif_data;
         u16 ultra = 0, multi    = 0;
@@ -340,7 +340,7 @@ static void sil_set_dma_mode(ide_drive_t *drive, const u8 speed)
 /* returns 1 if dma irq issued, 0 otherwise */
 static int siimage_io_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 dma_altstat          = 0;
         unsigned long addr      = siimage_selreg(hwif, 1);
@@ -367,7 +367,7 @@ static int siimage_io_dma_test_irq(ide_drive_t *drive)
 
 static int siimage_mmio_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long addr      = siimage_selreg(hwif, 0x1);
         void __iomem *sata_error_addr
                 = (void __iomem *)hwif->sata_scr[SATA_ERROR_OFFSET];
@@ -717,6 +717,7 @@ static const struct ide_dma_ops sil_dma_ops = {
         .dma_test_irq           = siimage_dma_test_irq,
         .dma_timeout            = ide_dma_timeout,
         .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 #define DECLARE_SII_DEV(p_ops)                          \
diff --git a/drivers/ide/sis5513.c b/drivers/ide/sis5513.c
index ad32e18c5ba3..9ec1a4a4432c 100644
--- a/drivers/ide/sis5513.c
+++ b/drivers/ide/sis5513.c
@@ -274,7 +274,7 @@ static void sis_program_timings(ide_drive_t *drive, const u8 mode)
 
 static void config_drive_art_rwp(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 reg4bh               = 0;
         u8 rw_prefetch          = 0;
diff --git a/drivers/ide/sl82c105.c b/drivers/ide/sl82c105.c
index 84dc33602ff8..48cc748c5043 100644
--- a/drivers/ide/sl82c105.c
+++ b/drivers/ide/sl82c105.c
@@ -140,7 +140,7 @@ static inline void sl82c105_reset_host(struct pci_dev *dev)
  */
 static void sl82c105_dma_lost_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u32 val, mask           = hwif->channel ? CTRL_IDE_IRQB : CTRL_IDE_IRQA;
         u8 dma_cmd;
@@ -177,7 +177,7 @@ static void sl82c105_dma_lost_irq(ide_drive_t *drive)
  */
 static void sl82c105_dma_start(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int reg                 = 0x44 + drive->dn * 4;
 
@@ -299,6 +299,7 @@ static const struct ide_dma_ops sl82c105_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = sl82c105_dma_lost_irq,
         .dma_timeout            = sl82c105_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info sl82c105_chipset __devinitdata = {
diff --git a/drivers/ide/slc90e66.c b/drivers/ide/slc90e66.c
index 0f759e4ed779..40b4b94a4288 100644
--- a/drivers/ide/slc90e66.c
+++ b/drivers/ide/slc90e66.c
@@ -20,7 +20,7 @@ static DEFINE_SPINLOCK(slc90e66_lock);
 
 static void slc90e66_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         int is_slave            = drive->dn & 1;
         int master_port         = hwif->channel ? 0x42 : 0x40;
@@ -73,7 +73,7 @@ static void slc90e66_set_pio_mode(ide_drive_t *drive, const u8 pio)
 
 static void slc90e66_set_dma_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         struct pci_dev *dev     = to_pci_dev(hwif->dev);
         u8 maslave              = hwif->channel ? 0x42 : 0x40;
         int sitre = 0, a_speed  = 7 << (drive->dn * 4);
diff --git a/drivers/ide/tc86c001.c b/drivers/ide/tc86c001.c
index 93e2cce4b296..84109f5a1632 100644
--- a/drivers/ide/tc86c001.c
+++ b/drivers/ide/tc86c001.c
@@ -15,7 +15,7 @@
 
 static void tc86c001_set_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long scr_port  = hwif->config_data + (drive->dn ? 0x02 : 0x00);
         u16 mode, scr           = inw(scr_port);
 
@@ -62,13 +62,12 @@ static void tc86c001_set_pio_mode(ide_drive_t *drive, const u8 pio)
  */
 static int tc86c001_timer_expiry(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         ide_expiry_t *expiry    = ide_get_hwifdata(hwif);
-        ide_hwgroup_t *hwgroup  = HWGROUP(drive);
         u8 dma_stat             = inb(hwif->dma_base + ATA_DMA_STATUS);
 
         /* Restore a higher level driver's expiry handler first. */
-        hwgroup->expiry = expiry;
+        hwif->expiry = expiry;
 
         if ((dma_stat & 5) == 1) {      /* DMA active and no interrupt */
                 unsigned long sc_base   = hwif->config_data;
@@ -110,11 +109,10 @@ static int tc86c001_timer_expiry(ide_drive_t *drive)
 
 static void tc86c001_dma_start(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
-        ide_hwgroup_t *hwgroup  = HWGROUP(drive);
+        ide_hwif_t *hwif        = drive->hwif;
         unsigned long sc_base   = hwif->config_data;
         unsigned long twcr_port = sc_base + (drive->dn ? 0x06 : 0x04);
-        unsigned long nsectors  = hwgroup->rq->nr_sectors;
+        unsigned long nsectors  = hwif->rq->nr_sectors;
 
         /*
          * We have to manually load the sector count and size into
@@ -125,8 +123,8 @@ static void tc86c001_dma_start(ide_drive_t *drive)
         outw(SECTOR_SIZE / 2, twcr_port); /* Transfer Word Count 1/2 */
 
         /* Install our timeout expiry hook, saving the current handler... */
-        ide_set_hwifdata(hwif, hwgroup->expiry);
-        hwgroup->expiry = &tc86c001_timer_expiry;
+        ide_set_hwifdata(hwif, hwif->expiry);
+        hwif->expiry = &tc86c001_timer_expiry;
 
         ide_dma_start(drive);
 }
@@ -190,6 +188,7 @@ static const struct ide_dma_ops tc86c001_dma_ops = {
         .dma_test_irq           = ide_dma_test_irq,
         .dma_lost_irq           = ide_dma_lost_irq,
         .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info tc86c001_chipset __devinitdata = {
diff --git a/drivers/ide/triflex.c b/drivers/ide/triflex.c
index b6ff40336aa9..8773c3ba7462 100644
--- a/drivers/ide/triflex.c
+++ b/drivers/ide/triflex.c
@@ -36,7 +36,7 @@
 
 static void triflex_set_mode(ide_drive_t *drive, const u8 speed)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         u32 triflex_timings = 0;
         u16 timing = 0;
diff --git a/drivers/ide/trm290.c b/drivers/ide/trm290.c
index 75ea61526566..b6a1285a4021 100644
--- a/drivers/ide/trm290.c
+++ b/drivers/ide/trm290.c
@@ -144,7 +144,7 @@
 
 static void trm290_prepare_drive (ide_drive_t *drive, unsigned int use_dma)
 {
-        ide_hwif_t *hwif = HWIF(drive);
+        ide_hwif_t *hwif = drive->hwif;
         u16 reg = 0;
         unsigned long flags;
 
@@ -184,7 +184,7 @@ static void trm290_dma_exec_cmd(ide_drive_t *drive, u8 command)
 static int trm290_dma_setup(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         unsigned int count, rw;
 
         if (rq_data_dir(rq)) {
@@ -222,15 +222,15 @@ static int trm290_dma_end(ide_drive_t *drive)
         drive->waiting_for_dma = 0;
         /* purge DMA mappings */
         ide_destroy_dmatable(drive);
-        status = inw(HWIF(drive)->dma_base + 2);
+        status = inw(drive->hwif->dma_base + 2);
+
         return status != 0x00ff;
 }
 
 static int trm290_dma_test_irq(ide_drive_t *drive)
 {
-        u16 status;
+        u16 status = inw(drive->hwif->dma_base + 2);
 
-        status = inw(HWIF(drive)->dma_base + 2);
         return status == 0x00ff;
 }
 
@@ -328,10 +328,10 @@ static struct ide_dma_ops trm290_dma_ops = {
 static const struct ide_port_info trm290_chipset __devinitdata = {
         .name           = DRV_NAME,
         .init_hwif      = init_hwif_trm290,
-        .chipset        = ide_trm290,
         .port_ops       = &trm290_port_ops,
         .dma_ops        = &trm290_dma_ops,
-        .host_flags     = IDE_HFLAG_NO_ATAPI_DMA |
+        .host_flags     = IDE_HFLAG_TRM290 |
+                          IDE_HFLAG_NO_ATAPI_DMA |
 #if 0 /* play it safe for now */
                           IDE_HFLAG_TRUST_BIOS_FOR_DMA |
 #endif
diff --git a/drivers/ide/tx4938ide.c b/drivers/ide/tx4938ide.c
index 9120063e8f87..b4ef218072cd 100644
--- a/drivers/ide/tx4938ide.c
+++ b/drivers/ide/tx4938ide.c
@@ -181,7 +181,7 @@ static void tx4938ide_input_data_swap(ide_drive_t *drive, struct request *rq,
 
         while (count--)
                 *ptr++ = cpu_to_le16(__raw_readw((void __iomem *)port));
-        __ide_flush_dcache_range((unsigned long)buf, count * 2);
+        __ide_flush_dcache_range((unsigned long)buf, roundup(len, 2));
 }
 
 static void tx4938ide_output_data_swap(ide_drive_t *drive, struct request *rq,
@@ -195,7 +195,7 @@ static void tx4938ide_output_data_swap(ide_drive_t *drive, struct request *rq,
                 __raw_writew(le16_to_cpu(*ptr), (void __iomem *)port);
                 ptr++;
         }
-        __ide_flush_dcache_range((unsigned long)buf, count * 2);
+        __ide_flush_dcache_range((unsigned long)buf, roundup(len, 2));
 }
 
 static const struct ide_tp_ops tx4938ide_tp_ops = {
@@ -216,16 +216,17 @@ static const struct ide_tp_ops tx4938ide_tp_ops = {
 #endif  /* __BIG_ENDIAN */
 
 static const struct ide_port_ops tx4938ide_port_ops = {
-        .set_pio_mode = tx4938ide_set_pio_mode,
+        .set_pio_mode           = tx4938ide_set_pio_mode,
 };
 
 static const struct ide_port_info tx4938ide_port_info __initdata = {
-        .port_ops = &tx4938ide_port_ops,
+        .port_ops               = &tx4938ide_port_ops,
 #ifdef __BIG_ENDIAN
-        .tp_ops = &tx4938ide_tp_ops,
+        .tp_ops                 = &tx4938ide_tp_ops,
 #endif
-        .host_flags = IDE_HFLAG_MMIO | IDE_HFLAG_NO_DMA,
-        .pio_mask = ATA_PIO5,
+        .host_flags             = IDE_HFLAG_MMIO | IDE_HFLAG_NO_DMA,
+        .pio_mask               = ATA_PIO5,
+        .chipset                = ide_generic,
 };
 
 static int __init tx4938ide_probe(struct platform_device *pdev)
diff --git a/drivers/ide/tx4939ide.c b/drivers/ide/tx4939ide.c
index bafb7d1a22e2..882f6f07c476 100644
--- a/drivers/ide/tx4939ide.c
+++ b/drivers/ide/tx4939ide.c
@@ -259,6 +259,12 @@ static int tx4939ide_build_dmatable(ide_drive_t *drive, struct request *rq)
                         bcount = 0x10000 - (cur_addr & 0xffff);
                         if (bcount > cur_len)
                                 bcount = cur_len;
+                        /*
+                         * This workaround for zero count seems required.
+                         * (standard ide_build_dmatable do it too)
+                         */
+                        if ((bcount & 0xffff) == 0x0000)
+                                bcount = 0x8000;
                         *table++ = bcount & 0xffff;
                         *table++ = cur_addr;
                         cur_addr += bcount;
@@ -287,7 +293,7 @@ static int tx4939ide_dma_setup(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
         void __iomem *base = TX4939IDE_BASE(hwif);
-        struct request *rq = hwif->hwgroup->rq;
+        struct request *rq = hwif->rq;
         u8 reading;
         int nent;
 
@@ -391,6 +397,17 @@ static int tx4939ide_dma_test_irq(ide_drive_t *drive)
         return found;
 }
 
+#ifdef __BIG_ENDIAN
+static u8 tx4939ide_dma_sff_read_status(ide_hwif_t *hwif)
+{
+        void __iomem *base = TX4939IDE_BASE(hwif);
+
+        return tx4939ide_readb(base, TX4939IDE_DMA_Stat);
+}
+#else
+#define tx4939ide_dma_sff_read_status ide_dma_sff_read_status
+#endif
+
 static void tx4939ide_init_hwif(ide_hwif_t *hwif)
 {
         void __iomem *base = TX4939IDE_BASE(hwif);
@@ -437,13 +454,6 @@ static void tx4939ide_tf_load_fixup(ide_drive_t *drive, ide_task_t *task)
 
 #ifdef __BIG_ENDIAN
 
-static u8 tx4939ide_read_sff_dma_status(ide_hwif_t *hwif)
-{
-        void __iomem *base = TX4939IDE_BASE(hwif);
-
-        return tx4939ide_readb(base, TX4939IDE_DMA_Stat);
-}
-
 /* custom iops (independent from SWAP_IO_SPACE) */
 static u8 tx4939ide_inb(unsigned long port)
 {
@@ -558,7 +568,7 @@ static void tx4939ide_input_data_swap(ide_drive_t *drive, struct request *rq,
 
         while (count--)
                 *ptr++ = cpu_to_le16(__raw_readw((void __iomem *)port));
-        __ide_flush_dcache_range((unsigned long)buf, count * 2);
+        __ide_flush_dcache_range((unsigned long)buf, roundup(len, 2));
 }
 
 static void tx4939ide_output_data_swap(ide_drive_t *drive, struct request *rq,
@@ -572,14 +582,13 @@ static void tx4939ide_output_data_swap(ide_drive_t *drive, struct request *rq,
                 __raw_writew(le16_to_cpu(*ptr), (void __iomem *)port);
                 ptr++;
         }
-        __ide_flush_dcache_range((unsigned long)buf, count * 2);
+        __ide_flush_dcache_range((unsigned long)buf, roundup(len, 2));
 }
 
 static const struct ide_tp_ops tx4939ide_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = tx4939ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
@@ -603,7 +612,6 @@ static const struct ide_tp_ops tx4939ide_tp_ops = {
         .exec_command           = ide_exec_command,
         .read_status            = ide_read_status,
         .read_altstatus         = ide_read_altstatus,
-        .read_sff_dma_status    = ide_read_sff_dma_status,
 
         .set_irq                = ide_set_irq,
 
@@ -617,33 +625,35 @@ static const struct ide_tp_ops tx4939ide_tp_ops = {
 #endif  /* __LITTLE_ENDIAN */
 
 static const struct ide_port_ops tx4939ide_port_ops = {
-        .set_pio_mode = tx4939ide_set_pio_mode,
-        .set_dma_mode = tx4939ide_set_dma_mode,
-        .clear_irq = tx4939ide_clear_irq,
-        .cable_detect = tx4939ide_cable_detect,
+        .set_pio_mode           = tx4939ide_set_pio_mode,
+        .set_dma_mode           = tx4939ide_set_dma_mode,
+        .clear_irq              = tx4939ide_clear_irq,
+        .cable_detect           = tx4939ide_cable_detect,
 };
 
 static const struct ide_dma_ops tx4939ide_dma_ops = {
-        .dma_host_set = tx4939ide_dma_host_set,
-        .dma_setup = tx4939ide_dma_setup,
-        .dma_exec_cmd = ide_dma_exec_cmd,
-        .dma_start = ide_dma_start,
-        .dma_end = tx4939ide_dma_end,
-        .dma_test_irq = tx4939ide_dma_test_irq,
-        .dma_lost_irq = ide_dma_lost_irq,
-        .dma_timeout = ide_dma_timeout,
+        .dma_host_set           = tx4939ide_dma_host_set,
+        .dma_setup              = tx4939ide_dma_setup,
+        .dma_exec_cmd           = ide_dma_exec_cmd,
+        .dma_start              = ide_dma_start,
+        .dma_end                = tx4939ide_dma_end,
+        .dma_test_irq           = tx4939ide_dma_test_irq,
+        .dma_lost_irq           = ide_dma_lost_irq,
+        .dma_timeout            = ide_dma_timeout,
+        .dma_sff_read_status    = tx4939ide_dma_sff_read_status,
 };
 
 static const struct ide_port_info tx4939ide_port_info __initdata = {
-        .init_hwif = tx4939ide_init_hwif,
-        .init_dma = tx4939ide_init_dma,
-        .port_ops = &tx4939ide_port_ops,
-        .dma_ops = &tx4939ide_dma_ops,
-        .tp_ops = &tx4939ide_tp_ops,
-        .host_flags = IDE_HFLAG_MMIO,
-        .pio_mask = ATA_PIO4,
-        .mwdma_mask = ATA_MWDMA2,
-        .udma_mask = ATA_UDMA5,
+        .init_hwif              = tx4939ide_init_hwif,
+        .init_dma               = tx4939ide_init_dma,
+        .port_ops               = &tx4939ide_port_ops,
+        .dma_ops                = &tx4939ide_dma_ops,
+        .tp_ops                 = &tx4939ide_tp_ops,
+        .host_flags             = IDE_HFLAG_MMIO,
+        .pio_mask               = ATA_PIO4,
+        .mwdma_mask             = ATA_MWDMA2,
+        .udma_mask              = ATA_UDMA5,
+        .chipset                = ide_generic,
 };
 
 static int __init tx4939ide_probe(struct platform_device *pdev)
diff --git a/drivers/ide/umc8672.c b/drivers/ide/umc8672.c
index 1da076e0c917..0608d41fb6d0 100644
--- a/drivers/ide/umc8672.c
+++ b/drivers/ide/umc8672.c
@@ -106,19 +106,21 @@ static void umc_set_speeds(u8 speeds[])
 
 static void umc_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        ide_hwif_t *hwif = drive->hwif;
-        unsigned long flags;
+        ide_hwif_t *hwif = drive->hwif, *mate = hwif->mate;
+        unsigned long uninitialized_var(flags);
 
         printk("%s: setting umc8672 to PIO mode%d (speed %d)\n",
                 drive->name, pio, pio_to_umc[pio]);
-        spin_lock_irqsave(&ide_lock, flags);
-        if (hwif->mate && hwif->mate->hwgroup->handler) {
+        if (mate)
+                spin_lock_irqsave(&mate->lock, flags);
+        if (mate && mate->handler) {
                 printk(KERN_ERR "umc8672: other interface is busy: exiting tune_umc()\n");
         } else {
                 current_speeds[drive->name[2] - 'a'] = pio_to_umc[pio];
                 umc_set_speeds(current_speeds);
         }
-        spin_unlock_irqrestore(&ide_lock, flags);
+        if (mate)
+                spin_unlock_irqrestore(&mate->lock, flags);
 }
 
 static const struct ide_port_ops umc8672_port_ops = {
diff --git a/drivers/ide/via82cxxx.c b/drivers/ide/via82cxxx.c
index 2a812d3207e9..fecc0e03c3fc 100644
--- a/drivers/ide/via82cxxx.c
+++ b/drivers/ide/via82cxxx.c
@@ -178,7 +178,7 @@ static void via_set_drive(ide_drive_t *drive, const u8 speed)
                 ide_timing_merge(&p, &t, &t, IDE_TIMING_8BIT);
         }
 
-        via_set_speed(HWIF(drive), drive->dn, &t);
+        via_set_speed(hwif, drive->dn, &t);
 }
 
 /**