config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / ata / libata-core.c
index ffd98e4..4a3a5ae 100644 (file)
 #include <linux/workqueue.h>
 #include <linux/scatterlist.h>
 #include <linux/io.h>
+#include <linux/async.h>
+#include <linux/log2.h>
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
 #include <asm/byteorder.h>
 #include <linux/cdrom.h>
+#include <linux/ratelimit.h>
 
 #include "libata.h"
-
+#include "libata-transport.h"
 
 /* debounce timing parameters in msecs { interval, duration, timeout } */
 const unsigned long sata_deb_timing_normal[]           = {   5,  100, 2000 };
@@ -87,15 +91,10 @@ const struct ata_port_operations sata_port_ops = {
 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 unsigned int ata_dev_set_feature(struct ata_device *dev,
-                                       u8 enable, u8 feature);
 static void ata_dev_xfermask(struct ata_device *dev);
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
 
 unsigned int ata_print_id = 1;
-static struct workqueue_struct *ata_wq;
-
-struct workqueue_struct *ata_aux_wq;
 
 struct ata_force_param {
        const char      *name;
@@ -123,19 +122,19 @@ MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link spe
 
 static int atapi_enabled = 1;
 module_param(atapi_enabled, int, 0444);
-MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
+MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on [default])");
 
 static int atapi_dmadir = 0;
 module_param(atapi_dmadir, int, 0444);
-MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
+MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");
 
 int atapi_passthru16 = 1;
 module_param(atapi_passthru16, int, 0444);
-MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");
+MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");
 
 int libata_fua = 0;
 module_param_named(fua, libata_fua, int, 0444);
-MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
+MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");
 
 static int ata_ignore_hpa;
 module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
@@ -151,11 +150,15 @@ MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
 
 int libata_noacpi = 0;
 module_param_named(noacpi, libata_noacpi, int, 0444);
-MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");
+MODULE_PARM_DESC(noacpi, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");
 
 int libata_allow_tpm = 0;
 module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
-MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands");
+MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
+
+static int atapi_an;
+module_param(atapi_an, int, 0444);
+MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");
 
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
@@ -163,6 +166,11 @@ MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
 
+static bool ata_sstatus_online(u32 sstatus)
+{
+       return (sstatus & 0xf) == 0x3;
+}
+
 /**
  *     ata_link_next - link iteration helper
  *     @link: the previous link, NULL to start
@@ -327,8 +335,7 @@ void ata_force_cbl(struct ata_port *ap)
                        continue;
 
                ap->cbl = fe->param.cbl;
-               ata_port_printk(ap, KERN_NOTICE,
-                               "FORCE: cable set to %s\n", fe->param.name);
+               ata_port_notice(ap, "FORCE: cable set to %s\n", fe->param.name);
                return;
        }
 }
@@ -370,8 +377,7 @@ static void ata_force_link_limits(struct ata_link *link)
                /* only honor the first spd limit */
                if (!did_spd && fe->param.spd_limit) {
                        link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
-                       ata_link_printk(link, KERN_NOTICE,
-                                       "FORCE: PHY spd limit set to %s\n",
+                       ata_link_notice(link, "FORCE: PHY spd limit set to %s\n",
                                        fe->param.name);
                        did_spd = true;
                }
@@ -379,7 +385,7 @@ static void ata_force_link_limits(struct ata_link *link)
                /* let lflags stack */
                if (fe->param.lflags) {
                        link->flags |= fe->param.lflags;
-                       ata_link_printk(link, KERN_NOTICE,
+                       ata_link_notice(link,
                                        "FORCE: link flag 0x%x forced -> 0x%x\n",
                                        fe->param.lflags, link->flags);
                }
@@ -434,8 +440,8 @@ static void ata_force_xfermask(struct ata_device *dev)
                        dev->pio_mask = pio_mask;
                }
 
-               ata_dev_printk(dev, KERN_NOTICE,
-                       "FORCE: xfer_mask set to %s\n", fe->param.name);
+               ata_dev_notice(dev, "FORCE: xfer_mask set to %s\n",
+                              fe->param.name);
                return;
        }
 }
@@ -478,8 +484,8 @@ static void ata_force_horkage(struct ata_device *dev)
                dev->horkage |= fe->param.horkage_on;
                dev->horkage &= ~fe->param.horkage_off;
 
-               ata_dev_printk(dev, KERN_NOTICE,
-                       "FORCE: horkage modified (%s)\n", fe->param.name);
+               ata_dev_notice(dev, "FORCE: horkage modified (%s)\n",
+                              fe->param.name);
        }
 }
 
@@ -702,7 +708,13 @@ u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
                head = tf->device & 0xf;
                sect = tf->lbal;
 
-               block = (cyl * dev->heads + head) * dev->sectors + sect;
+               if (!sect) {
+                       ata_dev_warn(dev,
+                                    "device reported invalid CHS sector 0\n");
+                       sect = 1; /* oh well */
+               }
+
+               block = (cyl * dev->heads + head) * dev->sectors + sect - 1;
        }
 
        return block;
@@ -1001,11 +1013,12 @@ const char *ata_mode_string(unsigned long xfer_mask)
        return "<n/a>";
 }
 
-static const char *sata_spd_string(unsigned int spd)
+const char *sata_spd_string(unsigned int spd)
 {
        static const char * const spd_str[] = {
                "1.5 Gbps",
                "3.0 Gbps",
+               "6.0 Gbps",
        };
 
        if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
@@ -1013,194 +1026,6 @@ static const char *sata_spd_string(unsigned int spd)
        return spd_str[spd - 1];
 }
 
-void ata_dev_disable(struct ata_device *dev)
-{
-       if (ata_dev_enabled(dev)) {
-               if (ata_msg_drv(dev->link->ap))
-                       ata_dev_printk(dev, KERN_WARNING, "disabled\n");
-               ata_acpi_on_disable(dev);
-               ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
-                                            ATA_DNXFER_QUIET);
-               dev->class++;
-       }
-}
-
-static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy)
-{
-       struct ata_link *link = dev->link;
-       struct ata_port *ap = link->ap;
-       u32 scontrol;
-       unsigned int err_mask;
-       int rc;
-
-       /*
-        * disallow DIPM for drivers which haven't set
-        * ATA_FLAG_IPM.  This is because when DIPM is enabled,
-        * phy ready will be set in the interrupt status on
-        * state changes, which will cause some drivers to
-        * think there are errors - additionally drivers will
-        * need to disable hot plug.
-        */
-       if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) {
-               ap->pm_policy = NOT_AVAILABLE;
-               return -EINVAL;
-       }
-
-       /*
-        * For DIPM, we will only enable it for the
-        * min_power setting.
-        *
-        * Why?  Because Disks are too stupid to know that
-        * If the host rejects a request to go to SLUMBER
-        * they should retry at PARTIAL, and instead it
-        * just would give up.  So, for medium_power to
-        * work at all, we need to only allow HIPM.
-        */
-       rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
-       if (rc)
-               return rc;
-
-       switch (policy) {
-       case MIN_POWER:
-               /* no restrictions on IPM transitions */
-               scontrol &= ~(0x3 << 8);
-               rc = sata_scr_write(link, SCR_CONTROL, scontrol);
-               if (rc)
-                       return rc;
-
-               /* enable DIPM */
-               if (dev->flags & ATA_DFLAG_DIPM)
-                       err_mask = ata_dev_set_feature(dev,
-                                       SETFEATURES_SATA_ENABLE, SATA_DIPM);
-               break;
-       case MEDIUM_POWER:
-               /* allow IPM to PARTIAL */
-               scontrol &= ~(0x1 << 8);
-               scontrol |= (0x2 << 8);
-               rc = sata_scr_write(link, SCR_CONTROL, scontrol);
-               if (rc)
-                       return rc;
-
-               /*
-                * we don't have to disable DIPM since IPM flags
-                * disallow transitions to SLUMBER, which effectively
-                * disable DIPM if it does not support PARTIAL
-                */
-               break;
-       case NOT_AVAILABLE:
-       case MAX_PERFORMANCE:
-               /* disable all IPM transitions */
-               scontrol |= (0x3 << 8);
-               rc = sata_scr_write(link, SCR_CONTROL, scontrol);
-               if (rc)
-                       return rc;
-
-               /*
-                * we don't have to disable DIPM since IPM flags
-                * disallow all transitions which effectively
-                * disable DIPM anyway.
-                */
-               break;
-       }
-
-       /* FIXME: handle SET FEATURES failure */
-       (void) err_mask;
-
-       return 0;
-}
-
-/**
- *     ata_dev_enable_pm - enable SATA interface power management
- *     @dev:  device to enable power management
- *     @policy: the link power management policy
- *
- *     Enable SATA Interface power management.  This will enable
- *     Device Interface Power Management (DIPM) for min_power
- *     policy, and then call driver specific callbacks for
- *     enabling Host Initiated Power management.
- *
- *     Locking: Caller.
- *     Returns: -EINVAL if IPM is not supported, 0 otherwise.
- */
-void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy)
-{
-       int rc = 0;
-       struct ata_port *ap = dev->link->ap;
-
-       /* set HIPM first, then DIPM */
-       if (ap->ops->enable_pm)
-               rc = ap->ops->enable_pm(ap, policy);
-       if (rc)
-               goto enable_pm_out;
-       rc = ata_dev_set_dipm(dev, policy);
-
-enable_pm_out:
-       if (rc)
-               ap->pm_policy = MAX_PERFORMANCE;
-       else
-               ap->pm_policy = policy;
-       return /* rc */;        /* hopefully we can use 'rc' eventually */
-}
-
-#ifdef CONFIG_PM
-/**
- *     ata_dev_disable_pm - disable SATA interface power management
- *     @dev: device to disable power management
- *
- *     Disable SATA Interface power management.  This will disable
- *     Device Interface Power Management (DIPM) without changing
- *     policy,  call driver specific callbacks for disabling Host
- *     Initiated Power management.
- *
- *     Locking: Caller.
- *     Returns: void
- */
-static void ata_dev_disable_pm(struct ata_device *dev)
-{
-       struct ata_port *ap = dev->link->ap;
-
-       ata_dev_set_dipm(dev, MAX_PERFORMANCE);
-       if (ap->ops->disable_pm)
-               ap->ops->disable_pm(ap);
-}
-#endif /* CONFIG_PM */
-
-void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
-{
-       ap->pm_policy = policy;
-       ap->link.eh_info.action |= ATA_EH_LPM;
-       ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY;
-       ata_port_schedule_eh(ap);
-}
-
-#ifdef CONFIG_PM
-static void ata_lpm_enable(struct ata_host *host)
-{
-       struct ata_link *link;
-       struct ata_port *ap;
-       struct ata_device *dev;
-       int i;
-
-       for (i = 0; i < host->n_ports; i++) {
-               ap = host->ports[i];
-               ata_for_each_link(link, ap, EDGE) {
-                       ata_for_each_dev(dev, link, ALL)
-                               ata_dev_disable_pm(dev);
-               }
-       }
-}
-
-static void ata_lpm_disable(struct ata_host *host)
-{
-       int i;
-
-       for (i = 0; i < host->n_ports; i++) {
-               struct ata_port *ap = host->ports[i];
-               ata_lpm_schedule(ap, ap->pm_policy);
-       }
-}
-#endif /* CONFIG_PM */
-
 /**
  *     ata_dev_classify - determine device type based on ATA-spec signature
  *     @tf: ATA taskfile register set for device to be identified
@@ -1235,6 +1060,9 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
         *
         * We follow the current spec and consider that 0x69/0x96
         * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
+        * Unfortunately, WDC WD1600JS-62MHB5 (a hard drive) reports
+        * SEMB signature.  This is worked around in
+        * ata_dev_read_id().
         */
        if ((tf->lbam == 0) && (tf->lbah == 0)) {
                DPRINTK("found ATA device by sig\n");
@@ -1252,8 +1080,8 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
        }
 
        if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
-               printk(KERN_INFO "ata: SEMB device ignored\n");
-               return ATA_DEV_SEMB_UNSUP; /* not yet */
+               DPRINTK("found SEMB device by sig (could be ATA device)\n");
+               return ATA_DEV_SEMB;
        }
 
        DPRINTK("unknown device\n");
@@ -1327,14 +1155,16 @@ static u64 ata_id_n_sectors(const u16 *id)
 {
        if (ata_id_has_lba(id)) {
                if (ata_id_has_lba48(id))
-                       return ata_id_u64(id, 100);
+                       return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
                else
-                       return ata_id_u32(id, 60);
+                       return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
        } else {
                if (ata_id_current_chs_valid(id))
-                       return ata_id_u32(id, 57);
+                       return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] *
+                              id[ATA_ID_CUR_SECTORS];
                else
-                       return id[1] * id[3] * id[6];
+                       return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] *
+                              id[ATA_ID_SECTORS];
        }
 }
 
@@ -1398,8 +1228,9 @@ static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
 
        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
        if (err_mask) {
-               ata_dev_printk(dev, KERN_WARNING, "failed to read native "
-                              "max address (err_mask=0x%x)\n", err_mask);
+               ata_dev_warn(dev,
+                            "failed to read native max address (err_mask=0x%x)\n",
+                            err_mask);
                if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
                        return -EACCES;
                return -EIO;
@@ -1460,8 +1291,9 @@ static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
 
        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
        if (err_mask) {
-               ata_dev_printk(dev, KERN_WARNING, "failed to set "
-                              "max address (err_mask=0x%x)\n", err_mask);
+               ata_dev_warn(dev,
+                            "failed to set max address (err_mask=0x%x)\n",
+                            err_mask);
                if (err_mask == AC_ERR_DEV &&
                    (tf.feature & (ATA_ABORTED | ATA_IDNF)))
                        return -EACCES;
@@ -1486,6 +1318,7 @@ static int ata_hpa_resize(struct ata_device *dev)
 {
        struct ata_eh_context *ehc = &dev->link->eh_context;
        int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
+       bool unlock_hpa = ata_ignore_hpa || dev->flags & ATA_DFLAG_UNLOCK_HPA;
        u64 sectors = ata_id_n_sectors(dev->id);
        u64 native_sectors;
        int rc;
@@ -1502,9 +1335,9 @@ static int ata_hpa_resize(struct ata_device *dev)
                /* If device aborted the command or HPA isn't going to
                 * be unlocked, skip HPA resizing.
                 */
-               if (rc == -EACCES || !ata_ignore_hpa) {
-                       ata_dev_printk(dev, KERN_WARNING, "HPA support seems "
-                                      "broken, skipping HPA handling\n");
+               if (rc == -EACCES || !unlock_hpa) {
+                       ata_dev_warn(dev,
+                                    "HPA support seems broken, skipping HPA handling\n");
                        dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
 
                        /* we can continue if device aborted the command */
@@ -1514,21 +1347,21 @@ static int ata_hpa_resize(struct ata_device *dev)
 
                return rc;
        }
+       dev->n_native_sectors = native_sectors;
 
        /* nothing to do? */
-       if (native_sectors <= sectors || !ata_ignore_hpa) {
+       if (native_sectors <= sectors || !unlock_hpa) {
                if (!print_info || native_sectors == sectors)
                        return 0;
 
                if (native_sectors > sectors)
-                       ata_dev_printk(dev, KERN_INFO,
+                       ata_dev_info(dev,
                                "HPA detected: current %llu, native %llu\n",
                                (unsigned long long)sectors,
                                (unsigned long long)native_sectors);
                else if (native_sectors < sectors)
-                       ata_dev_printk(dev, KERN_WARNING,
-                               "native sectors (%llu) is smaller than "
-                               "sectors (%llu)\n",
+                       ata_dev_warn(dev,
+                               "native sectors (%llu) is smaller than sectors (%llu)\n",
                                (unsigned long long)native_sectors,
                                (unsigned long long)sectors);
                return 0;
@@ -1538,10 +1371,10 @@ static int ata_hpa_resize(struct ata_device *dev)
        rc = ata_set_max_sectors(dev, native_sectors);
        if (rc == -EACCES) {
                /* if device aborted the command, skip HPA resizing */
-               ata_dev_printk(dev, KERN_WARNING, "device aborted resize "
-                              "(%llu -> %llu), skipping HPA handling\n",
-                              (unsigned long long)sectors,
-                              (unsigned long long)native_sectors);
+               ata_dev_warn(dev,
+                            "device aborted resize (%llu -> %llu), skipping HPA handling\n",
+                            (unsigned long long)sectors,
+                            (unsigned long long)native_sectors);
                dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
                return 0;
        } else if (rc)
@@ -1550,14 +1383,14 @@ static int ata_hpa_resize(struct ata_device *dev)
        /* re-read IDENTIFY data */
        rc = ata_dev_reread_id(dev, 0);
        if (rc) {
-               ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY "
-                              "data after HPA resizing\n");
+               ata_dev_err(dev,
+                           "failed to re-read IDENTIFY data after HPA resizing\n");
                return rc;
        }
 
        if (print_info) {
                u64 new_sectors = ata_id_n_sectors(dev->id);
-               ata_dev_printk(dev, KERN_INFO,
+               ata_dev_info(dev,
                        "HPA unlocked: %llu -> %llu, native %llu\n",
                        (unsigned long long)sectors,
                        (unsigned long long)new_sectors,
@@ -1655,8 +1488,8 @@ unsigned long ata_id_xfermask(const u16 *id)
                /*
                 *      Process compact flash extended modes
                 */
-               int pio = id[163] & 0x7;
-               int dma = (id[163] >> 3) & 7;
+               int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7;
+               int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7;
 
                if (pio)
                        pio_mask |= (1 << 5);
@@ -1675,52 +1508,6 @@ unsigned long ata_id_xfermask(const u16 *id)
        return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
 }
 
-/**
- *     ata_pio_queue_task - Queue port_task
- *     @ap: The ata_port to queue port_task for
- *     @data: data for @fn to use
- *     @delay: delay time in msecs for workqueue function
- *
- *     Schedule @fn(@data) for execution after @delay jiffies using
- *     port_task.  There is one port_task per port and it's the
- *     user(low level driver)'s responsibility to make sure that only
- *     one task is active at any given time.
- *
- *     libata core layer takes care of synchronization between
- *     port_task and EH.  ata_pio_queue_task() may be ignored for EH
- *     synchronization.
- *
- *     LOCKING:
- *     Inherited from caller.
- */
-void ata_pio_queue_task(struct ata_port *ap, void *data, unsigned long delay)
-{
-       ap->port_task_data = data;
-
-       /* may fail if ata_port_flush_task() in progress */
-       queue_delayed_work(ata_wq, &ap->port_task, msecs_to_jiffies(delay));
-}
-
-/**
- *     ata_port_flush_task - Flush port_task
- *     @ap: The ata_port to flush port_task for
- *
- *     After this function completes, port_task is guranteed not to
- *     be running or scheduled.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
- */
-void ata_port_flush_task(struct ata_port *ap)
-{
-       DPRINTK("ENTER\n");
-
-       cancel_rearming_delayed_work(&ap->port_task);
-
-       if (ata_msg_ctl(ap))
-               ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __func__);
-}
-
 static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
 {
        struct completion *waiting = qc->private_data;
@@ -1840,9 +1627,15 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
                }
        }
 
+       if (ap->ops->error_handler)
+               ata_eh_release(ap);
+
        rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
 
-       ata_port_flush_task(ap);
+       if (ap->ops->error_handler)
+               ata_eh_acquire(ap);
+
+       ata_sff_flush_pio_task(ap);
 
        if (!rc) {
                spin_lock_irqsave(ap->lock, flags);
@@ -1861,8 +1654,8 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
                                ata_qc_complete(qc);
 
                        if (ata_msg_warn(ap))
-                               ata_dev_printk(dev, KERN_WARNING,
-                                       "qc timeout (cmd 0x%x)\n", command);
+                               ata_dev_warn(dev, "qc timeout (cmd 0x%x)\n",
+                                            command);
                }
 
                spin_unlock_irqrestore(ap->lock, flags);
@@ -1896,22 +1689,6 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
        ap->qc_active = preempted_qc_active;
        ap->nr_active_links = preempted_nr_active_links;
 
-       /* XXX - Some LLDDs (sata_mv) disable port on command failure.
-        * Until those drivers are fixed, we detect the condition
-        * here, fail the command with AC_ERR_SYSTEM and reenable the
-        * port.
-        *
-        * Note that this doesn't change any behavior as internal
-        * command failure results in disabling the device in the
-        * higher layer for LLDDs without new reset/EH callbacks.
-        *
-        * Kill the following code as soon as those drivers are fixed.
-        */
-       if (ap->flags & ATA_FLAG_DISABLED) {
-               err_mask |= AC_ERR_SYSTEM;
-               ata_port_probe(ap);
-       }
-
        spin_unlock_irqrestore(ap->lock, flags);
 
        if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
@@ -1992,13 +1769,23 @@ unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
  *     Check if the current speed of the device requires IORDY. Used
  *     by various controllers for chip configuration.
  */
-
 unsigned int ata_pio_need_iordy(const struct ata_device *adev)
 {
-       /* Controller doesn't support  IORDY. Probably a pointless check
-          as the caller should know this */
+       /* Don't set IORDY if we're preparing for reset.  IORDY may
+        * lead to controller lock up on certain controllers if the
+        * port is not occupied.  See bko#11703 for details.
+        */
+       if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
+               return 0;
+       /* Controller doesn't support IORDY.  Probably a pointless
+        * check as the caller should know this.
+        */
        if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
                return 0;
+       /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6.  */
+       if (ata_id_is_cfa(adev->id)
+           && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6))
+               return 0;
        /* PIO3 and higher it is mandatory */
        if (adev->pio_mode > XFER_PIO_2)
                return 1;
@@ -2015,7 +1802,6 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
  *     Compute the highest mode possible if we are not using iordy. Return
  *     -1 if no iordy mode is available.
  */
-
 static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
 {
        /* If we have no drive specific rule, then PIO 2 is non IORDY */
@@ -2078,16 +1864,19 @@ int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
        struct ata_taskfile tf;
        unsigned int err_mask = 0;
        const char *reason;
+       bool is_semb = class == ATA_DEV_SEMB;
        int may_fallback = 1, tried_spinup = 0;
        int rc;
 
        if (ata_msg_ctl(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __func__);
+               ata_dev_dbg(dev, "%s: ENTER\n", __func__);
 
 retry:
        ata_tf_init(dev, &tf);
 
        switch (class) {
+       case ATA_DEV_SEMB:
+               class = ATA_DEV_ATA;    /* some hard drives report SEMB sig */
        case ATA_DEV_ATA:
                tf.command = ATA_CMD_ID_ATA;
                break;
@@ -2119,11 +1908,18 @@ retry:
 
        if (err_mask) {
                if (err_mask & AC_ERR_NODEV_HINT) {
-                       ata_dev_printk(dev, KERN_DEBUG,
-                                      "NODEV after polling detection\n");
+                       ata_dev_dbg(dev, "NODEV after polling detection\n");
                        return -ENOENT;
                }
 
+               if (is_semb) {
+                       ata_dev_info(dev,
+                    "IDENTIFY failed on device w/ SEMB sig, disabled\n");
+                       /* SEMB is not supported yet */
+                       *p_class = ATA_DEV_SEMB_UNSUP;
+                       return 0;
+               }
+
                if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
                        /* Device or controller might have reported
                         * the wrong device class.  Give a shot at the
@@ -2144,8 +1940,8 @@ retry:
                         * both flavors of IDENTIFYs which happens
                         * sometimes with phantom devices.
                         */
-                       ata_dev_printk(dev, KERN_DEBUG,
-                                      "both IDENTIFYs aborted, assuming NODEV\n");
+                       ata_dev_dbg(dev,
+                                   "both IDENTIFYs aborted, assuming NODEV\n");
                        return -ENOENT;
                }
 
@@ -2154,6 +1950,14 @@ retry:
                goto err_out;
        }
 
+       if (dev->horkage & ATA_HORKAGE_DUMP_ID) {
+               ata_dev_dbg(dev, "dumping IDENTIFY data, "
+                           "class=%d may_fallback=%d tried_spinup=%d\n",
+                           class, may_fallback, tried_spinup);
+               print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
+                              16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
+       }
+
        /* Falling back doesn't make sense if ID data was read
         * successfully at least once.
         */
@@ -2204,7 +2008,7 @@ retry:
                 * Some drives were very specific about that exact sequence.
                 *
                 * Note that ATA4 says lba is mandatory so the second check
-                * shoud never trigger.
+                * should never trigger.
                 */
                if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
                        err_mask = ata_dev_init_params(dev, id[3], id[6]);
@@ -2228,11 +2032,44 @@ retry:
 
  err_out:
        if (ata_msg_warn(ap))
-               ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
-                              "(%s, err_mask=0x%x)\n", reason, err_mask);
+               ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask=0x%x)\n",
+                            reason, err_mask);
        return rc;
 }
 
+static int ata_do_link_spd_horkage(struct ata_device *dev)
+{
+       struct ata_link *plink = ata_dev_phys_link(dev);
+       u32 target, target_limit;
+
+       if (!sata_scr_valid(plink))
+               return 0;
+
+       if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
+               target = 1;
+       else
+               return 0;
+
+       target_limit = (1 << target) - 1;
+
+       /* if already on stricter limit, no need to push further */
+       if (plink->sata_spd_limit <= target_limit)
+               return 0;
+
+       plink->sata_spd_limit = target_limit;
+
+       /* Request another EH round by returning -EAGAIN if link is
+        * going faster than the target speed.  Forward progress is
+        * guaranteed by setting sata_spd_limit to target_limit above.
+        */
+       if (plink->sata_spd > target) {
+               ata_dev_info(dev, "applying link speed limit horkage to %s\n",
+                            sata_spd_string(target));
+               return -EAGAIN;
+       }
+       return 0;
+}
+
 static inline u8 ata_dev_knobble(struct ata_device *dev)
 {
        struct ata_port *ap = dev->link->ap;
@@ -2243,29 +2080,50 @@ static inline u8 ata_dev_knobble(struct ata_device *dev)
        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
 }
 
-static void ata_dev_config_ncq(struct ata_device *dev,
+static int ata_dev_config_ncq(struct ata_device *dev,
                               char *desc, size_t desc_sz)
 {
        struct ata_port *ap = dev->link->ap;
        int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
+       unsigned int err_mask;
+       char *aa_desc = "";
 
        if (!ata_id_has_ncq(dev->id)) {
                desc[0] = '\0';
-               return;
+               return 0;
        }
        if (dev->horkage & ATA_HORKAGE_NONCQ) {
                snprintf(desc, desc_sz, "NCQ (not used)");
-               return;
+               return 0;
        }
        if (ap->flags & ATA_FLAG_NCQ) {
                hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
                dev->flags |= ATA_DFLAG_NCQ;
        }
 
+       if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
+               (ap->flags & ATA_FLAG_FPDMA_AA) &&
+               ata_id_has_fpdma_aa(dev->id)) {
+               err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
+                       SATA_FPDMA_AA);
+               if (err_mask) {
+                       ata_dev_err(dev,
+                                   "failed to enable AA (error_mask=0x%x)\n",
+                                   err_mask);
+                       if (err_mask != AC_ERR_DEV) {
+                               dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
+                               return -EIO;
+                       }
+               } else
+                       aa_desc = ", AA";
+       }
+
        if (hdepth >= ddepth)
-               snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
+               snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
        else
-               snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
+               snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
+                       ddepth, aa_desc);
+       return 0;
 }
 
 /**
@@ -2294,35 +2152,36 @@ int ata_dev_configure(struct ata_device *dev)
        int rc;
 
        if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
-               ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n",
-                              __func__);
+               ata_dev_info(dev, "%s: ENTER/EXIT -- nodev\n", __func__);
                return 0;
        }
 
        if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __func__);
+               ata_dev_dbg(dev, "%s: ENTER\n", __func__);
 
        /* set horkage */
        dev->horkage |= ata_dev_blacklisted(dev);
        ata_force_horkage(dev);
 
        if (dev->horkage & ATA_HORKAGE_DISABLE) {
-               ata_dev_printk(dev, KERN_INFO,
-                              "unsupported device, disabling\n");
+               ata_dev_info(dev, "unsupported device, disabling\n");
                ata_dev_disable(dev);
                return 0;
        }
 
        if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
            dev->class == ATA_DEV_ATAPI) {
-               ata_dev_printk(dev, KERN_WARNING,
-                       "WARNING: ATAPI is %s, device ignored.\n",
-                       atapi_enabled ? "not supported with this driver"
-                                     : "disabled");
+               ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
+                            atapi_enabled ? "not supported with this driver"
+                            : "disabled");
                ata_dev_disable(dev);
                return 0;
        }
 
+       rc = ata_do_link_spd_horkage(dev);
+       if (rc)
+               return rc;
+
        /* let ACPI work its magic */
        rc = ata_acpi_on_devcfg(dev);
        if (rc)
@@ -2335,12 +2194,12 @@ int ata_dev_configure(struct ata_device *dev)
 
        /* print device capabilities */
        if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG,
-                              "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
-                              "85:%04x 86:%04x 87:%04x 88:%04x\n",
-                              __func__,
-                              id[49], id[82], id[83], id[84],
-                              id[85], id[86], id[87], id[88]);
+               ata_dev_dbg(dev,
+                           "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
+                           "85:%04x 86:%04x 87:%04x 88:%04x\n",
+                           __func__,
+                           id[49], id[82], id[83], id[84],
+                           id[85], id[86], id[87], id[88]);
 
        /* initialize to-be-configured parameters */
        dev->flags &= ~ATA_DFLAG_CFG_MASK;
@@ -2350,6 +2209,7 @@ int ata_dev_configure(struct ata_device *dev)
        dev->cylinders = 0;
        dev->heads = 0;
        dev->sectors = 0;
+       dev->multi_count = 0;
 
        /*
         * common ATA, ATAPI feature tests
@@ -2371,28 +2231,34 @@ int ata_dev_configure(struct ata_device *dev)
        /* ATA-specific feature tests */
        if (dev->class == ATA_DEV_ATA) {
                if (ata_id_is_cfa(id)) {
-                       if (id[162] & 1) /* CPRM may make this media unusable */
-                               ata_dev_printk(dev, KERN_WARNING,
-                                              "supports DRM functions and may "
-                                              "not be fully accessable.\n");
+                       /* CPRM may make this media unusable */
+                       if (id[ATA_ID_CFA_KEY_MGMT] & 1)
+                               ata_dev_warn(dev,
+       "supports DRM functions and may not be fully accessible\n");
                        snprintf(revbuf, 7, "CFA");
                } else {
                        snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
                        /* Warn the user if the device has TPM extensions */
                        if (ata_id_has_tpm(id))
-                               ata_dev_printk(dev, KERN_WARNING,
-                                              "supports DRM functions and may "
-                                              "not be fully accessable.\n");
+                               ata_dev_warn(dev,
+       "supports DRM functions and may not be fully accessible\n");
                }
 
                dev->n_sectors = ata_id_n_sectors(id);
 
-               if (dev->id[59] & 0x100)
-                       dev->multi_count = dev->id[59] & 0xff;
+               /* get current R/W Multiple count setting */
+               if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
+                       unsigned int max = dev->id[47] & 0xff;
+                       unsigned int cnt = dev->id[59] & 0xff;
+                       /* only recognize/allow powers of two here */
+                       if (is_power_of_2(max) && is_power_of_2(cnt))
+                               if (cnt <= max)
+                                       dev->multi_count = cnt;
+               }
 
                if (ata_id_has_lba(id)) {
                        const char *lba_desc;
-                       char ncq_desc[20];
+                       char ncq_desc[24];
 
                        lba_desc = "LBA";
                        dev->flags |= ATA_DFLAG_LBA;
@@ -2406,16 +2272,17 @@ int ata_dev_configure(struct ata_device *dev)
                        }
 
                        /* config NCQ */
-                       ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
+                       rc = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
+                       if (rc)
+                               return rc;
 
                        /* print device info to dmesg */
                        if (ata_msg_drv(ap) && print_info) {
-                               ata_dev_printk(dev, KERN_INFO,
-                                       "%s: %s, %s, max %s\n",
-                                       revbuf, modelbuf, fwrevbuf,
-                                       ata_mode_string(xfer_mask));
-                               ata_dev_printk(dev, KERN_INFO,
-                                       "%Lu sectors, multi %u: %s %s\n",
+                               ata_dev_info(dev, "%s: %s, %s, max %s\n",
+                                            revbuf, modelbuf, fwrevbuf,
+                                            ata_mode_string(xfer_mask));
+                               ata_dev_info(dev,
+                                            "%llu sectors, multi %u: %s %s\n",
                                        (unsigned long long)dev->n_sectors,
                                        dev->multi_count, lba_desc, ncq_desc);
                        }
@@ -2436,15 +2303,14 @@ int ata_dev_configure(struct ata_device *dev)
 
                        /* print device info to dmesg */
                        if (ata_msg_drv(ap) && print_info) {
-                               ata_dev_printk(dev, KERN_INFO,
-                                       "%s: %s, %s, max %s\n",
-                                       revbuf, modelbuf, fwrevbuf,
-                                       ata_mode_string(xfer_mask));
-                               ata_dev_printk(dev, KERN_INFO,
-                                       "%Lu sectors, multi %u, CHS %u/%u/%u\n",
-                                       (unsigned long long)dev->n_sectors,
-                                       dev->multi_count, dev->cylinders,
-                                       dev->heads, dev->sectors);
+                               ata_dev_info(dev, "%s: %s, %s, max %s\n",
+                                            revbuf,    modelbuf, fwrevbuf,
+                                            ata_mode_string(xfer_mask));
+                               ata_dev_info(dev,
+                                            "%llu sectors, multi %u, CHS %u/%u/%u\n",
+                                            (unsigned long long)dev->n_sectors,
+                                            dev->multi_count, dev->cylinders,
+                                            dev->heads, dev->sectors);
                        }
                }
 
@@ -2461,8 +2327,7 @@ int ata_dev_configure(struct ata_device *dev)
                rc = atapi_cdb_len(id);
                if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
                        if (ata_msg_warn(ap))
-                               ata_dev_printk(dev, KERN_WARNING,
-                                              "unsupported CDB len\n");
+                               ata_dev_warn(dev, "unsupported CDB len\n");
                        rc = -EINVAL;
                        goto err_out_nosup;
                }
@@ -2473,7 +2338,8 @@ int ata_dev_configure(struct ata_device *dev)
                 * to enable ATAPI AN to discern between PHY status
                 * changed notifications and ATAPI ANs.
                 */
-               if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
+               if (atapi_an &&
+                   (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
                    (!sata_pmp_attached(ap) ||
                     sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
                        unsigned int err_mask;
@@ -2482,9 +2348,9 @@ int ata_dev_configure(struct ata_device *dev)
                        err_mask = ata_dev_set_feature(dev,
                                        SETFEATURES_SATA_ENABLE, SATA_AN);
                        if (err_mask)
-                               ata_dev_printk(dev, KERN_ERR,
-                                       "failed to enable ATAPI AN "
-                                       "(err_mask=0x%x)\n", err_mask);
+                               ata_dev_err(dev,
+                                           "failed to enable ATAPI AN (err_mask=0x%x)\n",
+                                           err_mask);
                        else {
                                dev->flags |= ATA_DFLAG_AN;
                                atapi_an_string = ", ATAPI AN";
@@ -2503,12 +2369,12 @@ int ata_dev_configure(struct ata_device *dev)
 
                /* print device info to dmesg */
                if (ata_msg_drv(ap) && print_info)
-                       ata_dev_printk(dev, KERN_INFO,
-                                      "ATAPI: %s, %s, max %s%s%s%s\n",
-                                      modelbuf, fwrevbuf,
-                                      ata_mode_string(xfer_mask),
-                                      cdb_intr_string, atapi_an_string,
-                                      dma_dir_string);
+                       ata_dev_info(dev,
+                                    "ATAPI: %s, %s, max %s%s%s%s\n",
+                                    modelbuf, fwrevbuf,
+                                    ata_mode_string(xfer_mask),
+                                    cdb_intr_string, atapi_an_string,
+                                    dma_dir_string);
        }
 
        /* determine max_sectors */
@@ -2516,19 +2382,11 @@ int ata_dev_configure(struct ata_device *dev)
        if (dev->flags & ATA_DFLAG_LBA48)
                dev->max_sectors = ATA_MAX_SECTORS_LBA48;
 
-       if (!(dev->horkage & ATA_HORKAGE_IPM)) {
-               if (ata_id_has_hipm(dev->id))
-                       dev->flags |= ATA_DFLAG_HIPM;
-               if (ata_id_has_dipm(dev->id))
-                       dev->flags |= ATA_DFLAG_DIPM;
-       }
-
        /* Limit PATA drive on SATA cable bridge transfers to udma5,
           200 sectors */
        if (ata_dev_knobble(dev)) {
                if (ata_msg_drv(ap) && print_info)
-                       ata_dev_printk(dev, KERN_INFO,
-                                      "applying bridge limits\n");
+                       ata_dev_info(dev, "applying bridge limits\n");
                dev->udma_mask &= ATA_UDMA5;
                dev->max_sectors = ATA_MAX_SECTORS;
        }
@@ -2543,13 +2401,6 @@ int ata_dev_configure(struct ata_device *dev)
                dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
                                         dev->max_sectors);
 
-       if (ata_dev_blacklisted(dev) & ATA_HORKAGE_IPM) {
-               dev->horkage |= ATA_HORKAGE_IPM;
-
-               /* reset link pm_policy for this port to no pm */
-               ap->pm_policy = MAX_PERFORMANCE;
-       }
-
        if (ap->ops->dev_config)
                ap->ops->dev_config(dev);
 
@@ -2561,26 +2412,23 @@ int ata_dev_configure(struct ata_device *dev)
                   bugs */
 
                if (print_info) {
-                       ata_dev_printk(dev, KERN_WARNING,
+                       ata_dev_warn(dev,
 "Drive reports diagnostics failure. This may indicate a drive\n");
-                       ata_dev_printk(dev, KERN_WARNING,
+                       ata_dev_warn(dev,
 "fault or invalid emulation. Contact drive vendor for information.\n");
                }
        }
 
        if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
-               ata_dev_printk(dev, KERN_WARNING, "WARNING: device requires "
-                              "firmware update to be fully functional.\n");
-               ata_dev_printk(dev, KERN_WARNING, "         contact the vendor "
-                              "or visit http://ata.wiki.kernel.org.\n");
+               ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
+               ata_dev_warn(dev, "         contact the vendor or visit http://ata.wiki.kernel.org\n");
        }
 
        return 0;
 
 err_out_nosup:
        if (ata_msg_probe(ap))
-               ata_dev_printk(dev, KERN_DEBUG,
-                              "%s: EXIT, err\n", __func__);
+               ata_dev_dbg(dev, "%s: EXIT, err\n", __func__);
        return rc;
 }
 
@@ -2668,8 +2516,6 @@ int ata_bus_probe(struct ata_port *ap)
        int rc;
        struct ata_device *dev;
 
-       ata_port_probe(ap);
-
        ata_for_each_dev(dev, &ap->link, ALL)
                tries[dev->devno] = ATA_PROBE_MAX_TRIES;
 
@@ -2697,8 +2543,7 @@ int ata_bus_probe(struct ata_port *ap)
        ap->ops->phy_reset(ap);
 
        ata_for_each_dev(dev, &ap->link, ALL) {
-               if (!(ap->flags & ATA_FLAG_DISABLED) &&
-                   dev->class != ATA_DEV_UNKNOWN)
+               if (dev->class != ATA_DEV_UNKNOWN)
                        classes[dev->devno] = dev->class;
                else
                        classes[dev->devno] = ATA_DEV_NONE;
@@ -2706,8 +2551,6 @@ int ata_bus_probe(struct ata_port *ap)
                dev->class = ATA_DEV_UNKNOWN;
        }
 
-       ata_port_probe(ap);
-
        /* read IDENTIFY page and configure devices. We have to do the identify
           specific sequence bass-ackwards so that PDIAG- is released by
           the slave device */
@@ -2757,8 +2600,6 @@ int ata_bus_probe(struct ata_port *ap)
        ata_for_each_dev(dev, &ap->link, ENABLED)
                return 0;
 
-       /* no device present, disable port */
-       ata_port_disable(ap);
        return -ENODEV;
 
  fail:
@@ -2778,7 +2619,7 @@ int ata_bus_probe(struct ata_port *ap)
                        /* This is the last chance, better to slow
                         * down than lose it.
                         */
-                       sata_down_spd_limit(&ap->link);
+                       sata_down_spd_limit(&ap->link, 0);
                        ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
                }
        }
@@ -2790,22 +2631,6 @@ int ata_bus_probe(struct ata_port *ap)
 }
 
 /**
- *     ata_port_probe - Mark port as enabled
- *     @ap: Port for which we indicate enablement
- *
- *     Modify @ap data structure such that the system
- *     thinks that the entire port is enabled.
- *
- *     LOCKING: host lock, or some other form of
- *     serialization.
- */
-
-void ata_port_probe(struct ata_port *ap)
-{
-       ap->flags &= ~ATA_FLAG_DISABLED;
-}
-
-/**
  *     sata_print_link_status - Print SATA link status
  *     @link: SATA link to printk link status about
  *
@@ -2824,13 +2649,11 @@ static void sata_print_link_status(struct ata_link *link)
 
        if (ata_phys_link_online(link)) {
                tmp = (sstatus >> 4) & 0xf;
-               ata_link_printk(link, KERN_INFO,
-                               "SATA link up %s (SStatus %X SControl %X)\n",
-                               sata_spd_string(tmp), sstatus, scontrol);
+               ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
+                             sata_spd_string(tmp), sstatus, scontrol);
        } else {
-               ata_link_printk(link, KERN_INFO,
-                               "SATA link down (SStatus %X SControl %X)\n",
-                               sstatus, scontrol);
+               ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
+                             sstatus, scontrol);
        }
 }
 
@@ -2852,43 +2675,29 @@ struct ata_device *ata_dev_pair(struct ata_device *adev)
 }
 
 /**
- *     ata_port_disable - Disable port.
- *     @ap: Port to be disabled.
- *
- *     Modify @ap data structure such that the system
- *     thinks that the entire port is disabled, and should
- *     never attempt to probe or communicate with devices
- *     on this port.
- *
- *     LOCKING: host lock, or some other form of
- *     serialization.
- */
-
-void ata_port_disable(struct ata_port *ap)
-{
-       ap->link.device[0].class = ATA_DEV_NONE;
-       ap->link.device[1].class = ATA_DEV_NONE;
-       ap->flags |= ATA_FLAG_DISABLED;
-}
-
-/**
  *     sata_down_spd_limit - adjust SATA spd limit downward
  *     @link: Link to adjust SATA spd limit for
+ *     @spd_limit: Additional limit
  *
  *     Adjust SATA spd limit of @link downward.  Note that this
  *     function only adjusts the limit.  The change must be applied
  *     using sata_set_spd().
  *
+ *     If @spd_limit is non-zero, the speed is limited to equal to or
+ *     lower than @spd_limit if such speed is supported.  If
+ *     @spd_limit is slower than any supported speed, only the lowest
+ *     supported speed is allowed.
+ *
  *     LOCKING:
  *     Inherited from caller.
  *
  *     RETURNS:
  *     0 on success, negative errno on failure
  */
-int sata_down_spd_limit(struct ata_link *link)
+int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
 {
        u32 sstatus, spd, mask;
-       int rc, highbit;
+       int rc, bit;
 
        if (!sata_scr_valid(link))
                return -EOPNOTSUPP;
@@ -2897,7 +2706,7 @@ int sata_down_spd_limit(struct ata_link *link)
         * If not, use cached value in link->sata_spd.
         */
        rc = sata_scr_read(link, SCR_STATUS, &sstatus);
-       if (rc == 0)
+       if (rc == 0 && ata_sstatus_online(sstatus))
                spd = (sstatus >> 4) & 0xf;
        else
                spd = link->sata_spd;
@@ -2907,8 +2716,8 @@ int sata_down_spd_limit(struct ata_link *link)
                return -EINVAL;
 
        /* unconditionally mask off the highest bit */
-       highbit = fls(mask) - 1;
-       mask &= ~(1 << highbit);
+       bit = fls(mask) - 1;
+       mask &= ~(1 << bit);
 
        /* Mask off all speeds higher than or equal to the current
         * one.  Force 1.5Gbps if current SPD is not available.
@@ -2922,10 +2731,19 @@ int sata_down_spd_limit(struct ata_link *link)
        if (!mask)
                return -EINVAL;
 
+       if (spd_limit) {
+               if (mask & ((1 << spd_limit) - 1))
+                       mask &= (1 << spd_limit) - 1;
+               else {
+                       bit = ffs(mask) - 1;
+                       mask = 1 << bit;
+               }
+       }
+
        link->sata_spd_limit = mask;
 
-       ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n",
-                       sata_spd_string(fls(mask)));
+       ata_link_warn(link, "limiting SATA link speed to %s\n",
+                     sata_spd_string(fls(mask)));
 
        return 0;
 }
@@ -3023,33 +2841,33 @@ int sata_set_spd(struct ata_link *link)
  */
 
 static const struct ata_timing ata_timing[] = {
-/*     { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
-       { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
-       { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
-       { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
-       { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
-       { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
-       { XFER_PIO_5,     15,  65,  25, 100,  65,  25, 100,   0 },
-       { XFER_PIO_6,     10,  55,  20,  80,  55,  20,  80,   0 },
-
-       { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
-       { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
-       { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
-
-       { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
-       { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
-       { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
-       { XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 100,   0 },
-       { XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20,  80,   0 },
-
-/*     { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
-       { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
-       { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
-       { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
-       { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
-       { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
-       { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
-       { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
+/*     { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 0,  960,   0 }, */
+       { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 0,  600,   0 },
+       { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 0,  383,   0 },
+       { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 0,  240,   0 },
+       { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 0,  180,   0 },
+       { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 0,  120,   0 },
+       { XFER_PIO_5,     15,  65,  25, 100,  65,  25, 0,  100,   0 },
+       { XFER_PIO_6,     10,  55,  20,  80,  55,  20, 0,   80,   0 },
+
+       { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 50, 960,   0 },
+       { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 30, 480,   0 },
+       { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 20, 240,   0 },
+
+       { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 20, 480,   0 },
+       { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 5,  150,   0 },
+       { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 5,  120,   0 },
+       { XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 5,  100,   0 },
+       { XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20, 5,   80,   0 },
+
+/*     { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0, 0,    0, 150 }, */
+       { XFER_UDMA_0,     0,   0,   0,   0,   0,   0, 0,    0, 120 },
+       { XFER_UDMA_1,     0,   0,   0,   0,   0,   0, 0,    0,  80 },
+       { XFER_UDMA_2,     0,   0,   0,   0,   0,   0, 0,    0,  60 },
+       { XFER_UDMA_3,     0,   0,   0,   0,   0,   0, 0,    0,  45 },
+       { XFER_UDMA_4,     0,   0,   0,   0,   0,   0, 0,    0,  30 },
+       { XFER_UDMA_5,     0,   0,   0,   0,   0,   0, 0,    0,  20 },
+       { XFER_UDMA_6,     0,   0,   0,   0,   0,   0, 0,    0,  15 },
 
        { 0xFF }
 };
@@ -3059,14 +2877,15 @@ static const struct ata_timing ata_timing[] = {
 
 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
 {
-       q->setup   = EZ(t->setup   * 1000,  T);
-       q->act8b   = EZ(t->act8b   * 1000,  T);
-       q->rec8b   = EZ(t->rec8b   * 1000,  T);
-       q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
-       q->active  = EZ(t->active  * 1000,  T);
-       q->recover = EZ(t->recover * 1000,  T);
-       q->cycle   = EZ(t->cycle   * 1000,  T);
-       q->udma    = EZ(t->udma    * 1000, UT);
+       q->setup        = EZ(t->setup      * 1000,  T);
+       q->act8b        = EZ(t->act8b      * 1000,  T);
+       q->rec8b        = EZ(t->rec8b      * 1000,  T);
+       q->cyc8b        = EZ(t->cyc8b      * 1000,  T);
+       q->active       = EZ(t->active     * 1000,  T);
+       q->recover      = EZ(t->recover    * 1000,  T);
+       q->dmack_hold   = EZ(t->dmack_hold * 1000,  T);
+       q->cycle        = EZ(t->cycle      * 1000,  T);
+       q->udma         = EZ(t->udma       * 1000, UT);
 }
 
 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
@@ -3078,6 +2897,7 @@ void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
        if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
        if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
        if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
+       if (what & ATA_TIMING_DMACK_HOLD) m->dmack_hold = max(a->dmack_hold, b->dmack_hold);
        if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
        if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
 }
@@ -3097,6 +2917,7 @@ const struct ata_timing *ata_timing_find_mode(u8 xfer_mode)
 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
                       struct ata_timing *t, int T, int UT)
 {
+       const u16 *id = adev->id;
        const struct ata_timing *s;
        struct ata_timing p;
 
@@ -3114,14 +2935,18 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
         * PIO/MW_DMA cycle timing.
         */
 
-       if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
+       if (id[ATA_ID_FIELD_VALID] & 2) {       /* EIDE drive */
                memset(&p, 0, sizeof(p));
+
                if (speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
-                       if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
-                                           else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
-               } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
-                       p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
-               }
+                       if (speed <= XFER_PIO_2)
+                               p.cycle = p.cyc8b = id[ATA_ID_EIDE_PIO];
+                       else if ((speed <= XFER_PIO_4) ||
+                                (speed == XFER_PIO_5 && !ata_id_is_cfa(id)))
+                               p.cycle = p.cyc8b = id[ATA_ID_EIDE_PIO_IORDY];
+               } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2)
+                       p.cycle = id[ATA_ID_EIDE_DMA_MIN];
+
                ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
        }
 
@@ -3295,8 +3120,7 @@ int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
                        snprintf(buf, sizeof(buf), "%s",
                                 ata_mode_string(xfer_mask));
 
-               ata_dev_printk(dev, KERN_WARNING,
-                              "limiting speed to %s\n", buf);
+               ata_dev_warn(dev, "limiting speed to %s\n", buf);
        }
 
        ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
@@ -3307,17 +3131,27 @@ int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
 
 static int ata_dev_set_mode(struct ata_device *dev)
 {
+       struct ata_port *ap = dev->link->ap;
        struct ata_eh_context *ehc = &dev->link->eh_context;
+       const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
        const char *dev_err_whine = "";
        int ign_dev_err = 0;
-       unsigned int err_mask;
+       unsigned int err_mask = 0;
        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(dev);
+       if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
+               dev_err_whine = " (SET_XFERMODE skipped)";
+       else {
+               if (nosetxfer)
+                       ata_dev_warn(dev,
+                                    "NOSETXFER but PATA detected - can't "
+                                    "skip SETXFER, might malfunction\n");
+               err_mask = ata_dev_set_xfermode(dev);
+       }
 
        if (err_mask & ~AC_ERR_DEV)
                goto fail;
@@ -3365,15 +3199,14 @@ static int ata_dev_set_mode(struct ata_device *dev)
        DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
                dev->xfer_shift, (int)dev->xfer_mode);
 
-       ata_dev_printk(dev, KERN_INFO, "configured for %s%s\n",
-                      ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
-                      dev_err_whine);
+       ata_dev_info(dev, "configured for %s%s\n",
+                    ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
+                    dev_err_whine);
 
        return 0;
 
  fail:
-       ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
-                      "(err_mask=0x%x)\n", err_mask);
+       ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
        return -EIO;
 }
 
@@ -3435,7 +3268,7 @@ int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
        /* step 2: always set host PIO timings */
        ata_for_each_dev(dev, link, ENABLED) {
                if (dev->pio_mode == 0xff) {
-                       ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
+                       ata_dev_warn(dev, "no PIO support\n");
                        rc = -EINVAL;
                        goto out;
                }
@@ -3500,9 +3333,15 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
                   int (*check_ready)(struct ata_link *link))
 {
        unsigned long start = jiffies;
-       unsigned long nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
+       unsigned long nodev_deadline;
        int warned = 0;
 
+       /* choose which 0xff timeout to use, read comment in libata.h */
+       if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
+               nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
+       else
+               nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
+
        /* Slave readiness can't be tested separately from master.  On
         * M/S emulation configuration, this function should be called
         * only on the master and it will handle both master and slave.
@@ -3520,12 +3359,12 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
                if (ready > 0)
                        return 0;
 
-               /* -ENODEV could be transient.  Ignore -ENODEV if link
+               /*
+                * -ENODEV could be transient.  Ignore -ENODEV if link
                 * is online.  Also, some SATA devices take a long
-                * time to clear 0xff after reset.  For example,
-                * HHD424020F7SV00 iVDR needs >= 800ms while Quantum
-                * GoVault needs even more than that.  Wait for
-                * ATA_TMOUT_FF_WAIT on -ENODEV if link isn't offline.
+                * time to clear 0xff after reset.  Wait for
+                * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
+                * offline.
                 *
                 * Note that some PATA controllers (pata_ali) explode
                 * if status register is read more than once when
@@ -3547,13 +3386,13 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
 
                if (!warned && time_after(now, start + 5 * HZ) &&
                    (deadline - now > 3 * HZ)) {
-                       ata_link_printk(link, KERN_WARNING,
+                       ata_link_warn(link,
                                "link is slow to respond, please be patient "
                                "(ready=%d)\n", tmp);
                        warned = 1;
                }
 
-               msleep(50);
+               ata_msleep(link->ap, 50);
        }
 }
 
@@ -3574,7 +3413,7 @@ int ata_wait_ready(struct ata_link *link, unsigned long deadline,
 int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
                                int (*check_ready)(struct ata_link *link))
 {
-       msleep(ATA_WAIT_AFTER_RESET);
+       ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
 
        return ata_wait_ready(link, deadline, check_ready);
 }
@@ -3585,7 +3424,7 @@ int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
  *     @params: timing parameters { interval, duratinon, timeout } in msec
  *     @deadline: deadline jiffies for the operation
  *
-*      Make sure SStatus of @link reaches stable state, determined by
+ *     Make sure SStatus of @link 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 DET gets stuck at 1 on
@@ -3622,7 +3461,7 @@ int sata_link_debounce(struct ata_link *link, const unsigned long *params,
        last_jiffies = jiffies;
 
        while (1) {
-               msleep(interval);
+               ata_msleep(link->ap, interval);
                if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
                        return rc;
                cur &= 0xf;
@@ -3666,21 +3505,43 @@ int sata_link_debounce(struct ata_link *link, const unsigned long *params,
 int sata_link_resume(struct ata_link *link, const unsigned long *params,
                     unsigned long deadline)
 {
+       int tries = ATA_LINK_RESUME_TRIES;
        u32 scontrol, serror;
        int rc;
 
        if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
                return rc;
 
-       scontrol = (scontrol & 0x0f0) | 0x300;
+       /*
+        * Writes to SControl sometimes get ignored under certain
+        * controllers (ata_piix SIDPR).  Make sure DET actually is
+        * cleared.
+        */
+       do {
+               scontrol = (scontrol & 0x0f0) | 0x300;
+               if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
+                       return rc;
+               /*
+                * Some PHYs react badly if SStatus is pounded
+                * immediately after resuming.  Delay 200ms before
+                * debouncing.
+                */
+               ata_msleep(link->ap, 200);
 
-       if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
-               return rc;
+               /* is SControl restored correctly? */
+               if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
+                       return rc;
+       } while ((scontrol & 0xf0f) != 0x300 && --tries);
 
-       /* Some PHYs react badly if SStatus is pounded immediately
-        * after resuming.  Delay 200ms before debouncing.
-        */
-       msleep(200);
+       if ((scontrol & 0xf0f) != 0x300) {
+               ata_link_warn(link, "failed to resume link (SControl %X)\n",
+                            scontrol);
+               return 0;
+       }
+
+       if (tries < ATA_LINK_RESUME_TRIES)
+               ata_link_warn(link, "link resume succeeded after %d retries\n",
+                             ATA_LINK_RESUME_TRIES - tries);
 
        if ((rc = sata_link_debounce(link, params, deadline)))
                return rc;
@@ -3693,6 +3554,78 @@ int sata_link_resume(struct ata_link *link, const unsigned long *params,
 }
 
 /**
+ *     sata_link_scr_lpm - manipulate SControl IPM and SPM fields
+ *     @link: ATA link to manipulate SControl for
+ *     @policy: LPM policy to configure
+ *     @spm_wakeup: initiate LPM transition to active state
+ *
+ *     Manipulate the IPM field of the SControl register of @link
+ *     according to @policy.  If @policy is ATA_LPM_MAX_POWER and
+ *     @spm_wakeup is %true, the SPM field is manipulated to wake up
+ *     the link.  This function also clears PHYRDY_CHG before
+ *     returning.
+ *
+ *     LOCKING:
+ *     EH context.
+ *
+ *     RETURNS:
+ *     0 on succes, -errno otherwise.
+ */
+int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                     bool spm_wakeup)
+{
+       struct ata_eh_context *ehc = &link->eh_context;
+       bool woken_up = false;
+       u32 scontrol;
+       int rc;
+
+       rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
+       if (rc)
+               return rc;
+
+       switch (policy) {
+       case ATA_LPM_MAX_POWER:
+               /* disable all LPM transitions */
+               scontrol |= (0x3 << 8);
+               /* initiate transition to active state */
+               if (spm_wakeup) {
+                       scontrol |= (0x4 << 12);
+                       woken_up = true;
+               }
+               break;
+       case ATA_LPM_MED_POWER:
+               /* allow LPM to PARTIAL */
+               scontrol &= ~(0x1 << 8);
+               scontrol |= (0x2 << 8);
+               break;
+       case ATA_LPM_MIN_POWER:
+               if (ata_link_nr_enabled(link) > 0)
+                       /* no restrictions on LPM transitions */
+                       scontrol &= ~(0x3 << 8);
+               else {
+                       /* empty port, power off */
+                       scontrol &= ~0xf;
+                       scontrol |= (0x1 << 2);
+               }
+               break;
+       default:
+               WARN_ON(1);
+       }
+
+       rc = sata_scr_write(link, SCR_CONTROL, scontrol);
+       if (rc)
+               return rc;
+
+       /* give the link time to transit out of LPM state */
+       if (woken_up)
+               msleep(10);
+
+       /* clear PHYRDY_CHG from SError */
+       ehc->i.serror &= ~SERR_PHYRDY_CHG;
+       return sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
+}
+
+/**
  *     ata_std_prereset - prepare for reset
  *     @link: ATA link to be reset
  *     @deadline: deadline jiffies for the operation
@@ -3725,8 +3658,9 @@ int ata_std_prereset(struct ata_link *link, unsigned long deadline)
                rc = sata_link_resume(link, timing, deadline);
                /* whine about phy resume failure but proceed */
                if (rc && rc != -EOPNOTSUPP)
-                       ata_link_printk(link, KERN_WARNING, "failed to resume "
-                                       "link for reset (errno=%d)\n", rc);
+                       ata_link_warn(link,
+                                     "failed to resume link for reset (errno=%d)\n",
+                                     rc);
        }
 
        /* no point in trying softreset on offline link */
@@ -3801,7 +3735,7 @@ int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
        /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
         * 10.4.2 says at least 1 ms.
         */
-       msleep(1);
+       ata_msleep(link->ap, 1);
 
        /* bring link back */
        rc = sata_link_resume(link, timing, deadline);
@@ -3842,8 +3776,7 @@ int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
                /* online is set iff link is online && reset succeeded */
                if (online)
                        *online = false;
-               ata_link_printk(link, KERN_ERR,
-                               "COMRESET failed (errno=%d)\n", rc);
+               ata_link_err(link, "COMRESET failed (errno=%d)\n", rc);
        }
        DPRINTK("EXIT, rc=%d\n", rc);
        return rc;
@@ -3927,8 +3860,8 @@ static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
        unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
 
        if (dev->class != new_class) {
-               ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
-                              dev->class, new_class);
+               ata_dev_info(dev, "class mismatch %d != %d\n",
+                            dev->class, new_class);
                return 0;
        }
 
@@ -3938,14 +3871,14 @@ static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
        ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
 
        if (strcmp(model[0], model[1])) {
-               ata_dev_printk(dev, KERN_INFO, "model number mismatch "
-                              "'%s' != '%s'\n", model[0], model[1]);
+               ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
+                            model[0], model[1]);
                return 0;
        }
 
        if (strcmp(serial[0], serial[1])) {
-               ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
-                              "'%s' != '%s'\n", serial[0], serial[1]);
+               ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
+                            serial[0], serial[1]);
                return 0;
        }
 
@@ -4004,6 +3937,7 @@ int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
                       unsigned int readid_flags)
 {
        u64 n_sectors = dev->n_sectors;
+       u64 n_native_sectors = dev->n_native_sectors;
        int rc;
 
        if (!ata_dev_enabled(dev))
@@ -4011,9 +3945,11 @@ int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
 
        /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
        if (ata_class_enabled(new_class) &&
-           new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) {
-               ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n",
-                              dev->class, new_class);
+           new_class != ATA_DEV_ATA &&
+           new_class != ATA_DEV_ATAPI &&
+           new_class != ATA_DEV_SEMB) {
+               ata_dev_info(dev, "class mismatch %u != %u\n",
+                            dev->class, new_class);
                rc = -ENODEV;
                goto fail;
        }
@@ -4029,24 +3965,52 @@ int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
                goto fail;
 
        /* verify n_sectors hasn't changed */
-       if (dev->class == ATA_DEV_ATA && n_sectors &&
-           dev->n_sectors != n_sectors) {
-               ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
-                              "%llu != %llu\n",
-                              (unsigned long long)n_sectors,
-                              (unsigned long long)dev->n_sectors);
+       if (dev->class != ATA_DEV_ATA || !n_sectors ||
+           dev->n_sectors == n_sectors)
+               return 0;
 
-               /* restore original n_sectors */
-               dev->n_sectors = n_sectors;
+       /* n_sectors has changed */
+       ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
+                    (unsigned long long)n_sectors,
+                    (unsigned long long)dev->n_sectors);
 
-               rc = -ENODEV;
-               goto fail;
+       /*
+        * Something could have caused HPA to be unlocked
+        * involuntarily.  If n_native_sectors hasn't changed and the
+        * new size matches it, keep the device.
+        */
+       if (dev->n_native_sectors == n_native_sectors &&
+           dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
+               ata_dev_warn(dev,
+                            "new n_sectors matches native, probably "
+                            "late HPA unlock, n_sectors updated\n");
+               /* use the larger n_sectors */
+               return 0;
        }
 
-       return 0;
+       /*
+        * Some BIOSes boot w/o HPA but resume w/ HPA locked.  Try
+        * unlocking HPA in those cases.
+        *
+        * https://bugzilla.kernel.org/show_bug.cgi?id=15396
+        */
+       if (dev->n_native_sectors == n_native_sectors &&
+           dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
+           !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
+               ata_dev_warn(dev,
+                            "old n_sectors matches native, probably "
+                            "late HPA lock, will try to unlock HPA\n");
+               /* try unlocking HPA */
+               dev->flags |= ATA_DFLAG_UNLOCK_HPA;
+               rc = -EIO;
+       } else
+               rc = -ENODEV;
 
+       /* restore original n_[native_]sectors and fail */
+       dev->n_native_sectors = n_native_sectors;
+       dev->n_sectors = n_sectors;
  fail:
-       ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
+       ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
        return rc;
 }
 
@@ -4067,15 +4031,13 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
        { "WDC AC23200L",       "21.10N21",     ATA_HORKAGE_NODMA },
        { "Compaq CRD-8241B",   NULL,           ATA_HORKAGE_NODMA },
        { "CRD-8400B",          NULL,           ATA_HORKAGE_NODMA },
-       { "CRD-8480B",          NULL,           ATA_HORKAGE_NODMA },
-       { "CRD-8482B",          NULL,           ATA_HORKAGE_NODMA },
+       { "CRD-848[02]B",       NULL,           ATA_HORKAGE_NODMA },
        { "CRD-84",             NULL,           ATA_HORKAGE_NODMA },
        { "SanDisk SDP3B",      NULL,           ATA_HORKAGE_NODMA },
        { "SanDisk SDP3B-64",   NULL,           ATA_HORKAGE_NODMA },
        { "SANYO CD-ROM CRD",   NULL,           ATA_HORKAGE_NODMA },
        { "HITACHI CDR-8",      NULL,           ATA_HORKAGE_NODMA },
-       { "HITACHI CDR-8335",   NULL,           ATA_HORKAGE_NODMA },
-       { "HITACHI CDR-8435",   NULL,           ATA_HORKAGE_NODMA },
+       { "HITACHI CDR-8[34]35",NULL,           ATA_HORKAGE_NODMA },
        { "Toshiba CD-ROM XM-6202B", NULL,      ATA_HORKAGE_NODMA },
        { "TOSHIBA CD-ROM XM-1702BC", NULL,     ATA_HORKAGE_NODMA },
        { "CD-532E-A",          NULL,           ATA_HORKAGE_NODMA },
@@ -4108,72 +4070,19 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
        { "Maxtor 7V300F0",     "VA111630",     ATA_HORKAGE_NONCQ },
        { "ST380817AS",         "3.42",         ATA_HORKAGE_NONCQ },
        { "ST3160023AS",        "3.42",         ATA_HORKAGE_NONCQ },
+       { "OCZ CORE_SSD",       "02.10104",     ATA_HORKAGE_NONCQ },
 
        /* Seagate NCQ + FLUSH CACHE firmware bug */
-       { "ST31500341AS",       "SD15",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31500341AS",       "SD16",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31500341AS",       "SD17",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31500341AS",       "SD18",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31500341AS",       "SD19",         ATA_HORKAGE_NONCQ |
+       { "ST31500341AS",       "SD1[5-9]",     ATA_HORKAGE_NONCQ |
                                                ATA_HORKAGE_FIRMWARE_WARN },
 
-       { "ST31000333AS",       "SD15",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31000333AS",       "SD16",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31000333AS",       "SD17",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31000333AS",       "SD18",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST31000333AS",       "SD19",         ATA_HORKAGE_NONCQ |
+       { "ST31000333AS",       "SD1[5-9]",     ATA_HORKAGE_NONCQ |
                                                ATA_HORKAGE_FIRMWARE_WARN },
 
-       { "ST3640623AS",        "SD15",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640623AS",        "SD16",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640623AS",        "SD17",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640623AS",        "SD18",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640623AS",        "SD19",         ATA_HORKAGE_NONCQ |
+       { "ST3640[36]23AS",     "SD1[5-9]",     ATA_HORKAGE_NONCQ |
                                                ATA_HORKAGE_FIRMWARE_WARN },
 
-       { "ST3640323AS",        "SD15",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640323AS",        "SD16",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640323AS",        "SD17",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640323AS",        "SD18",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3640323AS",        "SD19",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-
-       { "ST3320813AS",        "SD15",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320813AS",        "SD16",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320813AS",        "SD17",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320813AS",        "SD18",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320813AS",        "SD19",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-
-       { "ST3320613AS",        "SD15",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320613AS",        "SD16",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320613AS",        "SD17",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320613AS",        "SD18",         ATA_HORKAGE_NONCQ |
-                                               ATA_HORKAGE_FIRMWARE_WARN },
-       { "ST3320613AS",        "SD19",         ATA_HORKAGE_NONCQ |
+       { "ST3320[68]13AS",     "SD1[5-9]",     ATA_HORKAGE_NONCQ |
                                                ATA_HORKAGE_FIRMWARE_WARN },
 
        /* Blacklist entries taken from Silicon Image 3124/3132
@@ -4182,12 +4091,18 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
        { "HTS541080G9SA00",    "MB4OC60D",     ATA_HORKAGE_NONCQ, },
        { "HTS541010G9SA00",    "MBZOC60D",     ATA_HORKAGE_NONCQ, },
 
+       /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */
+       { "C300-CTFDDAC128MAG", "0001",         ATA_HORKAGE_NONCQ, },
+
        /* devices which puke on READ_NATIVE_MAX */
        { "HDS724040KLSA80",    "KFAOA20N",     ATA_HORKAGE_BROKEN_HPA, },
        { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
        { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
        { "MAXTOR 6L080L4",     "A93.0500",     ATA_HORKAGE_BROKEN_HPA },
 
+       /* this one allows HPA unlocking but fails IOs on the area */
+       { "OCZ-VERTEX",             "1.30",     ATA_HORKAGE_BROKEN_HPA },
+
        /* Devices which report 1 sector over size HPA */
        { "ST340823A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
        { "ST320413A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
@@ -4196,41 +4111,91 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
        /* Devices which get the IVB wrong */
        { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
        /* Maybe we should just blacklist TSSTcorp... */
-       { "TSSTcorp CDDVDW SH-S202H", "SB00",     ATA_HORKAGE_IVB, },
-       { "TSSTcorp CDDVDW SH-S202H", "SB01",     ATA_HORKAGE_IVB, },
-       { "TSSTcorp CDDVDW SH-S202J", "SB00",     ATA_HORKAGE_IVB, },
-       { "TSSTcorp CDDVDW SH-S202J", "SB01",     ATA_HORKAGE_IVB, },
-       { "TSSTcorp CDDVDW SH-S202N", "SB00",     ATA_HORKAGE_IVB, },
-       { "TSSTcorp CDDVDW SH-S202N", "SB01",     ATA_HORKAGE_IVB, },
+       { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]",  ATA_HORKAGE_IVB, },
 
        /* Devices that do not need bridging limits applied */
        { "MTRON MSP-SATA*",            NULL,   ATA_HORKAGE_BRIDGE_OK, },
 
+       /* Devices which aren't very happy with higher link speeds */
+       { "WD My Book",                 NULL,   ATA_HORKAGE_1_5_GBPS, },
+
+       /*
+        * Devices which choke on SETXFER.  Applies only if both the
+        * device and controller are SATA.
+        */
+       { "PIONEER DVD-RW  DVRTD08",    NULL,   ATA_HORKAGE_NOSETXFER },
+       { "PIONEER DVD-RW  DVR-212D",   NULL,   ATA_HORKAGE_NOSETXFER },
+       { "PIONEER DVD-RW  DVR-216D",   NULL,   ATA_HORKAGE_NOSETXFER },
+
        /* End Marker */
        { }
 };
 
-static int strn_pattern_cmp(const char *patt, const char *name, int wildchar)
+/**
+ *     glob_match - match a text string against a glob-style pattern
+ *     @text: the string to be examined
+ *     @pattern: the glob-style pattern to be matched against
+ *
+ *     Either/both of text and pattern can be empty strings.
+ *
+ *     Match text against a glob-style pattern, with wildcards and simple sets:
+ *
+ *             ?       matches any single character.
+ *             *       matches any run of characters.
+ *             [xyz]   matches a single character from the set: x, y, or z.
+ *             [a-d]   matches a single character from the range: a, b, c, or d.
+ *             [a-d0-9] matches a single character from either range.
+ *
+ *     The special characters ?, [, -, or *, can be matched using a set, eg. [*]
+ *     Behaviour with malformed patterns is undefined, though generally reasonable.
+ *
+ *     Sample patterns:  "SD1?",  "SD1[0-5]",  "*R0",  "SD*1?[012]*xx"
+ *
+ *     This function uses one level of recursion per '*' in pattern.
+ *     Since it calls _nothing_ else, and has _no_ explicit local variables,
+ *     this will not cause stack problems for any reasonable use here.
+ *
+ *     RETURNS:
+ *     0 on match, 1 otherwise.
+ */
+static int glob_match (const char *text, const char *pattern)
 {
-       const char *p;
-       int len;
-
-       /*
-        * check for trailing wildcard: *\0
-        */
-       p = strchr(patt, wildchar);
-       if (p && ((*(p + 1)) == 0))
-               len = p - patt;
-       else {
-               len = strlen(name);
-               if (!len) {
-                       if (!*patt)
-                               return 0;
-                       return -1;
+       do {
+               /* Match single character or a '?' wildcard */
+               if (*text == *pattern || *pattern == '?') {
+                       if (!*pattern++)
+                               return 0;  /* End of both strings: match */
+               } else {
+                       /* Match single char against a '[' bracketed ']' pattern set */
+                       if (!*text || *pattern != '[')
+                               break;  /* Not a pattern set */
+                       while (*++pattern && *pattern != ']' && *text != *pattern) {
+                               if (*pattern == '-' && *(pattern - 1) != '[')
+                                       if (*text > *(pattern - 1) && *text < *(pattern + 1)) {
+                                               ++pattern;
+                                               break;
+                                       }
+                       }
+                       if (!*pattern || *pattern == ']')
+                               return 1;  /* No match */
+                       while (*pattern && *pattern++ != ']');
+               }
+       } while (*++text && *pattern);
+
+       /* Match any run of chars against a '*' wildcard */
+       if (*pattern == '*') {
+               if (!*++pattern)
+                       return 0;  /* Match: avoid recursion at end of pattern */
+               /* Loop to handle additional pattern chars after the wildcard */
+               while (*text) {
+                       if (glob_match(text, pattern) == 0)
+                               return 0;  /* Remainder matched */
+                       ++text;  /* Absorb (match) this char and try again */
                }
        }
-
-       return strncmp(patt, name, len);
+       if (!*text && !*pattern)
+               return 0;  /* End of both strings: match */
+       return 1;  /* No match */
 }
 
 static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
@@ -4243,10 +4208,10 @@ static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
        ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
 
        while (ad->model_num) {
-               if (!strn_pattern_cmp(ad->model_num, model_num, '*')) {
+               if (!glob_match(model_num, ad->model_num)) {
                        if (ad->model_rev == NULL)
                                return ad->horkage;
-                       if (!strn_pattern_cmp(ad->model_rev, model_rev, '*'))
+                       if (!glob_match(model_rev, ad->model_rev))
                                return ad->horkage;
                }
                ad++;
@@ -4373,15 +4338,15 @@ static void ata_dev_xfermask(struct ata_device *dev)
 
        if (ata_dma_blacklisted(dev)) {
                xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
-               ata_dev_printk(dev, KERN_WARNING,
-                              "device is on DMA blacklist, disabling DMA\n");
+               ata_dev_warn(dev,
+                            "device is on DMA blacklist, disabling DMA\n");
        }
 
        if ((host->flags & ATA_HOST_SIMPLEX) &&
            host->simplex_claimed && host->simplex_claimed != ap) {
                xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
-               ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by "
-                              "other device, disabling DMA\n");
+               ata_dev_warn(dev,
+                            "simplex DMA is claimed by other device, disabling DMA\n");
        }
 
        if (ap->flags & ATA_FLAG_NO_IORDY)
@@ -4401,8 +4366,8 @@ static void ata_dev_xfermask(struct ata_device *dev)
        if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
                /* UDMA/44 or higher would be available */
                if (cable_is_40wire(ap)) {
-                       ata_dev_printk(dev, KERN_WARNING,
-                                "limited to UDMA/33 due to 40-wire cable\n");
+                       ata_dev_warn(dev,
+                                    "limited to UDMA/33 due to 40-wire cable\n");
                        xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
                }
 
@@ -4454,6 +4419,7 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
        DPRINTK("EXIT, err_mask=%x\n", err_mask);
        return err_mask;
 }
+
 /**
  *     ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES
  *     @dev: Device to which command will be sent
@@ -4469,8 +4435,7 @@ static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
  *     RETURNS:
  *     0 on success, AC_ERR_* mask otherwise.
  */
-static unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable,
-                                       u8 feature)
+unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, u8 feature)
 {
        struct ata_taskfile tf;
        unsigned int err_mask;
@@ -4549,12 +4514,12 @@ void ata_sg_clean(struct ata_queued_cmd *qc)
        struct scatterlist *sg = qc->sg;
        int dir = qc->dma_dir;
 
-       WARN_ON(sg == NULL);
+       WARN_ON_ONCE(sg == NULL);
 
        VPRINTK("unmapping %u sg elements\n", qc->n_elem);
 
        if (qc->n_elem)
-               dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
+               dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
 
        qc->flags &= ~ATA_QCFLAG_DMAMAP;
        qc->sg = NULL;
@@ -4669,7 +4634,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
                return -1;
 
        DPRINTK("%d sg elements mapped\n", n_elem);
-
+       qc->orig_n_elem = qc->n_elem;
        qc->n_elem = n_elem;
        qc->flags |= ATA_QCFLAG_DMAMAP;
 
@@ -4700,8 +4665,7 @@ void swap_buf_le16(u16 *buf, unsigned int buf_words)
 
 /**
  *     ata_qc_new - Request an available ATA command, for queueing
- *     @ap: Port associated with device @dev
- *     @dev: Device from whom we request an available command structure
+ *     @ap: target port
  *
  *     LOCKING:
  *     None.
@@ -4732,7 +4696,6 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
 /**
  *     ata_qc_new_init - Request an available ATA command, and initialize it
  *     @dev: Device from whom we request an available command structure
- *     @tag: command tag
  *
  *     LOCKING:
  *     None.
@@ -4767,10 +4730,11 @@ struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
  */
 void ata_qc_free(struct ata_queued_cmd *qc)
 {
-       struct ata_port *ap = qc->ap;
+       struct ata_port *ap;
        unsigned int tag;
 
-       WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
+       WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
+       ap = qc->ap;
 
        qc->flags = 0;
        tag = qc->tag;
@@ -4782,11 +4746,13 @@ void ata_qc_free(struct ata_queued_cmd *qc)
 
 void __ata_qc_complete(struct ata_queued_cmd *qc)
 {
-       struct ata_port *ap = qc->ap;
-       struct ata_link *link = qc->dev->link;
+       struct ata_port *ap;
+       struct ata_link *link;
 
-       WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
-       WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
+       WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
+       WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
+       ap = qc->ap;
+       link = qc->dev->link;
 
        if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
                ata_sg_clean(qc);
@@ -4829,9 +4795,6 @@ static void ata_verify_xfer(struct ata_queued_cmd *qc)
 {
        struct ata_device *dev = qc->dev;
 
-       if (ata_tag_internal(qc->tag))
-               return;
-
        if (ata_is_nodata(qc->tf.protocol))
                return;
 
@@ -4845,8 +4808,13 @@ static void ata_verify_xfer(struct ata_queued_cmd *qc)
  *     ata_qc_complete - Complete an active ATA command
  *     @qc: Command to complete
  *
- *     Indicate to the mid and upper layers that an ATA
- *     command has completed, with either an ok or not-ok status.
+ *     Indicate to the mid and upper layers that an ATA command has
+ *     completed, with either an ok or not-ok status.
+ *
+ *     Refrain from calling this function multiple times when
+ *     successfully completing multiple NCQ commands.
+ *     ata_qc_complete_multiple() should be used instead, which will
+ *     properly update IRQ expect state.
  *
  *     LOCKING:
  *     spin_lock_irqsave(host lock)
@@ -4872,20 +4840,31 @@ void ata_qc_complete(struct ata_queued_cmd *qc)
                struct ata_device *dev = qc->dev;
                struct ata_eh_info *ehi = &dev->link->eh_info;
 
-               WARN_ON(ap->pflags & ATA_PFLAG_FROZEN);
-
                if (unlikely(qc->err_mask))
                        qc->flags |= ATA_QCFLAG_FAILED;
 
+               /*
+                * Finish internal commands without any further processing
+                * and always with the result TF filled.
+                */
+               if (unlikely(ata_tag_internal(qc->tag))) {
+                       fill_result_tf(qc);
+                       __ata_qc_complete(qc);
+                       return;
+               }
+
+               /*
+                * Non-internal qc has failed.  Fill the result TF and
+                * summon EH.
+                */
                if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
-                       if (!ata_tag_internal(qc->tag)) {
-                               /* always fill result TF for failed qc */
-                               fill_result_tf(qc);
-                               ata_qc_schedule_eh(qc);
-                               return;
-                       }
+                       fill_result_tf(qc);
+                       ata_qc_schedule_eh(qc);
+                       return;
                }
 
+               WARN_ON_ONCE(ap->pflags & ATA_PFLAG_FROZEN);
+
                /* read result TF if requested */
                if (qc->flags & ATA_QCFLAG_RESULT_TF)
                        fill_result_tf(qc);
@@ -4937,6 +4916,10 @@ void ata_qc_complete(struct ata_queued_cmd *qc)
  *     requests normally.  ap->qc_active and @qc_active is compared
  *     and commands are completed accordingly.
  *
+ *     Always use this function when completing multiple NCQ commands
+ *     from IRQ handlers instead of calling ata_qc_complete()
+ *     multiple times to keep IRQ expect status properly in sync.
+ *
  *     LOCKING:
  *     spin_lock_irqsave(host lock)
  *
@@ -4947,26 +4930,25 @@ int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active)
 {
        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);
+               ata_port_err(ap, "illegal qc_active transition (%08x->%08x)\n",
+                            ap->qc_active, qc_active);
                return -EINVAL;
        }
 
-       for (i = 0; i < ATA_MAX_QUEUE; i++) {
+       while (done_mask) {
                struct ata_queued_cmd *qc;
+               unsigned int tag = __ffs(done_mask);
 
-               if (!(done_mask & (1 << i)))
-                       continue;
-
-               if ((qc = ata_qc_from_tag(ap, i))) {
+               qc = ata_qc_from_tag(ap, tag);
+               if (qc) {
                        ata_qc_complete(qc);
                        nr_done++;
                }
+               done_mask &= ~(1 << tag);
        }
 
        return nr_done;
@@ -4994,16 +4976,16 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
         * check is skipped for old EH because it reuses active qc to
         * request ATAPI sense.
         */
-       WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag));
+       WARN_ON_ONCE(ap->ops->error_handler && ata_tag_valid(link->active_tag));
 
        if (ata_is_ncq(prot)) {
-               WARN_ON(link->sactive & (1 << qc->tag));
+               WARN_ON_ONCE(link->sactive & (1 << qc->tag));
 
                if (!link->sactive)
                        ap->nr_active_links++;
                link->sactive |= 1 << qc->tag;
        } else {
-               WARN_ON(link->sactive);
+               WARN_ON_ONCE(link->sactive);
 
                ap->nr_active_links++;
                link->active_tag = qc->tag;
@@ -5012,15 +4994,18 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
        qc->flags |= ATA_QCFLAG_ACTIVE;
        ap->qc_active |= 1 << qc->tag;
 
-       /* We guarantee to LLDs that they will have at least one
+       /*
+        * We guarantee to LLDs that they will have at least one
         * non-zero sg if the command is a data command.
         */
-       BUG_ON(ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes));
+       if (WARN_ON_ONCE(ata_is_data(prot) &&
+                        (!qc->sg || !qc->n_elem || !qc->nbytes)))
+               goto sys_err;
 
        if (ata_is_dma(prot) || (ata_is_pio(prot) &&
                                 (ap->flags & ATA_FLAG_PIO_DMA)))
                if (ata_sg_setup(qc))
-                       goto sg_err;
+                       goto sys_err;
 
        /* if device is sleeping, schedule reset and abort the link */
        if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
@@ -5037,7 +5022,7 @@ void ata_qc_issue(struct ata_queued_cmd *qc)
                goto err;
        return;
 
-sg_err:
+sys_err:
        qc->err_mask |= AC_ERR_SYSTEM;
 err:
        ata_qc_complete(qc);
@@ -5167,7 +5152,7 @@ bool ata_phys_link_online(struct ata_link *link)
        u32 sstatus;
 
        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
-           (sstatus & 0xf) == 0x3)
+           ata_sstatus_online(sstatus))
                return true;
        return false;
 }
@@ -5191,7 +5176,7 @@ bool ata_phys_link_offline(struct ata_link *link)
        u32 sstatus;
 
        if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
-           (sstatus & 0xf) != 0x3)
+           !ata_sstatus_online(sstatus))
                return true;
        return false;
 }
@@ -5316,15 +5301,21 @@ static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
  */
 int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
 {
+       unsigned int ehi_flags = ATA_EHI_QUIET;
        int rc;
 
        /*
-        * disable link pm on all ports before requesting
-        * any pm activity
+        * On some hardware, device fails to respond after spun down
+        * for suspend.  As the device won't be used before being
+        * resumed, we don't need to touch the device.  Ask EH to skip
+        * the usual stuff and proceed directly to suspend.
+        *
+        * http://thread.gmane.org/gmane.linux.ide/46764
         */
-       ata_lpm_enable(host);
+       if (mesg.event == PM_EVENT_SUSPEND)
+               ehi_flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_NO_RECOVERY;
 
-       rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1);
+       rc = ata_host_request_pm(host, mesg, 0, ehi_flags, 1);
        if (rc == 0)
                host->dev->power.power_state = mesg;
        return rc;
@@ -5336,7 +5327,7 @@ int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
  *
  *     Resume @host.  Actual operation is performed by EH.  This
  *     function requests EH to perform PM operations and returns.
- *     Note that all resume operations are performed parallely.
+ *     Note that all resume operations are performed parallelly.
  *
  *     LOCKING:
  *     Kernel thread context (may sleep).
@@ -5346,37 +5337,10 @@ void ata_host_resume(struct ata_host *host)
        ata_host_request_pm(host, PMSG_ON, ATA_EH_RESET,
                            ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0);
        host->dev->power.power_state = PMSG_ON;
-
-       /* reenable link pm */
-       ata_lpm_disable(host);
 }
 #endif
 
 /**
- *     ata_port_start - Set port up for dma.
- *     @ap: Port to initialize
- *
- *     Called just after data structures for each port are
- *     initialized.  Allocates space for PRD table.
- *
- *     May be used as the port_start() entry in ata_port_operations.
- *
- *     LOCKING:
- *     Inherited from caller.
- */
-int ata_port_start(struct ata_port *ap)
-{
-       struct device *dev = ap->dev;
-
-       ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma,
-                                     GFP_KERNEL);
-       if (!ap->prd)
-               return -ENOMEM;
-
-       return 0;
-}
-
-/**
  *     ata_dev_init - Initialize an ata_device structure
  *     @dev: Device structure to initialize
  *
@@ -5404,8 +5368,8 @@ void ata_dev_init(struct ata_device *dev)
        dev->horkage = 0;
        spin_unlock_irqrestore(ap->lock, flags);
 
-       memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
-              sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
+       memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0,
+              ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN);
        dev->pio_mask = UINT_MAX;
        dev->mwdma_mask = UINT_MAX;
        dev->udma_mask = UINT_MAX;
@@ -5427,7 +5391,8 @@ void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
        int i;
 
        /* clear everything except for devices */
-       memset(link, 0, offsetof(struct ata_link, device[0]));
+       memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
+              ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
 
        link->ap = ap;
        link->pmp = pmp;
@@ -5440,6 +5405,9 @@ void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
 
                dev->link = link;
                dev->devno = dev - link->device;
+#ifdef CONFIG_ATA_ACPI
+               dev->gtf_filter = ata_acpi_gtf_filter;
+#endif
                ata_dev_init(dev);
        }
 }
@@ -5499,14 +5467,11 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
        if (!ap)
                return NULL;
 
-       ap->pflags |= ATA_PFLAG_INITIALIZING;
+       ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
        ap->lock = &host->lock;
-       ap->flags = ATA_FLAG_DISABLED;
        ap->print_id = -1;
-       ap->ctl = ATA_DEVCTL_OBS;
        ap->host = host;
        ap->dev = host->dev;
-       ap->last_ctl = 0xFF;
 
 #if defined(ATA_VERBOSE_DEBUG)
        /* turn on all debugging levels */
@@ -5517,11 +5482,7 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
        ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
 #endif
 
-#ifdef CONFIG_ATA_SFF
-       INIT_DELAYED_WORK(&ap->port_task, ata_pio_task);
-#else
-       INIT_DELAYED_WORK(&ap->port_task, NULL);
-#endif
+       mutex_init(&ap->scsi_scan_mutex);
        INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
        INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
        INIT_LIST_HEAD(&ap->eh_done_q);
@@ -5539,6 +5500,8 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
        ap->stats.unhandled_irq = 1;
        ap->stats.idle_irq = 1;
 #endif
+       ata_sff_port_init(ap);
+
        return ap;
 }
 
@@ -5607,6 +5570,7 @@ struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
        dev_set_drvdata(dev, host);
 
        spin_lock_init(&host->lock);
+       mutex_init(&host->eh_mutex);
        host->dev = dev;
        host->n_ports = max_ports;
 
@@ -5863,9 +5827,9 @@ int ata_host_start(struct ata_host *host)
                        rc = ap->ops->port_start(ap);
                        if (rc) {
                                if (rc != -ENODEV)
-                                       dev_printk(KERN_ERR, host->dev,
-                                               "failed to start port %d "
-                                               "(errno=%d)\n", i, rc);
+                                       dev_err(host->dev,
+                                               "failed to start port %d (errno=%d)\n",
+                                               i, rc);
                                goto err_out;
                        }
                }
@@ -5904,11 +5868,67 @@ void ata_host_init(struct ata_host *host, struct device *dev,
                   unsigned long flags, struct ata_port_operations *ops)
 {
        spin_lock_init(&host->lock);
+       mutex_init(&host->eh_mutex);
        host->dev = dev;
        host->flags = flags;
        host->ops = ops;
 }
 
+int ata_port_probe(struct ata_port *ap)
+{
+       int rc = 0;
+
+       /* probe */
+       if (ap->ops->error_handler) {
+               struct ata_eh_info *ehi = &ap->link.eh_info;
+               unsigned long flags;
+
+               /* kick EH for boot probing */
+               spin_lock_irqsave(ap->lock, flags);
+
+               ehi->probe_mask |= ATA_ALL_DEVICES;
+               ehi->action |= ATA_EH_RESET;
+               ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
+
+               ap->pflags &= ~ATA_PFLAG_INITIALIZING;
+               ap->pflags |= ATA_PFLAG_LOADING;
+               ata_port_schedule_eh(ap);
+
+               spin_unlock_irqrestore(ap->lock, flags);
+
+               /* wait for EH to finish */
+               ata_port_wait_eh(ap);
+       } else {
+               DPRINTK("ata%u: bus probe begin\n", ap->print_id);
+               rc = ata_bus_probe(ap);
+               DPRINTK("ata%u: bus probe end\n", ap->print_id);
+       }
+       return rc;
+}
+
+
+static void async_port_probe(void *data, async_cookie_t cookie)
+{
+       struct ata_port *ap = data;
+
+       /*
+        * If we're not allowed to scan this host in parallel,
+        * we need to wait until all previous scans have completed
+        * before going further.
+        * Jeff Garzik says this is only within a controller, so we
+        * don't need to wait for port 0, only for later ports.
+        */
+       if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
+               async_synchronize_cookie(cookie);
+
+       (void)ata_port_probe(ap);
+
+       /* in order to keep device order, we need to synchronize at this point */
+       async_synchronize_cookie(cookie);
+
+       ata_scsi_scan_host(ap, 1);
+}
+
 /**
  *     ata_host_register - register initialized ATA host
  *     @host: ATA host to register
@@ -5931,8 +5951,7 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
 
        /* host must have been started */
        if (!(host->flags & ATA_HOST_STARTED)) {
-               dev_printk(KERN_ERR, host->dev,
-                          "BUG: trying to register unstarted host\n");
+               dev_err(host->dev, "BUG: trying to register unstarted host\n");
                WARN_ON(1);
                return -EINVAL;
        }
@@ -5948,9 +5967,18 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
        for (i = 0; i < host->n_ports; i++)
                host->ports[i]->print_id = ata_print_id++;
 
+
+       /* Create associated sysfs transport objects  */
+       for (i = 0; i < host->n_ports; i++) {
+               rc = ata_tport_add(host->dev,host->ports[i]);
+               if (rc) {
+                       goto err_tadd;
+               }
+       }
+
        rc = ata_scsi_add_hosts(host, sht);
        if (rc)
-               return rc;
+               goto err_tadd;
 
        /* associate with ACPI nodes */
        ata_acpi_associate(host);
@@ -5974,68 +6002,29 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
                                              ap->udma_mask);
 
                if (!ata_port_is_dummy(ap)) {
-                       ata_port_printk(ap, KERN_INFO,
-                                       "%cATA max %s %s\n",
-                                       (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
-                                       ata_mode_string(xfer_mask),
-                                       ap->link.eh_info.desc);
+                       ata_port_info(ap, "%cATA max %s %s\n",
+                                     (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
+                                     ata_mode_string(xfer_mask),
+                                     ap->link.eh_info.desc);
                        ata_ehi_clear_desc(&ap->link.eh_info);
                } else
-                       ata_port_printk(ap, KERN_INFO, "DUMMY\n");
+                       ata_port_info(ap, "DUMMY\n");
        }
 
-       /* perform each probe synchronously */
-       DPRINTK("probe begin\n");
+       /* perform each probe asynchronously */
        for (i = 0; i < host->n_ports; i++) {
                struct ata_port *ap = host->ports[i];
-
-               /* probe */
-               if (ap->ops->error_handler) {
-                       struct ata_eh_info *ehi = &ap->link.eh_info;
-                       unsigned long flags;
-
-                       ata_port_probe(ap);
-
-                       /* kick EH for boot probing */
-                       spin_lock_irqsave(ap->lock, flags);
-
-                       ehi->probe_mask |= ATA_ALL_DEVICES;
-                       ehi->action |= ATA_EH_RESET | ATA_EH_LPM;
-                       ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
-
-                       ap->pflags &= ~ATA_PFLAG_INITIALIZING;
-                       ap->pflags |= ATA_PFLAG_LOADING;
-                       ata_port_schedule_eh(ap);
-
-                       spin_unlock_irqrestore(ap->lock, flags);
-
-                       /* wait for EH to finish */
-                       ata_port_wait_eh(ap);
-               } else {
-                       DPRINTK("ata%u: bus probe begin\n", ap->print_id);
-                       rc = ata_bus_probe(ap);
-                       DPRINTK("ata%u: bus probe end\n", ap->print_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.
-                                */
-                       }
-               }
+               async_schedule(async_port_probe, ap);
        }
 
-       /* probes are done, now scan each port's disk(s) */
-       DPRINTK("host probe begin\n");
-       for (i = 0; i < host->n_ports; i++) {
-               struct ata_port *ap = host->ports[i];
+       return 0;
 
-               ata_scsi_scan_host(ap, 1);
+ err_tadd:
+       while (--i >= 0) {
+               ata_tport_delete(host->ports[i]);
        }
+       return rc;
 
-       return 0;
 }
 
 /**
@@ -6107,8 +6096,6 @@ int ata_host_activate(struct ata_host *host, int irq,
 static void ata_port_detach(struct ata_port *ap)
 {
        unsigned long flags;
-       struct ata_link *link;
-       struct ata_device *dev;
 
        if (!ap->ops->error_handler)
                goto skip_eh;
@@ -6116,31 +6103,25 @@ static void ata_port_detach(struct ata_port *ap)
        /* tell EH we're leaving & flush EH */
        spin_lock_irqsave(ap->lock, flags);
        ap->pflags |= ATA_PFLAG_UNLOADING;
+       ata_port_schedule_eh(ap);
        spin_unlock_irqrestore(ap->lock, flags);
 
+       /* wait till EH commits suicide */
        ata_port_wait_eh(ap);
 
-       /* EH is now guaranteed to see UNLOADING - EH context belongs
-        * to us.  Restore SControl and disable all existing devices.
-        */
-       ata_for_each_link(link, ap, HOST_FIRST) {
-               sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
-               ata_for_each_dev(dev, link, ALL)
-                       ata_dev_disable(dev);
-       }
-
-       /* 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->lock, flags);
-       ata_port_freeze(ap);    /* won't be thawed */
-       spin_unlock_irqrestore(ap->lock, flags);
+       /* it better be dead now */
+       WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
 
-       ata_port_wait_eh(ap);
-       cancel_rearming_delayed_work(&ap->hotplug_task);
+       cancel_delayed_work_sync(&ap->hotplug_task);
 
  skip_eh:
+       if (ap->pmp_link) {
+               int i;
+               for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
+                       ata_tlink_delete(&ap->pmp_link[i]);
+       }
+       ata_tport_delete(ap);
+
        /* remove the associated SCSI host */
        scsi_remove_host(ap->scsi_host);
 }
@@ -6239,8 +6220,8 @@ int ata_pci_device_do_resume(struct pci_dev *pdev)
 
        rc = pcim_enable_device(pdev);
        if (rc) {
-               dev_printk(KERN_ERR, &pdev->dev,
-                          "failed to enable device after resume (%d)\n", rc);
+               dev_err(&pdev->dev,
+                       "failed to enable device after resume (%d)\n", rc);
                return rc;
        }
 
@@ -6296,6 +6277,7 @@ static int __init ata_parse_force_one(char **cur,
                { "3.0Gbps",    .spd_limit      = 2 },
                { "noncq",      .horkage_on     = ATA_HORKAGE_NONCQ },
                { "ncq",        .horkage_off    = ATA_HORKAGE_NONCQ },
+               { "dump_id",    .horkage_on     = ATA_HORKAGE_DUMP_ID },
                { "pio0",       .xfer_mask      = 1 << (ATA_SHIFT_PIO + 0) },
                { "pio1",       .xfer_mask      = 1 << (ATA_SHIFT_PIO + 1) },
                { "pio2",       .xfer_mask      = 1 << (ATA_SHIFT_PIO + 2) },
@@ -6456,59 +6438,79 @@ static void __init ata_parse_force_param(void)
 
 static int __init ata_init(void)
 {
+       int rc;
+
        ata_parse_force_param();
 
-       ata_wq = create_workqueue("ata");
-       if (!ata_wq)
-               goto free_force_tbl;
+       rc = ata_sff_init();
+       if (rc) {
+               kfree(ata_force_tbl);
+               return rc;
+       }
 
-       ata_aux_wq = create_singlethread_workqueue("ata_aux");
-       if (!ata_aux_wq)
-               goto free_wq;
+       libata_transport_init();
+       ata_scsi_transport_template = ata_attach_transport();
+       if (!ata_scsi_transport_template) {
+               ata_sff_exit();
+               rc = -ENOMEM;
+               goto err_out;
+       }
 
        printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
        return 0;
 
-free_wq:
-       destroy_workqueue(ata_wq);
-free_force_tbl:
-       kfree(ata_force_tbl);
-       return -ENOMEM;
+err_out:
+       return rc;
 }
 
 static void __exit ata_exit(void)
 {
+       ata_release_transport(ata_scsi_transport_template);
+       libata_transport_exit();
+       ata_sff_exit();
        kfree(ata_force_tbl);
-       destroy_workqueue(ata_wq);
-       destroy_workqueue(ata_aux_wq);
 }
 
 subsys_initcall(ata_init);
 module_exit(ata_exit);
 
-static unsigned long ratelimit_time;
-static DEFINE_SPINLOCK(ata_ratelimit_lock);
+static DEFINE_RATELIMIT_STATE(ratelimit, HZ / 5, 1);
 
 int ata_ratelimit(void)
 {
-       int rc;
-       unsigned long flags;
+       return __ratelimit(&ratelimit);
+}
 
-       spin_lock_irqsave(&ata_ratelimit_lock, flags);
+/**
+ *     ata_msleep - ATA EH owner aware msleep
+ *     @ap: ATA port to attribute the sleep to
+ *     @msecs: duration to sleep in milliseconds
+ *
+ *     Sleeps @msecs.  If the current task is owner of @ap's EH, the
+ *     ownership is released before going to sleep and reacquired
+ *     after the sleep is complete.  IOW, other ports sharing the
+ *     @ap->host will be allowed to own the EH while this task is
+ *     sleeping.
+ *
+ *     LOCKING:
+ *     Might sleep.
+ */
+void ata_msleep(struct ata_port *ap, unsigned int msecs)
+{
+       bool owns_eh = ap && ap->host->eh_owner == current;
 
-       if (time_after(jiffies, ratelimit_time)) {
-               rc = 1;
-               ratelimit_time = jiffies + (HZ/5);
-       } else
-               rc = 0;
+       if (owns_eh)
+               ata_eh_release(ap);
 
-       spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
+       msleep(msecs);
 
-       return rc;
+       if (owns_eh)
+               ata_eh_acquire(ap);
 }
 
 /**
  *     ata_wait_register - wait until register value changes
+ *     @ap: ATA port to wait register for, can be NULL
  *     @reg: IO-mapped register
  *     @mask: Mask to apply to read register value
  *     @val: Wait condition
@@ -6530,7 +6532,7 @@ int ata_ratelimit(void)
  *     RETURNS:
  *     The final register value.
  */
-u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
+u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
                      unsigned long interval, unsigned long timeout)
 {
        unsigned long deadline;
@@ -6545,7 +6547,7 @@ u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
        deadline = ata_deadline(jiffies, timeout);
 
        while ((tmp & mask) == val && time_before(jiffies, deadline)) {
-               msleep(interval);
+               ata_msleep(ap, interval);
                tmp = ioread32(reg);
        }
 
@@ -6576,6 +6578,82 @@ const struct ata_port_info ata_dummy_port_info = {
 };
 
 /*
+ * Utility print functions
+ */
+int ata_port_printk(const struct ata_port *ap, const char *level,
+                   const char *fmt, ...)
+{
+       struct va_format vaf;
+       va_list args;
+       int r;
+
+       va_start(args, fmt);
+
+       vaf.fmt = fmt;
+       vaf.va = &args;
+
+       r = printk("%sata%u: %pV", level, ap->print_id, &vaf);
+
+       va_end(args);
+
+       return r;
+}
+EXPORT_SYMBOL(ata_port_printk);
+
+int ata_link_printk(const struct ata_link *link, const char *level,
+                   const char *fmt, ...)
+{
+       struct va_format vaf;
+       va_list args;
+       int r;
+
+       va_start(args, fmt);
+
+       vaf.fmt = fmt;
+       vaf.va = &args;
+
+       if (sata_pmp_attached(link->ap) || link->ap->slave_link)
+               r = printk("%sata%u.%02u: %pV",
+                          level, link->ap->print_id, link->pmp, &vaf);
+       else
+               r = printk("%sata%u: %pV",
+                          level, link->ap->print_id, &vaf);
+
+       va_end(args);
+
+       return r;
+}
+EXPORT_SYMBOL(ata_link_printk);
+
+int ata_dev_printk(const struct ata_device *dev, const char *level,
+                   const char *fmt, ...)
+{
+       struct va_format vaf;
+       va_list args;
+       int r;
+
+       va_start(args, fmt);
+
+       vaf.fmt = fmt;
+       vaf.va = &args;
+
+       r = printk("%sata%u.%02u: %pV",
+                  level, dev->link->ap->print_id, dev->link->pmp + dev->devno,
+                  &vaf);
+
+       va_end(args);
+
+       return r;
+}
+EXPORT_SYMBOL(ata_dev_printk);
+
+void ata_print_version(const struct device *dev, const char *version)
+{
+       dev_printk(KERN_DEBUG, dev, "version %s\n", version);
+}
+EXPORT_SYMBOL(ata_print_version);
+
+/*
  * libata is essentially a library of internal helper functions for
  * low-level ATA host controller drivers.  As such, the API/ABI is
  * likely to change as new drivers are added and updated.
@@ -6591,6 +6669,7 @@ EXPORT_SYMBOL_GPL(ata_dummy_port_info);
 EXPORT_SYMBOL_GPL(ata_link_next);
 EXPORT_SYMBOL_GPL(ata_dev_next);
 EXPORT_SYMBOL_GPL(ata_std_bios_param);
+EXPORT_SYMBOL_GPL(ata_scsi_unlock_native_capacity);
 EXPORT_SYMBOL_GPL(ata_host_init);
 EXPORT_SYMBOL_GPL(ata_host_alloc);
 EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
@@ -6612,26 +6691,24 @@ EXPORT_SYMBOL_GPL(ata_xfer_mode2mask);
 EXPORT_SYMBOL_GPL(ata_xfer_mode2shift);
 EXPORT_SYMBOL_GPL(ata_mode_string);
 EXPORT_SYMBOL_GPL(ata_id_xfermask);
-EXPORT_SYMBOL_GPL(ata_port_start);
 EXPORT_SYMBOL_GPL(ata_do_set_mode);
 EXPORT_SYMBOL_GPL(ata_std_qc_defer);
 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
-EXPORT_SYMBOL_GPL(ata_port_probe);
 EXPORT_SYMBOL_GPL(ata_dev_disable);
 EXPORT_SYMBOL_GPL(sata_set_spd);
 EXPORT_SYMBOL_GPL(ata_wait_after_reset);
 EXPORT_SYMBOL_GPL(sata_link_debounce);
 EXPORT_SYMBOL_GPL(sata_link_resume);
+EXPORT_SYMBOL_GPL(sata_link_scr_lpm);
 EXPORT_SYMBOL_GPL(ata_std_prereset);
 EXPORT_SYMBOL_GPL(sata_link_hardreset);
 EXPORT_SYMBOL_GPL(sata_std_hardreset);
 EXPORT_SYMBOL_GPL(ata_std_postreset);
 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_msleep);
 EXPORT_SYMBOL_GPL(ata_wait_register);
-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);