Merge git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6: (24 commits)
  ide: use only ->set_pio_mode method for programming PIO modes (take 2)
  sis5513: don't change UDMA settings when programming PIO
  it8213/piix/slc90e66: don't change DMA settings when programming PIO
  alim15x3: PIO mode setup fixes
  siimage: fix ->set_pio_mode method to select PIO data transfer
  cs5520: don't enable VDMA in ->speedproc
  sc1200: remove redundant warning message from sc1200_tune_chipset()
  ide-pmac: PIO mode setup fixes (take 3)
  icside: fix ->speedproc to return on unsupported modes (take 5)
  sgiioc4: use ide_tune_dma()
  amd74xx/via82cxxx: use ide_tune_dma()
  ide: add ide_set{_max}_pio() (take 4)
  ide: Kconfig face-lift
  ide: move ide_rate_filter() calls to the upper layer (take 2)
  sis5513: add ->udma_filter method for chipset_family >= ATA_133
  ide: mode limiting fixes for user requested speed changes
  ide: add missing ide_rate_filter() calls to ->speedproc()-s
  ide: call udma_filter() before resorting to the UltraDMA mask
  ide: make jmicron match vendor and device class
  pdc202xx_new: switch to using pci_get_slot() (take 2)
  ...

30 files changed, 408 insertions, 598 deletions

diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index 74432830abf7..0d5f62c5dfae 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -87,12 +87,11 @@ static u8 pci_bus_clock_list_ultra (u8 speed, struct chipset_bus_clock_list_entr
         return chipset_table->ultra_settings;
 }
 
-static int aec6210_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int aec6210_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u16 d_conf              = 0;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         u8 ultra = 0, ultra_conf = 0;
         u8 tmp0 = 0, tmp1 = 0, tmp2 = 0;
         unsigned long flags;
@@ -115,11 +114,10 @@ static int aec6210_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         return(ide_config_drive_speed(drive, speed));
 }
 
-static int aec6260_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int aec6260_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
-        u8 speed        = ide_rate_filter(drive, xferspeed);
         u8 unit         = (drive->select.b.unit & 0x01);
         u8 tmp1 = 0, tmp2 = 0;
         u8 ultra = 0, drive_conf = 0, ultra_conf = 0;
@@ -140,9 +138,8 @@ static int aec6260_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         return(ide_config_drive_speed(drive, speed));
 }
 
-static void aec62xx_tune_drive (ide_drive_t *drive, u8 pio)
+static void aec_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) HWIF(drive)->speedproc(drive, pio + XFER_PIO_0);
 }
 
@@ -152,7 +149,7 @@ static int aec62xx_config_drive_xfer_rate (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                aec62xx_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -203,7 +200,7 @@ static void __devinit init_hwif_aec62xx(ide_hwif_t *hwif)
         u8 reg54 = 0,  mask     = hwif->channel ? 0xf0 : 0x0f;
         unsigned long flags;
 
-        hwif->tuneproc = &aec62xx_tune_drive;
+        hwif->set_pio_mode = &aec_set_pio_mode;
 
         if (dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF) {
                 if(hwif->mate)
diff --git a/drivers/ide/pci/alim15x3.c b/drivers/ide/pci/alim15x3.c
index 20ebe3b7049c..d04b966b4347 100644
--- a/drivers/ide/pci/alim15x3.c
+++ b/drivers/ide/pci/alim15x3.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/alim15x3.c             Version 0.25    Jun 9 2007
+ * linux/drivers/ide/pci/alim15x3.c             Version 0.26    Jul 14 2007
  *
  *  Copyright (C) 1998-2000 Michel Aubry, Maintainer
  *  Copyright (C) 1998-2000 Andrzej Krzysztofowicz, Maintainer
@@ -283,17 +283,14 @@ static int ali_get_info (char *buffer, char **addr, off_t offset, int count)
 #endif  /* defined(DISPLAY_ALI_TIMINGS) && defined(CONFIG_IDE_PROC_FS) */
 
 /**
- *      ali15x3_tune_pio        -       set up chipset for PIO mode
- *      @drive: drive to tune
- *      @pio: desired mode
- *
- *      Select the best PIO mode for the drive in question.
- *      Then program the controller for this mode.
+ *      ali_tune_pio    -       set host controller for PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
- *      Returns the PIO mode programmed.
+ *      Program the controller for the given PIO mode.
  */
- 
-static u8 ali15x3_tune_pio (ide_drive_t *drive, u8 pio)
+
+static void ali_tune_pio(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *dev = hwif->pci_dev;
@@ -306,7 +303,6 @@ static u8 ali15x3_tune_pio (ide_drive_t *drive, u8 pio)
         u8 cd_dma_fifo = 0;
         int unit = drive->select.b.unit & 1;
 
-        pio = ide_get_best_pio_mode(drive, pio, 5);
         s_time = ide_pio_timings[pio].setup_time;
         a_time = ide_pio_timings[pio].active_time;
         if ((s_clc = (s_time * bus_speed + 999) / 1000) >= 8)
@@ -359,22 +355,20 @@ static u8 ali15x3_tune_pio (ide_drive_t *drive, u8 pio)
          * { 25,   70,     25  },   PIO Mode 4 with IORDY  ns
          * { 20,   50,     30  }    PIO Mode 5 with IORDY (nonstandard)
          */
-
-        return pio;
 }
 
 /**
- *      ali15x3_tune_drive      -       set up drive for PIO mode
+ *      ali_set_pio_mode        -       set up drive for PIO mode
  *      @drive: drive to tune
  *      @pio: desired mode
  *
- *      Program the controller with the best PIO timing for the given drive.
+ *      Program the controller with the desired PIO timing for the given drive.
  *      Then set up the drive itself.
  */
 
-static void ali15x3_tune_drive (ide_drive_t *drive, u8 pio)
+static void ali_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ali15x3_tune_pio(drive, pio);
+        ali_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
@@ -409,22 +403,24 @@ static u8 ali_udma_filter(ide_drive_t *drive)
 /**
  *      ali15x3_tune_chipset    -       set up chipset/drive for new speed
  *      @drive: drive to configure for
- *      @xferspeed: desired speed
+ *      @speed: desired speed
  *
  *      Configure the hardware for the desired IDE transfer mode.
  *      We also do the needed drive configuration through helpers
  */
- 
-static int ali15x3_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+
+static int ali15x3_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         u8 speed1               = speed;
         u8 unit                 = (drive->select.b.unit & 0x01);
         u8 tmpbyte              = 0x00;
         int m5229_udma          = (hwif->channel) ? 0x57 : 0x56;
 
+        if (speed < XFER_PIO_0)
+                return 1;
+
         if (speed == XFER_UDMA_6)
                 speed1 = 0x47;
 
@@ -437,8 +433,9 @@ static int ali15x3_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 tmpbyte &= ultra_enable;
                 pci_write_config_byte(dev, m5229_udma, tmpbyte);
 
-                if (speed < XFER_SW_DMA_0)
-                        (void) ali15x3_tune_pio(drive, speed - XFER_PIO_0);
+                /*
+                 * FIXME: Oh, my... DMA timings are never set.
+                 */
         } else {
                 pci_read_config_byte(dev, m5229_udma, &tmpbyte);
                 tmpbyte &= (0x0f << ((1-unit) << 2));
@@ -471,7 +468,7 @@ static int ali15x3_config_drive_for_dma(ide_drive_t *drive)
         if (ide_tune_dma(drive))
                 return 0;
 
-        ali15x3_tune_drive(drive, 255);
+        ide_set_max_pio(drive);
 
         return -1;
 }
@@ -701,7 +698,7 @@ static u8 __devinit ata66_ali15x3(ide_hwif_t *hwif)
 static void __devinit init_hwif_common_ali15x3 (ide_hwif_t *hwif)
 {
         hwif->autodma = 0;
-        hwif->tuneproc = &ali15x3_tune_drive;
+        hwif->set_pio_mode = &ali_set_pio_mode;
         hwif->speedproc = &ali15x3_tune_chipset;
         hwif->udma_filter = &ali_udma_filter;
 
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 06c15a6a3e7d..513205e52ad2 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -1,5 +1,5 @@
 /*
- * Version 2.21
+ * Version 2.22
  *
  * AMD 755/756/766/8111 and nVidia nForce/2/2s/3/3s/CK804/MCP04
  * IDE driver for Linux.
@@ -234,7 +234,7 @@ static void amd_set_speed(struct pci_dev *dev, unsigned char dn, struct ide_timi
  * by upper layers.
  */
 
-static int amd_set_drive(ide_drive_t *drive, u8 speed)
+static int amd_set_drive(ide_drive_t *drive, const u8 speed)
 {
         ide_drive_t *peer = HWIF(drive)->drives + (~drive->dn & 1);
         struct ide_timing t, p;
@@ -266,32 +266,21 @@ static int amd_set_drive(ide_drive_t *drive, u8 speed)
 }
 
 /*
- * amd74xx_tune_drive() is a callback from upper layers for
- * PIO-only tuning.
+ * amd_set_pio_mode() is a callback from upper layers for PIO-only tuning.
  */
 
-static void amd74xx_tune_drive(ide_drive_t *drive, u8 pio)
+static void amd_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        if (pio == 255)
-                pio = ide_get_best_pio_mode(drive, 255, 5);
-
-        amd_set_drive(drive, XFER_PIO_0 + min_t(byte, pio, 5));
+        amd_set_drive(drive, XFER_PIO_0 + pio);
 }
 
 static int amd74xx_ide_dma_check(ide_drive_t *drive)
 {
-        u8 speed = ide_max_dma_mode(drive);
-
-        if (speed == 0) {
-                amd74xx_tune_drive(drive, 255);
-                return -1;
-        }
-
-        amd_set_drive(drive, speed);
-
-        if (drive->autodma)
+        if (ide_tune_dma(drive))
                 return 0;
 
+        ide_set_max_pio(drive);
+
         return -1;
 }
 
@@ -409,7 +398,7 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
 
         hwif->autodma = 0;
 
-        hwif->tuneproc = &amd74xx_tune_drive;
+        hwif->set_pio_mode = &amd_set_pio_mode;
         hwif->speedproc = &amd_set_drive;
 
         for (i = 0; i < 2; i++) {
diff --git a/drivers/ide/pci/atiixp.c b/drivers/ide/pci/atiixp.c
index 1725aa402d98..178876a3afca 100644
--- a/drivers/ide/pci/atiixp.c
+++ b/drivers/ide/pci/atiixp.c
@@ -153,9 +153,8 @@ static void atiixp_tune_pio(ide_drive_t *drive, u8 pio)
         spin_unlock_irqrestore(&atiixp_lock, flags);
 }
 
-static void atiixp_tuneproc(ide_drive_t *drive, u8 pio)
+static void atiixp_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         atiixp_tune_pio(drive, pio);
         (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -163,28 +162,21 @@ static void atiixp_tuneproc(ide_drive_t *drive, u8 pio)
 /**
  *      atiixp_tune_chipset     -       tune a ATIIXP interface
  *      @drive: IDE drive to tune
- *      @xferspeed: speed to configure
+ *      @speed: speed to configure
  *
  *      Set a ATIIXP interface channel to the desired speeds. This involves
  *      requires the right timing data into the ATIIXP configuration space
  *      then setting the drive parameters appropriately
  */
 
-static int atiixp_speedproc(ide_drive_t *drive, u8 xferspeed)
+static int atiixp_speedproc(ide_drive_t *drive, const u8 speed)
 {
         struct pci_dev *dev = drive->hwif->pci_dev;
         unsigned long flags;
         int timing_shift = (drive->dn & 2) ? 16 : 0 + (drive->dn & 1) ? 0 : 8;
         u32 tmp32;
         u16 tmp16;
-        u8 speed, pio;
-
-        speed = ide_rate_filter(drive, xferspeed);
-
-        if (speed >= XFER_PIO_0 && speed <= XFER_PIO_4) {
-                atiixp_tune_pio(drive, speed - XFER_PIO_0);
-                return ide_config_drive_speed(drive, speed);
-        }
+        u8 pio;
 
         spin_lock_irqsave(&atiixp_lock, flags);
 
@@ -233,7 +225,7 @@ static int atiixp_dma_check(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                atiixp_tuneproc(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -256,7 +248,7 @@ static void __devinit init_hwif_atiixp(ide_hwif_t *hwif)
                 hwif->irq = ch ? 15 : 14;
 
         hwif->autodma = 0;
-        hwif->tuneproc = &atiixp_tuneproc;
+        hwif->set_pio_mode = &atiixp_set_pio_mode;
         hwif->speedproc = &atiixp_speedproc;
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
@@ -325,7 +317,7 @@ static struct pci_device_id atiixp_pci_tbl[] = {
         { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP300_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
-        { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP700_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
+        { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP700_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, atiixp_pci_tbl);
diff --git a/drivers/ide/pci/cmd640.c b/drivers/ide/pci/cmd640.c
index 9689494efa24..f369645e4d16 100644
--- a/drivers/ide/pci/cmd640.c
+++ b/drivers/ide/pci/cmd640.c
@@ -628,45 +628,40 @@ static void cmd640_set_mode (unsigned int index, u8 pio_mode, unsigned int cycle
         program_drive_counts (index);
 }
 
-/*
- * Drive PIO mode selection:
- */
-static void cmd640_tune_drive (ide_drive_t *drive, u8 mode_wanted)
+static void cmd640_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         unsigned int index = 0, cycle_time;
         u8 b;
 
         while (drive != cmd_drives[index]) {
                 if (++index > 3) {
-                        printk("%s: bad news in cmd640_tune_drive\n", drive->name);
+                        printk(KERN_ERR "%s: bad news in %s\n",
+                                        drive->name, __FUNCTION__);
                         return;
                 }
         }
-        switch (mode_wanted) {
+        switch (pio) {
                 case 6: /* set fast-devsel off */
                 case 7: /* set fast-devsel on */
-                        mode_wanted &= 1;
                         b = get_cmd640_reg(CNTRL) & ~0x27;
-                        if (mode_wanted)
+                        if (pio & 1)
                                 b |= 0x27;
                         put_cmd640_reg(CNTRL, b);
-                        printk("%s: %sabled cmd640 fast host timing (devsel)\n", drive->name, mode_wanted ? "en" : "dis");
+                        printk("%s: %sabled cmd640 fast host timing (devsel)\n", drive->name, (pio & 1) ? "en" : "dis");
                         return;
 
                 case 8: /* set prefetch off */
                 case 9: /* set prefetch on */
-                        mode_wanted &= 1;
-                        set_prefetch_mode(index, mode_wanted);
-                        printk("%s: %sabled cmd640 prefetch\n", drive->name, mode_wanted ? "en" : "dis");
+                        set_prefetch_mode(index, pio & 1);
+                        printk("%s: %sabled cmd640 prefetch\n", drive->name, (pio & 1) ? "en" : "dis");
                         return;
         }
 
-        mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 5);
-        cycle_time = ide_pio_cycle_time(drive, mode_wanted);
-        cmd640_set_mode(index, mode_wanted, cycle_time);
+        cycle_time = ide_pio_cycle_time(drive, pio);
+        cmd640_set_mode(index, pio, cycle_time);
 
         printk("%s: selected cmd640 PIO mode%d (%dns)",
-                drive->name, mode_wanted, cycle_time);
+                drive->name, pio, cycle_time);
 
         display_clocks(index);
 }
@@ -766,8 +761,10 @@ int __init ide_probe_for_cmd640x (void)
                cmd_hwif0->name, 'a' + cmd640_chip_version - 1, bus_type, cfr);
         cmd_hwif0->chipset = ide_cmd640;
 #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
+        cmd_hwif0->host_flags = IDE_HFLAG_ABUSE_PREFETCH |
+                                IDE_HFLAG_ABUSE_FAST_DEVSEL;
         cmd_hwif0->pio_mask = ATA_PIO5;
-        cmd_hwif0->tuneproc = &cmd640_tune_drive;
+        cmd_hwif0->set_pio_mode = &cmd640_set_pio_mode;
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
 
         /*
@@ -822,8 +819,10 @@ int __init ide_probe_for_cmd640x (void)
                 cmd_hwif1->mate = cmd_hwif0;
                 cmd_hwif1->channel = 1;
 #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
+                cmd_hwif1->host_flags = IDE_HFLAG_ABUSE_PREFETCH |
+                                        IDE_HFLAG_ABUSE_FAST_DEVSEL;
                 cmd_hwif1->pio_mask = ATA_PIO5;
-                cmd_hwif1->tuneproc = &cmd640_tune_drive;
+                cmd_hwif1->set_pio_mode = &cmd640_set_pio_mode;
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
         }
         printk(KERN_INFO "%s: %sserialized, secondary interface %s\n", cmd_hwif1->name,
diff --git a/drivers/ide/pci/cmd64x.c b/drivers/ide/pci/cmd64x.c
index 0e3b5de26e69..0b568c60f926 100644
--- a/drivers/ide/pci/cmd64x.c
+++ b/drivers/ide/pci/cmd64x.c
@@ -214,28 +214,25 @@ static void program_cycle_times (ide_drive_t *drive, int cycle_time, int active_
 }
 
 /*
- * This routine selects drive's best PIO mode and writes into the chipset
- * registers setup/active/recovery timings.
+ * This routine writes into the chipset registers
+ * PIO setup/active/recovery timings.
  */
-static u8 cmd64x_tune_pio (ide_drive_t *drive, u8 mode_wanted)
+static void cmd64x_tune_pio(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         unsigned int cycle_time;
-        u8 pio_mode, setup_count, arttim = 0;
+        u8 setup_count, arttim = 0;
+
         static const u8 setup_values[] = {0x40, 0x40, 0x40, 0x80, 0, 0xc0};
         static const u8 arttim_regs[4] = {ARTTIM0, ARTTIM1, ARTTIM23, ARTTIM23};
 
-        pio_mode = ide_get_best_pio_mode(drive, mode_wanted, 5);
-        cycle_time = ide_pio_cycle_time(drive, pio_mode);
-
-        cmdprintk("%s: PIO mode wanted %d, selected %d (%d ns)\n",
-                  drive->name, mode_wanted, pio_mode, cycle_time);
+        cycle_time = ide_pio_cycle_time(drive, pio);
 
         program_cycle_times(drive, cycle_time,
-                            ide_pio_timings[pio_mode].active_time);
+                            ide_pio_timings[pio].active_time);
 
-        setup_count = quantize_timing(ide_pio_timings[pio_mode].setup_time,
+        setup_count = quantize_timing(ide_pio_timings[pio].setup_time,
                                       1000 / system_bus_clock());
 
         /*
@@ -266,16 +263,14 @@ static u8 cmd64x_tune_pio (ide_drive_t *drive, u8 mode_wanted)
         arttim |= setup_values[setup_count];
         (void) pci_write_config_byte(dev, arttim_regs[drive->dn], arttim);
         cmdprintk("Write 0x%02x to reg 0x%x\n", arttim, arttim_regs[drive->dn]);
-
-        return pio_mode;
 }
 
 /*
  * Attempts to set drive's PIO mode.
- * Special cases are 8: prefetch off, 9: prefetch on (both never worked),
- * and 255: auto-select best mode (used at boot time).
+ * Special cases are 8: prefetch off, 9: prefetch on (both never worked)
  */
-static void cmd64x_tune_drive (ide_drive_t *drive, u8 pio)
+
+static void cmd64x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         /*
          * Filter out the prefetch control values
@@ -284,19 +279,17 @@ static void cmd64x_tune_drive (ide_drive_t *drive, u8 pio)
         if (pio == 8 || pio == 9)
                 return;
 
-        pio = cmd64x_tune_pio(drive, pio);
+        cmd64x_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
-static int cmd64x_tune_chipset (ide_drive_t *drive, u8 speed)
+static int cmd64x_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u8 unit                 = drive->dn & 0x01;
         u8 regU = 0, pciU       = hwif->channel ? UDIDETCR1 : UDIDETCR0;
 
-        speed = ide_rate_filter(drive, speed);
-
         if (speed >= XFER_SW_DMA_0) {
                 (void) pci_read_config_byte(dev, pciU, &regU);
                 regU &= ~(unit ? 0xCA : 0x35);
@@ -330,14 +323,6 @@ static int cmd64x_tune_chipset (ide_drive_t *drive, u8 speed)
         case XFER_MW_DMA_0:
                 program_cycle_times(drive, 480, 215);
                 break;
-        case XFER_PIO_5:
-        case XFER_PIO_4:
-        case XFER_PIO_3:
-        case XFER_PIO_2:
-        case XFER_PIO_1:
-        case XFER_PIO_0:
-                (void) cmd64x_tune_pio(drive, speed - XFER_PIO_0);
-                break;
         default:
                 return 1;
         }
@@ -354,7 +339,7 @@ static int cmd64x_config_drive_for_dma (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                cmd64x_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -538,7 +523,7 @@ static void __devinit init_hwif_cmd64x(ide_hwif_t *hwif)
 
         pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
 
-        hwif->tuneproc  = &cmd64x_tune_drive;
+        hwif->set_pio_mode = &cmd64x_set_pio_mode;
         hwif->speedproc = &cmd64x_tune_chipset;
 
         hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
@@ -622,6 +607,7 @@ static ide_pci_device_t cmd64x_chipsets[] __devinitdata = {
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x00,0x00,0x00}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x00, /* no udma */
         },{     /* 1 */
@@ -632,6 +618,7 @@ static ide_pci_device_t cmd64x_chipsets[] __devinitdata = {
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x07, /* udma0-2 */
         },{     /* 2 */
@@ -642,6 +629,7 @@ static ide_pci_device_t cmd64x_chipsets[] __devinitdata = {
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x1f, /* udma0-4 */
         },{     /* 3 */
@@ -652,6 +640,7 @@ static ide_pci_device_t cmd64x_chipsets[] __devinitdata = {
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x3f, /* udma0-5 */
         }
diff --git a/drivers/ide/pci/cs5520.c b/drivers/ide/pci/cs5520.c
index b89e81656875..1217d2a747fb 100644
--- a/drivers/ide/pci/cs5520.c
+++ b/drivers/ide/pci/cs5520.c
@@ -66,32 +66,13 @@ static struct pio_clocks cs5520_pio_clocks[]={
         {1, 2, 1}
 };
 
-static int cs5520_tune_chipset(ide_drive_t *drive, u8 xferspeed)
+static void cs5520_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *pdev = hwif->pci_dev;
-        u8 speed = min((u8)XFER_PIO_4, xferspeed);
-        int pio = speed;
-        u8 reg;
         int controller = drive->dn > 1 ? 1 : 0;
-        int error;
-        
-        switch(speed)
-        {
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:
-                        pio -= XFER_PIO_0;
-                        break;
-                default:
-                        pio = 0;
-                        printk(KERN_ERR "cs55x0: bad ide timing.\n");
-        }
-        
-        printk("PIO clocking = %d\n", pio);
-        
+        u8 reg;
+
         /* FIXME: if DMA = 1 do we need to set the DMA bit here ? */
 
         /* 8bit CAT/CRT - 8bit command timing for channel */
@@ -115,25 +96,28 @@ static int cs5520_tune_chipset(ide_drive_t *drive, u8 xferspeed)
         reg = inb(hwif->dma_base + 0x02 + 8*controller);
         reg |= 1<<((drive->dn&1)+5);
         outb(reg, hwif->dma_base + 0x02 + 8*controller);
-                
-        error = ide_config_drive_speed(drive, speed);
-        /* ATAPI is harder so leave it for now */
-        if(!error && drive->media == ide_disk)
-                error = hwif->ide_dma_on(drive);
 
-        return error;
-}       
-        
-static void cs5520_tune_drive(ide_drive_t *drive, u8 pio)
+        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
+}
+
+static int cs5520_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
-        cs5520_tune_chipset(drive, (XFER_PIO_0 + pio));
+        printk(KERN_ERR "cs55x0: bad ide timing.\n");
+
+        cs5520_set_pio_mode(drive, 0);
+
+        /*
+         * FIXME: this is incorrect to return zero here but
+         * since all users of ide_set_xfer_rate() ignore
+         * the return value it is not a problem currently
+         */
+        return 0;
 }
 
 static int cs5520_config_drive_xfer_rate(ide_drive_t *drive)
 {
         /* Tune the drive for PIO modes up to PIO 4 */  
-        cs5520_tune_drive(drive, 255);
+        ide_set_max_pio(drive);
 
         /* Then tell the core to use DMA operations */
         return 0;
@@ -165,7 +149,7 @@ static int cs5520_dma_on(ide_drive_t *drive)
 
 static void __devinit init_hwif_cs5520(ide_hwif_t *hwif)
 {
-        hwif->tuneproc = &cs5520_tune_drive;
+        hwif->set_pio_mode = &cs5520_set_pio_mode;
         hwif->speedproc = &cs5520_tune_chipset;
         hwif->ide_dma_check = &cs5520_config_drive_xfer_rate;
         hwif->ide_dma_on = &cs5520_dma_on;
@@ -179,7 +163,8 @@ static void __devinit init_hwif_cs5520(ide_hwif_t *hwif)
                 hwif->drives[1].autotune = 1;
                 return;
         }
-        
+
+        /* ATAPI is harder so leave it for now */
         hwif->atapi_dma = 0;
         hwif->ultra_mask = 0;
         hwif->swdma_mask = 0;
diff --git a/drivers/ide/pci/cs5530.c b/drivers/ide/pci/cs5530.c
index e5949b1d3fb0..741507b4cd93 100644
--- a/drivers/ide/pci/cs5530.c
+++ b/drivers/ide/pci/cs5530.c
@@ -71,19 +71,18 @@ static void cs5530_tunepio(ide_drive_t *drive, u8 pio)
 }
 
 /**
- *      cs5530_tuneproc         -       select/set PIO modes
+ *      cs5530_set_pio_mode     -       set PIO mode
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
- *      cs5530_tuneproc() handles selection/setting of PIO modes
- *      for both the chipset and drive.
+ *      Handles setting of PIO mode for both the chipset and drive.
  *
- *      The ide_init_cs5530() routine guarantees that all drives
+ *      The init_hwif_cs5530() routine guarantees that all drives
  *      will have valid default PIO timings set up before we get here.
  */
 
-static void cs5530_tuneproc (ide_drive_t *drive, u8 pio)        /* pio=255 means "autotune" */
+static void cs5530_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
-
         if (cs5530_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
                 cs5530_tunepio(drive, pio);
 }
@@ -143,13 +142,11 @@ static int cs5530_config_dma(ide_drive_t *drive)
         return 1;
 }
 
-static int cs5530_tune_chipset(ide_drive_t *drive, u8 mode)
+static int cs5530_tune_chipset(ide_drive_t *drive, const u8 mode)
 {
         unsigned long basereg;
         unsigned int reg, timings = 0;
 
-        mode = ide_rate_filter(drive, mode);
-
         /*
          * Tell the drive to switch to the new mode; abort on failure.
          */
@@ -166,13 +163,6 @@ static int cs5530_tune_chipset(ide_drive_t *drive, u8 mode)
                 case XFER_MW_DMA_0:     timings = 0x00077771; break;
                 case XFER_MW_DMA_1:     timings = 0x00012121; break;
                 case XFER_MW_DMA_2:     timings = 0x00002020; break;
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:
-                        cs5530_tunepio(drive, mode - XFER_PIO_0);
-                        return 0;
                 default:
                         BUG();
                         break;
@@ -308,7 +298,7 @@ static void __devinit init_hwif_cs5530 (ide_hwif_t *hwif)
         if (hwif->mate)
                 hwif->serialized = hwif->mate->serialized = 1;
 
-        hwif->tuneproc = &cs5530_tuneproc;
+        hwif->set_pio_mode = &cs5530_set_pio_mode;
         hwif->speedproc = &cs5530_tune_chipset;
 
         basereg = CS5530_BASEREG(hwif);
diff --git a/drivers/ide/pci/cs5535.c b/drivers/ide/pci/cs5535.c
index 082ca7da2cbc..383b7eccbcbb 100644
--- a/drivers/ide/pci/cs5535.c
+++ b/drivers/ide/pci/cs5535.c
@@ -75,7 +75,7 @@ static unsigned int cs5535_udma_timings[5] =
  *
  *      cs5535_set_speed() configures the chipset to a new speed.
  */
-static void cs5535_set_speed(ide_drive_t *drive, u8 speed)
+static void cs5535_set_speed(ide_drive_t *drive, const u8 speed)
 {
 
         u32 reg = 0, dummy;
@@ -141,23 +141,22 @@ static void cs5535_set_speed(ide_drive_t *drive, u8 speed)
  */
 static int cs5535_set_drive(ide_drive_t *drive, u8 speed)
 {
-        speed = ide_rate_filter(drive, speed);
         ide_config_drive_speed(drive, speed);
         cs5535_set_speed(drive, speed);
 
         return 0;
 }
 
-/****
- *      cs5535_tuneproc    -       PIO setup
- *      @drive: drive to set up
- *      @pio: mode to use (255 for 'best possible')
+/**
+ *      cs5535_set_pio_mode     -       PIO setup
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      A callback from the upper layers for PIO-only tuning.
  */
-static void cs5535_tuneproc(ide_drive_t *drive, u8 pio)
+
+static void cs5535_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         ide_config_drive_speed(drive, XFER_PIO_0 + pio);
         cs5535_set_speed(drive, XFER_PIO_0 + pio);
 }
@@ -170,7 +169,7 @@ static int cs5535_dma_check(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                cs5535_tuneproc(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -199,7 +198,7 @@ static void __devinit init_hwif_cs5535(ide_hwif_t *hwif)
 
         hwif->autodma = 0;
 
-        hwif->tuneproc = &cs5535_tuneproc;
+        hwif->set_pio_mode = &cs5535_set_pio_mode;
         hwif->speedproc = &cs5535_set_drive;
         hwif->ide_dma_check = &cs5535_dma_check;
 
diff --git a/drivers/ide/pci/cy82c693.c b/drivers/ide/pci/cy82c693.c
index daa36fcbc8ef..dc278025d318 100644
--- a/drivers/ide/pci/cy82c693.c
+++ b/drivers/ide/pci/cy82c693.c
@@ -97,9 +97,6 @@
 #define CY82_INDEX_CHANNEL1     0x31
 #define CY82_INDEX_TIMEOUT      0x32
 
-/* the max PIO mode - from datasheet */
-#define CY82C693_MAX_PIO        4
-
 /* the min and max PCI bus speed in MHz - from datasheet */
 #define CY82C963_MIN_BUS_SPEED  25
 #define CY82C963_MAX_BUS_SPEED  33
@@ -148,9 +145,6 @@ static void compute_clocks (u8 pio, pio_clocks_t *p_pclk)
          * so you can play with the idebus=xx parameter
          */
 
-        if (pio > CY82C693_MAX_PIO)
-                pio = CY82C693_MAX_PIO;
-
         /* let's calc the address setup time clocks */
         p_pclk->address_time = (u8)calc_clk(ide_pio_timings[pio].setup_time, bus_speed);
 
@@ -269,10 +263,7 @@ static int cy82c693_ide_dma_on (ide_drive_t *drive)
         return __ide_dma_on(drive);
 }
 
-/*
- * tune ide drive - set PIO mode
- */
-static void cy82c693_tune_drive (ide_drive_t *drive, u8 pio)
+static void cy82c693_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *dev = hwif->pci_dev;
@@ -329,13 +320,6 @@ static void cy82c693_tune_drive (ide_drive_t *drive, u8 pio)
                 addrCtrl, pclk.time_16r, pclk.time_16w, pclk.time_8);
 #endif /* CY82C693_DEBUG_LOGS */
 
-        /* first let's calc the pio modes */
-        pio = ide_get_best_pio_mode(drive, pio, CY82C693_MAX_PIO);
-
-#if CY82C693_DEBUG_INFO
-        printk (KERN_INFO "%s: Selected PIO mode %d\n", drive->name, pio);
-#endif /* CY82C693_DEBUG_INFO */
-
         /* let's calc the values for this PIO mode */
         compute_clocks(pio, &pclk);
 
@@ -447,7 +431,7 @@ static void __devinit init_hwif_cy82c693(ide_hwif_t *hwif)
         hwif->autodma = 0;
 
         hwif->chipset = ide_cy82c693;
-        hwif->tuneproc = &cy82c693_tune_drive;
+        hwif->set_pio_mode = &cy82c693_set_pio_mode;
 
         if (!hwif->dma_base) {
                 hwif->drives[0].autotune = 1;
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
index cb8fe5643d3b..a1bb10188fe5 100644
--- a/drivers/ide/pci/hpt34x.c
+++ b/drivers/ide/pci/hpt34x.c
@@ -43,10 +43,9 @@
 
 #define HPT343_DEBUG_DRIVE_INFO         0
 
-static int hpt34x_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int hpt34x_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         struct pci_dev *dev     = HWIF(drive)->pci_dev;
-        u8 speed = ide_rate_filter(drive, xferspeed);
         u32 reg1= 0, tmp1 = 0, reg2 = 0, tmp2 = 0;
         u8                      hi_speed, lo_speed;
 
@@ -78,9 +77,8 @@ static int hpt34x_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         return(ide_config_drive_speed(drive, speed));
 }
 
-static void hpt34x_tune_drive (ide_drive_t *drive, u8 pio)
+static void hpt34x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 5);
         (void) hpt34x_tune_chipset(drive, (XFER_PIO_0 + pio));
 }
 
@@ -92,7 +90,7 @@ static int hpt34x_config_drive_xfer_rate (ide_drive_t *drive)
                 return -1;
 
         if (ide_use_fast_pio(drive))
-                hpt34x_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -146,7 +144,7 @@ static void __devinit init_hwif_hpt34x(ide_hwif_t *hwif)
 
         hwif->autodma = 0;
 
-        hwif->tuneproc = &hpt34x_tune_drive;
+        hwif->set_pio_mode = &hpt34x_set_pio_mode;
         hwif->speedproc = &hpt34x_tune_chipset;
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index 39f1c89f7c86..0e7d3b60d43c 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/hpt366.c               Version 1.12    Aug 19, 2007
+ * linux/drivers/ide/pci/hpt366.c               Version 1.13    Sep 29, 2007
  *
  * Copyright (C) 1999-2003              Andre Hedrick <andre@linux-ide.org>
  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
@@ -114,7 +114,7 @@
  *   unify HPT36x/37x timing setup code and the speedproc handlers by joining
  *   the register setting lists into the table indexed by the clock selected
  * - set the correct hwif->ultra_mask for each individual chip
- * - add UltraDMA mode filtering for the HPT37[24] based SATA cards
+ * - add Ultra and MW DMA mode filtering for the HPT37[24] based SATA cards
  *      Sergei Shtylyov, <sshtylyov@ru.mvista.com> or <source@mvista.com>
  */
 
@@ -562,6 +562,24 @@ static u8 hpt3xx_udma_filter(ide_drive_t *drive)
         return check_in_drive_list(drive, bad_ata33) ? 0x00 : mask;
 }
 
+static u8 hpt3xx_mdma_filter(ide_drive_t *drive)
+{
+        ide_hwif_t *hwif        = HWIF(drive);
+        struct hpt_info *info   = pci_get_drvdata(hwif->pci_dev);
+
+        switch (info->chip_type) {
+        case HPT372 :
+        case HPT372A:
+        case HPT372N:
+        case HPT374 :
+                if (ide_dev_is_sata(drive->id))
+                        return 0x00;
+                /* Fall thru */
+        default:
+                return 0x07;
+        }
+}
+
 static u32 get_speed_setting(u8 speed, struct hpt_info *info)
 {
         int i;
@@ -582,20 +600,15 @@ static u32 get_speed_setting(u8 speed, struct hpt_info *info)
         return (*info->settings)[i];
 }
 
-static int hpt36x_tune_chipset(ide_drive_t *drive, u8 xferspeed)
+static int hpt36x_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev  *dev    = hwif->pci_dev;
         struct hpt_info *info   = pci_get_drvdata(dev);
-        u8  speed               = ide_rate_filter(drive, xferspeed);
         u8  itr_addr            = drive->dn ? 0x44 : 0x40;
         u32 old_itr             = 0;
         u32 itr_mask, new_itr;
 
-        /* TODO: move this to ide_rate_filter() [ check ->atapi_dma ] */
-        if (drive->media != ide_disk)
-                speed = min_t(u8, speed, XFER_PIO_4);
-
         itr_mask = speed < XFER_MW_DMA_0 ? 0x30070000 :
                   (speed < XFER_UDMA_0   ? 0xc0070000 : 0xc03800ff);
 
@@ -614,20 +627,15 @@ static int hpt36x_tune_chipset(ide_drive_t *drive, u8 xferspeed)
         return ide_config_drive_speed(drive, speed);
 }
 
-static int hpt37x_tune_chipset(ide_drive_t *drive, u8 xferspeed)
+static int hpt37x_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev  *dev    = hwif->pci_dev;
         struct hpt_info *info   = pci_get_drvdata(dev);
-        u8  speed               = ide_rate_filter(drive, xferspeed);
         u8  itr_addr            = 0x40 + (drive->dn * 4);
         u32 old_itr             = 0;
         u32 itr_mask, new_itr;
 
-        /* TODO: move this to ide_rate_filter() [ check ->atapi_dma ] */
-        if (drive->media != ide_disk)
-                speed = min_t(u8, speed, XFER_PIO_4);
-
         itr_mask = speed < XFER_MW_DMA_0 ? 0x303c0000 :
                   (speed < XFER_UDMA_0   ? 0xc03c0000 : 0xc1c001ff);
 
@@ -654,9 +662,8 @@ static int hpt3xx_tune_chipset(ide_drive_t *drive, u8 speed)
                 return hpt36x_tune_chipset(drive, speed);
 }
 
-static void hpt3xx_tune_drive(ide_drive_t *drive, u8 pio)
+static void hpt3xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) hpt3xx_tune_chipset (drive, XFER_PIO_0 + pio);
 }
 
@@ -718,7 +725,7 @@ static int hpt366_config_drive_xfer_rate(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                hpt3xx_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -1249,7 +1256,7 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
         /* Cache the channel's MISC. control registers' offset */
         hwif->select_data       = hwif->channel ? 0x54 : 0x50;
 
-        hwif->tuneproc          = &hpt3xx_tune_drive;
+        hwif->set_pio_mode      = &hpt3xx_set_pio_mode;
         hwif->speedproc         = &hpt3xx_tune_chipset;
         hwif->quirkproc         = &hpt3xx_quirkproc;
         hwif->intrproc          = &hpt3xx_intrproc;
@@ -1257,6 +1264,7 @@ static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
         hwif->busproc           = &hpt3xx_busproc;
 
         hwif->udma_filter       = &hpt3xx_udma_filter;
+        hwif->mdma_filter       = &hpt3xx_mdma_filter;
 
         /*
          * HPT3xxN chips have some complications:
diff --git a/drivers/ide/pci/it8213.c b/drivers/ide/pci/it8213.c
index 70b3245dbf62..76e91ff9420b 100644
--- a/drivers/ide/pci/it8213.c
+++ b/drivers/ide/pci/it8213.c
@@ -105,9 +105,8 @@ static void it8213_tune_pio(ide_drive_t *drive, const u8 pio)
         spin_unlock_irqrestore(&tune_lock, flags);
 }
 
-static void it8213_tuneproc(ide_drive_t *drive, u8 pio)
+static void it8213_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         it8213_tune_pio(drive, pio);
         ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -115,20 +114,16 @@ static void it8213_tuneproc(ide_drive_t *drive, u8 pio)
 /**
  *      it8213_tune_chipset     -       set controller timings
  *      @drive: Drive to set up
- *      @xferspeed: speed we want to achieve
+ *      @speed: speed we want to achieve
  *
- *      Tune the ITE chipset for the desired mode. If we can't achieve
- *      the desired mode then tune for a lower one, but ultimately
- *      make the thing work.
+ *      Tune the ITE chipset for the desired mode.
  */
 
-static int it8213_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int it8213_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
-
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u8 maslave              = 0x40;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         int a_speed             = 3 << (drive->dn * 4);
         int u_flag              = 1 << drive->dn;
         int v_flag              = 0x01 << drive->dn;
@@ -156,12 +151,6 @@ static int it8213_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 case XFER_MW_DMA_1:
                 case XFER_SW_DMA_2:
                         break;
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:
-                        break;
                 default:
                         return -1;
         }
@@ -193,10 +182,7 @@ static int it8213_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                         pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
         }
 
-        if (speed > XFER_PIO_4)
-                it8213_tune_pio(drive, it8213_dma_2_pio(speed));
-        else
-                it8213_tune_pio(drive, speed - XFER_PIO_0);
+        it8213_tune_pio(drive, it8213_dma_2_pio(speed));
 
         return ide_config_drive_speed(drive, speed);
 }
@@ -216,7 +202,7 @@ static int it8213_config_drive_for_dma (ide_drive_t *drive)
         if (ide_tune_dma(drive))
                 return 0;
 
-        it8213_tuneproc(drive, 255);
+        ide_set_max_pio(drive);
 
         return -1;
 }
@@ -235,7 +221,7 @@ static void __devinit init_hwif_it8213(ide_hwif_t *hwif)
         u8 reg42h = 0;
 
         hwif->speedproc = &it8213_tune_chipset;
-        hwif->tuneproc  = &it8213_tuneproc;
+        hwif->set_pio_mode = &it8213_set_pio_mode;
 
         hwif->autodma = 0;
 
diff --git a/drivers/ide/pci/it821x.c b/drivers/ide/pci/it821x.c
index 9286c99e2ff0..758a98230cc5 100644
--- a/drivers/ide/pci/it821x.c
+++ b/drivers/ide/pci/it821x.c
@@ -274,9 +274,8 @@ static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
         return ide_config_drive_speed(drive, XFER_PIO_0 + set_pio);
 }
 
-static void it821x_tuneproc(ide_drive_t *drive, u8 pio)
+static void it821x_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void)it821x_tunepio(drive, pio);
 }
 
@@ -405,32 +404,19 @@ static int it821x_dma_end(ide_drive_t *drive)
         return ret;
 }
 
-
 /**
  *      it821x_tune_chipset     -       set controller timings
  *      @drive: Drive to set up
- *      @xferspeed: speed we want to achieve
+ *      @speed: speed we want to achieve
  *
- *      Tune the ITE chipset for the desired mode. If we can't achieve
- *      the desired mode then tune for a lower one, but ultimately
- *      make the thing work.
+ *      Tune the ITE chipset for the desired mode.
  */
 
-static int it821x_tune_chipset (ide_drive_t *drive, byte xferspeed)
+static int it821x_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
 
         ide_hwif_t *hwif        = drive->hwif;
         struct it821x_dev *itdev = ide_get_hwifdata(hwif);
-        u8 speed                = ide_rate_filter(drive, xferspeed);
-
-        switch (speed) {
-        case XFER_PIO_4:
-        case XFER_PIO_3:
-        case XFER_PIO_2:
-        case XFER_PIO_1:
-        case XFER_PIO_0:
-                return it821x_tunepio(drive, speed - XFER_PIO_0);
-        }
 
         if (itdev->smart == 0) {
                 switch (speed) {
@@ -477,7 +463,7 @@ static int it821x_config_drive_for_dma (ide_drive_t *drive)
         if (ide_tune_dma(drive))
                 return 0;
 
-        it821x_tuneproc(drive, 255);
+        ide_set_max_pio(drive);
 
         return -1;
 }
@@ -644,7 +630,7 @@ static void __devinit init_hwif_it821x(ide_hwif_t *hwif)
         }
 
         hwif->speedproc = &it821x_tune_chipset;
-        hwif->tuneproc  = &it821x_tuneproc;
+        hwif->set_pio_mode = &it821x_set_pio_mode;
 
         /* MWDMA/PIO clock switching for pass through mode */
         if(!idev->smart) {
diff --git a/drivers/ide/pci/jmicron.c b/drivers/ide/pci/jmicron.c
index 65a0ff352b98..d379fbaf6743 100644
--- a/drivers/ide/pci/jmicron.c
+++ b/drivers/ide/pci/jmicron.c
@@ -83,26 +83,22 @@ static u8 __devinit ata66_jmicron(ide_hwif_t *hwif)
         return ATA_CBL_PATA80;
 }
 
-static void jmicron_tuneproc(ide_drive_t *drive, u8 pio)
+static void jmicron_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 5);
         ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 /**
  *      jmicron_tune_chipset    -       set controller timings
  *      @drive: Drive to set up
- *      @xferspeed: speed we want to achieve
+ *      @speed: speed we want to achieve
  *
  *      As the JMicron snoops for timings all we actually need to do is
- *      make sure we don't set an invalid mode. We do need to honour
- *      the cable detect here.
+ *      set the transfer mode on the device.
  */
 
-static int jmicron_tune_chipset (ide_drive_t *drive, byte xferspeed)
+static int jmicron_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
-        u8 speed = ide_rate_filter(drive, xferspeed);
-
         return ide_config_drive_speed(drive, speed);
 }
 
@@ -119,7 +115,7 @@ static int jmicron_config_drive_for_dma (ide_drive_t *drive)
         if (ide_tune_dma(drive))
                 return 0;
 
-        jmicron_tuneproc(drive, 255);
+        ide_set_max_pio(drive);
 
         return -1;
 }
@@ -134,7 +130,7 @@ static int jmicron_config_drive_for_dma (ide_drive_t *drive)
 static void __devinit init_hwif_jmicron(ide_hwif_t *hwif)
 {
         hwif->speedproc = &jmicron_tune_chipset;
-        hwif->tuneproc  = &jmicron_tuneproc;
+        hwif->set_pio_mode = &jmicron_set_pio_mode;
 
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
@@ -160,22 +156,13 @@ fallback:
         return;
 }
 
-#define DECLARE_JMB_DEV(name_str)                       \
-        {                                               \
-                .name           = name_str,             \
-                .init_hwif      = init_hwif_jmicron,    \
-                .autodma        = AUTODMA,              \
-                .bootable       = ON_BOARD,             \
-                .enablebits     = { {0x40, 1, 1}, {0x40, 0x10, 0x10} }, \
-                .pio_mask       = ATA_PIO5,             \
-        }
-
-static ide_pci_device_t jmicron_chipsets[] __devinitdata = {
-        /* 0 */ DECLARE_JMB_DEV("JMB361"),
-        /* 1 */ DECLARE_JMB_DEV("JMB363"),
-        /* 2 */ DECLARE_JMB_DEV("JMB365"),
-        /* 3 */ DECLARE_JMB_DEV("JMB366"),
-        /* 4 */ DECLARE_JMB_DEV("JMB368"),
+static ide_pci_device_t jmicron_chipset __devinitdata = {
+        .name           = "JMB",
+        .init_hwif      = init_hwif_jmicron,
+        .autodma        = AUTODMA,
+        .bootable       = ON_BOARD,
+        .enablebits     = { { 0x40, 0x01, 0x01 }, { 0x40, 0x10, 0x10 } },
+        .pio_mask       = ATA_PIO5,
 };
 
 /**
@@ -189,35 +176,29 @@ static ide_pci_device_t jmicron_chipsets[] __devinitdata = {
 
 static int __devinit jmicron_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 {
-        ide_setup_pci_device(dev, &jmicron_chipsets[id->driver_data]);
+        ide_setup_pci_device(dev, &jmicron_chipset);
         return 0;
 }
 
-/* If libata is configured, jmicron PCI quirk will configure it such
- * that the SATA ports are in AHCI function while the PATA ports are
- * in a separate IDE function.  In such cases, match device class and
- * attach only to IDE.  If libata isn't configured, keep the old
- * behavior for backward compatibility.
+/* All JMB PATA controllers have and will continue to have the same
+ * interface.  Matching vendor and device class is enough for all
+ * current and future controllers if the controller is programmed
+ * properly.
+ *
+ * If libata is configured, jmicron PCI quirk programs the controller
+ * into the correct mode.  If libata isn't configured, match known
+ * device IDs too to maintain backward compatibility.
  */
-#if defined(CONFIG_ATA) || defined(CONFIG_ATA_MODULE)
-#define JMB_CLASS       PCI_CLASS_STORAGE_IDE << 8
-#define JMB_CLASS_MASK  0xffff00
-#else
-#define JMB_CLASS       0
-#define JMB_CLASS_MASK  0
-#endif
-
 static struct pci_device_id jmicron_pci_tbl[] = {
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB361,
-          PCI_ANY_ID, PCI_ANY_ID, JMB_CLASS, JMB_CLASS_MASK, 0},
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB363,
-          PCI_ANY_ID, PCI_ANY_ID, JMB_CLASS, JMB_CLASS_MASK, 1},
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB365,
-          PCI_ANY_ID, PCI_ANY_ID, JMB_CLASS, JMB_CLASS_MASK, 2},
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB366,
-          PCI_ANY_ID, PCI_ANY_ID, JMB_CLASS, JMB_CLASS_MASK, 3},
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB368,
-          PCI_ANY_ID, PCI_ANY_ID, JMB_CLASS, JMB_CLASS_MASK, 4},
+#if !defined(CONFIG_ATA) && !defined(CONFIG_ATA_MODULE)
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB361) },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB363) },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB365) },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB366) },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB368) },
+#endif
+        { PCI_VENDOR_ID_JMICRON, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
+          PCI_CLASS_STORAGE_IDE << 8, 0xffff00, 0 },
         { 0, },
 };
 
diff --git a/drivers/ide/pci/opti621.c b/drivers/ide/pci/opti621.c
index 3a2bb2723515..9fa06393469a 100644
--- a/drivers/ide/pci/opti621.c
+++ b/drivers/ide/pci/opti621.c
@@ -47,7 +47,7 @@
  * The main problem with OPTi is that some timings for master
  * and slave must be the same. For example, if you have master
  * PIO 3 and slave PIO 0, driver have to set some timings of
- * master for PIO 0. Second problem is that opti621_tune_drive
+ * master for PIO 0. Second problem is that opti621_set_pio_mode
  * got only one drive to set, but have to set both drives.
  * This is solved in compute_pios. If you don't set
  * the second drive, compute_pios use ide_get_best_pio_mode
@@ -103,7 +103,7 @@
 
 #include <asm/io.h>
 
-#define OPTI621_MAX_PIO 3
+//#define OPTI621_MAX_PIO 3
 /* In fact, I do not have any PIO 4 drive
  * (address: 25 ns, data: 70 ns, recovery: 35 ns),
  * but OPTi 82C621 is programmable and it can do (minimal values):
@@ -136,8 +136,8 @@ static int reg_base;
 #define PIO_NOT_EXIST 254
 #define PIO_DONT_KNOW 255
 
-/* there are stored pio numbers from other calls of opti621_tune_drive */
-static void compute_pios(ide_drive_t *drive, u8 pio)
+/* there are stored pio numbers from other calls of opti621_set_pio_mode */
+static void compute_pios(ide_drive_t *drive, const u8 pio)
 /* Store values into drive->drive_data
  *      second_contr - 0 for primary controller, 1 for secondary
  *      slave_drive - 0 -> pio is for master, 1 -> pio is for slave
@@ -147,12 +147,13 @@ static void compute_pios(ide_drive_t *drive, u8 pio)
         int d;
         ide_hwif_t *hwif = HWIF(drive);
 
-        drive->drive_data = ide_get_best_pio_mode(drive, pio, OPTI621_MAX_PIO);
+        drive->drive_data = pio;
+
         for (d = 0; d < 2; ++d) {
                 drive = &hwif->drives[d];
                 if (drive->present) {
                         if (drive->drive_data == PIO_DONT_KNOW)
-                                drive->drive_data = ide_get_best_pio_mode(drive, 255, OPTI621_MAX_PIO);
+                                drive->drive_data = ide_get_best_pio_mode(drive, 255, 3);
 #ifdef OPTI621_DEBUG
                         printk("%s: Selected PIO mode %d\n",
                                 drive->name, drive->drive_data);
@@ -240,8 +241,7 @@ static void compute_clocks(int pio, pio_clocks_t *clks)
  
 }
 
-/* Main tune procedure, called from tuneproc. */
-static void opti621_tune_drive (ide_drive_t *drive, u8 pio)
+static void opti621_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         /* primary and secondary drives share some registers,
          * so we have to program both drives
@@ -331,7 +331,8 @@ static void __devinit init_hwif_opti621 (ide_hwif_t *hwif)
         hwif->autodma = 0;
         hwif->drives[0].drive_data = PIO_DONT_KNOW;
         hwif->drives[1].drive_data = PIO_DONT_KNOW;
-        hwif->tuneproc = &opti621_tune_drive;
+
+        hwif->set_pio_mode = &opti621_set_pio_mode;
 
         if (!(hwif->dma_base))
                 return;
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index 7b0e479c355c..5fb1eedc8194 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -146,14 +146,12 @@ static struct udma_timing {
         { 0x1a, 0x01, 0xcb },   /* UDMA mode 6 */
 };
 
-static int pdcnew_tune_chipset(ide_drive_t *drive, u8 speed)
+static int pdcnew_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         u8 adj                  = (drive->dn & 1) ? 0x08 : 0x00;
         int                     err;
 
-        speed = ide_rate_filter(drive, speed);
-
         /*
          * Issue SETFEATURES_XFER to the drive first. PDC202xx hardware will
          * automatically set the timing registers based on 100 MHz PLL output.
@@ -217,9 +215,8 @@ static int pdcnew_tune_chipset(ide_drive_t *drive, u8 speed)
         return err;
 }
 
-static void pdcnew_tune_drive(ide_drive_t *drive, u8 pio)
+static void pdcnew_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void)pdcnew_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
@@ -239,7 +236,7 @@ static int pdcnew_config_drive_xfer_rate(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                pdcnew_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -492,7 +489,8 @@ static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
 {
         hwif->autodma = 0;
 
-        hwif->tuneproc  = &pdcnew_tune_drive;
+        hwif->set_pio_mode = &pdcnew_set_pio_mode;
+
         hwif->quirkproc = &pdcnew_quirkproc;
         hwif->speedproc = &pdcnew_tune_chipset;
         hwif->resetproc = &pdcnew_reset;
@@ -524,44 +522,52 @@ static int __devinit init_setup_pdcnew(struct pci_dev *dev, ide_pci_device_t *d)
         return ide_setup_pci_device(dev, d);
 }
 
-static int __devinit init_setup_pdc20270(struct pci_dev *dev,
-                                         ide_pci_device_t *d)
+static int __devinit init_setup_pdc20270(struct pci_dev *dev, ide_pci_device_t *d)
 {
-        struct pci_dev *findev = NULL;
-        int ret;
+        struct pci_dev *bridge = dev->bus->self;
+
+        if (bridge != NULL &&
+            bridge->vendor == PCI_VENDOR_ID_DEC &&
+            bridge->device == PCI_DEVICE_ID_DEC_21150) {
+                struct pci_dev *dev2;
 
-        if ((dev->bus->self &&
-             dev->bus->self->vendor == PCI_VENDOR_ID_DEC) &&
-            (dev->bus->self->device == PCI_DEVICE_ID_DEC_21150)) {
                 if (PCI_SLOT(dev->devfn) & 2)
                         return -ENODEV;
 
-                while ((findev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, findev)) != NULL) {
-                        if ((findev->vendor == dev->vendor) &&
-                            (findev->device == dev->device) &&
-                            (PCI_SLOT(findev->devfn) & 2)) {
-                                if (findev->irq != dev->irq) {
-                                        findev->irq = dev->irq;
-                                }
-                                ret = ide_setup_pci_devices(dev, findev, d);
-                                if (ret < 0)
-                                        pci_dev_put(findev);
-                                return ret;
+                dev2 = pci_get_slot(dev->bus, PCI_DEVFN(PCI_SLOT(dev->devfn) + 2,
+                                                        PCI_FUNC(dev->devfn)));
+                if (dev2 != NULL &&
+                    dev2->vendor == dev->vendor &&
+                    dev2->device == dev->device) {
+                        int ret;
+
+                        if (dev2->irq != dev->irq) {
+                                dev2->irq = dev->irq;
+
+                                printk(KERN_WARNING "%s: PCI config space "
+                                       "interrupt fixed.\n", d->name);
                         }
+
+                        ret = ide_setup_pci_devices(dev, dev2, d);
+                        if (ret < 0)
+                                pci_dev_put(dev2);
+                        return ret;
                 }
         }
         return ide_setup_pci_device(dev, d);
 }
 
-static int __devinit init_setup_pdc20276(struct pci_dev *dev,
-                                         ide_pci_device_t *d)
+static int __devinit init_setup_pdc20276(struct pci_dev *dev, ide_pci_device_t *d)
 {
-        if ((dev->bus->self) &&
-            (dev->bus->self->vendor == PCI_VENDOR_ID_INTEL) &&
-            ((dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960) ||
-             (dev->bus->self->device == PCI_DEVICE_ID_INTEL_I960RM))) {
-                printk(KERN_INFO "ide: Skipping Promise PDC20276 "
-                        "attached to I2O RAID controller.\n");
+        struct pci_dev *bridge = dev->bus->self;
+
+        if (bridge != NULL &&
+            bridge->vendor == PCI_VENDOR_ID_INTEL &&
+           (bridge->device == PCI_DEVICE_ID_INTEL_I960 ||
+            bridge->device == PCI_DEVICE_ID_INTEL_I960RM)) {
+
+                printk(KERN_INFO "%s: attached to I2O RAID controller, "
+                                 "skipping.\n", d->name);
                 return -ENODEV;
         }
         return ide_setup_pci_device(dev, d);
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index e19a891171cb..b578307fad51 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -63,12 +63,11 @@ static const char *pdc_quirk_drives[] = {
 
 static void pdc_old_disable_66MHz_clock(ide_hwif_t *);
 
-static int pdc202xx_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int pdc202xx_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u8 drive_pci            = 0x60 + (drive->dn << 2);
-        u8 speed                = ide_rate_filter(drive, xferspeed);
 
         u8                      AP = 0, BP = 0, CP = 0;
         u8                      TA = 0, TB = 0, TC = 0;
@@ -143,9 +142,8 @@ static int pdc202xx_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         return ide_config_drive_speed(drive, speed);
 }
 
-static void pdc202xx_tune_drive(ide_drive_t *drive, u8 pio)
+static void pdc202xx_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         pdc202xx_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
@@ -191,7 +189,7 @@ static int pdc202xx_config_drive_xfer_rate (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                pdc202xx_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -307,10 +305,11 @@ static void pdc202xx_reset (ide_drive_t *drive)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         ide_hwif_t *mate        = hwif->mate;
-        
+
         pdc202xx_reset_host(hwif);
         pdc202xx_reset_host(mate);
-        pdc202xx_tune_drive(drive, 255);
+
+        ide_set_max_pio(drive);
 }
 
 static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
@@ -329,7 +328,9 @@ static void __devinit init_hwif_pdc202xx(ide_hwif_t *hwif)
                 hwif->rqsize = 256;
 
         hwif->autodma = 0;
-        hwif->tuneproc  = &pdc202xx_tune_drive;
+
+        hwif->set_pio_mode = &pdc202xx_set_pio_mode;
+
         hwif->quirkproc = &pdc202xx_quirkproc;
 
         if (hwif->pci_dev->device != PCI_DEVICE_ID_PROMISE_20246)
diff --git a/drivers/ide/pci/piix.c b/drivers/ide/pci/piix.c
index 5cfa9378bbb8..fd8214a7ab98 100644
--- a/drivers/ide/pci/piix.c
+++ b/drivers/ide/pci/piix.c
@@ -1,5 +1,5 @@
 /*
- *  linux/drivers/ide/pci/piix.c        Version 0.51    Jul 6, 2007
+ *  linux/drivers/ide/pci/piix.c        Version 0.52    Jul 14, 2007
  *
  *  Copyright (C) 1998-1999 Andrzej Krzysztofowicz, Author and Maintainer
  *  Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
@@ -17,11 +17,11 @@
  *                 41
  *                 43
  *
- * | PIO 0       | c0 | 80 | 0 |        piix_tune_drive(drive, 0);
- * | PIO 2 | SW2 | d0 | 90 | 4 |        piix_tune_drive(drive, 2);
- * | PIO 3 | MW1 | e1 | a1 | 9 |        piix_tune_drive(drive, 3);
- * | PIO 4 | MW2 | e3 | a3 | b |        piix_tune_drive(drive, 4);
- * 
+ * | PIO 0       | c0 | 80 | 0 |
+ * | PIO 2 | SW2 | d0 | 90 | 4 |
+ * | PIO 3 | MW1 | e1 | a1 | 9 |
+ * | PIO 4 | MW2 | e3 | a3 | b |
+ *
  * sitre = word40 & 0x4000; primary
  * sitre = word42 & 0x4000; secondary
  *
@@ -204,16 +204,16 @@ static void piix_tune_pio (ide_drive_t *drive, u8 pio)
 }
 
 /**
- *      piix_tune_drive         -       tune a drive attached to PIIX
+ *      piix_set_pio_mode       -       set PIO mode
  *      @drive: drive to tune
  *      @pio: desired PIO mode
  *
  *      Set the drive's PIO mode (might be useful if drive is not registered
  *      in CMOS for any reason).
  */
-static void piix_tune_drive (ide_drive_t *drive, u8 pio)
+
+static void piix_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         piix_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -221,19 +221,18 @@ static void piix_tune_drive (ide_drive_t *drive, u8 pio)
 /**
  *      piix_tune_chipset       -       tune a PIIX interface
  *      @drive: IDE drive to tune
- *      @xferspeed: speed to configure
+ *      @speed: speed to configure
  *
  *      Set a PIIX interface channel to the desired speeds. This involves
  *      requires the right timing data into the PIIX configuration space
  *      then setting the drive parameters appropriately
  */
- 
-static int piix_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+
+static int piix_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u8 maslave              = hwif->channel ? 0x42 : 0x40;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         int a_speed             = 3 << (drive->dn * 4);
         int u_flag              = 1 << drive->dn;
         int v_flag              = 0x01 << drive->dn;
@@ -260,11 +259,6 @@ static int piix_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_SW_DMA_2:     break;
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:        break;
                 default:                return -1;
         }
 
@@ -294,10 +288,7 @@ static int piix_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                         pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
         }
 
-        if (speed > XFER_PIO_4)
-                piix_tune_pio(drive, piix_dma_2_pio(speed));
-        else
-                piix_tune_pio(drive, speed - XFER_PIO_0);
+        piix_tune_pio(drive, piix_dma_2_pio(speed));
 
         return ide_config_drive_speed(drive, speed);
 }
@@ -318,7 +309,7 @@ static int piix_config_drive_xfer_rate (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                piix_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -455,7 +446,8 @@ static void __devinit init_hwif_piix(ide_hwif_t *hwif)
         }
 
         hwif->autodma = 0;
-        hwif->tuneproc = &piix_tune_drive;
+
+        hwif->set_pio_mode = &piix_set_pio_mode;
         hwif->speedproc = &piix_tune_chipset;
         hwif->drives[0].autotune = 1;
         hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/sc1200.c b/drivers/ide/pci/sc1200.c
index 9bdc9694d50d..79ecab689489 100644
--- a/drivers/ide/pci/sc1200.c
+++ b/drivers/ide/pci/sc1200.c
@@ -138,7 +138,7 @@ out:
         return mask;
 }
 
-static int sc1200_tune_chipset(ide_drive_t *drive, u8 mode)
+static int sc1200_tune_chipset(ide_drive_t *drive, const u8 mode)
 {
         ide_hwif_t              *hwif = HWIF(drive);
         int                     unit = drive->select.b.unit;
@@ -146,25 +146,11 @@ static int sc1200_tune_chipset(ide_drive_t *drive, u8 mode)
         unsigned short          pci_clock;
         unsigned int            basereg = hwif->channel ? 0x50 : 0x40;
 
-        mode = ide_rate_filter(drive, mode);
-
         /*
          * Tell the drive to switch to the new mode; abort on failure.
          */
-        if (sc1200_set_xfer_mode(drive, mode)) {
-                printk("SC1200: set xfer mode failure\n");
+        if (sc1200_set_xfer_mode(drive, mode))
                 return 1;       /* failure */
-        }
-
-        switch (mode) {
-        case XFER_PIO_4:
-        case XFER_PIO_3:
-        case XFER_PIO_2:
-        case XFER_PIO_1:
-        case XFER_PIO_0:
-                sc1200_tunepio(drive, mode - XFER_PIO_0);
-                return 0;
-        }
 
         pci_clock = sc1200_get_pci_clock();
 
@@ -274,19 +260,20 @@ static int sc1200_ide_dma_end (ide_drive_t *drive)
 }
 
 /*
- * sc1200_tuneproc() handles selection/setting of PIO modes
+ * sc1200_set_pio_mode() handles setting of PIO modes
  * for both the chipset and drive.
  *
  * All existing BIOSs for this chipset guarantee that all drives
  * will have valid default PIO timings set up before we get here.
  */
-static void sc1200_tuneproc (ide_drive_t *drive, byte pio)      /* mode=255 means "autotune" */
+
+static void sc1200_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
         ide_hwif_t      *hwif = HWIF(drive);
         int             mode = -1;
 
         /*
-         * bad abuse of ->tuneproc interface
+         * bad abuse of ->set_pio_mode interface
          */
         switch (pio) {
                 case 200: mode = XFER_UDMA_0;   break;
@@ -304,9 +291,6 @@ static void sc1200_tuneproc (ide_drive_t *drive, byte pio)	/* mode=255 means "au
                 return;
         }
 
-        pio = ide_get_best_pio_mode(drive, pio, 4);
-        printk("SC1200: %s: setting PIO mode%d\n", drive->name, pio);
-
         if (sc1200_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
                 sc1200_tunepio(drive, pio);
 }
@@ -422,7 +406,8 @@ static void __devinit init_hwif_sc1200 (ide_hwif_t *hwif)
                 hwif->ide_dma_end   = &sc1200_ide_dma_end;
                 if (!noautodma)
                         hwif->autodma = 1;
-                hwif->tuneproc = &sc1200_tuneproc;
+
+                hwif->set_pio_mode = &sc1200_set_pio_mode;
                 hwif->speedproc = &sc1200_tune_chipset;
         }
         hwif->atapi_dma = 1;
@@ -438,6 +423,7 @@ static ide_pci_device_t sc1200_chipset __devinitdata = {
         .init_hwif      = init_hwif_sc1200,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
+        .host_flags     = IDE_HFLAG_ABUSE_DMA_MODES,
         .pio_mask       = ATA_PIO4,
 };
 
diff --git a/drivers/ide/pci/scc_pata.c b/drivers/ide/pci/scc_pata.c
index eeb0a6d434aa..66a526e0ece4 100644
--- a/drivers/ide/pci/scc_pata.c
+++ b/drivers/ide/pci/scc_pata.c
@@ -221,9 +221,8 @@ static void scc_tune_pio(ide_drive_t *drive, const u8 pio)
         out_be32((void __iomem *)pioct_port, reg);
 }
 
-static void scc_tuneproc(ide_drive_t *drive, u8 pio)
+static void scc_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         scc_tune_pio(drive, pio);
         ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -231,16 +230,15 @@ static void scc_tuneproc(ide_drive_t *drive, u8 pio)
 /**
  *      scc_tune_chipset        -       tune a drive DMA mode
  *      @drive: Drive to set up
- *      @xferspeed: speed we want to achieve
+ *      @speed: speed we want to achieve
  *
  *      Load the timing settings for this device mode into the
  *      controller.
  */
 
-static int scc_tune_chipset(ide_drive_t *drive, byte xferspeed)
+static int scc_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif = HWIF(drive);
-        u8 speed = ide_rate_filter(drive, xferspeed);
         struct scc_ports *ports = ide_get_hwifdata(hwif);
         unsigned long ctl_base = ports->ctl;
         unsigned long cckctrl_port = ctl_base + 0xff0;
@@ -272,13 +270,6 @@ static int scc_tune_chipset(ide_drive_t *drive, byte xferspeed)
         case XFER_UDMA_0:
                 idx = speed - XFER_UDMA_0;
                 break;
-        case XFER_PIO_4:
-        case XFER_PIO_3:
-        case XFER_PIO_2:
-        case XFER_PIO_1:
-        case XFER_PIO_0:
-                scc_tune_pio(drive, speed - XFER_PIO_0);
-                return ide_config_drive_speed(drive, speed);
         default:
                 return 1;
         }
@@ -317,7 +308,7 @@ static int scc_config_drive_for_dma(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                scc_tuneproc(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -718,7 +709,7 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
         hwif->dma_setup = scc_dma_setup;
         hwif->ide_dma_end = scc_ide_dma_end;
         hwif->speedproc = scc_tune_chipset;
-        hwif->tuneproc = scc_tuneproc;
+        hwif->set_pio_mode = scc_set_pio_mode;
         hwif->ide_dma_check = scc_config_drive_for_dma;
         hwif->ide_dma_test_irq = scc_dma_test_irq;
         hwif->udma_filter = scc_udma_filter;
diff --git a/drivers/ide/pci/serverworks.c b/drivers/ide/pci/serverworks.c
index 9fead2e7d4c8..0351cf210427 100644
--- a/drivers/ide/pci/serverworks.c
+++ b/drivers/ide/pci/serverworks.c
@@ -145,7 +145,7 @@ static void svwks_tune_pio(ide_drive_t *drive, const u8 pio)
         }
 }
 
-static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int svwks_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         static const u8 udma_modes[]            = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
         static const u8 dma_modes[]             = { 0x77, 0x21, 0x20 };
@@ -153,16 +153,10 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         u8 unit                 = (drive->select.b.unit & 0x01);
 
         u8 ultra_enable  = 0, ultra_timing = 0, dma_timing = 0;
 
-        if (speed >= XFER_PIO_0 && speed <= XFER_PIO_4) {
-                svwks_tune_pio(drive, speed - XFER_PIO_0);
-                return ide_config_drive_speed(drive, speed);
-        }
-
         /* If we are about to put a disk into UDMA mode we screwed up.
            Our code assumes we never _ever_ do this on an OSB4 */
            
@@ -203,9 +197,8 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         return (ide_config_drive_speed(drive, speed));
 }
 
-static void svwks_tune_drive (ide_drive_t *drive, u8 pio)
+static void svwks_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         svwks_tune_pio(drive, pio);
         (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -218,7 +211,7 @@ static int svwks_config_drive_xfer_rate (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                svwks_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -390,7 +383,7 @@ static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
         if (!hwif->irq)
                 hwif->irq = hwif->channel ? 15 : 14;
 
-        hwif->tuneproc = &svwks_tune_drive;
+        hwif->set_pio_mode = &svwks_set_pio_mode;
         hwif->speedproc = &svwks_tune_chipset;
         hwif->udma_filter = &svwks_udma_filter;
 
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index 57145767c3df..c292e1de1d56 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -34,6 +34,8 @@
 
 #include <linux/ide.h>
 
+#define DRV_NAME "SGIIOC4"
+
 /* IOC4 Specific Definitions */
 #define IOC4_CMD_OFFSET         0x100
 #define IOC4_CTRL_OFFSET        0x120
@@ -289,15 +291,26 @@ static void sgiioc4_dma_off_quietly(ide_drive_t *drive)
         drive->hwif->dma_host_off(drive);
 }
 
+static int sgiioc4_speedproc(ide_drive_t *drive, const u8 speed)
+{
+        if (speed != XFER_MW_DMA_2)
+                return 1;
+
+        return ide_config_drive_speed(drive, speed);
+}
+
 static int sgiioc4_ide_dma_check(ide_drive_t *drive)
 {
-        /* FIXME: check for available DMA modes */
-        if (ide_config_drive_speed(drive, XFER_MW_DMA_2) != 0) {
-                printk(KERN_WARNING "%s: couldn't set MWDMA2 mode, "
-                                    "using PIO instead\n", drive->name);
-                return -1;
-        } else
+        if (ide_tune_dma(drive))
                 return 0;
+
+        /*
+         * ->set_pio_mode is not implemented currently
+         * so this is just for the completness
+         */
+        ide_set_max_pio(drive);
+
+        return -1;
 }
 
 /* returns 1 if dma irq issued, 0 otherwise */
@@ -353,7 +366,7 @@ sgiioc4_INB(unsigned long port)
 }
 
 /* Creates a dma map for the scatter-gather list entries */
-static void __devinit
+static int __devinit
 ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
 {
         void __iomem *virt_dma_base;
@@ -369,7 +382,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
                        "ALREADY in use\n",
                        __FUNCTION__, hwif->name, (void *) dma_base,
                        (void *) dma_base + num_ports - 1);
-                goto dma_alloc_failure;
+                return -1;
         }
 
         virt_dma_base = ioremap(dma_base, num_ports);
@@ -395,7 +408,7 @@ ide_dma_sgiioc4(ide_hwif_t * hwif, unsigned long dma_base)
 
         if (pad) {
                 ide_set_hwifdata(hwif, pad);
-                return;
+                return 0;
         }
 
         pci_free_consistent(hwif->pci_dev,
@@ -413,10 +426,7 @@ dma_pci_alloc_failure:
 dma_remap_failure:
         release_mem_region(dma_base, num_ports);
 
-dma_alloc_failure:
-        /* Disable DMA because we couldnot allocate any DMA maps */
-        hwif->autodma = 0;
-        hwif->atapi_dma = 0;
+        return -1;
 }
 
 /* Initializes the IOC4 DMA Engine */
@@ -581,14 +591,11 @@ static void __devinit
 ide_init_sgiioc4(ide_hwif_t * hwif)
 {
         hwif->mmio = 1;
-        hwif->autodma = 1;
         hwif->atapi_dma = 1;
-        hwif->ultra_mask = 0x0; /* Disable Ultra DMA */
-        hwif->mwdma_mask = 0x2; /* Multimode-2 DMA  */
-        hwif->swdma_mask = 0x2;
+        hwif->mwdma_mask = 0x04;
         hwif->pio_mask = 0x00;
-        hwif->tuneproc = NULL;  /* Sets timing for PIO mode */
-        hwif->speedproc = NULL; /* Sets timing for DMA &/or PIO modes */
+        hwif->set_pio_mode = NULL; /* Sets timing for PIO mode */
+        hwif->speedproc = &sgiioc4_speedproc;
         hwif->selectproc = NULL;/* Use the default routine to select drive */
         hwif->reset_poll = NULL;/* No HBA specific reset_poll needed */
         hwif->pre_reset = NULL; /* No HBA specific pre_set needed */
@@ -615,7 +622,7 @@ ide_init_sgiioc4(ide_hwif_t * hwif)
 }
 
 static int __devinit
-sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
+sgiioc4_ide_setup_pci_device(struct pci_dev *dev)
 {
         unsigned long cmd_base, dma_base, irqport;
         unsigned long bar0, cmd_phys_base, ctl;
@@ -632,7 +639,8 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
                         break;
         }
         if (h == MAX_HWIFS) {
-                printk(KERN_ERR "%s: too many IDE interfaces, no room in table\n", d->name);
+                printk(KERN_ERR "%s: too many IDE interfaces, no room in table\n",
+                                DRV_NAME);
                 return -ENOMEM;
         }
 
@@ -641,7 +649,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
         virt_base = ioremap(bar0, pci_resource_len(dev, 0));
         if (virt_base == NULL) {
                 printk(KERN_ERR "%s: Unable to remap BAR 0 address: 0x%lx\n",
-                        d->name, bar0);
+                                DRV_NAME, bar0);
                 return -ENOMEM;
         }
         cmd_base = (unsigned long) virt_base + IOC4_CMD_OFFSET;
@@ -672,7 +680,6 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
         hwif->chipset = ide_pci;
         hwif->pci_dev = dev;
         hwif->channel = 0;      /* Single Channel chip */
-        hwif->cds = (struct ide_pci_device_s *) d;
         hwif->gendev.parent = &dev->dev;/* setup proper ancestral information */
 
         /* The IOC4 uses MMIO rather than Port IO. */
@@ -683,11 +690,14 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
 
         ide_init_sgiioc4(hwif);
 
-        if (dma_base)
-                ide_dma_sgiioc4(hwif, dma_base);
-        else
+        hwif->autodma = 0;
+
+        if (dma_base && ide_dma_sgiioc4(hwif, dma_base) == 0) {
+                hwif->autodma = 1;
+                hwif->drives[1].autodma = hwif->drives[0].autodma = 1;
+        } else
                 printk(KERN_INFO "%s: %s Bus-Master DMA disabled\n",
-                       hwif->name, d->name);
+                                 hwif->name, DRV_NAME);
 
         if (probe_hwif_init(hwif))
                 return -EIO;
@@ -699,7 +709,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
 }
 
 static unsigned int __devinit
-pci_init_sgiioc4(struct pci_dev *dev, ide_pci_device_t * d)
+pci_init_sgiioc4(struct pci_dev *dev)
 {
         unsigned int class_rev;
         int ret;
@@ -707,30 +717,20 @@ pci_init_sgiioc4(struct pci_dev *dev, ide_pci_device_t * d)
         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
         class_rev &= 0xff;
         printk(KERN_INFO "%s: IDE controller at PCI slot %s, revision %d\n",
-                        d->name, pci_name(dev), class_rev);
+                         DRV_NAME, pci_name(dev), class_rev);
         if (class_rev < IOC4_SUPPORTED_FIRMWARE_REV) {
                 printk(KERN_ERR "Skipping %s IDE controller in slot %s: "
-                        "firmware is obsolete - please upgrade to revision"
-                        "46 or higher\n", d->name, pci_name(dev));
+                                "firmware is obsolete - please upgrade to "
+                                "revision46 or higher\n",
+                                DRV_NAME, pci_name(dev));
                 ret = -EAGAIN;
                 goto out;
         }
-        ret = sgiioc4_ide_setup_pci_device(dev, d);
+        ret = sgiioc4_ide_setup_pci_device(dev);
 out:
         return ret;
 }
 
-static ide_pci_device_t sgiioc4_chipset __devinitdata = {
-         /* Channel 0 */
-         .name = "SGIIOC4",
-         .init_hwif = ide_init_sgiioc4,
-         .init_dma = ide_dma_sgiioc4,
-         .autodma = AUTODMA,
-         /* SGI IOC4 doesn't have enablebits. */
-         .bootable = ON_BOARD,
-         .host_flags = IDE_HFLAG_SINGLE,
-};
-
 int
 ioc4_ide_attach_one(struct ioc4_driver_data *idd)
 {
@@ -740,7 +740,7 @@ ioc4_ide_attach_one(struct ioc4_driver_data *idd)
         if (idd->idd_variant == IOC4_VARIANT_PCI_RT)
                 return 0;
 
-        return pci_init_sgiioc4(idd->idd_pdev, &sgiioc4_chipset);
+        return pci_init_sgiioc4(idd->idd_pdev);
 }
 
 static struct ioc4_submodule ioc4_ide_submodule = {
diff --git a/drivers/ide/pci/siimage.c b/drivers/ide/pci/siimage.c
index 50f6d172ef77..5d1e5e52a044 100644
--- a/drivers/ide/pci/siimage.c
+++ b/drivers/ide/pci/siimage.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/siimage.c              Version 1.15    Jun 29 2007
+ * linux/drivers/ide/pci/siimage.c              Version 1.16    Jul 13 2007
  *
  * Copyright (C) 2001-2002      Andre Hedrick <andre@linux-ide.org>
  * Copyright (C) 2003           Red Hat <alan@redhat.com>
@@ -185,7 +185,12 @@ static void sil_tune_pio(ide_drive_t *drive, u8 pio)
         u16 speedp              = 0;
         unsigned long addr      = siimage_seldev(drive, 0x04);
         unsigned long tfaddr    = siimage_selreg(hwif, 0x02);
+        unsigned long base      = (unsigned long)hwif->hwif_data;
         u8 tf_pio               = pio;
+        u8 addr_mask            = hwif->channel ? (hwif->mmio ? 0xF4 : 0x84)
+                                                : (hwif->mmio ? 0xB4 : 0x80);
+        u8 mode                 = 0;
+        u8 unit                 = drive->select.b.unit;
 
         /* trim *taskfile* PIO to the slowest of the master/slave */
         if (pair->present) {
@@ -207,6 +212,11 @@ static void sil_tune_pio(ide_drive_t *drive, u8 pio)
                         hwif->OUTW(hwif->INW(tfaddr-2)|0x200, tfaddr-2);
                 else
                         hwif->OUTW(hwif->INW(tfaddr-2)&~0x200, tfaddr-2);
+
+                mode = hwif->INB(base + addr_mask);
+                mode &= ~(unit ? 0x30 : 0x03);
+                mode |= (unit ? 0x10 : 0x01);
+                hwif->OUTB(mode, base + addr_mask);
         } else {
                 pci_write_config_word(hwif->pci_dev, addr, speedp);
                 pci_write_config_word(hwif->pci_dev, tfaddr, speedt);
@@ -216,12 +226,16 @@ static void sil_tune_pio(ide_drive_t *drive, u8 pio)
                 if (pio > 2)
                         speedp |= 0x200;
                 pci_write_config_word(hwif->pci_dev, tfaddr-2, speedp);
+
+                pci_read_config_byte(hwif->pci_dev, addr_mask, &mode);
+                mode &= ~(unit ? 0x30 : 0x03);
+                mode |= (unit ? 0x10 : 0x01);
+                pci_write_config_byte(hwif->pci_dev, addr_mask, mode);
         }
 }
 
-static void sil_tuneproc(ide_drive_t *drive, u8 pio)
+static void sil_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         sil_tune_pio(drive, pio);
         (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -229,14 +243,12 @@ static void sil_tuneproc(ide_drive_t *drive, u8 pio)
 /**
  *      siimage_tune_chipset    -       set controller timings
  *      @drive: Drive to set up
- *      @xferspeed: speed we want to achieve
+ *      @speed: speed we want to achieve
  *
- *      Tune the SII chipset for the desired mode. If we can't achieve
- *      the desired mode then tune for a lower one, but ultimately
- *      make the thing work.
+ *      Tune the SII chipset for the desired mode.
  */
- 
-static int siimage_tune_chipset (ide_drive_t *drive, byte xferspeed)
+
+static int siimage_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         u8 ultra6[]             = { 0x0F, 0x0B, 0x07, 0x05, 0x03, 0x02, 0x01 };
         u8 ultra5[]             = { 0x0C, 0x07, 0x05, 0x04, 0x02, 0x01 };
@@ -245,7 +257,6 @@ static int siimage_tune_chipset (ide_drive_t *drive, byte xferspeed)
         ide_hwif_t *hwif        = HWIF(drive);
         u16 ultra = 0, multi    = 0;
         u8 mode = 0, unit       = drive->select.b.unit;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         unsigned long base      = (unsigned long)hwif->hwif_data;
         u8 scsc = 0, addr_mask  = ((hwif->channel) ?
                                     ((hwif->mmio) ? 0xF4 : 0x84) :
@@ -273,14 +284,6 @@ static int siimage_tune_chipset (ide_drive_t *drive, byte xferspeed)
         scsc = is_sata(hwif) ? 1 : scsc;
 
         switch(speed) {
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:
-                        sil_tune_pio(drive, speed - XFER_PIO_0);
-                        mode |= ((unit) ? 0x10 : 0x01);
-                        break;
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_MW_DMA_0:
@@ -331,7 +334,7 @@ static int siimage_config_drive_for_dma (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                sil_tuneproc(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -902,7 +905,7 @@ static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
         
         hwif->resetproc = &siimage_reset;
         hwif->speedproc = &siimage_tune_chipset;
-        hwif->tuneproc  = &sil_tuneproc;
+        hwif->set_pio_mode = &sil_set_pio_mode;
         hwif->reset_poll = &siimage_reset_poll;
         hwif->pre_reset = &siimage_pre_reset;
         hwif->udma_filter = &sil_udma_filter;
diff --git a/drivers/ide/pci/sis5513.c b/drivers/ide/pci/sis5513.c
index 26f24802d3e8..3e18899de631 100644
--- a/drivers/ide/pci/sis5513.c
+++ b/drivers/ide/pci/sis5513.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/sis5513.c      Version 0.25    Jun 10, 2007
+ * linux/drivers/ide/pci/sis5513.c      Version 0.27    Jul 14, 2007
  *
  * Copyright (C) 1999-2000      Andre Hedrick <andre@linux-ide.org>
  * Copyright (C) 2002           Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer
@@ -519,27 +519,18 @@ static void config_art_rwp_pio (ide_drive_t *drive, u8 pio)
         }
 }
 
-static int sis5513_tune_drive(ide_drive_t *drive, u8 pio)
+static void sis_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         config_art_rwp_pio(drive, pio);
-        return ide_config_drive_speed(drive, XFER_PIO_0 + pio);
+        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
-static void sis5513_tuneproc(ide_drive_t *drive, u8 pio)
-{
-        (void)sis5513_tune_drive(drive, pio);
-}
-
-static int sis5513_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int sis5513_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
-
-        u8 drive_pci, reg, speed;
         u32 regdw;
-
-        speed = ide_rate_filter(drive, xferspeed);
+        u8 drive_pci, reg;
 
         /* See config_art_rwp_pio for drive pci config registers */
         drive_pci = 0x40;
@@ -582,9 +573,6 @@ static int sis5513_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                                         regdw |= (unsigned long)cycle_time_value[ATA_133][speed-XFER_UDMA_0] << 4;
                                         regdw |= (unsigned long)cvs_time_value[ATA_133][speed-XFER_UDMA_0] << 8;
                                 } else {
-                                /* if ATA133 disable, we should not set speed above UDMA5 */
-                                        if (speed > XFER_UDMA_5)
-                                                speed = XFER_UDMA_5;
                                         regdw |= (unsigned long)cycle_time_value[ATA_100][speed-XFER_UDMA_0] << 4;
                                         regdw |= (unsigned long)cvs_time_value[ATA_100][speed-XFER_UDMA_0] << 8;
                                 }
@@ -608,12 +596,6 @@ static int sis5513_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 case XFER_SW_DMA_1:
                 case XFER_SW_DMA_0:
                         break;
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:
-                        return sis5513_tune_drive(drive, speed - XFER_PIO_0);
                 default:
                         BUG();
                         break;
@@ -627,7 +609,7 @@ static int sis5513_config_xfer_rate(ide_drive_t *drive)
         /*
          * TODO: always set PIO mode and remove this
          */
-        sis5513_tuneproc(drive, 255);
+        ide_set_max_pio(drive);
 
         drive->init_speed = 0;
 
@@ -635,11 +617,25 @@ static int sis5513_config_xfer_rate(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                sis5513_tuneproc(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
 
+static u8 sis5513_ata133_udma_filter(ide_drive_t *drive)
+{
+        struct pci_dev *dev = drive->hwif->pci_dev;
+        int drive_pci;
+        u32 reg54 = 0, regdw = 0;
+
+        pci_read_config_dword(dev, 0x54, &reg54);
+        drive_pci = ((reg54 & 0x40000000) ? 0x70 : 0x40) + drive->dn * 4;
+        pci_read_config_dword(dev, drive_pci, &regdw);
+
+        /* if ATA133 disable, we should not set speed above UDMA5 */
+        return (regdw & 0x08) ? ATA_UDMA6 : ATA_UDMA5;
+}
+
 /* Chip detection and general config */
 static unsigned int __devinit init_chipset_sis5513 (struct pci_dev *dev, const char *name)
 {
@@ -844,9 +840,12 @@ static void __devinit init_hwif_sis5513 (ide_hwif_t *hwif)
         if (!hwif->irq)
                 hwif->irq = hwif->channel ? 15 : 14;
 
-        hwif->tuneproc = &sis5513_tuneproc;
+        hwif->set_pio_mode = &sis_set_pio_mode;
         hwif->speedproc = &sis5513_tune_chipset;
 
+        if (chipset_family >= ATA_133)
+                hwif->udma_filter = sis5513_ata133_udma_filter;
+
         if (!(hwif->dma_base)) {
                 hwif->drives[0].autotune = 1;
                 hwif->drives[1].autotune = 1;
diff --git a/drivers/ide/pci/sl82c105.c b/drivers/ide/pci/sl82c105.c
index 0947cab00595..f492318ba797 100644
--- a/drivers/ide/pci/sl82c105.c
+++ b/drivers/ide/pci/sl82c105.c
@@ -75,16 +75,12 @@ static unsigned int get_pio_timings(ide_drive_t *drive, u8 pio)
 /*
  * Configure the chipset for PIO mode.
  */
-static u8 sl82c105_tune_pio(ide_drive_t *drive, u8 pio)
+static void sl82c105_tune_pio(ide_drive_t *drive, const u8 pio)
 {
         struct pci_dev *dev     = HWIF(drive)->pci_dev;
         int reg                 = 0x44 + drive->dn * 4;
         u16 drv_ctrl;
 
-        DBG(("sl82c105_tune_pio(drive:%s, pio:%u)\n", drive->name, pio));
-
-        pio = ide_get_best_pio_mode(drive, pio, 5);
-
         drv_ctrl = get_pio_timings(drive, pio);
 
         /*
@@ -106,14 +102,12 @@ static u8 sl82c105_tune_pio(ide_drive_t *drive, u8 pio)
         printk(KERN_DEBUG "%s: selected %s (%dns) (%04X)\n", drive->name,
                           ide_xfer_verbose(pio + XFER_PIO_0),
                           ide_pio_cycle_time(drive, pio), drv_ctrl);
-
-        return pio;
 }
 
 /*
  * Configure the drive and chipset for a new transfer speed.
  */
-static int sl82c105_tune_chipset(ide_drive_t *drive, u8 speed)
+static int sl82c105_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         static u16 mwdma_timings[] = {0x0707, 0x0201, 0x0200};
         u16 drv_ctrl;
@@ -121,8 +115,6 @@ static int sl82c105_tune_chipset(ide_drive_t *drive, u8 speed)
         DBG(("sl82c105_tune_chipset(drive:%s, speed:%s)\n",
              drive->name, ide_xfer_verbose(speed)));
 
-        speed = ide_rate_filter(drive, speed);
-
         switch (speed) {
         case XFER_MW_DMA_2:
         case XFER_MW_DMA_1:
@@ -147,14 +139,6 @@ static int sl82c105_tune_chipset(ide_drive_t *drive, u8 speed)
                         pci_write_config_word(dev, reg, drv_ctrl);
                 }
                 break;
-        case XFER_PIO_5:
-        case XFER_PIO_4:
-        case XFER_PIO_3:
-        case XFER_PIO_2:
-        case XFER_PIO_1:
-        case XFER_PIO_0:
-                (void) sl82c105_tune_pio(drive, speed - XFER_PIO_0);
-                break;
         default:
                 return -1;
         }
@@ -327,11 +311,10 @@ static void sl82c105_resetproc(ide_drive_t *drive)
  * We only deal with PIO mode here - DMA mode 'using_dma' is not
  * initialised at the point that this function is called.
  */
-static void sl82c105_tune_drive(ide_drive_t *drive, u8 pio)
+static void sl82c105_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        DBG(("sl82c105_tune_drive(drive:%s, pio:%u)\n", drive->name, pio));
+        sl82c105_tune_pio(drive, pio);
 
-        pio = sl82c105_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
@@ -399,7 +382,7 @@ static void __devinit init_hwif_sl82c105(ide_hwif_t *hwif)
 
         DBG(("init_hwif_sl82c105(hwif: ide%d)\n", hwif->index));
 
-        hwif->tuneproc          = &sl82c105_tune_drive;
+        hwif->set_pio_mode      = &sl82c105_set_pio_mode;
         hwif->speedproc         = &sl82c105_tune_chipset;
         hwif->selectproc        = &sl82c105_selectproc;
         hwif->resetproc         = &sl82c105_resetproc;
diff --git a/drivers/ide/pci/slc90e66.c b/drivers/ide/pci/slc90e66.c
index 628b0664f576..ae8e91324577 100644
--- a/drivers/ide/pci/slc90e66.c
+++ b/drivers/ide/pci/slc90e66.c
@@ -1,5 +1,5 @@
 /*
- *  linux/drivers/ide/pci/slc90e66.c    Version 0.15    Jul 6, 2007
+ *  linux/drivers/ide/pci/slc90e66.c    Version 0.16    Jul 14, 2007
  *
  *  Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
  *  Copyright (C) 2006-2007 MontaVista Software, Inc. <source@mvista.com>
@@ -95,19 +95,17 @@ static void slc90e66_tune_pio (ide_drive_t *drive, u8 pio)
         spin_unlock_irqrestore(&ide_lock, flags);
 }
 
-static void slc90e66_tune_drive (ide_drive_t *drive, u8 pio)
+static void slc90e66_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         slc90e66_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
-static int slc90e66_tune_chipset (ide_drive_t *drive, u8 xferspeed)
+static int slc90e66_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u8 maslave              = hwif->channel ? 0x42 : 0x40;
-        u8 speed                = ide_rate_filter(drive, xferspeed);
         int sitre = 0, a_speed  = 7 << (drive->dn * 4);
         int u_speed = 0, u_flag = 1 << drive->dn;
         u16                     reg4042, reg44, reg48, reg4a;
@@ -127,11 +125,6 @@ static int slc90e66_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_SW_DMA_2:     break;
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:        break;
                 default:                return -1;
         }
 
@@ -151,10 +144,7 @@ static int slc90e66_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                         pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
         }
 
-        if (speed > XFER_PIO_4)
-                slc90e66_tune_pio(drive, slc90e66_dma_2_pio(speed));
-        else
-                slc90e66_tune_pio(drive, speed - XFER_PIO_0);
+        slc90e66_tune_pio(drive, slc90e66_dma_2_pio(speed));
 
         return ide_config_drive_speed(drive, speed);
 }
@@ -167,7 +157,7 @@ static int slc90e66_config_drive_xfer_rate (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                slc90e66_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -183,7 +173,7 @@ static void __devinit init_hwif_slc90e66 (ide_hwif_t *hwif)
                 hwif->irq = hwif->channel ? 15 : 14;
 
         hwif->speedproc = &slc90e66_tune_chipset;
-        hwif->tuneproc  = &slc90e66_tune_drive;
+        hwif->set_pio_mode = &slc90e66_set_pio_mode;
 
         pci_read_config_byte(hwif->pci_dev, 0x47, &reg47);
 
diff --git a/drivers/ide/pci/tc86c001.c b/drivers/ide/pci/tc86c001.c
index ec79bacc30c2..e23b9cfb6eb4 100644
--- a/drivers/ide/pci/tc86c001.c
+++ b/drivers/ide/pci/tc86c001.c
@@ -13,14 +13,12 @@
 #include <linux/pci.h>
 #include <linux/ide.h>
 
-static int tc86c001_tune_chipset(ide_drive_t *drive, u8 speed)
+static int tc86c001_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         unsigned long scr_port  = hwif->config_data + (drive->dn ? 0x02 : 0x00);
         u16 mode, scr           = hwif->INW(scr_port);
 
-        speed = ide_rate_filter(drive, speed);
-
         switch (speed) {
                 case XFER_UDMA_4:       mode = 0x00c0; break;
                 case XFER_UDMA_3:       mode = 0x00b0; break;
@@ -45,9 +43,8 @@ static int tc86c001_tune_chipset(ide_drive_t *drive, u8 speed)
         return ide_config_drive_speed(drive, speed);
 }
 
-static void tc86c001_tune_drive(ide_drive_t *drive, u8 pio)
+static void tc86c001_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) tc86c001_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
@@ -173,7 +170,7 @@ static int tc86c001_config_drive_xfer_rate(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                tc86c001_tune_drive(drive, 255);
+                ide_set_max_pio(drive);
 
         return -1;
 }
@@ -195,7 +192,7 @@ static void __devinit init_hwif_tc86c001(ide_hwif_t *hwif)
         /* Store the system control register base for convenience... */
         hwif->config_data = sc_base;
 
-        hwif->tuneproc  = &tc86c001_tune_drive;
+        hwif->set_pio_mode = &tc86c001_set_pio_mode;
         hwif->speedproc = &tc86c001_tune_chipset;
         hwif->busproc   = &tc86c001_busproc;
 
diff --git a/drivers/ide/pci/triflex.c b/drivers/ide/pci/triflex.c
index 098692a6d615..c3ff066eea5a 100644
--- a/drivers/ide/pci/triflex.c
+++ b/drivers/ide/pci/triflex.c
@@ -40,7 +40,7 @@
 #include <linux/ide.h>
 #include <linux/init.h>
 
-static int triflex_tune_chipset(ide_drive_t *drive, u8 xferspeed)
+static int triflex_tune_chipset(ide_drive_t *drive, const u8 speed)
 {
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *dev = hwif->pci_dev;
@@ -48,7 +48,6 @@ static int triflex_tune_chipset(ide_drive_t *drive, u8 xferspeed)
         u16 timing = 0;
         u32 triflex_timings = 0;
         u8 unit = (drive->select.b.unit & 0x01);
-        u8 speed = ide_rate_filter(drive, xferspeed);
         
         pci_read_config_dword(dev, channel_offset, &triflex_timings);
         
@@ -94,10 +93,9 @@ static int triflex_tune_chipset(ide_drive_t *drive, u8 xferspeed)
         return (ide_config_drive_speed(drive, speed));
 }
 
-static void triflex_tune_drive(ide_drive_t *drive, u8 pio)
+static void triflex_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        int use_pio = ide_get_best_pio_mode(drive, pio, 4);
-        (void) triflex_tune_chipset(drive, (XFER_PIO_0 + use_pio));
+        (void)triflex_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
 static int triflex_config_drive_xfer_rate(ide_drive_t *drive)
@@ -105,14 +103,14 @@ static int triflex_config_drive_xfer_rate(ide_drive_t *drive)
         if (ide_tune_dma(drive))
                 return 0;
 
-        triflex_tune_drive(drive, 255);
+        ide_set_max_pio(drive);
 
         return -1;
 }
 
 static void __devinit init_hwif_triflex(ide_hwif_t *hwif)
 {
-        hwif->tuneproc = &triflex_tune_drive;
+        hwif->set_pio_mode = &triflex_set_pio_mode;
         hwif->speedproc = &triflex_tune_chipset;
 
         if (hwif->dma_base == 0)
diff --git a/drivers/ide/pci/via82cxxx.c b/drivers/ide/pci/via82cxxx.c
index c10203a32159..378feb491ec4 100644
--- a/drivers/ide/pci/via82cxxx.c
+++ b/drivers/ide/pci/via82cxxx.c
@@ -1,6 +1,6 @@
 /*
  *
- * Version 3.47
+ * Version 3.48
  *
  * VIA IDE driver for Linux. Supported southbridges:
  *
@@ -158,7 +158,7 @@ static void via_set_speed(ide_hwif_t *hwif, u8 dn, struct ide_timing *timing)
  *      by upper layers.
  */
 
-static int via_set_drive(ide_drive_t *drive, u8 speed)
+static int via_set_drive(ide_drive_t *drive, const u8 speed)
 {
         ide_drive_t *peer = HWIF(drive)->drives + (~drive->dn & 1);
         struct via82cxxx_dev *vdev = pci_get_drvdata(drive->hwif->pci_dev);
@@ -195,19 +195,16 @@ static int via_set_drive(ide_drive_t *drive, u8 speed)
 }
 
 /**
- *      via82cxxx_tune_drive    -       PIO setup
- *      @drive: drive to set up
- *      @pio: mode to use (255 for 'best possible')
+ *      via_set_pio_mode        -       PIO setup
+ *      @drive: drive
+ *      @pio: PIO mode number
  *
  *      A callback from the upper layers for PIO-only tuning.
  */
 
-static void via82cxxx_tune_drive(ide_drive_t *drive, u8 pio)
+static void via_set_pio_mode(ide_drive_t *drive, const u8 pio)
 {
-        if (pio == 255)
-                pio = ide_get_best_pio_mode(drive, 255, 5);
-
-        via_set_drive(drive, XFER_PIO_0 + min_t(u8, pio, 5));
+        via_set_drive(drive, XFER_PIO_0 + pio);
 }
 
 /**
@@ -220,18 +217,11 @@ static void via82cxxx_tune_drive(ide_drive_t *drive, u8 pio)
  
 static int via82cxxx_ide_dma_check (ide_drive_t *drive)
 {
-        u8 speed = ide_max_dma_mode(drive);
-
-        if (speed == 0) {
-                via82cxxx_tune_drive(drive, 255);
-                return -1;
-        }
-
-        via_set_drive(drive, speed);
-
-        if (drive->autodma)
+        if (ide_tune_dma(drive))
                 return 0;
 
+        ide_set_max_pio(drive);
+
         return -1;
 }
 
@@ -465,7 +455,7 @@ static void __devinit init_hwif_via82cxxx(ide_hwif_t *hwif)
 
         hwif->autodma = 0;
 
-        hwif->tuneproc = &via82cxxx_tune_drive;
+        hwif->set_pio_mode = &via_set_pio_mode;
         hwif->speedproc = &via_set_drive;