1 files changed, 119 insertions, 133 deletions

diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 70aa86c8807e..06575a12b635 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -50,59 +50,54 @@
  
 static void generic_id(ide_drive_t *drive)
 {
-        drive->id->cyls = drive->cyl;
-        drive->id->heads = drive->head;
-        drive->id->sectors = drive->sect;
-        drive->id->cur_cyls = drive->cyl;
-        drive->id->cur_heads = drive->head;
-        drive->id->cur_sectors = drive->sect;
+        u16 *id = drive->id;
+
+        id[ATA_ID_CUR_CYLS]     = id[ATA_ID_CYLS]       = drive->cyl;
+        id[ATA_ID_CUR_HEADS]    = id[ATA_ID_HEADS]      = drive->head;
+        id[ATA_ID_CUR_SECTORS]  = id[ATA_ID_SECTORS]    = drive->sect;
 }
 
 static void ide_disk_init_chs(ide_drive_t *drive)
 {
-        struct hd_driveid *id = drive->id;
+        u16 *id = drive->id;
 
         /* Extract geometry if we did not already have one for the drive */
         if (!drive->cyl || !drive->head || !drive->sect) {
-                drive->cyl  = drive->bios_cyl  = id->cyls;
-                drive->head = drive->bios_head = id->heads;
-                drive->sect = drive->bios_sect = id->sectors;
+                drive->cyl  = drive->bios_cyl  = id[ATA_ID_CYLS];
+                drive->head = drive->bios_head = id[ATA_ID_HEADS];
+                drive->sect = drive->bios_sect = id[ATA_ID_SECTORS];
         }
 
         /* Handle logical geometry translation by the drive */
-        if ((id->field_valid & 1) && id->cur_cyls &&
-            id->cur_heads && (id->cur_heads <= 16) && id->cur_sectors) {
-                drive->cyl  = id->cur_cyls;
-                drive->head = id->cur_heads;
-                drive->sect = id->cur_sectors;
+        if (ata_id_current_chs_valid(id)) {
+                drive->cyl  = id[ATA_ID_CUR_CYLS];
+                drive->head = id[ATA_ID_CUR_HEADS];
+                drive->sect = id[ATA_ID_CUR_SECTORS];
         }
 
         /* Use physical geometry if what we have still makes no sense */
-        if (drive->head > 16 && id->heads && id->heads <= 16) {
-                drive->cyl  = id->cyls;
-                drive->head = id->heads;
-                drive->sect = id->sectors;
+        if (drive->head > 16 && id[ATA_ID_HEADS] && id[ATA_ID_HEADS] <= 16) {
+                drive->cyl  = id[ATA_ID_CYLS];
+                drive->head = id[ATA_ID_HEADS];
+                drive->sect = id[ATA_ID_SECTORS];
         }
 }
 
 static void ide_disk_init_mult_count(ide_drive_t *drive)
 {
-        struct hd_driveid *id = drive->id;
-
-        drive->mult_count = 0;
-        if (id->max_multsect) {
-#ifdef CONFIG_IDEDISK_MULTI_MODE
-                id->multsect = ((id->max_multsect/2) > 1) ? id->max_multsect : 0;
-                id->multsect_valid = id->multsect ? 1 : 0;
-                drive->mult_req = id->multsect_valid ? id->max_multsect : 0;
-                drive->special.b.set_multmode = drive->mult_req ? 1 : 0;
-#else   /* original, pre IDE-NFG, per request of AC */
-                drive->mult_req = 0;
-                if (drive->mult_req > id->max_multsect)
-                        drive->mult_req = id->max_multsect;
-                if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
+        u16 *id = drive->id;
+        u8 max_multsect = id[ATA_ID_MAX_MULTSECT] & 0xff;
+
+        if (max_multsect) {
+                if ((max_multsect / 2) > 1)
+                        id[ATA_ID_MULTSECT] = max_multsect | 0x100;
+                else
+                        id[ATA_ID_MULTSECT] &= ~0x1ff;
+
+                drive->mult_req = id[ATA_ID_MULTSECT] & 0xff;
+
+                if (drive->mult_req)
                         drive->special.b.set_multmode = 1;
-#endif
         }
 }
 
@@ -119,10 +114,10 @@ static void ide_disk_init_mult_count(ide_drive_t *drive)
 static inline void do_identify (ide_drive_t *drive, u8 cmd)
 {
         ide_hwif_t *hwif = HWIF(drive);
-        int bswap = 1;
-        struct hd_driveid *id;
+        u16 *id = drive->id;
+        char *m = (char *)&id[ATA_ID_PROD];
+        int bswap = 1, is_cfa;
 
-        id = drive->id;
         /* read 512 bytes of id info */
         hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
 
@@ -135,27 +130,28 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
         ide_fix_driveid(id);
 
         /*
-         *  WIN_IDENTIFY returns little-endian info,
-         *  WIN_PIDENTIFY *usually* returns little-endian info.
+         *  ATA_CMD_ID_ATA returns little-endian info,
+         *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
          */
-        if (cmd == WIN_PIDENTIFY) {
-                if ((id->model[0] == 'N' && id->model[1] == 'E') /* NEC */
-                 || (id->model[0] == 'F' && id->model[1] == 'X') /* Mitsumi */
-                 || (id->model[0] == 'P' && id->model[1] == 'i'))/* Pioneer */
+        if (cmd == ATA_CMD_ID_ATAPI) {
+                if ((m[0] == 'N' && m[1] == 'E') ||  /* NEC */
+                    (m[0] == 'F' && m[1] == 'X') ||  /* Mitsumi */
+                    (m[0] == 'P' && m[1] == 'i'))    /* Pioneer */
                         /* Vertos drives may still be weird */
-                        bswap ^= 1;     
+                        bswap ^= 1;
         }
-        ide_fixstring(id->model,     sizeof(id->model),     bswap);
-        ide_fixstring(id->fw_rev,    sizeof(id->fw_rev),    bswap);
-        ide_fixstring(id->serial_no, sizeof(id->serial_no), bswap);
+
+        ide_fixstring(m, ATA_ID_PROD_LEN, bswap);
+        ide_fixstring((char *)&id[ATA_ID_FW_REV], ATA_ID_FW_REV_LEN, bswap);
+        ide_fixstring((char *)&id[ATA_ID_SERNO], ATA_ID_SERNO_LEN, bswap);
 
         /* we depend on this a lot! */
-        id->model[sizeof(id->model)-1] = '\0';
+        m[ATA_ID_PROD_LEN - 1] = '\0';
 
-        if (strstr(id->model, "E X A B Y T E N E S T"))
+        if (strstr(m, "E X A B Y T E N E S T"))
                 goto err_misc;
 
-        printk(KERN_INFO "%s: %s, ", drive->name, id->model);
+        printk(KERN_INFO "%s: %s, ", drive->name, m);
 
         drive->present = 1;
         drive->dead = 0;
@@ -163,16 +159,16 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
         /*
          * Check for an ATAPI device
          */
-        if (cmd == WIN_PIDENTIFY) {
-                u8 type = (id->config >> 8) & 0x1f;
+        if (cmd == ATA_CMD_ID_ATAPI) {
+                u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
 
                 printk(KERN_CONT "ATAPI ");
                 switch (type) {
                         case ide_floppy:
-                                if (!strstr(id->model, "CD-ROM")) {
-                                        if (!strstr(id->model, "oppy") &&
-                                            !strstr(id->model, "poyp") &&
-                                            !strstr(id->model, "ZIP"))
+                                if (!strstr(m, "CD-ROM")) {
+                                        if (!strstr(m, "oppy") &&
+                                            !strstr(m, "poyp") &&
+                                            !strstr(m, "ZIP"))
                                                 printk(KERN_CONT "cdrom or floppy?, assuming ");
                                         if (drive->media != ide_cdrom) {
                                                 printk(KERN_CONT "FLOPPY");
@@ -186,8 +182,7 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
                                 drive->removable = 1;
 #ifdef CONFIG_PPC
                                 /* kludge for Apple PowerBook internal zip */
-                                if (!strstr(id->model, "CD-ROM") &&
-                                    strstr(id->model, "ZIP")) {
+                                if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
                                         printk(KERN_CONT "FLOPPY");
                                         type = ide_floppy;
                                         break;
@@ -217,18 +212,15 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
          * Not an ATAPI device: looks like a "regular" hard disk
          */
 
-        /*
-         * 0x848a = CompactFlash device
-         * These are *not* removable in Linux definition of the term
-         */
+        is_cfa = ata_id_is_cfa(id);
 
-        if ((id->config != 0x848a) && (id->config & (1<<7)))
+        /* CF devices are *not* removable in Linux definition of the term */
+        if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
                 drive->removable = 1;
 
         drive->media = ide_disk;
 
-        printk(KERN_CONT "%s DISK drive\n",
-                (id->config == 0x848a) ? "CFA" : "ATA");
+        printk(KERN_CONT "%s DISK drive\n", is_cfa ? "CFA" : "ATA");
 
         return;
 
@@ -268,7 +260,7 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
         if (io_ports->ctl_addr) {
                 a = tp_ops->read_altstatus(hwif);
                 s = tp_ops->read_status(hwif);
-                if ((a ^ s) & ~INDEX_STAT)
+                if ((a ^ s) & ~ATA_IDX)
                         /* ancient Seagate drives, broken interfaces */
                         printk(KERN_INFO "%s: probing with STATUS(0x%02x) "
                                          "instead of ALTSTATUS(0x%02x)\n",
@@ -281,7 +273,7 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
         /* set features register for atapi
          * identify command to be sure of reply
          */
-        if (cmd == WIN_PIDENTIFY) {
+        if (cmd == ATA_CMD_ID_ATAPI) {
                 ide_task_t task;
 
                 memset(&task, 0, sizeof(task));
@@ -294,24 +286,16 @@ static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
         /* ask drive for ID */
         tp_ops->exec_command(hwif, cmd);
 
-        timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
-        timeout += jiffies;
-        do {
-                if (time_after(jiffies, timeout)) {
-                        /* drive timed-out */
-                        return 1;
-                }
-                /* give drive a breather */
-                msleep(50);
-                s = use_altstatus ? tp_ops->read_altstatus(hwif)
-                                  : tp_ops->read_status(hwif);
-        } while (s & BUSY_STAT);
+        timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
 
-        /* wait for IRQ and DRQ_STAT */
+        if (ide_busy_sleep(hwif, timeout, use_altstatus))
+                return 1;
+
+        /* wait for IRQ and ATA_DRQ */
         msleep(50);
         s = tp_ops->read_status(hwif);
 
-        if (OK_STAT(s, DRQ_STAT, BAD_R_STAT)) {
+        if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
                 unsigned long flags;
 
                 /* local CPU only; some systems need this */
@@ -387,19 +371,21 @@ static int try_to_identify (ide_drive_t *drive, u8 cmd)
         return retval;
 }
 
-static int ide_busy_sleep(ide_hwif_t *hwif)
+int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
 {
-        unsigned long timeout = jiffies + WAIT_WORSTCASE;
         u8 stat;
 
+        timeout += jiffies;
+
         do {
-                msleep(50);
-                stat = hwif->tp_ops->read_status(hwif);
-                if ((stat & BUSY_STAT) == 0)
+                msleep(50);     /* give drive a breather */
+                stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
+                                 : hwif->tp_ops->read_status(hwif);
+                if ((stat & ATA_BUSY) == 0)
                         return 0;
         } while (time_before(jiffies, timeout));
 
-        return 1;
+        return 1;       /* drive timed-out */
 }
 
 static u8 ide_read_device(ide_drive_t *drive)
@@ -444,13 +430,13 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
 
         if (drive->present) {
                 /* avoid waiting for inappropriate probes */
-                if ((drive->media != ide_disk) && (cmd == WIN_IDENTIFY))
+                if (drive->media != ide_disk && cmd == ATA_CMD_ID_ATA)
                         return 4;
         }
 #ifdef DEBUG
         printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
                 drive->name, drive->present, drive->media,
-                (cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
+                (cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
 #endif
 
         /* needed for some systems
@@ -464,7 +450,7 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
                 if (drive->select.b.unit != 0) {
                         /* exit with drive0 selected */
                         SELECT_DRIVE(&hwif->drives[0]);
-                        /* allow BUSY_STAT to assert & clear */
+                        /* allow ATA_BUSY to assert & clear */
                         msleep(50);
                 }
                 /* no i/f present: mmm.. this should be a 4 -ml */
@@ -473,8 +459,8 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
 
         stat = tp_ops->read_status(hwif);
 
-        if (OK_STAT(stat, READY_STAT, BUSY_STAT) ||
-            drive->present || cmd == WIN_PIDENTIFY) {
+        if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
+            drive->present || cmd == ATA_CMD_ID_ATAPI) {
                 /* send cmd and wait */
                 if ((rc = try_to_identify(drive, cmd))) {
                         /* failed: try again */
@@ -483,17 +469,17 @@ static int do_probe (ide_drive_t *drive, u8 cmd)
 
                 stat = tp_ops->read_status(hwif);
 
-                if (stat == (BUSY_STAT | READY_STAT))
+                if (stat == (ATA_BUSY | ATA_DRDY))
                         return 4;
 
-                if (rc == 1 && cmd == WIN_PIDENTIFY) {
+                if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
                         printk(KERN_ERR "%s: no response (status = 0x%02x), "
                                         "resetting drive\n", drive->name, stat);
                         msleep(50);
                         SELECT_DRIVE(drive);
                         msleep(50);
-                        tp_ops->exec_command(hwif, WIN_SRST);
-                        (void)ide_busy_sleep(hwif);
+                        tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
+                        (void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
                         rc = try_to_identify(drive, cmd);
                 }
 
@@ -526,13 +512,14 @@ static void enable_nest (ide_drive_t *drive)
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
         u8 stat;
 
-        printk(KERN_INFO "%s: enabling %s -- ", hwif->name, drive->id->model);
+        printk(KERN_INFO "%s: enabling %s -- ",
+                hwif->name, (char *)&drive->id[ATA_ID_PROD]);
 
         SELECT_DRIVE(drive);
         msleep(50);
-        tp_ops->exec_command(hwif, EXABYTE_ENABLE_NEST);
+        tp_ops->exec_command(hwif, ATA_EXABYTE_ENABLE_NEST);
 
-        if (ide_busy_sleep(hwif)) {
+        if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 0)) {
                 printk(KERN_CONT "failed (timeout)\n");
                 return;
         }
@@ -545,12 +532,6 @@ static void enable_nest (ide_drive_t *drive)
                 printk(KERN_CONT "failed (status = 0x%02x)\n", stat);
         else
                 printk(KERN_CONT "success\n");
-
-        /* if !(success||timed-out) */
-        if (do_probe(drive, WIN_IDENTIFY) >= 2) {
-                /* look for ATAPI device */
-                (void) do_probe(drive, WIN_PIDENTIFY);
-        }
 }
 
 /**
@@ -567,6 +548,8 @@ static void enable_nest (ide_drive_t *drive)
  
 static inline u8 probe_for_drive (ide_drive_t *drive)
 {
+        char *m;
+
         /*
          *      In order to keep things simple we have an id
          *      block for all drives at all times. If the device
@@ -576,29 +559,34 @@ static inline u8 probe_for_drive (ide_drive_t *drive)
          *      Also note that 0 everywhere means "can't do X"
          */
  
-        drive->id = kzalloc(SECTOR_WORDS *4, GFP_KERNEL);
+        drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
         drive->id_read = 0;
         if(drive->id == NULL)
         {
                 printk(KERN_ERR "ide: out of memory for id data.\n");
                 return 0;
         }
-        strcpy(drive->id->model, "UNKNOWN");
-        
+
+        m = (char *)&drive->id[ATA_ID_PROD];
+        strcpy(m, "UNKNOWN");
+
         /* skip probing? */
-        if (!drive->noprobe)
-        {
+        if (!drive->noprobe) {
+retry:
                 /* if !(success||timed-out) */
-                if (do_probe(drive, WIN_IDENTIFY) >= 2) {
+                if (do_probe(drive, ATA_CMD_ID_ATA) >= 2)
                         /* look for ATAPI device */
-                        (void) do_probe(drive, WIN_PIDENTIFY);
-                }
+                        (void)do_probe(drive, ATA_CMD_ID_ATAPI);
+
                 if (!drive->present)
                         /* drive not found */
                         return 0;
-                if (strstr(drive->id->model, "E X A B Y T E N E S T"))
+
+                if (strstr(m, "E X A B Y T E N E S T")) {
                         enable_nest(drive);
-        
+                        goto retry;
+                }
+
                 /* identification failed? */
                 if (!drive->id_read) {
                         if (drive->media == ide_disk) {
@@ -740,36 +728,38 @@ out:
 
 /**
  *      ide_undecoded_slave     -       look for bad CF adapters
- *      @drive1: drive
+ *      @dev1: slave device
  *
  *      Analyse the drives on the interface and attempt to decide if we
  *      have the same drive viewed twice. This occurs with crap CF adapters
  *      and PCMCIA sometimes.
  */
 
-void ide_undecoded_slave(ide_drive_t *drive1)
+void ide_undecoded_slave(ide_drive_t *dev1)
 {
-        ide_drive_t *drive0 = &drive1->hwif->drives[0];
+        ide_drive_t *dev0 = &dev1->hwif->drives[0];
 
-        if ((drive1->dn & 1) == 0 || drive0->present == 0)
+        if ((dev1->dn & 1) == 0 || dev0->present == 0)
                 return;
 
         /* If the models don't match they are not the same product */
-        if (strcmp(drive0->id->model, drive1->id->model))
+        if (strcmp((char *)&dev0->id[ATA_ID_PROD],
+                   (char *)&dev1->id[ATA_ID_PROD]))
                 return;
 
         /* Serial numbers do not match */
-        if (strncmp(drive0->id->serial_no, drive1->id->serial_no, 20))
+        if (strncmp((char *)&dev0->id[ATA_ID_SERNO],
+                    (char *)&dev1->id[ATA_ID_SERNO], ATA_ID_SERNO_LEN))
                 return;
 
         /* No serial number, thankfully very rare for CF */
-        if (drive0->id->serial_no[0] == 0)
+        if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
                 return;
 
         /* Appears to be an IDE flash adapter with decode bugs */
         printk(KERN_WARNING "ide-probe: ignoring undecoded slave\n");
 
-        drive1->present = 0;
+        dev1->present = 0;
 }
 
 EXPORT_SYMBOL_GPL(ide_undecoded_slave);
@@ -853,7 +843,7 @@ static void ide_port_tune_devices(ide_hwif_t *hwif)
                 if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
                         drive->no_io_32bit = 1;
                 else
-                        drive->no_io_32bit = drive->id->dword_io ? 1 : 0;
+                        drive->no_io_32bit = drive->id[ATA_ID_DWORD_IO] ? 1 : 0;
         }
 }
 
@@ -1037,11 +1027,6 @@ static int init_irq (ide_hwif_t *hwif)
         ide_hwgroup_t *hwgroup;
         ide_hwif_t *match = NULL;
 
-
-        BUG_ON(in_interrupt());
-        BUG_ON(irqs_disabled());        
-        BUG_ON(hwif == NULL);
-
         mutex_lock(&ide_cfg_mtx);
         hwif->hwgroup = NULL;
 #if MAX_HWIFS > 1
@@ -1116,7 +1101,8 @@ static int init_irq (ide_hwif_t *hwif)
                 sa = IRQF_SHARED;
 #endif /* __mc68000__ */
 
-                if (IDE_CHIPSET_IS_PCI(hwif->chipset))
+                if (hwif->chipset == ide_pci || hwif->chipset == ide_cmd646 ||
+                    hwif->chipset == ide_ali14xx)
                         sa = IRQF_SHARED;
 
                 if (io_ports->ctl_addr)
@@ -1344,8 +1330,6 @@ static void hwif_register_devices(ide_hwif_t *hwif)
                 if (!drive->present)
                         continue;
 
-                ide_add_generic_settings(drive);
-
                 snprintf(dev->bus_id, BUS_ID_SIZE, "%u.%u", hwif->index, i);
                 dev->parent = &hwif->gendev;
                 dev->bus = &ide_bus_type;
@@ -1602,8 +1586,10 @@ struct ide_host *ide_host_alloc_all(const struct ide_port_info *d,
         if (hws[0])
                 host->dev[0] = hws[0]->dev;
 
-        if (d)
+        if (d) {
+                host->init_chipset = d->init_chipset;
                 host->host_flags = d->host_flags;
+        }
 
         return host;
 }