*     @drive: drive to consider
  *     @mode_wanted: preferred mode
  *     @max_mode: highest allowed mode
- *     @d: PIO data
  *
  *     This routine returns the recommended PIO settings for a given drive,
  *     based on the drive->id information and the ide_pio_blacklist[].
  *     This is used by most chipset support modules when "auto-tuning".
  */
 
-u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_pio_data_t *d)
+u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
 {
        int pio_mode;
        struct hd_driveid* id = drive->id;
        if (pio_mode > max_mode)
                pio_mode = max_mode;
 
-       if (d)
-               d->pio_mode = pio_mode;
-
        return pio_mode;
 }
 
 
        unsigned long flags;
        int bus_speed = system_bus_clock();
 
-       pio = ide_get_best_pio_mode(drive, pio, ALI_MAX_PIO, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, ALI_MAX_PIO);
 
        /* calculate timing, according to PIO mode */
        time1 = ide_pio_cycle_time(drive, pio);
 
 {
        unsigned long flags;
 
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
 
        if (pio >= 3) {
                spin_lock_irqsave(&ide_lock, flags);
 
         if (pio) {
                unsigned int cycle_time;
 
-               pio = ide_get_best_pio_mode(drive, pio, 5, NULL);
+               pio = ide_get_best_pio_mode(drive, pio, 5);
                cycle_time = ide_pio_cycle_time(drive, pio);
 
                /*
 
        int recovery_time = 415; /* worst case values from the dos driver */
 
        if (drive->id && !qd_find_disk_type(drive, &active_time, &recovery_time)) {
-               pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+               pio = ide_get_best_pio_mode(drive, pio, 4);
                cycle_time = ide_pio_cycle_time(drive, pio);
 
                switch (pio) {
 
        unsigned long flags;
        ide_hwgroup_t *hwgroup = ide_hwifs[HWIF(drive)->index^1].hwgroup;
 
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        printk("%s: setting umc8672 to PIO mode%d (speed %d)\n",
                drive->name, pio, pio_to_umc[pio]);
        spin_lock_irqsave(&ide_lock, flags);
 
        u8 speed;
 
        /* get the best pio mode for the drive */
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
 
        printk(KERN_INFO "%s: setting Au1XXX IDE to PIO mode%d\n",
               drive->name, pio);
 
 
 static void aec62xx_tune_drive (ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        (void) HWIF(drive)->speedproc(drive, pio + XFER_PIO_0);
 }
 
 
  
 static u8 ali15x3_tune_pio (ide_drive_t *drive, u8 pio)
 {
-       ide_pio_data_t d;
        ide_hwif_t *hwif = HWIF(drive);
        struct pci_dev *dev = hwif->pci_dev;
        int s_time, a_time, c_time;
        u8 cd_dma_fifo = 0;
        int unit = drive->select.b.unit & 1;
 
-       pio = ide_get_best_pio_mode(drive, pio, 5, &d);
+       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)
 
 
 static void atiixp_tuneproc(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        atiixp_tune_pio(drive, pio);
        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
                        return;
        }
 
-       mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 5, NULL);
+       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);
 
 
        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, NULL);
+       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",
 
        
 static void cs5520_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        cs5520_tune_chipset(drive, (XFER_PIO_0 + pio));
 }
 
 
 
 static void cs5530_tuneproc (ide_drive_t *drive, u8 pio)       /* pio=255 means "autotune" */
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
 
        if (cs5530_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
                cs5530_tunepio(drive, pio);
 
 
                pioa = speed - XFER_PIO_0;
                piob = ide_get_best_pio_mode(&(drive->hwif->drives[!unit]),
-                                               255, 4, NULL);
+                                               255, 4);
                cmd = pioa < piob ? pioa : piob;
 
                /* Write the speed of the current drive */
        /* cs5535 max pio is pio 4, best_pio will check the blacklist.
        i think we don't need to rate_filter the incoming xferspeed
        since we know we're only going to choose pio */
-       xferspeed = ide_get_best_pio_mode(drive, xferspeed, 4, NULL);
+       xferspeed = ide_get_best_pio_mode(drive, xferspeed, 4);
        ide_config_drive_speed(drive, modes[xferspeed]);
        cs5535_set_speed(drive, xferspeed);
 }
                return 0;
 
        if (ide_use_fast_pio(drive)) {
-               speed = ide_get_best_pio_mode(drive, 255, 4, NULL);
+               speed = ide_get_best_pio_mode(drive, 255, 4);
                cs5535_set_drive(drive, speed);
        }
 
 
 #endif /* CY82C693_DEBUG_LOGS */
 
        /* first let's calc the pio modes */
-       pio = ide_get_best_pio_mode(drive, pio, CY82C693_MAX_PIO, NULL);
+       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);
 
 
 static void hpt34x_tune_drive (ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 5, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 5);
        (void) hpt34x_tune_chipset(drive, (XFER_PIO_0 + pio));
 }
 
 
 
 static void hpt3xx_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        (void) hpt3xx_tune_chipset (drive, XFER_PIO_0 + pio);
 }
 
 
                                        { 2, 1 },
                                        { 2, 3 }, };
 
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
 
        spin_lock_irqsave(&tune_lock, flags);
        pci_read_config_word(dev, master_port, &master_data);
        if (ide_tune_dma(drive))
                return 0;
 
-       pio = ide_get_best_pio_mode(drive, 255, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, 255, 4);
        it8213_tune_chipset(drive, XFER_PIO_0 + pio);
 
        return -1;
 
         * on the cable.
         */
        if (pair) {
-               u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4, NULL);
+               u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4);
                /* trim PIO to the slowest of the master/slave */
                if (pair_pio < set_pio)
                        set_pio = pair_pio;
 
 static void it821x_tuneproc(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        (void)it821x_tunepio(drive, pio);
 }
 
 
 
 static void config_jmicron_chipset_for_pio (ide_drive_t *drive, byte set_speed)
 {
-       u8 speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5, NULL);
+       u8 speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5);
        if (set_speed)
                (void) ide_config_drive_speed(drive, speed);
 }
 
        int d;
        ide_hwif_t *hwif = HWIF(drive);
 
-       drive->drive_data = ide_get_best_pio_mode(drive, pio, OPTI621_MAX_PIO, NULL);
+       drive->drive_data = ide_get_best_pio_mode(drive, pio, OPTI621_MAX_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, NULL);
+                               drive->drive_data = ide_get_best_pio_mode(drive, 255, OPTI621_MAX_PIO);
 #ifdef OPTI621_DEBUG
                        printk("%s: Selected PIO mode %d\n",
                                drive->name, drive->drive_data);
 
 
 static void pdcnew_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        (void)pdcnew_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
 
 
 static void pdc202xx_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        pdc202xx_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
 
  */
 static void piix_tune_drive (ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        piix_tune_pio(drive, pio);
        (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
                return;
        }
 
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       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)
 
        unsigned char speed = XFER_PIO_0;
        int offset;
 
-       mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 4, NULL);
+       mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 4);
        switch (mode_wanted) {
        case 4:
                speed = XFER_PIO_4;
 
 
 static void svwks_tune_drive (ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        svwks_tune_pio(drive, pio);
        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 
        /* trim *taskfile* PIO to the slowest of the master/slave */
        if (pair->present) {
-               u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4, NULL);
+               u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4);
 
                if (pair_pio < tf_pio)
                        tf_pio = pair_pio;
 
 static void sil_tuneproc(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        sil_tune_pio(drive, pio);
        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 
 static int sis5513_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       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);
 }
 
 
        DBG(("sl82c105_tune_pio(drive:%s, pio:%u)\n", drive->name, pio));
 
-       pio = ide_get_best_pio_mode(drive, pio, 5, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 5);
 
        drv_ctrl = get_pio_timings(drive, pio);
 
 
 
 static void slc90e66_tune_drive (ide_drive_t *drive, u8 pio)
 {
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       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 void tc86c001_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       pio =  ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        (void) tc86c001_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
 
 
 static void triflex_tune_drive(ide_drive_t *drive, u8 pio)
 {
-       int use_pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       int use_pio = ide_get_best_pio_mode(drive, pio, 4);
        (void) triflex_tune_chipset(drive, (XFER_PIO_0 + use_pio));
 }
 
 
 static void
 m8xx_ide_tuneproc(ide_drive_t *drive, u8 pio)
 {
-       ide_pio_data_t d;
 #if defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_DIRECT)
        volatile pcmconf8xx_t   *pcmp;
        ulong timing, mask, reg;
 #endif
 
-       pio = ide_get_best_pio_mode(drive, pio, 4, &d);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
 
 #if 1
        printk("%s[%d] %s: best PIO mode: %d\n",
 
        /* which drive is it ? */
        timings = &pmif->timings[drive->select.b.unit & 0x01];
 
-       pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+       pio = ide_get_best_pio_mode(drive, pio, 4);
        cycle_time = ide_pio_cycle_time(drive, pio);
 
        switch (pmif->kind) {
 
                                /* active + recovery (+ setup for some chips) */
 } ide_pio_timings_t;
 
-typedef struct ide_pio_data_s {
-       u8 pio_mode;
-} ide_pio_data_t;
-
 unsigned int ide_pio_cycle_time(ide_drive_t *, u8);
-extern u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_pio_data_t *d);
+u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
 extern const ide_pio_timings_t ide_pio_timings[6];