1 files changed, 132 insertions, 190 deletions

diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index 2cbadffe922e..5d6ba14e211d 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -1,6 +1,6 @@
 /*
  *  Copyright (C) 2000-2002     Andre Hedrick <andre@linux-ide.org>
- *  Copyright (C) 2003          Red Hat <alan@redhat.com>
+ *  Copyright (C) 2003          Red Hat
  *
  */
 
@@ -18,7 +18,6 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
-#include <linux/hdreg.h>
 #include <linux/ide.h>
 #include <linux/bitops.h>
 #include <linux/nmi.h>
@@ -182,7 +181,7 @@ void ide_tf_load(ide_drive_t *drive, ide_task_t *task)
                 tf_outb(tf->lbah, io_ports->lbah_addr);
 
         if (task->tf_flags & IDE_TFLAG_OUT_DEVICE)
-                tf_outb((tf->device & HIHI) | drive->select.all,
+                tf_outb((tf->device & HIHI) | drive->select,
                          io_ports->device_addr);
 }
 EXPORT_SYMBOL_GPL(ide_tf_load);
@@ -400,97 +399,14 @@ const struct ide_tp_ops default_tp_ops = {
         .output_data            = ide_output_data,
 };
 
-void ide_fix_driveid (struct hd_driveid *id)
+void ide_fix_driveid(u16 *id)
 {
 #ifndef __LITTLE_ENDIAN
 # ifdef __BIG_ENDIAN
         int i;
-        u16 *stringcast;
-
-        id->config         = __le16_to_cpu(id->config);
-        id->cyls           = __le16_to_cpu(id->cyls);
-        id->reserved2      = __le16_to_cpu(id->reserved2);
-        id->heads          = __le16_to_cpu(id->heads);
-        id->track_bytes    = __le16_to_cpu(id->track_bytes);
-        id->sector_bytes   = __le16_to_cpu(id->sector_bytes);
-        id->sectors        = __le16_to_cpu(id->sectors);
-        id->vendor0        = __le16_to_cpu(id->vendor0);
-        id->vendor1        = __le16_to_cpu(id->vendor1);
-        id->vendor2        = __le16_to_cpu(id->vendor2);
-        stringcast = (u16 *)&id->serial_no[0];
-        for (i = 0; i < (20/2); i++)
-                stringcast[i] = __le16_to_cpu(stringcast[i]);
-        id->buf_type       = __le16_to_cpu(id->buf_type);
-        id->buf_size       = __le16_to_cpu(id->buf_size);
-        id->ecc_bytes      = __le16_to_cpu(id->ecc_bytes);
-        stringcast = (u16 *)&id->fw_rev[0];
-        for (i = 0; i < (8/2); i++)
-                stringcast[i] = __le16_to_cpu(stringcast[i]);
-        stringcast = (u16 *)&id->model[0];
-        for (i = 0; i < (40/2); i++)
-                stringcast[i] = __le16_to_cpu(stringcast[i]);
-        id->dword_io       = __le16_to_cpu(id->dword_io);
-        id->reserved50     = __le16_to_cpu(id->reserved50);
-        id->field_valid    = __le16_to_cpu(id->field_valid);
-        id->cur_cyls       = __le16_to_cpu(id->cur_cyls);
-        id->cur_heads      = __le16_to_cpu(id->cur_heads);
-        id->cur_sectors    = __le16_to_cpu(id->cur_sectors);
-        id->cur_capacity0  = __le16_to_cpu(id->cur_capacity0);
-        id->cur_capacity1  = __le16_to_cpu(id->cur_capacity1);
-        id->lba_capacity   = __le32_to_cpu(id->lba_capacity);
-        id->dma_1word      = __le16_to_cpu(id->dma_1word);
-        id->dma_mword      = __le16_to_cpu(id->dma_mword);
-        id->eide_pio_modes = __le16_to_cpu(id->eide_pio_modes);
-        id->eide_dma_min   = __le16_to_cpu(id->eide_dma_min);
-        id->eide_dma_time  = __le16_to_cpu(id->eide_dma_time);
-        id->eide_pio       = __le16_to_cpu(id->eide_pio);
-        id->eide_pio_iordy = __le16_to_cpu(id->eide_pio_iordy);
-        for (i = 0; i < 2; ++i)
-                id->words69_70[i] = __le16_to_cpu(id->words69_70[i]);
-        for (i = 0; i < 4; ++i)
-                id->words71_74[i] = __le16_to_cpu(id->words71_74[i]);
-        id->queue_depth    = __le16_to_cpu(id->queue_depth);
-        for (i = 0; i < 4; ++i)
-                id->words76_79[i] = __le16_to_cpu(id->words76_79[i]);
-        id->major_rev_num  = __le16_to_cpu(id->major_rev_num);
-        id->minor_rev_num  = __le16_to_cpu(id->minor_rev_num);
-        id->command_set_1  = __le16_to_cpu(id->command_set_1);
-        id->command_set_2  = __le16_to_cpu(id->command_set_2);
-        id->cfsse          = __le16_to_cpu(id->cfsse);
-        id->cfs_enable_1   = __le16_to_cpu(id->cfs_enable_1);
-        id->cfs_enable_2   = __le16_to_cpu(id->cfs_enable_2);
-        id->csf_default    = __le16_to_cpu(id->csf_default);
-        id->dma_ultra      = __le16_to_cpu(id->dma_ultra);
-        id->trseuc         = __le16_to_cpu(id->trseuc);
-        id->trsEuc         = __le16_to_cpu(id->trsEuc);
-        id->CurAPMvalues   = __le16_to_cpu(id->CurAPMvalues);
-        id->mprc           = __le16_to_cpu(id->mprc);
-        id->hw_config      = __le16_to_cpu(id->hw_config);
-        id->acoustic       = __le16_to_cpu(id->acoustic);
-        id->msrqs          = __le16_to_cpu(id->msrqs);
-        id->sxfert         = __le16_to_cpu(id->sxfert);
-        id->sal            = __le16_to_cpu(id->sal);
-        id->spg            = __le32_to_cpu(id->spg);
-        id->lba_capacity_2 = __le64_to_cpu(id->lba_capacity_2);
-        for (i = 0; i < 22; i++)
-                id->words104_125[i]   = __le16_to_cpu(id->words104_125[i]);
-        id->last_lun       = __le16_to_cpu(id->last_lun);
-        id->word127        = __le16_to_cpu(id->word127);
-        id->dlf            = __le16_to_cpu(id->dlf);
-        id->csfo           = __le16_to_cpu(id->csfo);
-        for (i = 0; i < 26; i++)
-                id->words130_155[i] = __le16_to_cpu(id->words130_155[i]);
-        id->word156        = __le16_to_cpu(id->word156);
-        for (i = 0; i < 3; i++)
-                id->words157_159[i] = __le16_to_cpu(id->words157_159[i]);
-        id->cfa_power      = __le16_to_cpu(id->cfa_power);
-        for (i = 0; i < 15; i++)
-                id->words161_175[i] = __le16_to_cpu(id->words161_175[i]);
-        for (i = 0; i < 30; i++)
-                id->words176_205[i] = __le16_to_cpu(id->words176_205[i]);
-        for (i = 0; i < 49; i++)
-                id->words206_254[i] = __le16_to_cpu(id->words206_254[i]);
-        id->integrity_word  = __le16_to_cpu(id->integrity_word);
+
+        for (i = 0; i < 256; i++)
+                id[i] = __le16_to_cpu(id[i]);
 # else
 #  error "Please fix <asm/byteorder.h>"
 # endif
@@ -501,19 +417,21 @@ void ide_fix_driveid (struct hd_driveid *id)
  * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
  * removing leading/trailing blanks and compressing internal blanks.
  * It is primarily used to tidy up the model name/number fields as
- * returned by the WIN_[P]IDENTIFY commands.
+ * returned by the ATA_CMD_ID_ATA[PI] commands.
  */
 
 void ide_fixstring (u8 *s, const int bytecount, const int byteswap)
 {
-        u8 *p = s, *end = &s[bytecount & ~1]; /* bytecount must be even */
+        u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
 
         if (byteswap) {
                 /* convert from big-endian to host byte order */
-                for (p = end ; p != s;)
-                        be16_to_cpus((u16 *)(p -= 2));
+                for (p = s ; p != end ; p += 2)
+                        be16_to_cpus((u16 *) p);
         }
+
         /* strip leading blanks */
+        p = s;
         while (s != end && *s == ' ')
                 ++s;
         /* compress internal blanks and strip trailing blanks */
@@ -556,7 +474,7 @@ int drive_is_ready (ide_drive_t *drive)
                 /* Note: this may clear a pending IRQ!! */
                 stat = hwif->tp_ops->read_status(hwif);
 
-        if (stat & BUSY_STAT)
+        if (stat & ATA_BUSY)
                 /* drive busy:  definitely not interrupting */
                 return 0;
 
@@ -588,10 +506,10 @@ static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long ti
         udelay(1);      /* spec allows drive 400ns to assert "BUSY" */
         stat = tp_ops->read_status(hwif);
 
-        if (stat & BUSY_STAT) {
+        if (stat & ATA_BUSY) {
                 local_irq_set(flags);
                 timeout += jiffies;
-                while ((stat = tp_ops->read_status(hwif)) & BUSY_STAT) {
+                while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
                         if (time_after(jiffies, timeout)) {
                                 /*
                                  * One last read after the timeout in case
@@ -599,7 +517,7 @@ static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad, unsigned long ti
                                  * progress during the timeout..
                                  */
                                 stat = tp_ops->read_status(hwif);
-                                if (!(stat & BUSY_STAT))
+                                if ((stat & ATA_BUSY) == 0)
                                         break;
 
                                 local_irq_restore(flags);
@@ -660,18 +578,18 @@ EXPORT_SYMBOL(ide_wait_stat);
 /**
  *      ide_in_drive_list       -       look for drive in black/white list
  *      @id: drive identifier
- *      @drive_table: list to inspect
+ *      @table: list to inspect
  *
  *      Look for a drive in the blacklist and the whitelist tables
  *      Returns 1 if the drive is found in the table.
  */
 
-int ide_in_drive_list(struct hd_driveid *id, const struct drive_list_entry *drive_table)
+int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
 {
-        for ( ; drive_table->id_model; drive_table++)
-                if ((!strcmp(drive_table->id_model, id->model)) &&
-                    (!drive_table->id_firmware ||
-                     strstr(id->fw_rev, drive_table->id_firmware)))
+        for ( ; table->id_model; table++)
+                if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
+                    (!table->id_firmware ||
+                     strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
                         return 1;
         return 0;
 }
@@ -702,7 +620,7 @@ static const struct drive_list_entry ivb_list[] = {
 u8 eighty_ninty_three (ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
-        struct hd_driveid *id = drive->id;
+        u16 *id = drive->id;
         int ivb = ide_in_drive_list(id, ivb_list);
 
         if (hwif->cbl == ATA_CBL_PATA40_SHORT)
@@ -712,7 +630,7 @@ u8 eighty_ninty_three (ide_drive_t *drive)
                 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
                                   drive->name);
 
-        if (ide_dev_is_sata(id) && !ivb)
+        if (ata_id_is_sata(id) && !ivb)
                 return 1;
 
         if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
@@ -724,11 +642,12 @@ u8 eighty_ninty_three (ide_drive_t *drive)
          * - force bit13 (80c cable present) check also for !ivb devices
          *   (unless the slave device is pre-ATA3)
          */
-        if ((id->hw_config & 0x4000) || (ivb && (id->hw_config & 0x2000)))
+        if ((id[ATA_ID_HW_CONFIG] & 0x4000) ||
+            (ivb && (id[ATA_ID_HW_CONFIG] & 0x2000)))
                 return 1;
 
 no_80w:
-        if (drive->udma33_warned == 1)
+        if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
                 return 0;
 
         printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
@@ -736,7 +655,7 @@ no_80w:
                             drive->name,
                             hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
 
-        drive->udma33_warned = 1;
+        drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
 
         return 0;
 }
@@ -745,8 +664,8 @@ int ide_driveid_update(ide_drive_t *drive)
 {
         ide_hwif_t *hwif = drive->hwif;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
-        struct hd_driveid *id;
-        unsigned long timeout, flags;
+        u16 *id;
+        unsigned long flags;
         u8 stat;
 
         /*
@@ -757,29 +676,24 @@ int ide_driveid_update(ide_drive_t *drive)
         SELECT_MASK(drive, 1);
         tp_ops->set_irq(hwif, 0);
         msleep(50);
-        tp_ops->exec_command(hwif, WIN_IDENTIFY);
-        timeout = jiffies + WAIT_WORSTCASE;
-        do {
-                if (time_after(jiffies, timeout)) {
-                        SELECT_MASK(drive, 0);
-                        return 0;       /* drive timed-out */
-                }
+        tp_ops->exec_command(hwif, ATA_CMD_ID_ATA);
 
-                msleep(50);     /* give drive a breather */
-                stat = tp_ops->read_altstatus(hwif);
-        } while (stat & BUSY_STAT);
+        if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 1)) {
+                SELECT_MASK(drive, 0);
+                return 0;
+        }
 
-        msleep(50);     /* wait for IRQ and DRQ_STAT */
+        msleep(50);     /* wait for IRQ and ATA_DRQ */
         stat = tp_ops->read_status(hwif);
 
-        if (!OK_STAT(stat, DRQ_STAT, BAD_R_STAT)) {
+        if (!OK_STAT(stat, ATA_DRQ, BAD_R_STAT)) {
                 SELECT_MASK(drive, 0);
                 printk("%s: CHECK for good STATUS\n", drive->name);
                 return 0;
         }
         local_irq_save(flags);
         SELECT_MASK(drive, 0);
-        id = kmalloc(SECTOR_WORDS*4, GFP_ATOMIC);
+        id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
         if (!id) {
                 local_irq_restore(flags);
                 return 0;
@@ -789,16 +703,16 @@ int ide_driveid_update(ide_drive_t *drive)
         local_irq_enable();
         local_irq_restore(flags);
         ide_fix_driveid(id);
-        if (id) {
-                drive->id->dma_ultra = id->dma_ultra;
-                drive->id->dma_mword = id->dma_mword;
-                drive->id->dma_1word = id->dma_1word;
-                /* anything more ? */
-                kfree(id);
-
-                if (drive->using_dma && ide_id_dma_bug(drive))
-                        ide_dma_off(drive);
-        }
+
+        drive->id[ATA_ID_UDMA_MODES]  = id[ATA_ID_UDMA_MODES];
+        drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
+        drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
+        /* anything more ? */
+
+        kfree(id);
+
+        if ((drive->dev_flags & IDE_DFLAG_USING_DMA) && ide_id_dma_bug(drive))
+                ide_dma_off(drive);
 
         return 1;
 }
@@ -807,6 +721,7 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 {
         ide_hwif_t *hwif = drive->hwif;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
+        u16 *id = drive->id, i;
         int error = 0;
         u8 stat;
         ide_task_t task;
@@ -817,7 +732,7 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 #endif
 
         /* Skip setting PIO flow-control modes on pre-EIDE drives */
-        if ((speed & 0xf8) == XFER_PIO_0 && !(drive->id->capability & 0x08))
+        if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
                 goto skip;
 
         /*
@@ -840,7 +755,7 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
          
         udelay(1);
         SELECT_DRIVE(drive);
-        SELECT_MASK(drive, 0);
+        SELECT_MASK(drive, 1);
         udelay(1);
         tp_ops->set_irq(hwif, 0);
 
@@ -851,13 +766,13 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
 
         tp_ops->tf_load(drive, &task);
 
-        tp_ops->exec_command(hwif, WIN_SETFEATURES);
+        tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
 
         if (drive->quirk_list == 2)
                 tp_ops->set_irq(hwif, 1);
 
         error = __ide_wait_stat(drive, drive->ready_stat,
-                                BUSY_STAT|DRQ_STAT|ERR_STAT,
+                                ATA_BUSY | ATA_DRQ | ATA_ERR,
                                 WAIT_CMD, &stat);
 
         SELECT_MASK(drive, 0);
@@ -869,35 +784,29 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
                 return error;
         }
 
-        drive->id->dma_ultra &= ~0xFF00;
-        drive->id->dma_mword &= ~0x0F00;
-        drive->id->dma_1word &= ~0x0F00;
+        id[ATA_ID_UDMA_MODES]  &= ~0xFF00;
+        id[ATA_ID_MWDMA_MODES] &= ~0x0F00;
+        id[ATA_ID_SWDMA_MODES] &= ~0x0F00;
 
  skip:
 #ifdef CONFIG_BLK_DEV_IDEDMA
-        if (speed >= XFER_SW_DMA_0 && drive->using_dma)
+        if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
                 hwif->dma_ops->dma_host_set(drive, 1);
         else if (hwif->dma_ops) /* check if host supports DMA */
                 ide_dma_off_quietly(drive);
 #endif
 
-        switch(speed) {
-                case XFER_UDMA_7:   drive->id->dma_ultra |= 0x8080; break;
-                case XFER_UDMA_6:   drive->id->dma_ultra |= 0x4040; break;
-                case XFER_UDMA_5:   drive->id->dma_ultra |= 0x2020; break;
-                case XFER_UDMA_4:   drive->id->dma_ultra |= 0x1010; break;
-                case XFER_UDMA_3:   drive->id->dma_ultra |= 0x0808; break;
-                case XFER_UDMA_2:   drive->id->dma_ultra |= 0x0404; break;
-                case XFER_UDMA_1:   drive->id->dma_ultra |= 0x0202; break;
-                case XFER_UDMA_0:   drive->id->dma_ultra |= 0x0101; break;
-                case XFER_MW_DMA_2: drive->id->dma_mword |= 0x0404; break;
-                case XFER_MW_DMA_1: drive->id->dma_mword |= 0x0202; break;
-                case XFER_MW_DMA_0: drive->id->dma_mword |= 0x0101; break;
-                case XFER_SW_DMA_2: drive->id->dma_1word |= 0x0404; break;
-                case XFER_SW_DMA_1: drive->id->dma_1word |= 0x0202; break;
-                case XFER_SW_DMA_0: drive->id->dma_1word |= 0x0101; break;
-                default: break;
+        if (speed >= XFER_UDMA_0) {
+                i = 1 << (speed - XFER_UDMA_0);
+                id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
+        } else if (speed >= XFER_MW_DMA_0) {
+                i = 1 << (speed - XFER_MW_DMA_0);
+                id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
+        } else if (speed >= XFER_SW_DMA_0) {
+                i = 1 << (speed - XFER_SW_DMA_0);
+                id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
         }
+
         if (!drive->init_speed)
                 drive->init_speed = speed;
         drive->current_speed = speed;
@@ -977,7 +886,7 @@ void ide_execute_pkt_cmd(ide_drive_t *drive)
         unsigned long flags;
 
         spin_lock_irqsave(&ide_lock, flags);
-        hwif->tp_ops->exec_command(hwif, WIN_PACKETCMD);
+        hwif->tp_ops->exec_command(hwif, ATA_CMD_PACKET);
         ndelay(400);
         spin_unlock_irqrestore(&ide_lock, flags);
 }
@@ -1010,7 +919,7 @@ static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
         udelay (10);
         stat = hwif->tp_ops->read_status(hwif);
 
-        if (OK_STAT(stat, 0, BUSY_STAT))
+        if (OK_STAT(stat, 0, ATA_BUSY))
                 printk("%s: ATAPI reset complete\n", drive->name);
         else {
                 if (time_before(jiffies, hwgroup->poll_timeout)) {
@@ -1031,6 +940,25 @@ static ide_startstop_t atapi_reset_pollfunc (ide_drive_t *drive)
         return ide_stopped;
 }
 
+static void ide_reset_report_error(ide_hwif_t *hwif, u8 err)
+{
+        static const char *err_master_vals[] =
+                { NULL, "passed", "formatter device error",
+                  "sector buffer error", "ECC circuitry error",
+                  "controlling MPU error" };
+
+        u8 err_master = err & 0x7f;
+
+        printk(KERN_ERR "%s: reset: master: ", hwif->name);
+        if (err_master && err_master < 6)
+                printk(KERN_CONT "%s", err_master_vals[err_master]);
+        else
+                printk(KERN_CONT "error (0x%02x?)", err);
+        if (err & 0x80)
+                printk(KERN_CONT "; slave: failed");
+        printk(KERN_CONT "\n");
+}
+
 /*
  * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
  * during an ide reset operation. If the drives have not yet responded,
@@ -1056,7 +984,7 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
 
         tmp = hwif->tp_ops->read_status(hwif);
 
-        if (!OK_STAT(tmp, 0, BUSY_STAT)) {
+        if (!OK_STAT(tmp, 0, ATA_BUSY)) {
                 if (time_before(jiffies, hwgroup->poll_timeout)) {
                         ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL);
                         /* continue polling */
@@ -1066,31 +994,14 @@ static ide_startstop_t reset_pollfunc (ide_drive_t *drive)
                 drive->failures++;
                 err = -EIO;
         } else  {
-                printk("%s: reset: ", hwif->name);
                 tmp = ide_read_error(drive);
 
                 if (tmp == 1) {
-                        printk("success\n");
+                        printk(KERN_INFO "%s: reset: success\n", hwif->name);
                         drive->failures = 0;
                 } else {
+                        ide_reset_report_error(hwif, tmp);
                         drive->failures++;
-                        printk("master: ");
-                        switch (tmp & 0x7f) {
-                                case 1: printk("passed");
-                                        break;
-                                case 2: printk("formatter device error");
-                                        break;
-                                case 3: printk("sector buffer error");
-                                        break;
-                                case 4: printk("ECC circuitry error");
-                                        break;
-                                case 5: printk("controlling MPU error");
-                                        break;
-                                default:printk("error (0x%02x?)", tmp);
-                        }
-                        if (tmp & 0x80)
-                                printk("; slave: failed");
-                        printk("\n");
                         err = -EIO;
                 }
         }
@@ -1102,14 +1013,19 @@ out:
 
 static void ide_disk_pre_reset(ide_drive_t *drive)
 {
-        int legacy = (drive->id->cfs_enable_2 & 0x0400) ? 0 : 1;
+        int legacy = (drive->id[ATA_ID_CFS_ENABLE_2] & 0x0400) ? 0 : 1;
 
         drive->special.all = 0;
         drive->special.b.set_geometry = legacy;
         drive->special.b.recalibrate  = legacy;
+
         drive->mult_count = 0;
-        if (!drive->keep_settings && !drive->using_dma)
+        drive->dev_flags &= ~IDE_DFLAG_PARKED;
+
+        if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0 &&
+            (drive->dev_flags & IDE_DFLAG_USING_DMA) == 0)
                 drive->mult_req = 0;
+
         if (drive->mult_req != drive->mult_count)
                 drive->special.b.set_multmode = 1;
 }
@@ -1121,18 +1037,18 @@ static void pre_reset(ide_drive_t *drive)
         if (drive->media == ide_disk)
                 ide_disk_pre_reset(drive);
         else
-                drive->post_reset = 1;
+                drive->dev_flags |= IDE_DFLAG_POST_RESET;
 
-        if (drive->using_dma) {
+        if (drive->dev_flags & IDE_DFLAG_USING_DMA) {
                 if (drive->crc_count)
                         ide_check_dma_crc(drive);
                 else
                         ide_dma_off(drive);
         }
 
-        if (!drive->keep_settings) {
-                if (!drive->using_dma) {
-                        drive->unmask = 0;
+        if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0) {
+                if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) {
+                        drive->dev_flags &= ~IDE_DFLAG_UNMASK;
                         drive->io_32bit = 0;
                 }
                 return;
@@ -1164,12 +1080,13 @@ static void pre_reset(ide_drive_t *drive)
 static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
 {
         unsigned int unit;
-        unsigned long flags;
+        unsigned long flags, timeout;
         ide_hwif_t *hwif;
         ide_hwgroup_t *hwgroup;
         struct ide_io_ports *io_ports;
         const struct ide_tp_ops *tp_ops;
         const struct ide_port_ops *port_ops;
+        DEFINE_WAIT(wait);
 
         spin_lock_irqsave(&ide_lock, flags);
         hwif = HWIF(drive);
@@ -1187,7 +1104,7 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
                 pre_reset(drive);
                 SELECT_DRIVE(drive);
                 udelay (20);
-                tp_ops->exec_command(hwif, WIN_SRST);
+                tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
                 ndelay(400);
                 hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
                 hwgroup->polling = 1;
@@ -1196,6 +1113,31 @@ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
                 return ide_started;
         }
 
+        /* We must not disturb devices in the IDE_DFLAG_PARKED state. */
+        do {
+                unsigned long now;
+
+                prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE);
+                timeout = jiffies;
+                for (unit = 0; unit < MAX_DRIVES; unit++) {
+                        ide_drive_t *tdrive = &hwif->drives[unit];
+
+                        if (tdrive->dev_flags & IDE_DFLAG_PRESENT &&
+                            tdrive->dev_flags & IDE_DFLAG_PARKED &&
+                            time_after(tdrive->sleep, timeout))
+                                timeout = tdrive->sleep;
+                }
+
+                now = jiffies;
+                if (time_before_eq(timeout, now))
+                        break;
+
+                spin_unlock_irqrestore(&ide_lock, flags);
+                timeout = schedule_timeout_uninterruptible(timeout - now);
+                spin_lock_irqsave(&ide_lock, flags);
+        } while (timeout);
+        finish_wait(&ide_park_wq, &wait);
+
         /*
          * First, reset any device state data we were maintaining
          * for any of the drives on this interface.
@@ -1270,7 +1212,7 @@ int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
                  */
                 mdelay(1);
                 stat = hwif->tp_ops->read_status(hwif);
-                if ((stat & BUSY_STAT) == 0)
+                if ((stat & ATA_BUSY) == 0)
                         return 0;
                 /*
                  * Assume a value of 0xff means nothing is connected to