Merge branch 'master' into upstream
[linux-2.6.git] / drivers / scsi / libata-core.c
index de9ba7890b5adceeea4c909062de63e9afeb6f71..df483adc3f75506ee498c5e8fc58e6abc42cb59d 100644 (file)
 
 #include "libata.h"
 
-static unsigned int ata_dev_init_params(struct ata_port *ap,
-                                       struct ata_device *dev,
-                                       u16 heads,
-                                       u16 sectors);
-static void ata_set_mode(struct ata_port *ap);
-static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
-                                        struct ata_device *dev);
-static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
+/* debounce timing parameters in msecs { interval, duration, timeout } */
+const unsigned long sata_deb_timing_boot[]             = {   5,  100, 2000 };
+const unsigned long sata_deb_timing_eh[]               = {  25,  500, 2000 };
+const unsigned long sata_deb_timing_before_fsrst[]     = { 100, 2000, 5000 };
+
+static unsigned int ata_dev_init_params(struct ata_device *dev,
+                                       u16 heads, u16 sectors);
+static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
+static void ata_dev_xfermask(struct ata_device *dev);
 
 static unsigned int ata_unique_id = 1;
 static struct workqueue_struct *ata_wq;
 
+struct workqueue_struct *ata_aux_wq;
+
 int atapi_enabled = 1;
 module_param(atapi_enabled, int, 0444);
 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
 
+int atapi_dmadir = 0;
+module_param(atapi_dmadir, int, 0444);
+MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
+
 int libata_fua = 0;
 module_param_named(fua, libata_fua, int, 0444);
 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
@@ -397,11 +404,22 @@ static const char *ata_mode_string(unsigned int xfer_mask)
        return "<n/a>";
 }
 
-static void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
+static const char *sata_spd_string(unsigned int spd)
+{
+       static const char * const spd_str[] = {
+               "1.5 Gbps",
+               "3.0 Gbps",
+       };
+
+       if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
+               return "<unknown>";
+       return spd_str[spd - 1];
+}
+
+void ata_dev_disable(struct ata_device *dev)
 {
-       if (ata_dev_present(dev)) {
-               printk(KERN_WARNING "ata%u: dev %u disabled\n",
-                      ap->id, dev->devno);
+       if (ata_dev_enabled(dev)) {
+               ata_dev_printk(dev, KERN_WARNING, "disabled\n");
                dev->class++;
        }
 }
@@ -943,15 +961,14 @@ void ata_qc_complete_internal(struct ata_queued_cmd *qc)
 {
        struct completion *waiting = qc->private_data;
 
-       qc->ap->ops->tf_read(qc->ap, &qc->tf);
        complete(waiting);
 }
 
 /**
  *     ata_exec_internal - execute libata internal command
- *     @ap: Port to which the command is sent
  *     @dev: Device to which the command is sent
  *     @tf: Taskfile registers for the command and the result
+ *     @cdb: CDB for packet command
  *     @dma_dir: Data tranfer direction of the command
  *     @buf: Data buffer of the command
  *     @buflen: Length of data buffer
@@ -964,25 +981,66 @@ void ata_qc_complete_internal(struct ata_queued_cmd *qc)
  *
  *     LOCKING:
  *     None.  Should be called with kernel context, might sleep.
+ *
+ *     RETURNS:
+ *     Zero on success, AC_ERR_* mask on failure
  */
-
-static unsigned
-ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
-                 struct ata_taskfile *tf,
-                 int dma_dir, void *buf, unsigned int buflen)
+unsigned ata_exec_internal(struct ata_device *dev,
+                          struct ata_taskfile *tf, const u8 *cdb,
+                          int dma_dir, void *buf, unsigned int buflen)
 {
+       struct ata_port *ap = dev->ap;
        u8 command = tf->command;
        struct ata_queued_cmd *qc;
+       unsigned int tag, preempted_tag;
+       u32 preempted_sactive, preempted_qc_active;
        DECLARE_COMPLETION(wait);
        unsigned long flags;
        unsigned int err_mask;
+       int rc;
 
        spin_lock_irqsave(&ap->host_set->lock, flags);
 
-       qc = ata_qc_new_init(ap, dev);
-       BUG_ON(qc == NULL);
+       /* no internal command while frozen */
+       if (ap->flags & ATA_FLAG_FROZEN) {
+               spin_unlock_irqrestore(&ap->host_set->lock, flags);
+               return AC_ERR_SYSTEM;
+       }
+
+       /* initialize internal qc */
+
+       /* XXX: Tag 0 is used for drivers with legacy EH as some
+        * drivers choke if any other tag is given.  This breaks
+        * ata_tag_internal() test for those drivers.  Don't use new
+        * EH stuff without converting to it.
+        */
+       if (ap->ops->error_handler)
+               tag = ATA_TAG_INTERNAL;
+       else
+               tag = 0;
+
+       if (test_and_set_bit(tag, &ap->qc_allocated))
+               BUG();
+       qc = __ata_qc_from_tag(ap, tag);
+
+       qc->tag = tag;
+       qc->scsicmd = NULL;
+       qc->ap = ap;
+       qc->dev = dev;
+       ata_qc_reinit(qc);
+
+       preempted_tag = ap->active_tag;
+       preempted_sactive = ap->sactive;
+       preempted_qc_active = ap->qc_active;
+       ap->active_tag = ATA_TAG_POISON;
+       ap->sactive = 0;
+       ap->qc_active = 0;
 
+       /* prepare & issue qc */
        qc->tf = *tf;
+       if (cdb)
+               memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
+       qc->flags |= ATA_QCFLAG_RESULT_TF;
        qc->dma_dir = dma_dir;
        if (dma_dir != DMA_NONE) {
                ata_sg_init_one(qc, buf, buflen);
@@ -996,31 +1054,53 @@ ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
 
        spin_unlock_irqrestore(&ap->host_set->lock, flags);
 
-       if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) {
-               ata_port_flush_task(ap);
+       rc = wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL);
+
+       ata_port_flush_task(ap);
 
+       if (!rc) {
                spin_lock_irqsave(&ap->host_set->lock, flags);
 
                /* We're racing with irq here.  If we lose, the
                 * following test prevents us from completing the qc
-                * again.  If completion irq occurs after here but
-                * before the caller cleans up, it will result in a
-                * spurious interrupt.  We can live with that.
+                * twice.  If we win, the port is frozen and will be
+                * cleaned up by ->post_internal_cmd().
                 */
                if (qc->flags & ATA_QCFLAG_ACTIVE) {
-                       qc->err_mask = AC_ERR_TIMEOUT;
-                       ata_qc_complete(qc);
-                       printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n",
-                              ap->id, command);
+                       qc->err_mask |= AC_ERR_TIMEOUT;
+
+                       if (ap->ops->error_handler)
+                               ata_port_freeze(ap);
+                       else
+                               ata_qc_complete(qc);
+
+                       ata_dev_printk(dev, KERN_WARNING,
+                                      "qc timeout (cmd 0x%x)\n", command);
                }
 
                spin_unlock_irqrestore(&ap->host_set->lock, flags);
        }
 
-       *tf = qc->tf;
+       /* do post_internal_cmd */
+       if (ap->ops->post_internal_cmd)
+               ap->ops->post_internal_cmd(qc);
+
+       if (qc->flags & ATA_QCFLAG_FAILED && !qc->err_mask) {
+               ata_dev_printk(dev, KERN_WARNING, "zero err_mask for failed "
+                              "internal command, assuming AC_ERR_OTHER\n");
+               qc->err_mask |= AC_ERR_OTHER;
+       }
+
+       /* finish up */
+       spin_lock_irqsave(&ap->host_set->lock, flags);
+
+       *tf = qc->result_tf;
        err_mask = qc->err_mask;
 
        ata_qc_free(qc);
+       ap->active_tag = preempted_tag;
+       ap->sactive = preempted_sactive;
+       ap->qc_active = preempted_qc_active;
 
        /* XXX - Some LLDDs (sata_mv) disable port on command failure.
         * Until those drivers are fixed, we detect the condition
@@ -1033,11 +1113,13 @@ ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
         *
         * Kill the following code as soon as those drivers are fixed.
         */
-       if (ap->flags & ATA_FLAG_PORT_DISABLED) {
+       if (ap->flags & ATA_FLAG_DISABLED) {
                err_mask |= AC_ERR_SYSTEM;
                ata_port_probe(ap);
        }
 
+       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
        return err_mask;
 }
 
@@ -1076,11 +1158,10 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
 
 /**
  *     ata_dev_read_id - Read ID data from the specified device
- *     @ap: port on which target device resides
  *     @dev: target device
  *     @p_class: pointer to class of the target device (may be changed)
  *     @post_reset: is this read ID post-reset?
- *     @p_id: read IDENTIFY page (newly allocated)
+ *     @id: buffer to read IDENTIFY data into
  *
  *     Read ID data from the specified device.  ATA_CMD_ID_ATA is
  *     performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
@@ -1093,13 +1174,13 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
-                          unsigned int *p_class, int post_reset, u16 **p_id)
+int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
+                   int post_reset, u16 *id)
 {
+       struct ata_port *ap = dev->ap;
        unsigned int class = *p_class;
        struct ata_taskfile tf;
        unsigned int err_mask = 0;
-       u16 *id;
        const char *reason;
        int rc;
 
@@ -1107,15 +1188,8 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
 
        ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
 
-       id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
-       if (id == NULL) {
-               rc = -ENOMEM;
-               reason = "out of memory";
-               goto err_out;
-       }
-
  retry:
-       ata_tf_init(ap, &tf, dev->devno);
+       ata_tf_init(dev, &tf);
 
        switch (class) {
        case ATA_DEV_ATA:
@@ -1132,7 +1206,7 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
 
        tf.protocol = ATA_PROT_PIO;
 
-       err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
+       err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
                                     id, sizeof(id[0]) * ATA_ID_WORDS);
        if (err_mask) {
                rc = -EIO;
@@ -1159,7 +1233,7 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
                 * Some drives were very specific about that exact sequence.
                 */
                if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
-                       err_mask = ata_dev_init_params(ap, dev, id[3], id[6]);
+                       err_mask = ata_dev_init_params(dev, id[3], id[6]);
                        if (err_mask) {
                                rc = -EIO;
                                reason = "INIT_DEV_PARAMS failed";
@@ -1175,25 +1249,44 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
        }
 
        *p_class = class;
-       *p_id = id;
+
        return 0;
 
  err_out:
-       printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
-              ap->id, dev->devno, reason);
-       kfree(id);
+       ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
+                      "(%s, err_mask=0x%x)\n", reason, err_mask);
        return rc;
 }
 
-static inline u8 ata_dev_knobble(const struct ata_port *ap,
-                                struct ata_device *dev)
+static inline u8 ata_dev_knobble(struct ata_device *dev)
+{
+       return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
+}
+
+static void ata_dev_config_ncq(struct ata_device *dev,
+                              char *desc, size_t desc_sz)
 {
-       return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
+       struct ata_port *ap = dev->ap;
+       int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
+
+       if (!ata_id_has_ncq(dev->id)) {
+               desc[0] = '\0';
+               return;
+       }
+
+       if (ap->flags & ATA_FLAG_NCQ) {
+               hdepth = min(ap->host->can_queue, ATA_MAX_QUEUE - 1);
+               dev->flags |= ATA_DFLAG_NCQ;
+       }
+
+       if (hdepth >= ddepth)
+               snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
+       else
+               snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
 }
 
 /**
  *     ata_dev_configure - Configure the specified ATA/ATAPI device
- *     @ap: Port on which target device resides
  *     @dev: Target device to configure
  *     @print_info: Enable device info printout
  *
@@ -1206,14 +1299,14 @@ static inline u8 ata_dev_knobble(const struct ata_port *ap,
  *     RETURNS:
  *     0 on success, -errno otherwise
  */
-static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
-                            int print_info)
+int ata_dev_configure(struct ata_device *dev, int print_info)
 {
+       struct ata_port *ap = dev->ap;
        const u16 *id = dev->id;
        unsigned int xfer_mask;
        int i, rc;
 
-       if (!ata_dev_present(dev)) {
+       if (!ata_dev_enabled(dev)) {
                DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
                        ap->id, dev->devno);
                return 0;
@@ -1223,13 +1316,13 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
 
        /* print device capabilities */
        if (print_info)
-               printk(KERN_DEBUG "ata%u: dev %u cfg 49:%04x 82:%04x 83:%04x "
-                      "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
-                      ap->id, dev->devno, id[49], id[82], id[83],
-                      id[84], id[85], id[86], id[87], id[88]);
+               ata_dev_printk(dev, KERN_DEBUG, "cfg 49:%04x 82:%04x 83:%04x "
+                              "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
+                              id[49], id[82], id[83], id[84],
+                              id[85], id[86], id[87], id[88]);
 
        /* initialize to-be-configured parameters */
-       dev->flags = 0;
+       dev->flags &= ~ATA_DFLAG_CFG_MASK;
        dev->max_sectors = 0;
        dev->cdb_len = 0;
        dev->n_sectors = 0;
@@ -1252,6 +1345,7 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
 
                if (ata_id_has_lba(id)) {
                        const char *lba_desc;
+                       char ncq_desc[20];
 
                        lba_desc = "LBA";
                        dev->flags |= ATA_DFLAG_LBA;
@@ -1260,15 +1354,17 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
                                lba_desc = "LBA48";
                        }
 
+                       /* config NCQ */
+                       ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
+
                        /* print device info to dmesg */
                        if (print_info)
-                               printk(KERN_INFO "ata%u: dev %u ATA-%d, "
-                                      "max %s, %Lu sectors: %s\n",
-                                      ap->id, dev->devno,
-                                      ata_id_major_version(id),
-                                      ata_mode_string(xfer_mask),
-                                      (unsigned long long)dev->n_sectors,
-                                      lba_desc);
+                               ata_dev_printk(dev, KERN_INFO, "ATA-%d, "
+                                       "max %s, %Lu sectors: %s %s\n",
+                                       ata_id_major_version(id),
+                                       ata_mode_string(xfer_mask),
+                                       (unsigned long long)dev->n_sectors,
+                                       lba_desc, ncq_desc);
                } else {
                        /* CHS */
 
@@ -1286,13 +1382,18 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
 
                        /* print device info to dmesg */
                        if (print_info)
-                               printk(KERN_INFO "ata%u: dev %u ATA-%d, "
-                                      "max %s, %Lu sectors: CHS %u/%u/%u\n",
-                                      ap->id, dev->devno,
-                                      ata_id_major_version(id),
-                                      ata_mode_string(xfer_mask),
-                                      (unsigned long long)dev->n_sectors,
-                                      dev->cylinders, dev->heads, dev->sectors);
+                               ata_dev_printk(dev, KERN_INFO, "ATA-%d, "
+                                       "max %s, %Lu sectors: CHS %u/%u/%u\n",
+                                       ata_id_major_version(id),
+                                       ata_mode_string(xfer_mask),
+                                       (unsigned long long)dev->n_sectors,
+                                       dev->cylinders, dev->heads, dev->sectors);
+               }
+
+               if (dev->id[59] & 0x100) {
+                       dev->multi_count = dev->id[59] & 0xff;
+                       DPRINTK("ata%u: dev %u multi count %u\n",
+                               ap->id, dev->devno, dev->multi_count);
                }
 
                dev->cdb_len = 16;
@@ -1300,18 +1401,27 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
 
        /* ATAPI-specific feature tests */
        else if (dev->class == ATA_DEV_ATAPI) {
+               char *cdb_intr_string = "";
+
                rc = atapi_cdb_len(id);
                if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
-                       printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
+                       ata_dev_printk(dev, KERN_WARNING,
+                                      "unsupported CDB len\n");
                        rc = -EINVAL;
                        goto err_out_nosup;
                }
                dev->cdb_len = (unsigned int) rc;
 
+               if (ata_id_cdb_intr(dev->id)) {
+                       dev->flags |= ATA_DFLAG_CDB_INTR;
+                       cdb_intr_string = ", CDB intr";
+               }
+
                /* print device info to dmesg */
                if (print_info)
-                       printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
-                              ap->id, dev->devno, ata_mode_string(xfer_mask));
+                       ata_dev_printk(dev, KERN_INFO, "ATAPI, max %s%s\n",
+                                      ata_mode_string(xfer_mask),
+                                      cdb_intr_string);
        }
 
        ap->host->max_cmd_len = 0;
@@ -1321,10 +1431,10 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
                                              ap->device[i].cdb_len);
 
        /* limit bridge transfers to udma5, 200 sectors */
-       if (ata_dev_knobble(ap, dev)) {
+       if (ata_dev_knobble(dev)) {
                if (print_info)
-                       printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
-                              ap->id, dev->devno);
+                       ata_dev_printk(dev, KERN_INFO,
+                                      "applying bridge limits\n");
                dev->udma_mask &= ATA_UDMA5;
                dev->max_sectors = ATA_MAX_SECTORS;
        }
@@ -1352,79 +1462,104 @@ err_out_nosup:
  *     PCI/etc. bus probe sem.
  *
  *     RETURNS:
- *     Zero on success, non-zero on error.
+ *     Zero on success, negative errno otherwise.
  */
 
 static int ata_bus_probe(struct ata_port *ap)
 {
        unsigned int classes[ATA_MAX_DEVICES];
-       unsigned int i, rc, found = 0;
+       int tries[ATA_MAX_DEVICES];
+       int i, rc, down_xfermask;
+       struct ata_device *dev;
 
        ata_port_probe(ap);
 
-       /* reset and determine device classes */
        for (i = 0; i < ATA_MAX_DEVICES; i++)
-               classes[i] = ATA_DEV_UNKNOWN;
+               tries[i] = ATA_PROBE_MAX_TRIES;
 
-       if (ap->ops->probe_reset) {
-               rc = ap->ops->probe_reset(ap, classes);
-               if (rc) {
-                       printk("ata%u: reset failed (errno=%d)\n", ap->id, rc);
-                       return rc;
-               }
-       } else {
-               ap->ops->phy_reset(ap);
+ retry:
+       down_xfermask = 0;
 
-               if (!(ap->flags & ATA_FLAG_PORT_DISABLED))
-                       for (i = 0; i < ATA_MAX_DEVICES; i++)
-                               classes[i] = ap->device[i].class;
+       /* reset and determine device classes */
+       ap->ops->phy_reset(ap);
 
-               ata_port_probe(ap);
+       for (i = 0; i < ATA_MAX_DEVICES; i++) {
+               dev = &ap->device[i];
+
+               if (!(ap->flags & ATA_FLAG_DISABLED) &&
+                   dev->class != ATA_DEV_UNKNOWN)
+                       classes[dev->devno] = dev->class;
+               else
+                       classes[dev->devno] = ATA_DEV_NONE;
+
+               dev->class = ATA_DEV_UNKNOWN;
        }
 
+       ata_port_probe(ap);
+
+       /* after the reset the device state is PIO 0 and the controller
+          state is undefined. Record the mode */
+
        for (i = 0; i < ATA_MAX_DEVICES; i++)
-               if (classes[i] == ATA_DEV_UNKNOWN)
-                       classes[i] = ATA_DEV_NONE;
+               ap->device[i].pio_mode = XFER_PIO_0;
 
        /* read IDENTIFY page and configure devices */
        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-               struct ata_device *dev = &ap->device[i];
+               dev = &ap->device[i];
 
-               dev->class = classes[i];
+               if (tries[i])
+                       dev->class = classes[i];
 
-               if (!ata_dev_present(dev))
+               if (!ata_dev_enabled(dev))
                        continue;
 
-               WARN_ON(dev->id != NULL);
-               if (ata_dev_read_id(ap, dev, &dev->class, 1, &dev->id)) {
-                       dev->class = ATA_DEV_NONE;
-                       continue;
-               }
+               rc = ata_dev_read_id(dev, &dev->class, 1, dev->id);
+               if (rc)
+                       goto fail;
 
-               if (ata_dev_configure(ap, dev, 1)) {
-                       ata_dev_disable(ap, dev);
-                       continue;
-               }
+               rc = ata_dev_configure(dev, 1);
+               if (rc)
+                       goto fail;
+       }
 
-               found = 1;
+       /* configure transfer mode */
+       rc = ata_set_mode(ap, &dev);
+       if (rc) {
+               down_xfermask = 1;
+               goto fail;
        }
 
-       if (!found)
-               goto err_out_disable;
+       for (i = 0; i < ATA_MAX_DEVICES; i++)
+               if (ata_dev_enabled(&ap->device[i]))
+                       return 0;
 
-       if (ap->ops->set_mode)
-               ap->ops->set_mode(ap);
-       else
-               ata_set_mode(ap);
+       /* no device present, disable port */
+       ata_port_disable(ap);
+       ap->ops->port_disable(ap);
+       return -ENODEV;
 
-       if (ap->flags & ATA_FLAG_PORT_DISABLED)
-               goto err_out_disable;
+ fail:
+       switch (rc) {
+       case -EINVAL:
+       case -ENODEV:
+               tries[dev->devno] = 0;
+               break;
+       case -EIO:
+               sata_down_spd_limit(ap);
+               /* fall through */
+       default:
+               tries[dev->devno]--;
+               if (down_xfermask &&
+                   ata_down_xfermask_limit(dev, tries[dev->devno] == 1))
+                       tries[dev->devno] = 0;
+       }
 
-       return 0;
+       if (!tries[dev->devno]) {
+               ata_down_xfermask_limit(dev, 1);
+               ata_dev_disable(dev);
+       }
 
-err_out_disable:
-       ap->ops->port_disable(ap);
-       return -1;
+       goto retry;
 }
 
 /**
@@ -1440,7 +1575,7 @@ err_out_disable:
 
 void ata_port_probe(struct ata_port *ap)
 {
-       ap->flags &= ~ATA_FLAG_PORT_DISABLED;
+       ap->flags &= ~ATA_FLAG_DISABLED;
 }
 
 /**
@@ -1454,27 +1589,21 @@ void ata_port_probe(struct ata_port *ap)
  */
 static void sata_print_link_status(struct ata_port *ap)
 {
-       u32 sstatus, tmp;
-       const char *speed;
+       u32 sstatus, scontrol, tmp;
 
-       if (!ap->ops->scr_read)
+       if (sata_scr_read(ap, SCR_STATUS, &sstatus))
                return;
+       sata_scr_read(ap, SCR_CONTROL, &scontrol);
 
-       sstatus = scr_read(ap, SCR_STATUS);
-
-       if (sata_dev_present(ap)) {
+       if (ata_port_online(ap)) {
                tmp = (sstatus >> 4) & 0xf;
-               if (tmp & (1 << 0))
-                       speed = "1.5";
-               else if (tmp & (1 << 1))
-                       speed = "3.0";
-               else
-                       speed = "<unknown>";
-               printk(KERN_INFO "ata%u: SATA link up %s Gbps (SStatus %X)\n",
-                      ap->id, speed, sstatus);
+               ata_port_printk(ap, KERN_INFO,
+                               "SATA link up %s (SStatus %X SControl %X)\n",
+                               sata_spd_string(tmp), sstatus, scontrol);
        } else {
-               printk(KERN_INFO "ata%u: SATA link down (SStatus %X)\n",
-                      ap->id, sstatus);
+               ata_port_printk(ap, KERN_INFO,
+                               "SATA link down (SStatus %X SControl %X)\n",
+                               sstatus, scontrol);
        }
 }
 
@@ -1497,17 +1626,18 @@ void __sata_phy_reset(struct ata_port *ap)
 
        if (ap->flags & ATA_FLAG_SATA_RESET) {
                /* issue phy wake/reset */
-               scr_write_flush(ap, SCR_CONTROL, 0x301);
+               sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
                /* Couldn't find anything in SATA I/II specs, but
                 * AHCI-1.1 10.4.2 says at least 1 ms. */
                mdelay(1);
        }
-       scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
+       /* phy wake/clear reset */
+       sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
 
        /* wait for phy to become ready, if necessary */
        do {
                msleep(200);
-               sstatus = scr_read(ap, SCR_STATUS);
+               sata_scr_read(ap, SCR_STATUS, &sstatus);
                if ((sstatus & 0xf) != 1)
                        break;
        } while (time_before(jiffies, timeout));
@@ -1516,12 +1646,12 @@ void __sata_phy_reset(struct ata_port *ap)
        sata_print_link_status(ap);
 
        /* TODO: phy layer with polling, timeouts, etc. */
-       if (sata_dev_present(ap))
+       if (!ata_port_offline(ap))
                ata_port_probe(ap);
        else
                ata_port_disable(ap);
 
-       if (ap->flags & ATA_FLAG_PORT_DISABLED)
+       if (ap->flags & ATA_FLAG_DISABLED)
                return;
 
        if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
@@ -1546,24 +1676,24 @@ void __sata_phy_reset(struct ata_port *ap)
 void sata_phy_reset(struct ata_port *ap)
 {
        __sata_phy_reset(ap);
-       if (ap->flags & ATA_FLAG_PORT_DISABLED)
+       if (ap->flags & ATA_FLAG_DISABLED)
                return;
        ata_bus_reset(ap);
 }
 
 /**
  *     ata_dev_pair            -       return other device on cable
- *     @ap: port
  *     @adev: device
  *
  *     Obtain the other device on the same cable, or if none is
  *     present NULL is returned
  */
 
-struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
+struct ata_device *ata_dev_pair(struct ata_device *adev)
 {
+       struct ata_port *ap = adev->ap;
        struct ata_device *pair = &ap->device[1 - adev->devno];
-       if (!ata_dev_present(pair))
+       if (!ata_dev_enabled(pair))
                return NULL;
        return pair;
 }
@@ -1585,7 +1715,122 @@ void ata_port_disable(struct ata_port *ap)
 {
        ap->device[0].class = ATA_DEV_NONE;
        ap->device[1].class = ATA_DEV_NONE;
-       ap->flags |= ATA_FLAG_PORT_DISABLED;
+       ap->flags |= ATA_FLAG_DISABLED;
+}
+
+/**
+ *     sata_down_spd_limit - adjust SATA spd limit downward
+ *     @ap: Port to adjust SATA spd limit for
+ *
+ *     Adjust SATA spd limit of @ap downward.  Note that this
+ *     function only adjusts the limit.  The change must be applied
+ *     using sata_set_spd().
+ *
+ *     LOCKING:
+ *     Inherited from caller.
+ *
+ *     RETURNS:
+ *     0 on success, negative errno on failure
+ */
+int sata_down_spd_limit(struct ata_port *ap)
+{
+       u32 sstatus, spd, mask;
+       int rc, highbit;
+
+       rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
+       if (rc)
+               return rc;
+
+       mask = ap->sata_spd_limit;
+       if (mask <= 1)
+               return -EINVAL;
+       highbit = fls(mask) - 1;
+       mask &= ~(1 << highbit);
+
+       spd = (sstatus >> 4) & 0xf;
+       if (spd <= 1)
+               return -EINVAL;
+       spd--;
+       mask &= (1 << spd) - 1;
+       if (!mask)
+               return -EINVAL;
+
+       ap->sata_spd_limit = mask;
+
+       ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
+                       sata_spd_string(fls(mask)));
+
+       return 0;
+}
+
+static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
+{
+       u32 spd, limit;
+
+       if (ap->sata_spd_limit == UINT_MAX)
+               limit = 0;
+       else
+               limit = fls(ap->sata_spd_limit);
+
+       spd = (*scontrol >> 4) & 0xf;
+       *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
+
+       return spd != limit;
+}
+
+/**
+ *     sata_set_spd_needed - is SATA spd configuration needed
+ *     @ap: Port in question
+ *
+ *     Test whether the spd limit in SControl matches
+ *     @ap->sata_spd_limit.  This function is used to determine
+ *     whether hardreset is necessary to apply SATA spd
+ *     configuration.
+ *
+ *     LOCKING:
+ *     Inherited from caller.
+ *
+ *     RETURNS:
+ *     1 if SATA spd configuration is needed, 0 otherwise.
+ */
+int sata_set_spd_needed(struct ata_port *ap)
+{
+       u32 scontrol;
+
+       if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
+               return 0;
+
+       return __sata_set_spd_needed(ap, &scontrol);
+}
+
+/**
+ *     sata_set_spd - set SATA spd according to spd limit
+ *     @ap: Port to set SATA spd for
+ *
+ *     Set SATA spd of @ap according to sata_spd_limit.
+ *
+ *     LOCKING:
+ *     Inherited from caller.
+ *
+ *     RETURNS:
+ *     0 if spd doesn't need to be changed, 1 if spd has been
+ *     changed.  Negative errno if SCR registers are inaccessible.
+ */
+int sata_set_spd(struct ata_port *ap)
+{
+       u32 scontrol;
+       int rc;
+
+       if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+               return rc;
+
+       if (!__sata_set_spd_needed(ap, &scontrol))
+               return 0;
+
+       if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+               return rc;
+
+       return 1;
 }
 
 /*
@@ -1736,151 +1981,196 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
        return 0;
 }
 
-static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
+/**
+ *     ata_down_xfermask_limit - adjust dev xfer masks downward
+ *     @dev: Device to adjust xfer masks
+ *     @force_pio0: Force PIO0
+ *
+ *     Adjust xfer masks of @dev downward.  Note that this function
+ *     does not apply the change.  Invoking ata_set_mode() afterwards
+ *     will apply the limit.
+ *
+ *     LOCKING:
+ *     Inherited from caller.
+ *
+ *     RETURNS:
+ *     0 on success, negative errno on failure
+ */
+int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0)
+{
+       unsigned long xfer_mask;
+       int highbit;
+
+       xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
+                                     dev->udma_mask);
+
+       if (!xfer_mask)
+               goto fail;
+       /* don't gear down to MWDMA from UDMA, go directly to PIO */
+       if (xfer_mask & ATA_MASK_UDMA)
+               xfer_mask &= ~ATA_MASK_MWDMA;
+
+       highbit = fls(xfer_mask) - 1;
+       xfer_mask &= ~(1 << highbit);
+       if (force_pio0)
+               xfer_mask &= 1 << ATA_SHIFT_PIO;
+       if (!xfer_mask)
+               goto fail;
+
+       ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
+                           &dev->udma_mask);
+
+       ata_dev_printk(dev, KERN_WARNING, "limiting speed to %s\n",
+                      ata_mode_string(xfer_mask));
+
+       return 0;
+
+ fail:
+       return -EINVAL;
+}
+
+static int ata_dev_set_mode(struct ata_device *dev)
 {
        unsigned int err_mask;
        int rc;
 
+       dev->flags &= ~ATA_DFLAG_PIO;
        if (dev->xfer_shift == ATA_SHIFT_PIO)
                dev->flags |= ATA_DFLAG_PIO;
 
-       err_mask = ata_dev_set_xfermode(ap, dev);
+       err_mask = ata_dev_set_xfermode(dev);
        if (err_mask) {
-               printk(KERN_ERR
-                      "ata%u: failed to set xfermode (err_mask=0x%x)\n",
-                      ap->id, err_mask);
+               ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
+                              "(err_mask=0x%x)\n", err_mask);
                return -EIO;
        }
 
-       rc = ata_dev_revalidate(ap, dev, 0);
-       if (rc) {
-               printk(KERN_ERR
-                      "ata%u: failed to revalidate after set xfermode\n",
-                      ap->id);
+       rc = ata_dev_revalidate(dev, 0);
+       if (rc)
                return rc;
-       }
 
        DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
                dev->xfer_shift, (int)dev->xfer_mode);
 
-       printk(KERN_INFO "ata%u: dev %u configured for %s\n",
-              ap->id, dev->devno,
-              ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
-       return 0;
-}
-
-static int ata_host_set_pio(struct ata_port *ap)
-{
-       int i;
-
-       for (i = 0; i < ATA_MAX_DEVICES; i++) {
-               struct ata_device *dev = &ap->device[i];
-
-               if (!ata_dev_present(dev))
-                       continue;
-
-               if (!dev->pio_mode) {
-                       printk(KERN_WARNING "ata%u: no PIO support for device %d.\n", ap->id, i);
-                       return -1;
-               }
-
-               dev->xfer_mode = dev->pio_mode;
-               dev->xfer_shift = ATA_SHIFT_PIO;
-               if (ap->ops->set_piomode)
-                       ap->ops->set_piomode(ap, dev);
-       }
-
+       ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
+                      ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
        return 0;
 }
 
-static void ata_host_set_dma(struct ata_port *ap)
-{
-       int i;
-
-       for (i = 0; i < ATA_MAX_DEVICES; i++) {
-               struct ata_device *dev = &ap->device[i];
-
-               if (!ata_dev_present(dev) || !dev->dma_mode)
-                       continue;
-
-               dev->xfer_mode = dev->dma_mode;
-               dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
-               if (ap->ops->set_dmamode)
-                       ap->ops->set_dmamode(ap, dev);
-       }
-}
-
 /**
  *     ata_set_mode - Program timings and issue SET FEATURES - XFER
  *     @ap: port on which timings will be programmed
+ *     @r_failed_dev: out paramter for failed device
  *
- *     Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
+ *     Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
+ *     ata_set_mode() fails, pointer to the failing device is
+ *     returned in @r_failed_dev.
  *
  *     LOCKING:
  *     PCI/etc. bus probe sem.
+ *
+ *     RETURNS:
+ *     0 on success, negative errno otherwise
  */
-static void ata_set_mode(struct ata_port *ap)
+int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
 {
-       int i, rc, used_dma = 0;
+       struct ata_device *dev;
+       int i, rc = 0, used_dma = 0, found = 0;
+
+       /* has private set_mode? */
+       if (ap->ops->set_mode) {
+               /* FIXME: make ->set_mode handle no device case and
+                * return error code and failing device on failure.
+                */
+               for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                       if (ata_dev_enabled(&ap->device[i])) {
+                               ap->ops->set_mode(ap);
+                               break;
+                       }
+               }
+               return 0;
+       }
 
        /* step 1: calculate xfer_mask */
        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-               struct ata_device *dev = &ap->device[i];
                unsigned int pio_mask, dma_mask;
 
-               if (!ata_dev_present(dev))
-                       continue;
+               dev = &ap->device[i];
 
-               ata_dev_xfermask(ap, dev);
+               if (!ata_dev_enabled(dev))
+                       continue;
 
-               /* TODO: let LLDD filter dev->*_mask here */
+               ata_dev_xfermask(dev);
 
                pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
                dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
                dev->pio_mode = ata_xfer_mask2mode(pio_mask);
                dev->dma_mode = ata_xfer_mask2mode(dma_mask);
 
+               found = 1;
                if (dev->dma_mode)
                        used_dma = 1;
        }
+       if (!found)
+               goto out;
 
        /* step 2: always set host PIO timings */
-       rc = ata_host_set_pio(ap);
-       if (rc)
-               goto err_out;
-
-       /* step 3: set host DMA timings */
-       ata_host_set_dma(ap);
-
-       /* step 4: update devices' xfer mode */
        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-               struct ata_device *dev = &ap->device[i];
-
-               if (!ata_dev_present(dev))
+               dev = &ap->device[i];
+               if (!ata_dev_enabled(dev))
                        continue;
 
-               if (ata_dev_set_mode(ap, dev))
-                       goto err_out;
-       }
-
-       /*
-        *      Record simplex status. If we selected DMA then the other
-        *      host channels are not permitted to do so.
-        */
+               if (!dev->pio_mode) {
+                       ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
+                       rc = -EINVAL;
+                       goto out;
+               }
+
+               dev->xfer_mode = dev->pio_mode;
+               dev->xfer_shift = ATA_SHIFT_PIO;
+               if (ap->ops->set_piomode)
+                       ap->ops->set_piomode(ap, dev);
+       }
+
+       /* step 3: set host DMA timings */
+       for (i = 0; i < ATA_MAX_DEVICES; i++) {
+               dev = &ap->device[i];
+
+               if (!ata_dev_enabled(dev) || !dev->dma_mode)
+                       continue;
 
+               dev->xfer_mode = dev->dma_mode;
+               dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
+               if (ap->ops->set_dmamode)
+                       ap->ops->set_dmamode(ap, dev);
+       }
+
+       /* step 4: update devices' xfer mode */
+       for (i = 0; i < ATA_MAX_DEVICES; i++) {
+               dev = &ap->device[i];
+
+               if (!ata_dev_enabled(dev))
+                       continue;
+
+               rc = ata_dev_set_mode(dev);
+               if (rc)
+                       goto out;
+       }
+
+       /* Record simplex status. If we selected DMA then the other
+        * host channels are not permitted to do so.
+        */
        if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
                ap->host_set->simplex_claimed = 1;
 
-       /*
-        *      Chip specific finalisation
-        */
+       /* step5: chip specific finalisation */
        if (ap->ops->post_set_mode)
                ap->ops->post_set_mode(ap);
 
-       return;
-
-err_out:
-       ata_port_disable(ap);
+ out:
+       if (rc)
+               *r_failed_dev = dev;
+       return rc;
 }
 
 /**
@@ -1930,8 +2220,8 @@ unsigned int ata_busy_sleep (struct ata_port *ap,
        }
 
        if (status & ATA_BUSY)
-               printk(KERN_WARNING "ata%u is slow to respond, "
-                      "please be patient\n", ap->id);
+               ata_port_printk(ap, KERN_WARNING,
+                               "port is slow to respond, please be patient\n");
 
        timeout = timer_start + tmout;
        while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
@@ -1940,8 +2230,8 @@ unsigned int ata_busy_sleep (struct ata_port *ap,
        }
 
        if (status & ATA_BUSY) {
-               printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
-                      ap->id, tmout / HZ);
+               ata_port_printk(ap, KERN_ERR, "port failed to respond "
+                               "(%lu secs)\n", tmout / HZ);
                return 1;
        }
 
@@ -2033,8 +2323,10 @@ static unsigned int ata_bus_softreset(struct ata_port *ap,
         * the bus shows 0xFF because the odd clown forgets the D7
         * pulldown resistor.
         */
-       if (ata_check_status(ap) == 0xFF)
+       if (ata_check_status(ap) == 0xFF) {
+               ata_port_printk(ap, KERN_ERR, "SRST failed (status 0xFF)\n");
                return AC_ERR_OTHER;
+       }
 
        ata_bus_post_reset(ap, devmask);
 
@@ -2058,7 +2350,7 @@ static unsigned int ata_bus_softreset(struct ata_port *ap,
  *     Obtains host_set lock.
  *
  *     SIDE EFFECTS:
- *     Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
+ *     Sets ATA_FLAG_DISABLED if bus reset fails.
  */
 
 void ata_bus_reset(struct ata_port *ap)
@@ -2126,60 +2418,195 @@ void ata_bus_reset(struct ata_port *ap)
        return;
 
 err_out:
-       printk(KERN_ERR "ata%u: disabling port\n", ap->id);
+       ata_port_printk(ap, KERN_ERR, "disabling port\n");
        ap->ops->port_disable(ap);
 
        DPRINTK("EXIT\n");
 }
 
-static int sata_phy_resume(struct ata_port *ap)
+/**
+ *     sata_phy_debounce - debounce SATA phy status
+ *     @ap: ATA port to debounce SATA phy status for
+ *     @params: timing parameters { interval, duratinon, timeout } in msec
+ *
+ *     Make sure SStatus of @ap reaches stable state, determined by
+ *     holding the same value where DET is not 1 for @duration polled
+ *     every @interval, before @timeout.  Timeout constraints the
+ *     beginning of the stable state.  Because, after hot unplugging,
+ *     DET gets stuck at 1 on some controllers, this functions waits
+ *     until timeout then returns 0 if DET is stable at 1.
+ *
+ *     LOCKING:
+ *     Kernel thread context (may sleep)
+ *
+ *     RETURNS:
+ *     0 on success, -errno on failure.
+ */
+int sata_phy_debounce(struct ata_port *ap, const unsigned long *params)
 {
-       unsigned long timeout = jiffies + (HZ * 5);
-       u32 sstatus;
+       unsigned long interval_msec = params[0];
+       unsigned long duration = params[1] * HZ / 1000;
+       unsigned long timeout = jiffies + params[2] * HZ / 1000;
+       unsigned long last_jiffies;
+       u32 last, cur;
+       int rc;
 
-       scr_write_flush(ap, SCR_CONTROL, 0x300);
+       if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
+               return rc;
+       cur &= 0xf;
 
-       /* Wait for phy to become ready, if necessary. */
-       do {
-               msleep(200);
-               sstatus = scr_read(ap, SCR_STATUS);
-               if ((sstatus & 0xf) != 1)
-                       return 0;
-       } while (time_before(jiffies, timeout));
+       last = cur;
+       last_jiffies = jiffies;
 
-       return -1;
+       while (1) {
+               msleep(interval_msec);
+               if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
+                       return rc;
+               cur &= 0xf;
+
+               /* DET stable? */
+               if (cur == last) {
+                       if (cur == 1 && time_before(jiffies, timeout))
+                               continue;
+                       if (time_after(jiffies, last_jiffies + duration))
+                               return 0;
+                       continue;
+               }
+
+               /* unstable, start over */
+               last = cur;
+               last_jiffies = jiffies;
+
+               /* check timeout */
+               if (time_after(jiffies, timeout))
+                       return -EBUSY;
+       }
 }
 
 /**
- *     ata_std_probeinit - initialize probing
- *     @ap: port to be probed
+ *     sata_phy_resume - resume SATA phy
+ *     @ap: ATA port to resume SATA phy for
+ *     @params: timing parameters { interval, duratinon, timeout } in msec
  *
- *     @ap is about to be probed.  Initialize it.  This function is
- *     to be used as standard callback for ata_drive_probe_reset().
+ *     Resume SATA phy of @ap and debounce it.
  *
- *     NOTE!!! Do not use this function as probeinit if a low level
- *     driver implements only hardreset.  Just pass NULL as probeinit
- *     in that case.  Using this function is probably okay but doing
- *     so makes reset sequence different from the original
- *     ->phy_reset implementation and Jeff nervous.  :-P
+ *     LOCKING:
+ *     Kernel thread context (may sleep)
+ *
+ *     RETURNS:
+ *     0 on success, -errno on failure.
+ */
+int sata_phy_resume(struct ata_port *ap, const unsigned long *params)
+{
+       u32 scontrol;
+       int rc;
+
+       if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+               return rc;
+
+       scontrol = (scontrol & 0x0f0) | 0x300;
+
+       if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+               return rc;
+
+       /* Some PHYs react badly if SStatus is pounded immediately
+        * after resuming.  Delay 200ms before debouncing.
+        */
+       msleep(200);
+
+       return sata_phy_debounce(ap, params);
+}
+
+static void ata_wait_spinup(struct ata_port *ap)
+{
+       struct ata_eh_context *ehc = &ap->eh_context;
+       unsigned long end, secs;
+       int rc;
+
+       /* first, debounce phy if SATA */
+       if (ap->cbl == ATA_CBL_SATA) {
+               rc = sata_phy_debounce(ap, sata_deb_timing_eh);
+
+               /* if debounced successfully and offline, no need to wait */
+               if ((rc == 0 || rc == -EOPNOTSUPP) && ata_port_offline(ap))
+                       return;
+       }
+
+       /* okay, let's give the drive time to spin up */
+       end = ehc->i.hotplug_timestamp + ATA_SPINUP_WAIT * HZ / 1000;
+       secs = ((end - jiffies) + HZ - 1) / HZ;
+
+       if (time_after(jiffies, end))
+               return;
+
+       if (secs > 5)
+               ata_port_printk(ap, KERN_INFO, "waiting for device to spin up "
+                               "(%lu secs)\n", secs);
+
+       schedule_timeout_uninterruptible(end - jiffies);
+}
+
+/**
+ *     ata_std_prereset - prepare for reset
+ *     @ap: ATA port to be reset
+ *
+ *     @ap is about to be reset.  Initialize it.
+ *
+ *     LOCKING:
+ *     Kernel thread context (may sleep)
+ *
+ *     RETURNS:
+ *     0 on success, -errno otherwise.
  */
-void ata_std_probeinit(struct ata_port *ap)
+int ata_std_prereset(struct ata_port *ap)
 {
-       if ((ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read) {
-               sata_phy_resume(ap);
-               if (sata_dev_present(ap))
-                       ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+       struct ata_eh_context *ehc = &ap->eh_context;
+       const unsigned long *timing;
+       int rc;
+
+       /* hotplug? */
+       if (ehc->i.flags & ATA_EHI_HOTPLUGGED) {
+               if (ap->flags & ATA_FLAG_HRST_TO_RESUME)
+                       ehc->i.action |= ATA_EH_HARDRESET;
+               if (ap->flags & ATA_FLAG_SKIP_D2H_BSY)
+                       ata_wait_spinup(ap);
+       }
+
+       /* if we're about to do hardreset, nothing more to do */
+       if (ehc->i.action & ATA_EH_HARDRESET)
+               return 0;
+
+       /* if SATA, resume phy */
+       if (ap->cbl == ATA_CBL_SATA) {
+               if (ap->flags & ATA_FLAG_LOADING)
+                       timing = sata_deb_timing_boot;
+               else
+                       timing = sata_deb_timing_eh;
+
+               rc = sata_phy_resume(ap, timing);
+               if (rc && rc != -EOPNOTSUPP) {
+                       /* phy resume failed */
+                       ata_port_printk(ap, KERN_WARNING, "failed to resume "
+                                       "link for reset (errno=%d)\n", rc);
+                       return rc;
+               }
        }
+
+       /* Wait for !BSY if the controller can wait for the first D2H
+        * Reg FIS and we don't know that no device is attached.
+        */
+       if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap))
+               ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+
+       return 0;
 }
 
 /**
  *     ata_std_softreset - reset host port via ATA SRST
  *     @ap: port to reset
- *     @verbose: fail verbosely
  *     @classes: resulting classes of attached devices
  *
- *     Reset host port using ATA SRST.  This function is to be used
- *     as standard callback for ata_drive_*_reset() functions.
+ *     Reset host port using ATA SRST.
  *
  *     LOCKING:
  *     Kernel thread context (may sleep)
@@ -2187,7 +2614,7 @@ void ata_std_probeinit(struct ata_port *ap)
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
+int ata_std_softreset(struct ata_port *ap, unsigned int *classes)
 {
        unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
        unsigned int devmask = 0, err_mask;
@@ -2195,7 +2622,7 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
 
        DPRINTK("ENTER\n");
 
-       if (ap->ops->scr_read && !sata_dev_present(ap)) {
+       if (ata_port_offline(ap)) {
                classes[0] = ATA_DEV_NONE;
                goto out;
        }
@@ -2213,11 +2640,7 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
        DPRINTK("about to softreset, devmask=%x\n", devmask);
        err_mask = ata_bus_softreset(ap, devmask);
        if (err_mask) {
-               if (verbose)
-                       printk(KERN_ERR "ata%u: SRST failed (err_mask=0x%x)\n",
-                              ap->id, err_mask);
-               else
-                       DPRINTK("EXIT, softreset failed (err_mask=0x%x)\n",
+               ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
                                err_mask);
                return -EIO;
        }
@@ -2235,12 +2658,9 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
 /**
  *     sata_std_hardreset - reset host port via SATA phy reset
  *     @ap: port to reset
- *     @verbose: fail verbosely
  *     @class: resulting class of attached device
  *
  *     SATA phy-reset host port using DET bits of SControl register.
- *     This function is to be used as standard callback for
- *     ata_drive_*_reset().
  *
  *     LOCKING:
  *     Kernel thread context (may sleep)
@@ -2248,35 +2668,57 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
  *     RETURNS:
  *     0 on success, -errno otherwise.
  */
-int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
+int sata_std_hardreset(struct ata_port *ap, unsigned int *class)
 {
+       u32 scontrol;
+       int rc;
+
        DPRINTK("ENTER\n");
 
-       /* Issue phy wake/reset */
-       scr_write_flush(ap, SCR_CONTROL, 0x301);
+       if (sata_set_spd_needed(ap)) {
+               /* SATA spec says nothing about how to reconfigure
+                * spd.  To be on the safe side, turn off phy during
+                * reconfiguration.  This works for at least ICH7 AHCI
+                * and Sil3124.
+                */
+               if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+                       return rc;
 
-       /*
-        * Couldn't find anything in SATA I/II specs, but AHCI-1.1
+               scontrol = (scontrol & 0x0f0) | 0x302;
+
+               if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
+                       return rc;
+
+               sata_set_spd(ap);
+       }
+
+       /* issue phy wake/reset */
+       if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
+               return rc;
+
+       scontrol = (scontrol & 0x0f0) | 0x301;
+
+       if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
+               return rc;
+
+       /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
         * 10.4.2 says at least 1 ms.
         */
        msleep(1);
 
-       /* Bring phy back */
-       sata_phy_resume(ap);
+       /* bring phy back */
+       sata_phy_resume(ap, sata_deb_timing_eh);
 
        /* TODO: phy layer with polling, timeouts, etc. */
-       if (!sata_dev_present(ap)) {
+       if (ata_port_offline(ap)) {
                *class = ATA_DEV_NONE;
                DPRINTK("EXIT, link offline\n");
                return 0;
        }
 
        if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
-               if (verbose)
-                       printk(KERN_ERR "ata%u: COMRESET failed "
-                              "(device not ready)\n", ap->id);
-               else
-                       DPRINTK("EXIT, device not ready\n");
+               ata_port_printk(ap, KERN_ERR,
+                               "COMRESET failed (device not ready)\n");
                return -EIO;
        }
 
@@ -2297,27 +2739,28 @@ int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
  *     the device might have been reset more than once using
  *     different reset methods before postreset is invoked.
  *
- *     This function is to be used as standard callback for
- *     ata_drive_*_reset().
- *
  *     LOCKING:
  *     Kernel thread context (may sleep)
  */
 void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
 {
-       DPRINTK("ENTER\n");
+       u32 serror;
 
-       /* set cable type if it isn't already set */
-       if (ap->cbl == ATA_CBL_NONE && ap->flags & ATA_FLAG_SATA)
-               ap->cbl = ATA_CBL_SATA;
+       DPRINTK("ENTER\n");
 
        /* print link status */
-       if (ap->cbl == ATA_CBL_SATA)
-               sata_print_link_status(ap);
+       sata_print_link_status(ap);
+
+       /* clear SError */
+       if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
+               sata_scr_write(ap, SCR_ERROR, serror);
 
        /* re-enable interrupts */
-       if (ap->ioaddr.ctl_addr)        /* FIXME: hack. create a hook instead */
-               ata_irq_on(ap);
+       if (!ap->ops->error_handler) {
+               /* FIXME: hack. create a hook instead */
+               if (ap->ioaddr.ctl_addr)
+                       ata_irq_on(ap);
+       }
 
        /* is double-select really necessary? */
        if (classes[0] != ATA_DEV_NONE)
@@ -2342,127 +2785,8 @@ void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
        DPRINTK("EXIT\n");
 }
 
-/**
- *     ata_std_probe_reset - standard probe reset method
- *     @ap: prot to perform probe-reset
- *     @classes: resulting classes of attached devices
- *
- *     The stock off-the-shelf ->probe_reset method.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
- *
- *     RETURNS:
- *     0 on success, -errno otherwise.
- */
-int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes)
-{
-       ata_reset_fn_t hardreset;
-
-       hardreset = NULL;
-       if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read)
-               hardreset = sata_std_hardreset;
-
-       return ata_drive_probe_reset(ap, ata_std_probeinit,
-                                    ata_std_softreset, hardreset,
-                                    ata_std_postreset, classes);
-}
-
-static int do_probe_reset(struct ata_port *ap, ata_reset_fn_t reset,
-                         ata_postreset_fn_t postreset,
-                         unsigned int *classes)
-{
-       int i, rc;
-
-       for (i = 0; i < ATA_MAX_DEVICES; i++)
-               classes[i] = ATA_DEV_UNKNOWN;
-
-       rc = reset(ap, 0, classes);
-       if (rc)
-               return rc;
-
-       /* If any class isn't ATA_DEV_UNKNOWN, consider classification
-        * is complete and convert all ATA_DEV_UNKNOWN to
-        * ATA_DEV_NONE.
-        */
-       for (i = 0; i < ATA_MAX_DEVICES; i++)
-               if (classes[i] != ATA_DEV_UNKNOWN)
-                       break;
-
-       if (i < ATA_MAX_DEVICES)
-               for (i = 0; i < ATA_MAX_DEVICES; i++)
-                       if (classes[i] == ATA_DEV_UNKNOWN)
-                               classes[i] = ATA_DEV_NONE;
-
-       if (postreset)
-               postreset(ap, classes);
-
-       return classes[0] != ATA_DEV_UNKNOWN ? 0 : -ENODEV;
-}
-
-/**
- *     ata_drive_probe_reset - Perform probe reset with given methods
- *     @ap: port to reset
- *     @probeinit: probeinit method (can be NULL)
- *     @softreset: softreset method (can be NULL)
- *     @hardreset: hardreset method (can be NULL)
- *     @postreset: postreset method (can be NULL)
- *     @classes: resulting classes of attached devices
- *
- *     Reset the specified port and classify attached devices using
- *     given methods.  This function prefers softreset but tries all
- *     possible reset sequences to reset and classify devices.  This
- *     function is intended to be used for constructing ->probe_reset
- *     callback by low level drivers.
- *
- *     Reset methods should follow the following rules.
- *
- *     - Return 0 on sucess, -errno on failure.
- *     - If classification is supported, fill classes[] with
- *       recognized class codes.
- *     - If classification is not supported, leave classes[] alone.
- *     - If verbose is non-zero, print error message on failure;
- *       otherwise, shut up.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
- *
- *     RETURNS:
- *     0 on success, -EINVAL if no reset method is avaliable, -ENODEV
- *     if classification fails, and any error code from reset
- *     methods.
- */
-int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
-                         ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
-                         ata_postreset_fn_t postreset, unsigned int *classes)
-{
-       int rc = -EINVAL;
-
-       if (probeinit)
-               probeinit(ap);
-
-       if (softreset) {
-               rc = do_probe_reset(ap, softreset, postreset, classes);
-               if (rc == 0)
-                       return 0;
-       }
-
-       if (!hardreset)
-               return rc;
-
-       rc = do_probe_reset(ap, hardreset, postreset, classes);
-       if (rc == 0 || rc != -ENODEV)
-               return rc;
-
-       if (softreset)
-               rc = do_probe_reset(ap, softreset, postreset, classes);
-
-       return rc;
-}
-
 /**
  *     ata_dev_same_device - Determine whether new ID matches configured device
- *     @ap: port on which the device to compare against resides
  *     @dev: device to compare against
  *     @new_class: class of the new device
  *     @new_id: IDENTIFY page of the new device
@@ -2477,17 +2801,16 @@ int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
  *     RETURNS:
  *     1 if @dev matches @new_class and @new_id, 0 otherwise.
  */
-static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
-                              unsigned int new_class, const u16 *new_id)
+static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
+                              const u16 *new_id)
 {
        const u16 *old_id = dev->id;
        unsigned char model[2][41], serial[2][21];
        u64 new_n_sectors;
 
        if (dev->class != new_class) {
-               printk(KERN_INFO
-                      "ata%u: dev %u class mismatch %d != %d\n",
-                      ap->id, dev->devno, dev->class, new_class);
+               ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
+                              dev->class, new_class);
                return 0;
        }
 
@@ -2498,24 +2821,22 @@ static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
        new_n_sectors = ata_id_n_sectors(new_id);
 
        if (strcmp(model[0], model[1])) {
-               printk(KERN_INFO
-                      "ata%u: dev %u model number mismatch '%s' != '%s'\n",
-                      ap->id, dev->devno, model[0], model[1]);
+               ata_dev_printk(dev, KERN_INFO, "model number mismatch "
+                              "'%s' != '%s'\n", model[0], model[1]);
                return 0;
        }
 
        if (strcmp(serial[0], serial[1])) {
-               printk(KERN_INFO
-                      "ata%u: dev %u serial number mismatch '%s' != '%s'\n",
-                      ap->id, dev->devno, serial[0], serial[1]);
+               ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
+                              "'%s' != '%s'\n", serial[0], serial[1]);
                return 0;
        }
 
        if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
-               printk(KERN_INFO
-                      "ata%u: dev %u n_sectors mismatch %llu != %llu\n",
-                      ap->id, dev->devno, (unsigned long long)dev->n_sectors,
-                      (unsigned long long)new_n_sectors);
+               ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
+                              "%llu != %llu\n",
+                              (unsigned long long)dev->n_sectors,
+                              (unsigned long long)new_n_sectors);
                return 0;
        }
 
@@ -2524,7 +2845,6 @@ static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
 
 /**
  *     ata_dev_revalidate - Revalidate ATA device
- *     @ap: port on which the device to revalidate resides
  *     @dev: device to revalidate
  *     @post_reset: is this revalidation after reset?
  *
@@ -2537,40 +2857,37 @@ static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
  *     RETURNS:
  *     0 on success, negative errno otherwise
  */
-int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
-                      int post_reset)
+int ata_dev_revalidate(struct ata_device *dev, int post_reset)
 {
-       unsigned int class;
-       u16 *id;
+       unsigned int class = dev->class;
+       u16 *id = (void *)dev->ap->sector_buf;
        int rc;
 
-       if (!ata_dev_present(dev))
-               return -ENODEV;
-
-       class = dev->class;
-       id = NULL;
+       if (!ata_dev_enabled(dev)) {
+               rc = -ENODEV;
+               goto fail;
+       }
 
-       /* allocate & read ID data */
-       rc = ata_dev_read_id(ap, dev, &class, post_reset, &id);
+       /* read ID data */
+       rc = ata_dev_read_id(dev, &class, post_reset, id);
        if (rc)
                goto fail;
 
        /* is the device still there? */
-       if (!ata_dev_same_device(ap, dev, class, id)) {
+       if (!ata_dev_same_device(dev, class, id)) {
                rc = -ENODEV;
                goto fail;
        }
 
-       kfree(dev->id);
-       dev->id = id;
+       memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
 
        /* configure device according to the new ID */
-       return ata_dev_configure(ap, dev, 0);
+       rc = ata_dev_configure(dev, 0);
+       if (rc == 0)
+               return 0;
 
  fail:
-       printk(KERN_ERR "ata%u: dev %u revalidation failed (errno=%d)\n",
-              ap->id, dev->devno, rc);
-       kfree(id);
+       ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
        return rc;
 }
 
@@ -2646,7 +2963,6 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
 
 /**
  *     ata_dev_xfermask - Compute supported xfermask of the given device
- *     @ap: Port on which the device to compute xfermask for resides
  *     @dev: Device to compute xfermask for
  *
  *     Compute supported xfermask of @dev and store it in
@@ -2661,49 +2977,61 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
  *     LOCKING:
  *     None.
  */
-static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
+static void ata_dev_xfermask(struct ata_device *dev)
 {
+       struct ata_port *ap = dev->ap;
        struct ata_host_set *hs = ap->host_set;
        unsigned long xfer_mask;
        int i;
 
-       xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
-                                     ap->udma_mask);
+       xfer_mask = ata_pack_xfermask(ap->pio_mask,
+                                     ap->mwdma_mask, ap->udma_mask);
+
+       /* Apply cable rule here.  Don't apply it early because when
+        * we handle hot plug the cable type can itself change.
+        */
+       if (ap->cbl == ATA_CBL_PATA40)
+               xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
 
        /* FIXME: Use port-wide xfermask for now */
        for (i = 0; i < ATA_MAX_DEVICES; i++) {
                struct ata_device *d = &ap->device[i];
-               if (!ata_dev_present(d))
+
+               if (ata_dev_absent(d))
+                       continue;
+
+               if (ata_dev_disabled(d)) {
+                       /* to avoid violating device selection timing */
+                       xfer_mask &= ata_pack_xfermask(d->pio_mask,
+                                                      UINT_MAX, UINT_MAX);
                        continue;
-               xfer_mask &= ata_pack_xfermask(d->pio_mask, d->mwdma_mask,
-                                              d->udma_mask);
+               }
+
+               xfer_mask &= ata_pack_xfermask(d->pio_mask,
+                                              d->mwdma_mask, d->udma_mask);
                xfer_mask &= ata_id_xfermask(d->id);
                if (ata_dma_blacklisted(d))
                        xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
-               /* Apply cable rule here. Don't apply it early because when
-                  we handle hot plug the cable type can itself change */
-               if (ap->cbl == ATA_CBL_PATA40)
-                       xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
        }
 
        if (ata_dma_blacklisted(dev))
-               printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
-                      "disabling DMA\n", ap->id, dev->devno);
+               ata_dev_printk(dev, KERN_WARNING,
+                              "device is on DMA blacklist, disabling DMA\n");
 
        if (hs->flags & ATA_HOST_SIMPLEX) {
                if (hs->simplex_claimed)
                        xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
        }
+
        if (ap->ops->mode_filter)
                xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
 
-       ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
-                           &dev->udma_mask);
+       ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
+                           &dev->mwdma_mask, &dev->udma_mask);
 }
 
 /**
  *     ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
- *     @ap: Port associated with device @dev
  *     @dev: Device to which command will be sent
  *
  *     Issue SET FEATURES - XFER MODE command to device @dev
@@ -2716,8 +3044,7 @@ static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
  *     0 on success, AC_ERR_* mask otherwise.
  */
 
-static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
-                                        struct ata_device *dev)
+static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
 {
        struct ata_taskfile tf;
        unsigned int err_mask;
@@ -2725,14 +3052,14 @@ static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
        /* set up set-features taskfile */
        DPRINTK("set features - xfer mode\n");
 
-       ata_tf_init(ap, &tf, dev->devno);
+       ata_tf_init(dev, &tf);
        tf.command = ATA_CMD_SET_FEATURES;
        tf.feature = SETFEATURES_XFER;
        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
        tf.protocol = ATA_PROT_NODATA;
        tf.nsect = dev->xfer_mode;
 
-       err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
+       err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
 
        DPRINTK("EXIT, err_mask=%x\n", err_mask);
        return err_mask;
@@ -2740,7 +3067,6 @@ static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
 
 /**
  *     ata_dev_init_params - Issue INIT DEV PARAMS command
- *     @ap: Port associated with device @dev
  *     @dev: Device to which command will be sent
  *     @heads: Number of heads (taskfile parameter)
  *     @sectors: Number of sectors (taskfile parameter)
@@ -2751,11 +3077,8 @@ static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
  *     RETURNS:
  *     0 on success, AC_ERR_* mask otherwise.
  */
-
-static unsigned int ata_dev_init_params(struct ata_port *ap,
-                                       struct ata_device *dev,
-                                       u16 heads,
-                                       u16 sectors)
+static unsigned int ata_dev_init_params(struct ata_device *dev,
+                                       u16 heads, u16 sectors)
 {
        struct ata_taskfile tf;
        unsigned int err_mask;
@@ -2767,14 +3090,14 @@ static unsigned int ata_dev_init_params(struct ata_port *ap,
        /* set up init dev params taskfile */
        DPRINTK("init dev params \n");
 
-       ata_tf_init(ap, &tf, dev->devno);
+       ata_tf_init(dev, &tf);
        tf.command = ATA_CMD_INIT_DEV_PARAMS;
        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
        tf.protocol = ATA_PROT_NODATA;
        tf.nsect = sectors;
        tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
 
-       err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
+       err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
 
        DPRINTK("EXIT, err_mask=%x\n", err_mask);
        return err_mask;
@@ -2912,6 +3235,15 @@ int ata_check_atapi_dma(struct ata_queued_cmd *qc)
        if (ap->ops->check_atapi_dma)
                rc = ap->ops->check_atapi_dma(qc);
 
+       /* We don't support polling DMA.
+        * Use PIO if the LLDD handles only interrupts in
+        * the HSM_ST_LAST state and the ATAPI device
+        * generates CDB interrupts.
+        */
+       if ((ap->flags & ATA_FLAG_PIO_POLLING) &&
+           (qc->dev->flags & ATA_DFLAG_CDB_INTR))
+               rc = 1;
+
        return rc;
 }
 /**
@@ -2957,6 +3289,7 @@ void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
        qc->n_elem = 1;
        qc->orig_n_elem = 1;
        qc->buf_virt = buf;
+       qc->nbytes = buflen;
 
        sg = qc->__sg;
        sg_init_one(sg, buf, buflen);
@@ -3140,171 +3473,44 @@ skip_map:
 }
 
 /**
- *     ata_poll_qc_complete - turn irq back on and finish qc
- *     @qc: Command to complete
- *     @err_mask: ATA status register content
+ *     swap_buf_le16 - swap halves of 16-bit words in place
+ *     @buf:  Buffer to swap
+ *     @buf_words:  Number of 16-bit words in buffer.
+ *
+ *     Swap halves of 16-bit words if needed to convert from
+ *     little-endian byte order to native cpu byte order, or
+ *     vice-versa.
  *
  *     LOCKING:
- *     None.  (grabs host lock)
+ *     Inherited from caller.
  */
-
-void ata_poll_qc_complete(struct ata_queued_cmd *qc)
+void swap_buf_le16(u16 *buf, unsigned int buf_words)
 {
-       struct ata_port *ap = qc->ap;
-       unsigned long flags;
+#ifdef __BIG_ENDIAN
+       unsigned int i;
 
-       spin_lock_irqsave(&ap->host_set->lock, flags);
-       ap->flags &= ~ATA_FLAG_NOINTR;
-       ata_irq_on(ap);
-       ata_qc_complete(qc);
-       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+       for (i = 0; i < buf_words; i++)
+               buf[i] = le16_to_cpu(buf[i]);
+#endif /* __BIG_ENDIAN */
 }
 
 /**
- *     ata_pio_poll - poll using PIO, depending on current state
- *     @ap: the target ata_port
+ *     ata_mmio_data_xfer - Transfer data by MMIO
+ *     @adev: device for this I/O
+ *     @buf: data buffer
+ *     @buflen: buffer length
+ *     @write_data: read/write
  *
- *     LOCKING:
- *     None.  (executing in kernel thread context)
+ *     Transfer data from/to the device data register by MMIO.
  *
- *     RETURNS:
- *     timeout value to use
+ *     LOCKING:
+ *     Inherited from caller.
  */
 
-static unsigned long ata_pio_poll(struct ata_port *ap)
-{
-       struct ata_queued_cmd *qc;
-       u8 status;
-       unsigned int poll_state = HSM_ST_UNKNOWN;
-       unsigned int reg_state = HSM_ST_UNKNOWN;
-
-       qc = ata_qc_from_tag(ap, ap->active_tag);
-       WARN_ON(qc == NULL);
-
-       switch (ap->hsm_task_state) {
-       case HSM_ST:
-       case HSM_ST_POLL:
-               poll_state = HSM_ST_POLL;
-               reg_state = HSM_ST;
-               break;
-       case HSM_ST_LAST:
-       case HSM_ST_LAST_POLL:
-               poll_state = HSM_ST_LAST_POLL;
-               reg_state = HSM_ST_LAST;
-               break;
-       default:
-               BUG();
-               break;
-       }
-
-       status = ata_chk_status(ap);
-       if (status & ATA_BUSY) {
-               if (time_after(jiffies, ap->pio_task_timeout)) {
-                       qc->err_mask |= AC_ERR_TIMEOUT;
-                       ap->hsm_task_state = HSM_ST_TMOUT;
-                       return 0;
-               }
-               ap->hsm_task_state = poll_state;
-               return ATA_SHORT_PAUSE;
-       }
-
-       ap->hsm_task_state = reg_state;
-       return 0;
-}
-
-/**
- *     ata_pio_complete - check if drive is busy or idle
- *     @ap: the target ata_port
- *
- *     LOCKING:
- *     None.  (executing in kernel thread context)
- *
- *     RETURNS:
- *     Non-zero if qc completed, zero otherwise.
- */
-
-static int ata_pio_complete (struct ata_port *ap)
-{
-       struct ata_queued_cmd *qc;
-       u8 drv_stat;
-
-       /*
-        * This is purely heuristic.  This is a fast path.  Sometimes when
-        * we enter, BSY will be cleared in a chk-status or two.  If not,
-        * the drive is probably seeking or something.  Snooze for a couple
-        * msecs, then chk-status again.  If still busy, fall back to
-        * HSM_ST_POLL state.
-        */
-       drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
-       if (drv_stat & ATA_BUSY) {
-               msleep(2);
-               drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
-               if (drv_stat & ATA_BUSY) {
-                       ap->hsm_task_state = HSM_ST_LAST_POLL;
-                       ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
-                       return 0;
-               }
-       }
-
-       qc = ata_qc_from_tag(ap, ap->active_tag);
-       WARN_ON(qc == NULL);
-
-       drv_stat = ata_wait_idle(ap);
-       if (!ata_ok(drv_stat)) {
-               qc->err_mask |= __ac_err_mask(drv_stat);
-               ap->hsm_task_state = HSM_ST_ERR;
-               return 0;
-       }
-
-       ap->hsm_task_state = HSM_ST_IDLE;
-
-       WARN_ON(qc->err_mask);
-       ata_poll_qc_complete(qc);
-
-       /* another command may start at this point */
-
-       return 1;
-}
-
-
-/**
- *     swap_buf_le16 - swap halves of 16-bit words in place
- *     @buf:  Buffer to swap
- *     @buf_words:  Number of 16-bit words in buffer.
- *
- *     Swap halves of 16-bit words if needed to convert from
- *     little-endian byte order to native cpu byte order, or
- *     vice-versa.
- *
- *     LOCKING:
- *     Inherited from caller.
- */
-void swap_buf_le16(u16 *buf, unsigned int buf_words)
-{
-#ifdef __BIG_ENDIAN
-       unsigned int i;
-
-       for (i = 0; i < buf_words; i++)
-               buf[i] = le16_to_cpu(buf[i]);
-#endif /* __BIG_ENDIAN */
-}
-
-/**
- *     ata_mmio_data_xfer - Transfer data by MMIO
- *     @ap: port to read/write
- *     @buf: data buffer
- *     @buflen: buffer length
- *     @write_data: read/write
- *
- *     Transfer data from/to the device data register by MMIO.
- *
- *     LOCKING:
- *     Inherited from caller.
- */
-
-static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
-                              unsigned int buflen, int write_data)
+void ata_mmio_data_xfer(struct ata_device *adev, unsigned char *buf, 
+                       unsigned int buflen, int write_data)
 {
+       struct ata_port *ap = adev->ap;
        unsigned int i;
        unsigned int words = buflen >> 1;
        u16 *buf16 = (u16 *) buf;
@@ -3336,7 +3542,7 @@ static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
 
 /**
  *     ata_pio_data_xfer - Transfer data by PIO
- *     @ap: port to read/write
+ *     @adev: device to target
  *     @buf: data buffer
  *     @buflen: buffer length
  *     @write_data: read/write
@@ -3347,9 +3553,10 @@ static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
  *     Inherited from caller.
  */
 
-static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
-                             unsigned int buflen, int write_data)
+void ata_pio_data_xfer(struct ata_device *adev, unsigned char *buf, 
+                      unsigned int buflen, int write_data)
 {
+       struct ata_port *ap = adev->ap;
        unsigned int words = buflen >> 1;
 
        /* Transfer multiple of 2 bytes */
@@ -3374,38 +3581,29 @@ static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
 }
 
 /**
- *     ata_data_xfer - Transfer data from/to the data register.
- *     @ap: port to read/write
+ *     ata_pio_data_xfer_noirq - Transfer data by PIO
+ *     @adev: device to target
  *     @buf: data buffer
  *     @buflen: buffer length
- *     @do_write: read/write
+ *     @write_data: read/write
  *
- *     Transfer data from/to the device data register.
+ *     Transfer data from/to the device data register by PIO. Do the 
+ *     transfer with interrupts disabled.
  *
  *     LOCKING:
  *     Inherited from caller.
  */
 
-static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
-                         unsigned int buflen, int do_write)
+void ata_pio_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
+                                   unsigned int buflen, int write_data)
 {
-       /* Make the crap hardware pay the costs not the good stuff */
-       if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
-               unsigned long flags;
-               local_irq_save(flags);
-               if (ap->flags & ATA_FLAG_MMIO)
-                       ata_mmio_data_xfer(ap, buf, buflen, do_write);
-               else
-                       ata_pio_data_xfer(ap, buf, buflen, do_write);
-               local_irq_restore(flags);
-       } else {
-               if (ap->flags & ATA_FLAG_MMIO)
-                       ata_mmio_data_xfer(ap, buf, buflen, do_write);
-               else
-                       ata_pio_data_xfer(ap, buf, buflen, do_write);
-       }
+       unsigned long flags;
+       local_irq_save(flags);
+       ata_pio_data_xfer(adev, buf, buflen, write_data);
+       local_irq_restore(flags);
 }
 
+
 /**
  *     ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
  *     @qc: Command on going
@@ -3435,7 +3633,24 @@ static void ata_pio_sector(struct ata_queued_cmd *qc)
        page = nth_page(page, (offset >> PAGE_SHIFT));
        offset %= PAGE_SIZE;
 
-       buf = kmap(page) + offset;
+       DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
+
+       if (PageHighMem(page)) {
+               unsigned long flags;
+
+               /* FIXME: use a bounce buffer */
+               local_irq_save(flags);
+               buf = kmap_atomic(page, KM_IRQ0);
+
+               /* do the actual data transfer */
+               ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
+
+               kunmap_atomic(buf, KM_IRQ0);
+               local_irq_restore(flags);
+       } else {
+               buf = page_address(page);
+               ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
+       }
 
        qc->cursect++;
        qc->cursg_ofs++;
@@ -3444,14 +3659,68 @@ static void ata_pio_sector(struct ata_queued_cmd *qc)
                qc->cursg++;
                qc->cursg_ofs = 0;
        }
+}
 
-       DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
+/**
+ *     ata_pio_sectors - Transfer one or many 512-byte sectors.
+ *     @qc: Command on going
+ *
+ *     Transfer one or many ATA_SECT_SIZE of data from/to the
+ *     ATA device for the DRQ request.
+ *
+ *     LOCKING:
+ *     Inherited from caller.
+ */
+
+static void ata_pio_sectors(struct ata_queued_cmd *qc)
+{
+       if (is_multi_taskfile(&qc->tf)) {
+               /* READ/WRITE MULTIPLE */
+               unsigned int nsect;
 
-       /* do the actual data transfer */
-       do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
-       ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
+               WARN_ON(qc->dev->multi_count == 0);
 
-       kunmap(page);
+               nsect = min(qc->nsect - qc->cursect, qc->dev->multi_count);
+               while (nsect--)
+                       ata_pio_sector(qc);
+       } else
+               ata_pio_sector(qc);
+}
+
+/**
+ *     atapi_send_cdb - Write CDB bytes to hardware
+ *     @ap: Port to which ATAPI device is attached.
+ *     @qc: Taskfile currently active
+ *
+ *     When device has indicated its readiness to accept
+ *     a CDB, this function is called.  Send the CDB.
+ *
+ *     LOCKING:
+ *     caller.
+ */
+
+static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
+{
+       /* send SCSI cdb */
+       DPRINTK("send cdb\n");
+       WARN_ON(qc->dev->cdb_len < 12);
+
+       ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
+       ata_altstatus(ap); /* flush */
+
+       switch (qc->tf.protocol) {
+       case ATA_PROT_ATAPI:
+               ap->hsm_task_state = HSM_ST;
+               break;
+       case ATA_PROT_ATAPI_NODATA:
+               ap->hsm_task_state = HSM_ST_LAST;
+               break;
+       case ATA_PROT_ATAPI_DMA:
+               ap->hsm_task_state = HSM_ST_LAST;
+               /* initiate bmdma */
+               ap->ops->bmdma_start(qc);
+               break;
+       }
 }
 
 /**
@@ -3492,11 +3761,11 @@ next_sg:
                unsigned int i;
 
                if (words) /* warning if bytes > 1 */
-                       printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
-                              ap->id, bytes);
+                       ata_dev_printk(qc->dev, KERN_WARNING,
+                                      "%u bytes trailing data\n", bytes);
 
                for (i = 0; i < words; i++)
-                       ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
+                       ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write);
 
                ap->hsm_task_state = HSM_ST_LAST;
                return;
@@ -3517,7 +3786,24 @@ next_sg:
        /* don't cross page boundaries */
        count = min(count, (unsigned int)PAGE_SIZE - offset);
 
-       buf = kmap(page) + offset;
+       DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
+
+       if (PageHighMem(page)) {
+               unsigned long flags;
+
+               /* FIXME: use bounce buffer */
+               local_irq_save(flags);
+               buf = kmap_atomic(page, KM_IRQ0);
+
+               /* do the actual data transfer */
+               ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
+
+               kunmap_atomic(buf, KM_IRQ0);
+               local_irq_restore(flags);
+       } else {
+               buf = page_address(page);
+               ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
+       }
 
        bytes -= count;
        qc->curbytes += count;
@@ -3528,13 +3814,6 @@ next_sg:
                qc->cursg_ofs = 0;
        }
 
-       DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
-
-       /* do the actual data transfer */
-       ata_data_xfer(ap, buf, count, do_write);
-
-       kunmap(page);
-
        if (bytes)
                goto next_sg;
 }
@@ -3556,10 +3835,16 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
        unsigned int ireason, bc_lo, bc_hi, bytes;
        int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
 
-       ap->ops->tf_read(ap, &qc->tf);
-       ireason = qc->tf.nsect;
-       bc_lo = qc->tf.lbam;
-       bc_hi = qc->tf.lbah;
+       /* Abuse qc->result_tf for temp storage of intermediate TF
+        * here to save some kernel stack usage.
+        * For normal completion, qc->result_tf is not relevant. For
+        * error, qc->result_tf is later overwritten by ata_qc_complete().
+        * So, the correctness of qc->result_tf is not affected.
+        */
+       ap->ops->tf_read(ap, &qc->result_tf);
+       ireason = qc->result_tf.nsect;
+       bc_lo = qc->result_tf.lbam;
+       bc_hi = qc->result_tf.lbah;
        bytes = (bc_hi << 8) | bc_lo;
 
        /* shall be cleared to zero, indicating xfer of data */
@@ -3571,307 +3856,365 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
        if (do_write != i_write)
                goto err_out;
 
+       VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
+
        __atapi_pio_bytes(qc, bytes);
 
        return;
 
 err_out:
-       printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
-             ap->id, dev->devno);
+       ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n");
        qc->err_mask |= AC_ERR_HSM;
        ap->hsm_task_state = HSM_ST_ERR;
 }
 
 /**
- *     ata_pio_block - start PIO on a block
+ *     ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
  *     @ap: the target ata_port
+ *     @qc: qc on going
  *
- *     LOCKING:
- *     None.  (executing in kernel thread context)
+ *     RETURNS:
+ *     1 if ok in workqueue, 0 otherwise.
  */
 
-static void ata_pio_block(struct ata_port *ap)
+static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
 {
-       struct ata_queued_cmd *qc;
-       u8 status;
+       if (qc->tf.flags & ATA_TFLAG_POLLING)
+               return 1;
 
-       /*
-        * This is purely heuristic.  This is a fast path.
-        * Sometimes when we enter, BSY will be cleared in
-        * a chk-status or two.  If not, the drive is probably seeking
-        * or something.  Snooze for a couple msecs, then
-        * chk-status again.  If still busy, fall back to
-        * HSM_ST_POLL state.
-        */
-       status = ata_busy_wait(ap, ATA_BUSY, 5);
-       if (status & ATA_BUSY) {
-               msleep(2);
-               status = ata_busy_wait(ap, ATA_BUSY, 10);
-               if (status & ATA_BUSY) {
-                       ap->hsm_task_state = HSM_ST_POLL;
-                       ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
-                       return;
-               }
+       if (ap->hsm_task_state == HSM_ST_FIRST) {
+               if (qc->tf.protocol == ATA_PROT_PIO &&
+                   (qc->tf.flags & ATA_TFLAG_WRITE))
+                   return 1;
+
+               if (is_atapi_taskfile(&qc->tf) &&
+                   !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
+                       return 1;
        }
 
-       qc = ata_qc_from_tag(ap, ap->active_tag);
-       WARN_ON(qc == NULL);
+       return 0;
+}
 
-       /* check error */
-       if (status & (ATA_ERR | ATA_DF)) {
-               qc->err_mask |= AC_ERR_DEV;
-               ap->hsm_task_state = HSM_ST_ERR;
-               return;
-       }
+/**
+ *     ata_hsm_qc_complete - finish a qc running on standard HSM
+ *     @qc: Command to complete
+ *     @in_wq: 1 if called from workqueue, 0 otherwise
+ *
+ *     Finish @qc which is running on standard HSM.
+ *
+ *     LOCKING:
+ *     If @in_wq is zero, spin_lock_irqsave(host_set lock).
+ *     Otherwise, none on entry and grabs host lock.
+ */
+static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
+{
+       struct ata_port *ap = qc->ap;
+       unsigned long flags;
 
-       /* transfer data if any */
-       if (is_atapi_taskfile(&qc->tf)) {
-               /* DRQ=0 means no more data to transfer */
-               if ((status & ATA_DRQ) == 0) {
-                       ap->hsm_task_state = HSM_ST_LAST;
-                       return;
-               }
+       if (ap->ops->error_handler) {
+               if (in_wq) {
+                       spin_lock_irqsave(&ap->host_set->lock, flags);
 
-               atapi_pio_bytes(qc);
-       } else {
-               /* handle BSY=0, DRQ=0 as error */
-               if ((status & ATA_DRQ) == 0) {
-                       qc->err_mask |= AC_ERR_HSM;
-                       ap->hsm_task_state = HSM_ST_ERR;
-                       return;
-               }
+                       /* EH might have kicked in while host_set lock
+                        * is released.
+                        */
+                       qc = ata_qc_from_tag(ap, qc->tag);
+                       if (qc) {
+                               if (likely(!(qc->err_mask & AC_ERR_HSM))) {
+                                       ata_irq_on(ap);
+                                       ata_qc_complete(qc);
+                               } else
+                                       ata_port_freeze(ap);
+                       }
 
-               ata_pio_sector(qc);
+                       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+               } else {
+                       if (likely(!(qc->err_mask & AC_ERR_HSM)))
+                               ata_qc_complete(qc);
+                       else
+                               ata_port_freeze(ap);
+               }
+       } else {
+               if (in_wq) {
+                       spin_lock_irqsave(&ap->host_set->lock, flags);
+                       ata_irq_on(ap);
+                       ata_qc_complete(qc);
+                       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+               } else
+                       ata_qc_complete(qc);
        }
 
        ata_altstatus(ap); /* flush */
 }
 
-static void ata_pio_error(struct ata_port *ap)
+/**
+ *     ata_hsm_move - move the HSM to the next state.
+ *     @ap: the target ata_port
+ *     @qc: qc on going
+ *     @status: current device status
+ *     @in_wq: 1 if called from workqueue, 0 otherwise
+ *
+ *     RETURNS:
+ *     1 when poll next status needed, 0 otherwise.
+ */
+int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
+                u8 status, int in_wq)
 {
-       struct ata_queued_cmd *qc;
-
-       qc = ata_qc_from_tag(ap, ap->active_tag);
-       WARN_ON(qc == NULL);
+       unsigned long flags = 0;
+       int poll_next;
 
-       if (qc->tf.command != ATA_CMD_PACKET)
-               printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
+       WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
 
-       /* make sure qc->err_mask is available to
-        * know what's wrong and recover
+       /* Make sure ata_qc_issue_prot() does not throw things
+        * like DMA polling into the workqueue. Notice that
+        * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
         */
-       WARN_ON(qc->err_mask == 0);
-
-       ap->hsm_task_state = HSM_ST_IDLE;
-
-       ata_poll_qc_complete(qc);
-}
-
-static void ata_pio_task(void *_data)
-{
-       struct ata_port *ap = _data;
-       unsigned long timeout;
-       int qc_completed;
+       WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
 
 fsm_start:
-       timeout = 0;
-       qc_completed = 0;
+       DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
+               ap->id, qc->tf.protocol, ap->hsm_task_state, status);
 
        switch (ap->hsm_task_state) {
-       case HSM_ST_IDLE:
-               return;
-
-       case HSM_ST:
-               ata_pio_block(ap);
-               break;
-
-       case HSM_ST_LAST:
-               qc_completed = ata_pio_complete(ap);
-               break;
-
-       case HSM_ST_POLL:
-       case HSM_ST_LAST_POLL:
-               timeout = ata_pio_poll(ap);
-               break;
-
-       case HSM_ST_TMOUT:
-       case HSM_ST_ERR:
-               ata_pio_error(ap);
-               return;
-       }
+       case HSM_ST_FIRST:
+               /* Send first data block or PACKET CDB */
 
-       if (timeout)
-               ata_port_queue_task(ap, ata_pio_task, ap, timeout);
-       else if (!qc_completed)
-               goto fsm_start;
-}
-
-/**
- *     atapi_packet_task - Write CDB bytes to hardware
- *     @_data: Port to which ATAPI device is attached.
- *
- *     When device has indicated its readiness to accept
- *     a CDB, this function is called.  Send the CDB.
- *     If DMA is to be performed, exit immediately.
- *     Otherwise, we are in polling mode, so poll
- *     status under operation succeeds or fails.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
- */
-
-static void atapi_packet_task(void *_data)
-{
-       struct ata_port *ap = _data;
-       struct ata_queued_cmd *qc;
-       u8 status;
-
-       qc = ata_qc_from_tag(ap, ap->active_tag);
-       WARN_ON(qc == NULL);
-       WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
+               /* If polling, we will stay in the work queue after
+                * sending the data. Otherwise, interrupt handler
+                * takes over after sending the data.
+                */
+               poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
+
+               /* check device status */
+               if (unlikely((status & ATA_DRQ) == 0)) {
+                       /* handle BSY=0, DRQ=0 as error */
+                       if (likely(status & (ATA_ERR | ATA_DF)))
+                               /* device stops HSM for abort/error */
+                               qc->err_mask |= AC_ERR_DEV;
+                       else
+                               /* HSM violation. Let EH handle this */
+                               qc->err_mask |= AC_ERR_HSM;
 
-       /* sleep-wait for BSY to clear */
-       DPRINTK("busy wait\n");
-       if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) {
-               qc->err_mask |= AC_ERR_TIMEOUT;
-               goto err_out;
-       }
+                       ap->hsm_task_state = HSM_ST_ERR;
+                       goto fsm_start;
+               }
 
-       /* make sure DRQ is set */
-       status = ata_chk_status(ap);
-       if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) {
-               qc->err_mask |= AC_ERR_HSM;
-               goto err_out;
-       }
+               /* Device should not ask for data transfer (DRQ=1)
+                * when it finds something wrong.
+                * We ignore DRQ here and stop the HSM by
+                * changing hsm_task_state to HSM_ST_ERR and
+                * let the EH abort the command or reset the device.
+                */
+               if (unlikely(status & (ATA_ERR | ATA_DF))) {
+                       printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
+                              ap->id, status);
+                       qc->err_mask |= AC_ERR_HSM;
+                       ap->hsm_task_state = HSM_ST_ERR;
+                       goto fsm_start;
+               }
 
-       /* send SCSI cdb */
-       DPRINTK("send cdb\n");
-       WARN_ON(qc->dev->cdb_len < 12);
+               /* Send the CDB (atapi) or the first data block (ata pio out).
+                * During the state transition, interrupt handler shouldn't
+                * be invoked before the data transfer is complete and
+                * hsm_task_state is changed. Hence, the following locking.
+                */
+               if (in_wq)
+                       spin_lock_irqsave(&ap->host_set->lock, flags);
 
-       if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
-           qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
-               unsigned long flags;
+               if (qc->tf.protocol == ATA_PROT_PIO) {
+                       /* PIO data out protocol.
+                        * send first data block.
+                        */
 
-               /* Once we're done issuing command and kicking bmdma,
-                * irq handler takes over.  To not lose irq, we need
-                * to clear NOINTR flag before sending cdb, but
-                * interrupt handler shouldn't be invoked before we're
-                * finished.  Hence, the following locking.
+                       /* ata_pio_sectors() might change the state
+                        * to HSM_ST_LAST. so, the state is changed here
+                        * before ata_pio_sectors().
+                        */
+                       ap->hsm_task_state = HSM_ST;
+                       ata_pio_sectors(qc);
+                       ata_altstatus(ap); /* flush */
+               } else
+                       /* send CDB */
+                       atapi_send_cdb(ap, qc);
+
+               if (in_wq)
+                       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+               /* if polling, ata_pio_task() handles the rest.
+                * otherwise, interrupt handler takes over from here.
                 */
-               spin_lock_irqsave(&ap->host_set->lock, flags);
-               ap->flags &= ~ATA_FLAG_NOINTR;
-               ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
-               ata_altstatus(ap); /* flush */
+               break;
 
-               if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
-                       ap->ops->bmdma_start(qc);       /* initiate bmdma */
-               spin_unlock_irqrestore(&ap->host_set->lock, flags);
-       } else {
-               ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
-               ata_altstatus(ap); /* flush */
+       case HSM_ST:
+               /* complete command or read/write the data register */
+               if (qc->tf.protocol == ATA_PROT_ATAPI) {
+                       /* ATAPI PIO protocol */
+                       if ((status & ATA_DRQ) == 0) {
+                               /* No more data to transfer or device error.
+                                * Device error will be tagged in HSM_ST_LAST.
+                                */
+                               ap->hsm_task_state = HSM_ST_LAST;
+                               goto fsm_start;
+                       }
 
-               /* PIO commands are handled by polling */
-               ap->hsm_task_state = HSM_ST;
-               ata_port_queue_task(ap, ata_pio_task, ap, 0);
-       }
+                       /* Device should not ask for data transfer (DRQ=1)
+                        * when it finds something wrong.
+                        * We ignore DRQ here and stop the HSM by
+                        * changing hsm_task_state to HSM_ST_ERR and
+                        * let the EH abort the command or reset the device.
+                        */
+                       if (unlikely(status & (ATA_ERR | ATA_DF))) {
+                               printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
+                                      ap->id, status);
+                               qc->err_mask |= AC_ERR_HSM;
+                               ap->hsm_task_state = HSM_ST_ERR;
+                               goto fsm_start;
+                       }
 
-       return;
+                       atapi_pio_bytes(qc);
 
-err_out:
-       ata_poll_qc_complete(qc);
-}
+                       if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
+                               /* bad ireason reported by device */
+                               goto fsm_start;
 
-/**
- *     ata_qc_timeout - Handle timeout of queued command
- *     @qc: Command that timed out
- *
- *     Some part of the kernel (currently, only the SCSI layer)
- *     has noticed that the active command on port @ap has not
- *     completed after a specified length of time.  Handle this
- *     condition by disabling DMA (if necessary) and completing
- *     transactions, with error if necessary.
- *
- *     This also handles the case of the "lost interrupt", where
- *     for some reason (possibly hardware bug, possibly driver bug)
- *     an interrupt was not delivered to the driver, even though the
- *     transaction completed successfully.
- *
- *     LOCKING:
- *     Inherited from SCSI layer (none, can sleep)
- */
+               } else {
+                       /* ATA PIO protocol */
+                       if (unlikely((status & ATA_DRQ) == 0)) {
+                               /* handle BSY=0, DRQ=0 as error */
+                               if (likely(status & (ATA_ERR | ATA_DF)))
+                                       /* device stops HSM for abort/error */
+                                       qc->err_mask |= AC_ERR_DEV;
+                               else
+                                       /* HSM violation. Let EH handle this */
+                                       qc->err_mask |= AC_ERR_HSM;
+
+                               ap->hsm_task_state = HSM_ST_ERR;
+                               goto fsm_start;
+                       }
 
-static void ata_qc_timeout(struct ata_queued_cmd *qc)
-{
-       struct ata_port *ap = qc->ap;
-       struct ata_host_set *host_set = ap->host_set;
-       u8 host_stat = 0, drv_stat;
-       unsigned long flags;
+                       /* For PIO reads, some devices may ask for
+                        * data transfer (DRQ=1) alone with ERR=1.
+                        * We respect DRQ here and transfer one
+                        * block of junk data before changing the
+                        * hsm_task_state to HSM_ST_ERR.
+                        *
+                        * For PIO writes, ERR=1 DRQ=1 doesn't make
+                        * sense since the data block has been
+                        * transferred to the device.
+                        */
+                       if (unlikely(status & (ATA_ERR | ATA_DF))) {
+                               /* data might be corrputed */
+                               qc->err_mask |= AC_ERR_DEV;
+
+                               if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
+                                       ata_pio_sectors(qc);
+                                       ata_altstatus(ap);
+                                       status = ata_wait_idle(ap);
+                               }
+
+                               if (status & (ATA_BUSY | ATA_DRQ))
+                                       qc->err_mask |= AC_ERR_HSM;
+
+                               /* ata_pio_sectors() might change the
+                                * state to HSM_ST_LAST. so, the state
+                                * is changed after ata_pio_sectors().
+                                */
+                               ap->hsm_task_state = HSM_ST_ERR;
+                               goto fsm_start;
+                       }
 
-       DPRINTK("ENTER\n");
+                       ata_pio_sectors(qc);
 
-       ap->hsm_task_state = HSM_ST_IDLE;
+                       if (ap->hsm_task_state == HSM_ST_LAST &&
+                           (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
+                               /* all data read */
+                               ata_altstatus(ap);
+                               status = ata_wait_idle(ap);
+                               goto fsm_start;
+                       }
+               }
 
-       spin_lock_irqsave(&host_set->lock, flags);
+               ata_altstatus(ap); /* flush */
+               poll_next = 1;
+               break;
 
-       switch (qc->tf.protocol) {
+       case HSM_ST_LAST:
+               if (unlikely(!ata_ok(status))) {
+                       qc->err_mask |= __ac_err_mask(status);
+                       ap->hsm_task_state = HSM_ST_ERR;
+                       goto fsm_start;
+               }
 
-       case ATA_PROT_DMA:
-       case ATA_PROT_ATAPI_DMA:
-               host_stat = ap->ops->bmdma_status(ap);
+               /* no more data to transfer */
+               DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
+                       ap->id, qc->dev->devno, status);
 
-               /* before we do anything else, clear DMA-Start bit */
-               ap->ops->bmdma_stop(qc);
+               WARN_ON(qc->err_mask);
 
-               /* fall through */
+               ap->hsm_task_state = HSM_ST_IDLE;
 
-       default:
-               ata_altstatus(ap);
-               drv_stat = ata_chk_status(ap);
+               /* complete taskfile transaction */
+               ata_hsm_qc_complete(qc, in_wq);
 
-               /* ack bmdma irq events */
-               ap->ops->irq_clear(ap);
+               poll_next = 0;
+               break;
 
-               printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
-                      ap->id, qc->tf.command, drv_stat, host_stat);
+       case HSM_ST_ERR:
+               /* make sure qc->err_mask is available to
+                * know what's wrong and recover
+                */
+               WARN_ON(qc->err_mask == 0);
+
+               ap->hsm_task_state = HSM_ST_IDLE;
 
                /* complete taskfile transaction */
-               qc->err_mask |= ac_err_mask(drv_stat);
+               ata_hsm_qc_complete(qc, in_wq);
+
+               poll_next = 0;
                break;
+       default:
+               poll_next = 0;
+               BUG();
        }
 
-       spin_unlock_irqrestore(&host_set->lock, flags);
-
-       ata_eh_qc_complete(qc);
-
-       DPRINTK("EXIT\n");
+       return poll_next;
 }
 
-/**
- *     ata_eng_timeout - Handle timeout of queued command
- *     @ap: Port on which timed-out command is active
- *
- *     Some part of the kernel (currently, only the SCSI layer)
- *     has noticed that the active command on port @ap has not
- *     completed after a specified length of time.  Handle this
- *     condition by disabling DMA (if necessary) and completing
- *     transactions, with error if necessary.
- *
- *     This also handles the case of the "lost interrupt", where
- *     for some reason (possibly hardware bug, possibly driver bug)
- *     an interrupt was not delivered to the driver, even though the
- *     transaction completed successfully.
- *
- *     LOCKING:
- *     Inherited from SCSI layer (none, can sleep)
- */
-
-void ata_eng_timeout(struct ata_port *ap)
+static void ata_pio_task(void *_data)
 {
-       DPRINTK("ENTER\n");
+       struct ata_queued_cmd *qc = _data;
+       struct ata_port *ap = qc->ap;
+       u8 status;
+       int poll_next;
 
-       ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
+fsm_start:
+       WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
 
-       DPRINTK("EXIT\n");
+       /*
+        * This is purely heuristic.  This is a fast path.
+        * Sometimes when we enter, BSY will be cleared in
+        * a chk-status or two.  If not, the drive is probably seeking
+        * or something.  Snooze for a couple msecs, then
+        * chk-status again.  If still busy, queue delayed work.
+        */
+       status = ata_busy_wait(ap, ATA_BUSY, 5);
+       if (status & ATA_BUSY) {
+               msleep(2);
+               status = ata_busy_wait(ap, ATA_BUSY, 10);
+               if (status & ATA_BUSY) {
+                       ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
+                       return;
+               }
+       }
+
+       /* move the HSM */
+       poll_next = ata_hsm_move(ap, qc, status, 1);
+
+       /* another command or interrupt handler
+        * may be running at this point.
+        */
+       if (poll_next)
+               goto fsm_start;
 }
 
 /**
@@ -3888,9 +4231,14 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
        struct ata_queued_cmd *qc = NULL;
        unsigned int i;
 
-       for (i = 0; i < ATA_MAX_QUEUE; i++)
-               if (!test_and_set_bit(i, &ap->qactive)) {
-                       qc = ata_qc_from_tag(ap, i);
+       /* no command while frozen */
+       if (unlikely(ap->flags & ATA_FLAG_FROZEN))
+               return NULL;
+
+       /* the last tag is reserved for internal command. */
+       for (i = 0; i < ATA_MAX_QUEUE - 1; i++)
+               if (!test_and_set_bit(i, &ap->qc_allocated)) {
+                       qc = __ata_qc_from_tag(ap, i);
                        break;
                }
 
@@ -3902,16 +4250,15 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
 
 /**
  *     ata_qc_new_init - Request an available ATA command, and initialize it
- *     @ap: Port associated with device @dev
  *     @dev: Device from whom we request an available command structure
  *
  *     LOCKING:
  *     None.
  */
 
-struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
-                                     struct ata_device *dev)
+struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
 {
+       struct ata_port *ap = dev->ap;
        struct ata_queued_cmd *qc;
 
        qc = ata_qc_new(ap);
@@ -3946,36 +4293,153 @@ void ata_qc_free(struct ata_queued_cmd *qc)
        qc->flags = 0;
        tag = qc->tag;
        if (likely(ata_tag_valid(tag))) {
-               if (tag == ap->active_tag)
-                       ap->active_tag = ATA_TAG_POISON;
                qc->tag = ATA_TAG_POISON;
-               clear_bit(tag, &ap->qactive);
+               clear_bit(tag, &ap->qc_allocated);
        }
 }
 
 void __ata_qc_complete(struct ata_queued_cmd *qc)
 {
+       struct ata_port *ap = qc->ap;
+
        WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
        WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
 
        if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
                ata_sg_clean(qc);
 
+       /* command should be marked inactive atomically with qc completion */
+       if (qc->tf.protocol == ATA_PROT_NCQ)
+               ap->sactive &= ~(1 << qc->tag);
+       else
+               ap->active_tag = ATA_TAG_POISON;
+
        /* atapi: mark qc as inactive to prevent the interrupt handler
         * from completing the command twice later, before the error handler
         * is called. (when rc != 0 and atapi request sense is needed)
         */
        qc->flags &= ~ATA_QCFLAG_ACTIVE;
+       ap->qc_active &= ~(1 << qc->tag);
 
        /* call completion callback */
        qc->complete_fn(qc);
 }
 
+/**
+ *     ata_qc_complete - Complete an active ATA command
+ *     @qc: Command to complete
+ *     @err_mask: ATA Status register contents
+ *
+ *     Indicate to the mid and upper layers that an ATA
+ *     command has completed, with either an ok or not-ok status.
+ *
+ *     LOCKING:
+ *     spin_lock_irqsave(host_set lock)
+ */
+void ata_qc_complete(struct ata_queued_cmd *qc)
+{
+       struct ata_port *ap = qc->ap;
+
+       /* XXX: New EH and old EH use different mechanisms to
+        * synchronize EH with regular execution path.
+        *
+        * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
+        * Normal execution path is responsible for not accessing a
+        * failed qc.  libata core enforces the rule by returning NULL
+        * from ata_qc_from_tag() for failed qcs.
+        *
+        * Old EH depends on ata_qc_complete() nullifying completion
+        * requests if ATA_QCFLAG_EH_SCHEDULED is set.  Old EH does
+        * not synchronize with interrupt handler.  Only PIO task is
+        * taken care of.
+        */
+       if (ap->ops->error_handler) {
+               WARN_ON(ap->flags & ATA_FLAG_FROZEN);
+
+               if (unlikely(qc->err_mask))
+                       qc->flags |= ATA_QCFLAG_FAILED;
+
+               if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
+                       if (!ata_tag_internal(qc->tag)) {
+                               /* always fill result TF for failed qc */
+                               ap->ops->tf_read(ap, &qc->result_tf);
+                               ata_qc_schedule_eh(qc);
+                               return;
+                       }
+               }
+
+               /* read result TF if requested */
+               if (qc->flags & ATA_QCFLAG_RESULT_TF)
+                       ap->ops->tf_read(ap, &qc->result_tf);
+
+               __ata_qc_complete(qc);
+       } else {
+               if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
+                       return;
+
+               /* read result TF if failed or requested */
+               if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
+                       ap->ops->tf_read(ap, &qc->result_tf);
+
+               __ata_qc_complete(qc);
+       }
+}
+
+/**
+ *     ata_qc_complete_multiple - Complete multiple qcs successfully
+ *     @ap: port in question
+ *     @qc_active: new qc_active mask
+ *     @finish_qc: LLDD callback invoked before completing a qc
+ *
+ *     Complete in-flight commands.  This functions is meant to be
+ *     called from low-level driver's interrupt routine to complete
+ *     requests normally.  ap->qc_active and @qc_active is compared
+ *     and commands are completed accordingly.
+ *
+ *     LOCKING:
+ *     spin_lock_irqsave(host_set lock)
+ *
+ *     RETURNS:
+ *     Number of completed commands on success, -errno otherwise.
+ */
+int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
+                            void (*finish_qc)(struct ata_queued_cmd *))
+{
+       int nr_done = 0;
+       u32 done_mask;
+       int i;
+
+       done_mask = ap->qc_active ^ qc_active;
+
+       if (unlikely(done_mask & qc_active)) {
+               ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
+                               "(%08x->%08x)\n", ap->qc_active, qc_active);
+               return -EINVAL;
+       }
+
+       for (i = 0; i < ATA_MAX_QUEUE; i++) {
+               struct ata_queued_cmd *qc;
+
+               if (!(done_mask & (1 << i)))
+                       continue;
+
+               if ((qc = ata_qc_from_tag(ap, i))) {
+                       if (finish_qc)
+                               finish_qc(qc);
+                       ata_qc_complete(qc);
+                       nr_done++;
+               }
+       }
+
+       return nr_done;
+}
+
 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
 {
        struct ata_port *ap = qc->ap;
 
        switch (qc->tf.protocol) {
+       case ATA_PROT_NCQ:
        case ATA_PROT_DMA:
        case ATA_PROT_ATAPI_DMA:
                return 1;
@@ -4010,8 +4474,22 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
 {
        struct ata_port *ap = qc->ap;
 
-       qc->ap->active_tag = qc->tag;
+       /* Make sure only one non-NCQ command is outstanding.  The
+        * check is skipped for old EH because it reuses active qc to
+        * request ATAPI sense.
+        */
+       WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
+
+       if (qc->tf.protocol == ATA_PROT_NCQ) {
+               WARN_ON(ap->sactive & (1 << qc->tag));
+               ap->sactive |= 1 << qc->tag;
+       } else {
+               WARN_ON(ap->sactive);
+               ap->active_tag = qc->tag;
+       }
+
        qc->flags |= ATA_QCFLAG_ACTIVE;
+       ap->qc_active |= 1 << qc->tag;
 
        if (ata_should_dma_map(qc)) {
                if (qc->flags & ATA_QCFLAG_SG) {
@@ -4061,43 +4539,105 @@ unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
 {
        struct ata_port *ap = qc->ap;
 
+       /* Use polling pio if the LLD doesn't handle
+        * interrupt driven pio and atapi CDB interrupt.
+        */
+       if (ap->flags & ATA_FLAG_PIO_POLLING) {
+               switch (qc->tf.protocol) {
+               case ATA_PROT_PIO:
+               case ATA_PROT_ATAPI:
+               case ATA_PROT_ATAPI_NODATA:
+                       qc->tf.flags |= ATA_TFLAG_POLLING;
+                       break;
+               case ATA_PROT_ATAPI_DMA:
+                       if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
+                               /* see ata_check_atapi_dma() */
+                               BUG();
+                       break;
+               default:
+                       break;
+               }
+       }
+
+       /* select the device */
        ata_dev_select(ap, qc->dev->devno, 1, 0);
 
+       /* start the command */
        switch (qc->tf.protocol) {
        case ATA_PROT_NODATA:
+               if (qc->tf.flags & ATA_TFLAG_POLLING)
+                       ata_qc_set_polling(qc);
+
                ata_tf_to_host(ap, &qc->tf);
+               ap->hsm_task_state = HSM_ST_LAST;
+
+               if (qc->tf.flags & ATA_TFLAG_POLLING)
+                       ata_port_queue_task(ap, ata_pio_task, qc, 0);
+
                break;
 
        case ATA_PROT_DMA:
+               WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
+
                ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
                ap->ops->bmdma_setup(qc);           /* set up bmdma */
                ap->ops->bmdma_start(qc);           /* initiate bmdma */
+               ap->hsm_task_state = HSM_ST_LAST;
                break;
 
-       case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
-               ata_qc_set_polling(qc);
-               ata_tf_to_host(ap, &qc->tf);
-               ap->hsm_task_state = HSM_ST;
-               ata_port_queue_task(ap, ata_pio_task, ap, 0);
-               break;
+       case ATA_PROT_PIO:
+               if (qc->tf.flags & ATA_TFLAG_POLLING)
+                       ata_qc_set_polling(qc);
 
-       case ATA_PROT_ATAPI:
-               ata_qc_set_polling(qc);
                ata_tf_to_host(ap, &qc->tf);
-               ata_port_queue_task(ap, atapi_packet_task, ap, 0);
+
+               if (qc->tf.flags & ATA_TFLAG_WRITE) {
+                       /* PIO data out protocol */
+                       ap->hsm_task_state = HSM_ST_FIRST;
+                       ata_port_queue_task(ap, ata_pio_task, qc, 0);
+
+                       /* always send first data block using
+                        * the ata_pio_task() codepath.
+                        */
+               } else {
+                       /* PIO data in protocol */
+                       ap->hsm_task_state = HSM_ST;
+
+                       if (qc->tf.flags & ATA_TFLAG_POLLING)
+                               ata_port_queue_task(ap, ata_pio_task, qc, 0);
+
+                       /* if polling, ata_pio_task() handles the rest.
+                        * otherwise, interrupt handler takes over from here.
+                        */
+               }
+
                break;
 
+       case ATA_PROT_ATAPI:
        case ATA_PROT_ATAPI_NODATA:
-               ap->flags |= ATA_FLAG_NOINTR;
+               if (qc->tf.flags & ATA_TFLAG_POLLING)
+                       ata_qc_set_polling(qc);
+
                ata_tf_to_host(ap, &qc->tf);
-               ata_port_queue_task(ap, atapi_packet_task, ap, 0);
+
+               ap->hsm_task_state = HSM_ST_FIRST;
+
+               /* send cdb by polling if no cdb interrupt */
+               if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
+                   (qc->tf.flags & ATA_TFLAG_POLLING))
+                       ata_port_queue_task(ap, ata_pio_task, qc, 0);
                break;
 
        case ATA_PROT_ATAPI_DMA:
-               ap->flags |= ATA_FLAG_NOINTR;
+               WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
+
                ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
                ap->ops->bmdma_setup(qc);           /* set up bmdma */
-               ata_port_queue_task(ap, atapi_packet_task, ap, 0);
+               ap->hsm_task_state = HSM_ST_FIRST;
+
+               /* send cdb by polling if no cdb interrupt */
+               if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
+                       ata_port_queue_task(ap, ata_pio_task, qc, 0);
                break;
 
        default:
@@ -4127,52 +4667,66 @@ unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
 inline unsigned int ata_host_intr (struct ata_port *ap,
                                   struct ata_queued_cmd *qc)
 {
-       u8 status, host_stat;
-
-       switch (qc->tf.protocol) {
-
-       case ATA_PROT_DMA:
-       case ATA_PROT_ATAPI_DMA:
-       case ATA_PROT_ATAPI:
-               /* check status of DMA engine */
-               host_stat = ap->ops->bmdma_status(ap);
-               VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
-
-               /* if it's not our irq... */
-               if (!(host_stat & ATA_DMA_INTR))
-                       goto idle_irq;
-
-               /* before we do anything else, clear DMA-Start bit */
-               ap->ops->bmdma_stop(qc);
+       u8 status, host_stat = 0;
 
-               /* fall through */
+       VPRINTK("ata%u: protocol %d task_state %d\n",
+               ap->id, qc->tf.protocol, ap->hsm_task_state);
 
-       case ATA_PROT_ATAPI_NODATA:
-       case ATA_PROT_NODATA:
-               /* check altstatus */
-               status = ata_altstatus(ap);
-               if (status & ATA_BUSY)
-                       goto idle_irq;
+       /* Check whether we are expecting interrupt in this state */
+       switch (ap->hsm_task_state) {
+       case HSM_ST_FIRST:
+               /* Some pre-ATAPI-4 devices assert INTRQ
+                * at this state when ready to receive CDB.
+                */
 
-               /* check main status, clearing INTRQ */
-               status = ata_chk_status(ap);
-               if (unlikely(status & ATA_BUSY))
+               /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
+                * The flag was turned on only for atapi devices.
+                * No need to check is_atapi_taskfile(&qc->tf) again.
+                */
+               if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
                        goto idle_irq;
-               DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
-                       ap->id, qc->tf.protocol, status);
-
-               /* ack bmdma irq events */
-               ap->ops->irq_clear(ap);
-
-               /* complete taskfile transaction */
-               qc->err_mask |= ac_err_mask(status);
-               ata_qc_complete(qc);
                break;
-
+       case HSM_ST_LAST:
+               if (qc->tf.protocol == ATA_PROT_DMA ||
+                   qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
+                       /* check status of DMA engine */
+                       host_stat = ap->ops->bmdma_status(ap);
+                       VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
+
+                       /* if it's not our irq... */
+                       if (!(host_stat & ATA_DMA_INTR))
+                               goto idle_irq;
+
+                       /* before we do anything else, clear DMA-Start bit */
+                       ap->ops->bmdma_stop(qc);
+
+                       if (unlikely(host_stat & ATA_DMA_ERR)) {
+                               /* error when transfering data to/from memory */
+                               qc->err_mask |= AC_ERR_HOST_BUS;
+                               ap->hsm_task_state = HSM_ST_ERR;
+                       }
+               }
+               break;
+       case HSM_ST:
+               break;
        default:
                goto idle_irq;
        }
 
+       /* check altstatus */
+       status = ata_altstatus(ap);
+       if (status & ATA_BUSY)
+               goto idle_irq;
+
+       /* check main status, clearing INTRQ */
+       status = ata_chk_status(ap);
+       if (unlikely(status & ATA_BUSY))
+               goto idle_irq;
+
+       /* ack bmdma irq events */
+       ap->ops->irq_clear(ap);
+
+       ata_hsm_move(ap, qc, status, 0);
        return 1;       /* irq handled */
 
 idle_irq:
@@ -4181,7 +4735,7 @@ idle_irq:
 #ifdef ATA_IRQ_TRAP
        if ((ap->stats.idle_irq % 1000) == 0) {
                ata_irq_ack(ap, 0); /* debug trap */
-               printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
+               ata_port_printk(ap, KERN_WARNING, "irq trap\n");
                return 1;
        }
 #endif
@@ -4219,11 +4773,11 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
 
                ap = host_set->ports[i];
                if (ap &&
-                   !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
+                   !(ap->flags & ATA_FLAG_DISABLED)) {
                        struct ata_queued_cmd *qc;
 
                        qc = ata_qc_from_tag(ap, ap->active_tag);
-                       if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
+                       if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
                            (qc->flags & ATA_QCFLAG_ACTIVE))
                                handled |= ata_host_intr(ap, qc);
                }
@@ -4234,32 +4788,168 @@ irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
        return IRQ_RETVAL(handled);
 }
 
+/**
+ *     sata_scr_valid - test whether SCRs are accessible
+ *     @ap: ATA port to test SCR accessibility for
+ *
+ *     Test whether SCRs are accessible for @ap.
+ *
+ *     LOCKING:
+ *     None.
+ *
+ *     RETURNS:
+ *     1 if SCRs are accessible, 0 otherwise.
+ */
+int sata_scr_valid(struct ata_port *ap)
+{
+       return ap->cbl == ATA_CBL_SATA && ap->ops->scr_read;
+}
+
+/**
+ *     sata_scr_read - read SCR register of the specified port
+ *     @ap: ATA port to read SCR for
+ *     @reg: SCR to read
+ *     @val: Place to store read value
+ *
+ *     Read SCR register @reg of @ap into *@val.  This function is
+ *     guaranteed to succeed if the cable type of the port is SATA
+ *     and the port implements ->scr_read.
+ *
+ *     LOCKING:
+ *     None.
+ *
+ *     RETURNS:
+ *     0 on success, negative errno on failure.
+ */
+int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
+{
+       if (sata_scr_valid(ap)) {
+               *val = ap->ops->scr_read(ap, reg);
+               return 0;
+       }
+       return -EOPNOTSUPP;
+}
+
+/**
+ *     sata_scr_write - write SCR register of the specified port
+ *     @ap: ATA port to write SCR for
+ *     @reg: SCR to write
+ *     @val: value to write
+ *
+ *     Write @val to SCR register @reg of @ap.  This function is
+ *     guaranteed to succeed if the cable type of the port is SATA
+ *     and the port implements ->scr_read.
+ *
+ *     LOCKING:
+ *     None.
+ *
+ *     RETURNS:
+ *     0 on success, negative errno on failure.
+ */
+int sata_scr_write(struct ata_port *ap, int reg, u32 val)
+{
+       if (sata_scr_valid(ap)) {
+               ap->ops->scr_write(ap, reg, val);
+               return 0;
+       }
+       return -EOPNOTSUPP;
+}
+
+/**
+ *     sata_scr_write_flush - write SCR register of the specified port and flush
+ *     @ap: ATA port to write SCR for
+ *     @reg: SCR to write
+ *     @val: value to write
+ *
+ *     This function is identical to sata_scr_write() except that this
+ *     function performs flush after writing to the register.
+ *
+ *     LOCKING:
+ *     None.
+ *
+ *     RETURNS:
+ *     0 on success, negative errno on failure.
+ */
+int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
+{
+       if (sata_scr_valid(ap)) {
+               ap->ops->scr_write(ap, reg, val);
+               ap->ops->scr_read(ap, reg);
+               return 0;
+       }
+       return -EOPNOTSUPP;
+}
+
+/**
+ *     ata_port_online - test whether the given port is online
+ *     @ap: ATA port to test
+ *
+ *     Test whether @ap is online.  Note that this function returns 0
+ *     if online status of @ap cannot be obtained, so
+ *     ata_port_online(ap) != !ata_port_offline(ap).
+ *
+ *     LOCKING:
+ *     None.
+ *
+ *     RETURNS:
+ *     1 if the port online status is available and online.
+ */
+int ata_port_online(struct ata_port *ap)
+{
+       u32 sstatus;
+
+       if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
+               return 1;
+       return 0;
+}
+
+/**
+ *     ata_port_offline - test whether the given port is offline
+ *     @ap: ATA port to test
+ *
+ *     Test whether @ap is offline.  Note that this function returns
+ *     0 if offline status of @ap cannot be obtained, so
+ *     ata_port_online(ap) != !ata_port_offline(ap).
+ *
+ *     LOCKING:
+ *     None.
+ *
+ *     RETURNS:
+ *     1 if the port offline status is available and offline.
+ */
+int ata_port_offline(struct ata_port *ap)
+{
+       u32 sstatus;
+
+       if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
+               return 1;
+       return 0;
+}
 
 /*
  * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
  * without filling any other registers
  */
-static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
-                            u8 cmd)
+static int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
 {
        struct ata_taskfile tf;
        int err;
 
-       ata_tf_init(ap, &tf, dev->devno);
+       ata_tf_init(dev, &tf);
 
        tf.command = cmd;
        tf.flags |= ATA_TFLAG_DEVICE;
        tf.protocol = ATA_PROT_NODATA;
 
-       err = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
+       err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
        if (err)
-               printk(KERN_ERR "%s: ata command failed: %d\n",
-                               __FUNCTION__, err);
+               ata_dev_printk(dev, KERN_ERR, "%s: ata command failed: %d\n",
+                              __FUNCTION__, err);
 
        return err;
 }
 
-static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
+static int ata_flush_cache(struct ata_device *dev)
 {
        u8 cmd;
 
@@ -4271,22 +4961,21 @@ static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
        else
                cmd = ATA_CMD_FLUSH;
 
-       return ata_do_simple_cmd(ap, dev, cmd);
+       return ata_do_simple_cmd(dev, cmd);
 }
 
-static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
+static int ata_standby_drive(struct ata_device *dev)
 {
-       return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
+       return ata_do_simple_cmd(dev, ATA_CMD_STANDBYNOW1);
 }
 
-static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
+static int ata_start_drive(struct ata_device *dev)
 {
-       return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
+       return ata_do_simple_cmd(dev, ATA_CMD_IDLEIMMEDIATE);
 }
 
 /**
  *     ata_device_resume - wakeup a previously suspended devices
- *     @ap: port the device is connected to
  *     @dev: the device to resume
  *
  *     Kick the drive back into action, by sending it an idle immediate
@@ -4294,40 +4983,47 @@ static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
  *     and host.
  *
  */
-int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
+int ata_device_resume(struct ata_device *dev)
 {
+       struct ata_port *ap = dev->ap;
+
        if (ap->flags & ATA_FLAG_SUSPENDED) {
+               struct ata_device *failed_dev;
+
                ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
                ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 200000);
+
                ap->flags &= ~ATA_FLAG_SUSPENDED;
-               ata_set_mode(ap);
+               while (ata_set_mode(ap, &failed_dev))
+                       ata_dev_disable(failed_dev);
        }
-       if (!ata_dev_present(dev))
+       if (!ata_dev_enabled(dev))
                return 0;
        if (dev->class == ATA_DEV_ATA)
-               ata_start_drive(ap, dev);
+               ata_start_drive(dev);
 
        return 0;
 }
 
 /**
  *     ata_device_suspend - prepare a device for suspend
- *     @ap: port the device is connected to
  *     @dev: the device to suspend
  *     @state: target power management state
  *
  *     Flush the cache on the drive, if appropriate, then issue a
  *     standbynow command.
  */
-int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
+int ata_device_suspend(struct ata_device *dev, pm_message_t state)
 {
-       if (!ata_dev_present(dev))
+       struct ata_port *ap = dev->ap;
+
+       if (!ata_dev_enabled(dev))
                return 0;
        if (dev->class == ATA_DEV_ATA)
-               ata_flush_cache(ap, dev);
+               ata_flush_cache(dev);
 
        if (state.event != PM_EVENT_FREEZE)
-               ata_standby_drive(ap, dev);
+               ata_standby_drive(dev);
        ap->flags |= ATA_FLAG_SUSPENDED;
        return 0;
 }
@@ -4414,6 +5110,38 @@ static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
        ap->ops->port_stop(ap);
 }
 
+/**
+ *     ata_dev_init - Initialize an ata_device structure
+ *     @dev: Device structure to initialize
+ *
+ *     Initialize @dev in preparation for probing.
+ *
+ *     LOCKING:
+ *     Inherited from caller.
+ */
+void ata_dev_init(struct ata_device *dev)
+{
+       struct ata_port *ap = dev->ap;
+       unsigned long flags;
+
+       /* SATA spd limit is bound to the first device */
+       ap->sata_spd_limit = ap->hw_sata_spd_limit;
+
+       /* High bits of dev->flags are used to record warm plug
+        * requests which occur asynchronously.  Synchronize using
+        * host_set lock.
+        */
+       spin_lock_irqsave(&ap->host_set->lock, flags);
+       dev->flags &= ~ATA_DFLAG_INIT_MASK;
+       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+       memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
+              sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
+       dev->pio_mask = UINT_MAX;
+       dev->mwdma_mask = UINT_MAX;
+       dev->udma_mask = UINT_MAX;
+}
+
 /**
  *     ata_host_init - Initialize an ata_port structure
  *     @ap: Structure to initialize
@@ -4428,7 +5156,6 @@ static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
  *     LOCKING:
  *     Inherited from caller.
  */
-
 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
                          struct ata_host_set *host_set,
                          const struct ata_probe_ent *ent, unsigned int port_no)
@@ -4441,7 +5168,7 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
        host->unique_id = ata_unique_id++;
        host->max_cmd_len = 12;
 
-       ap->flags = ATA_FLAG_PORT_DISABLED;
+       ap->flags = ATA_FLAG_DISABLED;
        ap->id = host->unique_id;
        ap->host = host;
        ap->ctl = ATA_DEVCTL_OBS;
@@ -4455,19 +5182,35 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
        ap->udma_mask = ent->udma_mask;
        ap->flags |= ent->host_flags;
        ap->ops = ent->port_ops;
-       ap->cbl = ATA_CBL_NONE;
+       ap->hw_sata_spd_limit = UINT_MAX;
        ap->active_tag = ATA_TAG_POISON;
        ap->last_ctl = 0xFF;
 
+#if defined(ATA_VERBOSE_DEBUG)
+       /* turn on all debugging levels */
+       ap->msg_enable = 0x00FF;
+#elif defined(ATA_DEBUG)
+       ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
+#else 
+       ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR;
+#endif
+
        INIT_WORK(&ap->port_task, NULL, NULL);
+       INIT_WORK(&ap->hotplug_task, ata_scsi_hotplug, ap);
+       INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan, ap);
        INIT_LIST_HEAD(&ap->eh_done_q);
+       init_waitqueue_head(&ap->eh_wait_q);
+
+       /* set cable type */
+       ap->cbl = ATA_CBL_NONE;
+       if (ap->flags & ATA_FLAG_SATA)
+               ap->cbl = ATA_CBL_SATA;
 
        for (i = 0; i < ATA_MAX_DEVICES; i++) {
                struct ata_device *dev = &ap->device[i];
+               dev->ap = ap;
                dev->devno = i;
-               dev->pio_mask = UINT_MAX;
-               dev->mwdma_mask = UINT_MAX;
-               dev->udma_mask = UINT_MAX;
+               ata_dev_init(dev);
        }
 
 #ifdef ATA_IRQ_TRAP
@@ -4503,7 +5246,7 @@ static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
 
        DPRINTK("ENTER\n");
 
-       if (!ent->port_ops->probe_reset &&
+       if (!ent->port_ops->error_handler &&
            !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
                printk(KERN_ERR "ata%u: no reset mechanism available\n",
                       port_no);
@@ -4516,7 +5259,7 @@ static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
 
        host->transportt = &ata_scsi_transport_template;
 
-       ap = (struct ata_port *) &host->hostdata[0];
+       ap = ata_shost_to_port(host);
 
        ata_host_init(ap, host, host_set, ent, port_no);
 
@@ -4549,12 +5292,12 @@ err_out:
  *     RETURNS:
  *     Number of ports registered.  Zero on error (no ports registered).
  */
-
 int ata_device_add(const struct ata_probe_ent *ent)
 {
        unsigned int count = 0, i;
        struct device *dev = ent->dev;
        struct ata_host_set *host_set;
+       int rc;
 
        DPRINTK("ENTER\n");
        /* alloc a container for our list of ATA ports (buses) */
@@ -4587,18 +5330,18 @@ int ata_device_add(const struct ata_probe_ent *ent)
                                (ap->pio_mask << ATA_SHIFT_PIO);
 
                /* print per-port info to dmesg */
-               printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
-                                "bmdma 0x%lX irq %lu\n",
-                       ap->id,
-                       ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
-                       ata_mode_string(xfer_mode_mask),
-                       ap->ioaddr.cmd_addr,
-                       ap->ioaddr.ctl_addr,
-                       ap->ioaddr.bmdma_addr,
-                       ent->irq);
+               ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%lX "
+                               "ctl 0x%lX bmdma 0x%lX irq %lu\n",
+                               ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
+                               ata_mode_string(xfer_mode_mask),
+                               ap->ioaddr.cmd_addr,
+                               ap->ioaddr.ctl_addr,
+                               ap->ioaddr.bmdma_addr,
+                               ent->irq);
 
                ata_chk_status(ap);
                host_set->ops->irq_clear(ap);
+               ata_eh_freeze_port(ap); /* freeze port before requesting IRQ */
                count++;
        }
 
@@ -4606,41 +5349,72 @@ int ata_device_add(const struct ata_probe_ent *ent)
                goto err_free_ret;
 
        /* obtain irq, that is shared between channels */
-       if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
-                       DRV_NAME, host_set))
+       rc = request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
+                        DRV_NAME, host_set);
+       if (rc) {
+               dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
+                          ent->irq, rc);
                goto err_out;
+       }
 
        /* perform each probe synchronously */
        DPRINTK("probe begin\n");
        for (i = 0; i < count; i++) {
                struct ata_port *ap;
+               u32 scontrol;
                int rc;
 
                ap = host_set->ports[i];
 
-               DPRINTK("ata%u: bus probe begin\n", ap->id);
-               rc = ata_bus_probe(ap);
-               DPRINTK("ata%u: bus probe end\n", ap->id);
-
-               if (rc) {
-                       /* FIXME: do something useful here?
-                        * Current libata behavior will
-                        * tear down everything when
-                        * the module is removed
-                        * or the h/w is unplugged.
-                        */
+               /* init sata_spd_limit to the current value */
+               if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
+                       int spd = (scontrol >> 4) & 0xf;
+                       ap->hw_sata_spd_limit &= (1 << spd) - 1;
                }
+               ap->sata_spd_limit = ap->hw_sata_spd_limit;
 
                rc = scsi_add_host(ap->host, dev);
                if (rc) {
-                       printk(KERN_ERR "ata%u: scsi_add_host failed\n",
-                              ap->id);
+                       ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n");
                        /* FIXME: do something useful here */
                        /* FIXME: handle unconditional calls to
                         * scsi_scan_host and ata_host_remove, below,
                         * at the very least
                         */
                }
+
+               if (ap->ops->error_handler) {
+                       unsigned long flags;
+
+                       ata_port_probe(ap);
+
+                       /* kick EH for boot probing */
+                       spin_lock_irqsave(&ap->host_set->lock, flags);
+
+                       ap->eh_info.probe_mask = (1 << ATA_MAX_DEVICES) - 1;
+                       ap->eh_info.action |= ATA_EH_SOFTRESET;
+
+                       ap->flags |= ATA_FLAG_LOADING;
+                       ata_port_schedule_eh(ap);
+
+                       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+                       /* wait for EH to finish */
+                       ata_port_wait_eh(ap);
+               } else {
+                       DPRINTK("ata%u: bus probe begin\n", ap->id);
+                       rc = ata_bus_probe(ap);
+                       DPRINTK("ata%u: bus probe end\n", ap->id);
+
+                       if (rc) {
+                               /* FIXME: do something useful here?
+                                * Current libata behavior will
+                                * tear down everything when
+                                * the module is removed
+                                * or the h/w is unplugged.
+                                */
+                       }
+               }
        }
 
        /* probes are done, now scan each port's disk(s) */
@@ -4667,6 +5441,63 @@ err_free_ret:
        return 0;
 }
 
+/**
+ *     ata_port_detach - Detach ATA port in prepration of device removal
+ *     @ap: ATA port to be detached
+ *
+ *     Detach all ATA devices and the associated SCSI devices of @ap;
+ *     then, remove the associated SCSI host.  @ap is guaranteed to
+ *     be quiescent on return from this function.
+ *
+ *     LOCKING:
+ *     Kernel thread context (may sleep).
+ */
+void ata_port_detach(struct ata_port *ap)
+{
+       unsigned long flags;
+       int i;
+
+       if (!ap->ops->error_handler)
+               return;
+
+       /* tell EH we're leaving & flush EH */
+       spin_lock_irqsave(&ap->host_set->lock, flags);
+       ap->flags |= ATA_FLAG_UNLOADING;
+       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+       ata_port_wait_eh(ap);
+
+       /* EH is now guaranteed to see UNLOADING, so no new device
+        * will be attached.  Disable all existing devices.
+        */
+       spin_lock_irqsave(&ap->host_set->lock, flags);
+
+       for (i = 0; i < ATA_MAX_DEVICES; i++)
+               ata_dev_disable(&ap->device[i]);
+
+       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+       /* Final freeze & EH.  All in-flight commands are aborted.  EH
+        * will be skipped and retrials will be terminated with bad
+        * target.
+        */
+       spin_lock_irqsave(&ap->host_set->lock, flags);
+       ata_port_freeze(ap);    /* won't be thawed */
+       spin_unlock_irqrestore(&ap->host_set->lock, flags);
+
+       ata_port_wait_eh(ap);
+
+       /* Flush hotplug task.  The sequence is similar to
+        * ata_port_flush_task().
+        */
+       flush_workqueue(ata_aux_wq);
+       cancel_delayed_work(&ap->hotplug_task);
+       flush_workqueue(ata_aux_wq);
+
+       /* remove the associated SCSI host */
+       scsi_remove_host(ap->host);
+}
+
 /**
  *     ata_host_set_remove - PCI layer callback for device removal
  *     @host_set: ATA host set that was removed
@@ -4680,18 +5511,15 @@ err_free_ret:
 
 void ata_host_set_remove(struct ata_host_set *host_set)
 {
-       struct ata_port *ap;
        unsigned int i;
 
-       for (i = 0; i < host_set->n_ports; i++) {
-               ap = host_set->ports[i];
-               scsi_remove_host(ap->host);
-       }
+       for (i = 0; i < host_set->n_ports; i++)
+               ata_port_detach(host_set->ports[i]);
 
        free_irq(host_set->irq, host_set);
 
        for (i = 0; i < host_set->n_ports; i++) {
-               ap = host_set->ports[i];
+               struct ata_port *ap = host_set->ports[i];
 
                ata_scsi_release(ap->host);
 
@@ -4729,15 +5557,12 @@ void ata_host_set_remove(struct ata_host_set *host_set)
 
 int ata_scsi_release(struct Scsi_Host *host)
 {
-       struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
-       int i;
+       struct ata_port *ap = ata_shost_to_port(host);
 
        DPRINTK("ENTER\n");
 
        ap->ops->port_disable(ap);
        ata_host_remove(ap, 0);
-       for (i = 0; i < ATA_MAX_DEVICES; i++)
-               kfree(ap->device[i].id);
 
        DPRINTK("EXIT\n");
        return 1;
@@ -4797,8 +5622,12 @@ void ata_pci_remove_one (struct pci_dev *pdev)
 {
        struct device *dev = pci_dev_to_dev(pdev);
        struct ata_host_set *host_set = dev_get_drvdata(dev);
+       struct ata_host_set *host_set2 = host_set->next;
 
        ata_host_set_remove(host_set);
+       if (host_set2)
+               ata_host_set_remove(host_set2);
+
        pci_release_regions(pdev);
        pci_disable_device(pdev);
        dev_set_drvdata(dev, NULL);
@@ -4863,6 +5692,12 @@ static int __init ata_init(void)
        if (!ata_wq)
                return -ENOMEM;
 
+       ata_aux_wq = create_singlethread_workqueue("ata_aux");
+       if (!ata_aux_wq) {
+               destroy_workqueue(ata_wq);
+               return -ENOMEM;
+       }
+
        printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
        return 0;
 }
@@ -4870,6 +5705,7 @@ static int __init ata_init(void)
 static void __exit ata_exit(void)
 {
        destroy_workqueue(ata_wq);
+       destroy_workqueue(ata_aux_wq);
 }
 
 module_init(ata_init);
@@ -4896,6 +5732,52 @@ int ata_ratelimit(void)
        return rc;
 }
 
+/**
+ *     ata_wait_register - wait until register value changes
+ *     @reg: IO-mapped register
+ *     @mask: Mask to apply to read register value
+ *     @val: Wait condition
+ *     @interval_msec: polling interval in milliseconds
+ *     @timeout_msec: timeout in milliseconds
+ *
+ *     Waiting for some bits of register to change is a common
+ *     operation for ATA controllers.  This function reads 32bit LE
+ *     IO-mapped register @reg and tests for the following condition.
+ *
+ *     (*@reg & mask) != val
+ *
+ *     If the condition is met, it returns; otherwise, the process is
+ *     repeated after @interval_msec until timeout.
+ *
+ *     LOCKING:
+ *     Kernel thread context (may sleep)
+ *
+ *     RETURNS:
+ *     The final register value.
+ */
+u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
+                     unsigned long interval_msec,
+                     unsigned long timeout_msec)
+{
+       unsigned long timeout;
+       u32 tmp;
+
+       tmp = ioread32(reg);
+
+       /* Calculate timeout _after_ the first read to make sure
+        * preceding writes reach the controller before starting to
+        * eat away the timeout.
+        */
+       timeout = jiffies + (timeout_msec * HZ) / 1000;
+
+       while ((tmp & mask) == val && time_before(jiffies, timeout)) {
+               msleep(interval_msec);
+               tmp = ioread32(reg);
+       }
+
+       return tmp;
+}
+
 /*
  * libata is essentially a library of internal helper functions for
  * low-level ATA host controller drivers.  As such, the API/ABI is
@@ -4903,15 +5785,20 @@ int ata_ratelimit(void)
  * Do not depend on ABI/API stability.
  */
 
+EXPORT_SYMBOL_GPL(sata_deb_timing_boot);
+EXPORT_SYMBOL_GPL(sata_deb_timing_eh);
+EXPORT_SYMBOL_GPL(sata_deb_timing_before_fsrst);
 EXPORT_SYMBOL_GPL(ata_std_bios_param);
 EXPORT_SYMBOL_GPL(ata_std_ports);
 EXPORT_SYMBOL_GPL(ata_device_add);
+EXPORT_SYMBOL_GPL(ata_port_detach);
 EXPORT_SYMBOL_GPL(ata_host_set_remove);
 EXPORT_SYMBOL_GPL(ata_sg_init);
 EXPORT_SYMBOL_GPL(ata_sg_init_one);
-EXPORT_SYMBOL_GPL(__ata_qc_complete);
+EXPORT_SYMBOL_GPL(ata_hsm_move);
+EXPORT_SYMBOL_GPL(ata_qc_complete);
+EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
-EXPORT_SYMBOL_GPL(ata_eng_timeout);
 EXPORT_SYMBOL_GPL(ata_tf_load);
 EXPORT_SYMBOL_GPL(ata_tf_read);
 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
@@ -4925,6 +5812,9 @@ EXPORT_SYMBOL_GPL(ata_port_start);
 EXPORT_SYMBOL_GPL(ata_port_stop);
 EXPORT_SYMBOL_GPL(ata_host_stop);
 EXPORT_SYMBOL_GPL(ata_interrupt);
+EXPORT_SYMBOL_GPL(ata_mmio_data_xfer);
+EXPORT_SYMBOL_GPL(ata_pio_data_xfer);
+EXPORT_SYMBOL_GPL(ata_pio_data_xfer_noirq);
 EXPORT_SYMBOL_GPL(ata_qc_prep);
 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
@@ -4932,33 +5822,46 @@ EXPORT_SYMBOL_GPL(ata_bmdma_start);
 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
 EXPORT_SYMBOL_GPL(ata_bmdma_status);
 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
+EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
+EXPORT_SYMBOL_GPL(ata_bmdma_thaw);
+EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
+EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
+EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
 EXPORT_SYMBOL_GPL(ata_port_probe);
+EXPORT_SYMBOL_GPL(sata_set_spd);
+EXPORT_SYMBOL_GPL(sata_phy_debounce);
+EXPORT_SYMBOL_GPL(sata_phy_resume);
 EXPORT_SYMBOL_GPL(sata_phy_reset);
 EXPORT_SYMBOL_GPL(__sata_phy_reset);
 EXPORT_SYMBOL_GPL(ata_bus_reset);
-EXPORT_SYMBOL_GPL(ata_std_probeinit);
+EXPORT_SYMBOL_GPL(ata_std_prereset);
 EXPORT_SYMBOL_GPL(ata_std_softreset);
 EXPORT_SYMBOL_GPL(sata_std_hardreset);
 EXPORT_SYMBOL_GPL(ata_std_postreset);
-EXPORT_SYMBOL_GPL(ata_std_probe_reset);
-EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
 EXPORT_SYMBOL_GPL(ata_dev_revalidate);
 EXPORT_SYMBOL_GPL(ata_dev_classify);
 EXPORT_SYMBOL_GPL(ata_dev_pair);
 EXPORT_SYMBOL_GPL(ata_port_disable);
 EXPORT_SYMBOL_GPL(ata_ratelimit);
+EXPORT_SYMBOL_GPL(ata_wait_register);
 EXPORT_SYMBOL_GPL(ata_busy_sleep);
 EXPORT_SYMBOL_GPL(ata_port_queue_task);
 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
+EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
+EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
 EXPORT_SYMBOL_GPL(ata_scsi_release);
 EXPORT_SYMBOL_GPL(ata_host_intr);
+EXPORT_SYMBOL_GPL(sata_scr_valid);
+EXPORT_SYMBOL_GPL(sata_scr_read);
+EXPORT_SYMBOL_GPL(sata_scr_write);
+EXPORT_SYMBOL_GPL(sata_scr_write_flush);
+EXPORT_SYMBOL_GPL(ata_port_online);
+EXPORT_SYMBOL_GPL(ata_port_offline);
 EXPORT_SYMBOL_GPL(ata_id_string);
 EXPORT_SYMBOL_GPL(ata_id_c_string);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
-EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
-EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
 
 EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
 EXPORT_SYMBOL_GPL(ata_timing_compute);
@@ -4980,3 +5883,13 @@ EXPORT_SYMBOL_GPL(ata_device_suspend);
 EXPORT_SYMBOL_GPL(ata_device_resume);
 EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
 EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
+
+EXPORT_SYMBOL_GPL(ata_eng_timeout);
+EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
+EXPORT_SYMBOL_GPL(ata_port_abort);
+EXPORT_SYMBOL_GPL(ata_port_freeze);
+EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
+EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
+EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
+EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
+EXPORT_SYMBOL_GPL(ata_do_eh);