ide/ata: Add export.h for EXPORT_SYMBOL/THIS_MODULE where needed
[linux-2.6.git] / drivers / ata / libata-pmp.c
index c0c4dbc..104462d 100644 (file)
@@ -8,8 +8,19 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/export.h>
 #include <linux/libata.h>
+#include <linux/slab.h>
 #include "libata.h"
+#include "libata-transport.h"
+
+const struct ata_port_operations sata_pmp_port_ops = {
+       .inherits               = &sata_port_ops,
+       .pmp_prereset           = ata_std_prereset,
+       .pmp_hardreset          = sata_std_hardreset,
+       .pmp_postreset          = ata_std_postreset,
+       .error_handler          = sata_pmp_error_handler,
+};
 
 /**
  *     sata_pmp_read - read PMP register
@@ -35,12 +46,12 @@ static unsigned int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
        ata_tf_init(pmp_dev, &tf);
        tf.command = ATA_CMD_PMP_READ;
        tf.protocol = ATA_PROT_NODATA;
-       tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+       tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48;
        tf.feature = reg;
        tf.device = link->pmp;
 
        err_mask = ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
-                                    SATA_PMP_SCR_TIMEOUT);
+                                    SATA_PMP_RW_TIMEOUT);
        if (err_mask)
                return err_mask;
 
@@ -71,7 +82,7 @@ static unsigned int sata_pmp_write(struct ata_link *link, int reg, u32 val)
        ata_tf_init(pmp_dev, &tf);
        tf.command = ATA_CMD_PMP_WRITE;
        tf.protocol = ATA_PROT_NODATA;
-       tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
+       tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48;
        tf.feature = reg;
        tf.device = link->pmp;
        tf.nsect = val & 0xff;
@@ -80,7 +91,7 @@ static unsigned int sata_pmp_write(struct ata_link *link, int reg, u32 val)
        tf.lbah = (val >> 24) & 0xff;
 
        return ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
-                                SATA_PMP_SCR_TIMEOUT);
+                                SATA_PMP_RW_TIMEOUT);
 }
 
 /**
@@ -137,8 +148,8 @@ int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
 
        err_mask = sata_pmp_read(link, reg, r_val);
        if (err_mask) {
-               ata_link_printk(link, KERN_WARNING, "failed to read SCR %d "
-                               "(Emask=0x%x)\n", reg, err_mask);
+               ata_link_warn(link, "failed to read SCR %d (Emask=0x%x)\n",
+                             reg, err_mask);
                return -EIO;
        }
        return 0;
@@ -168,145 +179,32 @@ int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
 
        err_mask = sata_pmp_write(link, reg, val);
        if (err_mask) {
-               ata_link_printk(link, KERN_WARNING, "failed to write SCR %d "
-                               "(Emask=0x%x)\n", reg, err_mask);
+               ata_link_warn(link, "failed to write SCR %d (Emask=0x%x)\n",
+                             reg, err_mask);
                return -EIO;
        }
        return 0;
 }
 
 /**
- *     sata_pmp_std_prereset - prepare PMP link for reset
- *     @link: link to be reset
- *     @deadline: deadline jiffies for the operation
- *
- *     @link is about to be reset.  Initialize it.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
- *
- *     RETURNS:
- *     0 on success, -errno otherwise.
- */
-int sata_pmp_std_prereset(struct ata_link *link, unsigned long deadline)
-{
-       struct ata_eh_context *ehc = &link->eh_context;
-       const unsigned long *timing = sata_ehc_deb_timing(ehc);
-       int rc;
-
-       /* force HRST? */
-       if (link->flags & ATA_LFLAG_NO_SRST)
-               ehc->i.action |= ATA_EH_HARDRESET;
-
-       /* handle link resume */
-       if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
-           (link->flags & ATA_LFLAG_HRST_TO_RESUME))
-               ehc->i.action |= ATA_EH_HARDRESET;
-
-       /* if we're about to do hardreset, nothing more to do */
-       if (ehc->i.action & ATA_EH_HARDRESET)
-               return 0;
-
-       /* resume link */
-       rc = sata_link_resume(link, timing, deadline);
-       if (rc) {
-               /* phy resume failed */
-               ata_link_printk(link, KERN_WARNING, "failed to resume link "
-                               "for reset (errno=%d)\n", rc);
-               return rc;
-       }
-
-       /* clear SError bits including .X which blocks the port when set */
-       rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
-       if (rc) {
-               ata_link_printk(link, KERN_ERR,
-                               "failed to clear SError (errno=%d)\n", rc);
-               return rc;
-       }
-
-       return 0;
-}
-
-/**
- *     sata_pmp_std_hardreset - standard hardreset method for PMP link
- *     @link: link to be reset
- *     @class: resulting class of attached device
- *     @deadline: deadline jiffies for the operation
+ *     sata_pmp_set_lpm - configure LPM for a PMP link
+ *     @link: PMP link to configure LPM for
+ *     @policy: target LPM policy
+ *     @hints: LPM hints
  *
- *     Hardreset PMP port @link.  Note that this function doesn't
- *     wait for BSY clearance.  There simply isn't a generic way to
- *     wait the event.  Instead, this function return -EAGAIN thus
- *     telling libata-EH to followup with softreset.
+ *     Configure LPM for @link.  This function will contain any PMP
+ *     specific workarounds if necessary.
  *
  *     LOCKING:
- *     Kernel thread context (may sleep)
+ *     EH context.
  *
  *     RETURNS:
- *     0 on success, -errno otherwise.
- */
-int sata_pmp_std_hardreset(struct ata_link *link, unsigned int *class,
-                          unsigned long deadline)
-{
-       const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
-       u32 tmp;
-       int rc;
-
-       DPRINTK("ENTER\n");
-
-       /* do hardreset */
-       rc = sata_link_hardreset(link, timing, deadline);
-       if (rc) {
-               ata_link_printk(link, KERN_ERR,
-                               "COMRESET failed (errno=%d)\n", rc);
-               goto out;
-       }
-
-       /* clear SError bits including .X which blocks the port when set */
-       rc = sata_scr_write(link, SCR_ERROR, 0xffffffff);
-       if (rc) {
-               ata_link_printk(link, KERN_ERR, "failed to clear SError "
-                               "during hardreset (errno=%d)\n", rc);
-               goto out;
-       }
-
-       /* if device is present, follow up with srst to wait for !BSY */
-       if (ata_link_online(link))
-               rc = -EAGAIN;
- out:
-       /* if SCR isn't accessible, we need to reset the PMP */
-       if (rc && rc != -EAGAIN && sata_scr_read(link, SCR_STATUS, &tmp))
-               rc = -ERESTART;
-
-       DPRINTK("EXIT, rc=%d\n", rc);
-       return rc;
-}
-
-/**
- *     ata_std_postreset - standard postreset method for PMP link
- *     @link: the target ata_link
- *     @classes: classes of attached devices
- *
- *     This function is invoked after a successful reset.  Note that
- *     the device might have been reset more than once using
- *     different reset methods before postreset is invoked.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
+ *     0 on success, -errno on failure.
  */
-void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class)
+int sata_pmp_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
+                    unsigned hints)
 {
-       u32 serror;
-
-       DPRINTK("ENTER\n");
-
-       /* clear SError */
-       if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
-               sata_scr_write(link, SCR_ERROR, serror);
-
-       /* print link status */
-       sata_print_link_status(link);
-
-       DPRINTK("EXIT\n");
+       return sata_link_scr_lpm(link, policy, true);
 }
 
 /**
@@ -334,8 +232,8 @@ static int sata_pmp_read_gscr(struct ata_device *dev, u32 *gscr)
 
                err_mask = sata_pmp_read(dev->link, reg, &gscr[reg]);
                if (err_mask) {
-                       ata_dev_printk(dev, KERN_ERR, "failed to read PMP "
-                               "GSCR[%d] (Emask=0x%x)\n", reg, err_mask);
+                       ata_dev_err(dev, "failed to read PMP GSCR[%d] (Emask=0x%x)\n",
+                                   reg, err_mask);
                        return -EIO;
                }
        }
@@ -347,6 +245,8 @@ static const char *sata_pmp_spec_rev_str(const u32 *gscr)
 {
        u32 rev = gscr[SATA_PMP_GSCR_REV];
 
+       if (rev & (1 << 3))
+               return "1.2";
        if (rev & (1 << 2))
                return "1.1";
        if (rev & (1 << 1))
@@ -354,10 +254,14 @@ static const char *sata_pmp_spec_rev_str(const u32 *gscr)
        return "<unknown>";
 }
 
+#define PMP_GSCR_SII_POL 129
+
 static int sata_pmp_configure(struct ata_device *dev, int print_info)
 {
        struct ata_port *ap = dev->link->ap;
        u32 *gscr = dev->gscr;
+       u16 vendor = sata_pmp_gscr_vendor(gscr);
+       u16 devid = sata_pmp_gscr_devid(gscr);
        unsigned int err_mask = 0;
        const char *reason;
        int nr_ports, rc;
@@ -383,49 +287,57 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
                goto fail;
        }
 
-       /* turn off notification till fan-out ports are reset and configured */
-       if (gscr[SATA_PMP_GSCR_FEAT_EN] & SATA_PMP_FEAT_NOTIFY) {
-               gscr[SATA_PMP_GSCR_FEAT_EN] &= ~SATA_PMP_FEAT_NOTIFY;
+       /* Disable sending Early R_OK.
+        * With "cached read" HDD testing and multiple ports busy on a SATA
+        * host controller, 3726 PMP will very rarely drop a deferred
+        * R_OK that was intended for the host. Symptom will be all
+        * 5 drives under test will timeout, get reset, and recover.
+        */
+       if (vendor == 0x1095 && devid == 0x3726) {
+               u32 reg;
 
-               err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_FEAT_EN,
-                                         gscr[SATA_PMP_GSCR_FEAT_EN]);
+               err_mask = sata_pmp_read(&ap->link, PMP_GSCR_SII_POL, &reg);
                if (err_mask) {
                        rc = -EIO;
-                       reason = "failed to write GSCR_FEAT_EN";
+                       reason = "failed to read Sil3726 Private Register";
+                       goto fail;
+               }
+               reg &= ~0x1;
+               err_mask = sata_pmp_write(&ap->link, PMP_GSCR_SII_POL, reg);
+               if (err_mask) {
+                       rc = -EIO;
+                       reason = "failed to write Sil3726 Private Register";
                        goto fail;
                }
        }
 
        if (print_info) {
-               ata_dev_printk(dev, KERN_INFO, "Port Multiplier %s, "
-                              "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
-                              sata_pmp_spec_rev_str(gscr),
-                              sata_pmp_gscr_vendor(gscr),
-                              sata_pmp_gscr_devid(gscr),
-                              sata_pmp_gscr_rev(gscr),
-                              nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
-                              gscr[SATA_PMP_GSCR_FEAT]);
+               ata_dev_info(dev, "Port Multiplier %s, "
+                            "0x%04x:0x%04x r%d, %d ports, feat 0x%x/0x%x\n",
+                            sata_pmp_spec_rev_str(gscr), vendor, devid,
+                            sata_pmp_gscr_rev(gscr),
+                            nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
+                            gscr[SATA_PMP_GSCR_FEAT]);
 
                if (!(dev->flags & ATA_DFLAG_AN))
-                       ata_dev_printk(dev, KERN_INFO,
+                       ata_dev_info(dev,
                                "Asynchronous notification not supported, "
-                               "hotplug won't\n         work on fan-out "
-                               "ports. Use warm-plug instead.\n");
+                               "hotplug won't work on fan-out ports. Use warm-plug instead.\n");
        }
 
        return 0;
 
  fail:
-       ata_dev_printk(dev, KERN_ERR,
-                      "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
-                      reason, err_mask);
+       ata_dev_err(dev,
+                   "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
+                   reason, err_mask);
        return rc;
 }
 
-static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
+static int sata_pmp_init_links (struct ata_port *ap, int nr_ports)
 {
        struct ata_link *pmp_link = ap->pmp_link;
-       int i;
+       int i, err;
 
        if (!pmp_link) {
                pmp_link = kzalloc(sizeof(pmp_link[0]) * SATA_PMP_MAX_PORTS,
@@ -437,6 +349,13 @@ static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
                        ata_link_init(ap, &pmp_link[i], i);
 
                ap->pmp_link = pmp_link;
+
+               for (i = 0; i < SATA_PMP_MAX_PORTS; i++) {
+                       err = ata_tlink_add(&pmp_link[i]);
+                       if (err) {
+                               goto err_tlink;
+                       }
+               }
        }
 
        for (i = 0; i < nr_ports; i++) {
@@ -444,12 +363,17 @@ static int sata_pmp_init_links(struct ata_port *ap, int nr_ports)
                struct ata_eh_context *ehc = &link->eh_context;
 
                link->flags = 0;
-               ehc->i.probe_mask |= 1;
-               ehc->i.action |= ATA_EH_SOFTRESET;
-               ehc->i.flags |= ATA_EHI_RESUME_LINK;
+               ehc->i.probe_mask |= ATA_ALL_DEVICES;
+               ehc->i.action |= ATA_EH_RESET;
        }
 
        return 0;
+  err_tlink:
+       while (--i >= 0)
+               ata_tlink_delete(&pmp_link[i]);
+       kfree(pmp_link);
+       ap->pmp_link = NULL;
+       return err;
 }
 
 static void sata_pmp_quirks(struct ata_port *ap)
@@ -461,13 +385,16 @@ static void sata_pmp_quirks(struct ata_port *ap)
 
        if (vendor == 0x1095 && devid == 0x3726) {
                /* sil3726 quirks */
-               ata_port_for_each_link(link, ap) {
-                       /* SError.N need a kick in the ass to get working */
-                       link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+               ata_for_each_link(link, ap, EDGE) {
+                       /* link reports offline after LPM */
+                       link->flags |= ATA_LFLAG_NO_LPM;
 
-                       /* class code report is unreliable */
+                       /* Class code report is unreliable and SRST
+                        * times out under certain configurations.
+                        */
                        if (link->pmp < 5)
-                               link->flags |= ATA_LFLAG_ASSUME_ATA;
+                               link->flags |= ATA_LFLAG_NO_SRST |
+                                              ATA_LFLAG_ASSUME_ATA;
 
                        /* port 5 is for SEMB device and it doesn't like SRST */
                        if (link->pmp == 5)
@@ -476,9 +403,9 @@ static void sata_pmp_quirks(struct ata_port *ap)
                }
        } else if (vendor == 0x1095 && devid == 0x4723) {
                /* sil4723 quirks */
-               ata_port_for_each_link(link, ap) {
-                       /* SError.N need a kick in the ass to get working */
-                       link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+               ata_for_each_link(link, ap, EDGE) {
+                       /* link reports offline after LPM */
+                       link->flags |= ATA_LFLAG_NO_LPM;
 
                        /* class code report is unreliable */
                        if (link->pmp < 2)
@@ -491,18 +418,16 @@ static void sata_pmp_quirks(struct ata_port *ap)
                }
        } else if (vendor == 0x1095 && devid == 0x4726) {
                /* sil4726 quirks */
-               ata_port_for_each_link(link, ap) {
-                       /* SError.N need a kick in the ass to get working */
-                       link->flags |= ATA_LFLAG_HRST_TO_RESUME;
-
-                       /* class code report is unreliable */
-                       if (link->pmp < 5)
-                               link->flags |= ATA_LFLAG_ASSUME_ATA;
-
-                       /* The config device, which can be either at
-                        * port 0 or 5, locks up on SRST.
+               ata_for_each_link(link, ap, EDGE) {
+                       /* link reports offline after LPM */
+                       link->flags |= ATA_LFLAG_NO_LPM;
+
+                       /* Class code report is unreliable and SRST
+                        * times out under certain configurations.
+                        * Config device can be at port 0 or 5 and
+                        * locks up on SRST.
                         */
-                       if (link->pmp == 0 || link->pmp == 5)
+                       if (link->pmp <= 5)
                                link->flags |= ATA_LFLAG_NO_SRST |
                                               ATA_LFLAG_ASSUME_ATA;
 
@@ -524,13 +449,16 @@ static void sata_pmp_quirks(struct ata_port *ap)
                 * otherwise.  Don't try hard to recover it.
                 */
                ap->pmp_link[ap->nr_pmp_links - 1].flags |= ATA_LFLAG_NO_RETRY;
-       } else if (vendor == 0x11ab && devid == 0x4140) {
-               /* Marvell 88SM4140 quirks.  Fan-out ports require PHY
-                * reset to work; other than that, it behaves very
-                * nicely.
-                */
-               ata_port_for_each_link(link, ap)
-                       link->flags |= ATA_LFLAG_HRST_TO_RESUME;
+       } else if (vendor == 0x197b && devid == 0x2352) {
+               /* chip found in Thermaltake BlackX Duet, jmicron JMB350? */
+               ata_for_each_link(link, ap, EDGE) {
+                       /* SRST breaks detection and disks get misclassified
+                        * LPM disabled to avoid potential problems
+                        */
+                       link->flags |= ATA_LFLAG_NO_LPM |
+                                      ATA_LFLAG_NO_SRST |
+                                      ATA_LFLAG_ASSUME_ATA;
+               }
        }
 }
 
@@ -556,21 +484,18 @@ int sata_pmp_attach(struct ata_device *dev)
        int rc;
 
        /* is it hanging off the right place? */
-       if (!(ap->flags & ATA_FLAG_PMP)) {
-               ata_dev_printk(dev, KERN_ERR,
-                              "host does not support Port Multiplier\n");
+       if (!sata_pmp_supported(ap)) {
+               ata_dev_err(dev, "host does not support Port Multiplier\n");
                return -EINVAL;
        }
 
        if (!ata_is_host_link(link)) {
-               ata_dev_printk(dev, KERN_ERR,
-                              "Port Multipliers cannot be nested\n");
+               ata_dev_err(dev, "Port Multipliers cannot be nested\n");
                return -EINVAL;
        }
 
        if (dev->devno) {
-               ata_dev_printk(dev, KERN_ERR,
-                              "Port Multiplier must be the first device\n");
+               ata_dev_err(dev, "Port Multiplier must be the first device\n");
                return -EINVAL;
        }
 
@@ -589,8 +514,7 @@ int sata_pmp_attach(struct ata_device *dev)
 
        rc = sata_pmp_init_links(ap, sata_pmp_gscr_ports(dev->gscr));
        if (rc) {
-               ata_dev_printk(dev, KERN_INFO,
-                              "failed to initialize PMP links\n");
+               ata_dev_info(dev, "failed to initialize PMP links\n");
                goto fail;
        }
 
@@ -605,7 +529,7 @@ int sata_pmp_attach(struct ata_device *dev)
        if (ap->ops->pmp_attach)
                ap->ops->pmp_attach(ap);
 
-       ata_port_for_each_link(tlink, ap)
+       ata_for_each_link(tlink, ap, EDGE)
                sata_link_init_spd(tlink);
 
        ata_acpi_associate_sata_port(ap);
@@ -634,7 +558,7 @@ static void sata_pmp_detach(struct ata_device *dev)
        struct ata_link *tlink;
        unsigned long flags;
 
-       ata_dev_printk(dev, KERN_INFO, "Port Multiplier detaching\n");
+       ata_dev_info(dev, "Port Multiplier detaching\n");
 
        WARN_ON(!ata_is_host_link(link) || dev->devno ||
                link->pmp != SATA_PMP_CTRL_PORT);
@@ -642,7 +566,7 @@ static void sata_pmp_detach(struct ata_device *dev)
        if (ap->ops->pmp_detach)
                ap->ops->pmp_detach(ap);
 
-       ata_port_for_each_link(tlink, ap)
+       ata_for_each_link(tlink, ap, EDGE)
                ata_eh_detach_dev(tlink->device);
 
        spin_lock_irqsave(ap->lock, flags);
@@ -681,23 +605,23 @@ static int sata_pmp_same_pmp(struct ata_device *dev, const u32 *new_gscr)
        new_nr_ports = sata_pmp_gscr_ports(new_gscr);
 
        if (old_vendor != new_vendor) {
-               ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
-                              "vendor mismatch '0x%x' != '0x%x'\n",
-                              old_vendor, new_vendor);
+               ata_dev_info(dev,
+                            "Port Multiplier vendor mismatch '0x%x' != '0x%x'\n",
+                            old_vendor, new_vendor);
                return 0;
        }
 
        if (old_devid != new_devid) {
-               ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
-                              "device ID mismatch '0x%x' != '0x%x'\n",
-                              old_devid, new_devid);
+               ata_dev_info(dev,
+                            "Port Multiplier device ID mismatch '0x%x' != '0x%x'\n",
+                            old_devid, new_devid);
                return 0;
        }
 
        if (old_nr_ports != new_nr_ports) {
-               ata_dev_printk(dev, KERN_INFO, "Port Multiplier "
-                              "nr_ports mismatch '0x%x' != '0x%x'\n",
-                              old_nr_ports, new_nr_ports);
+               ata_dev_info(dev,
+                            "Port Multiplier nr_ports mismatch '0x%x' != '0x%x'\n",
+                            old_nr_ports, new_nr_ports);
                return 0;
        }
 
@@ -763,8 +687,7 @@ static int sata_pmp_revalidate(struct ata_device *dev, unsigned int new_class)
        return 0;
 
  fail:
-       ata_dev_printk(dev, KERN_ERR,
-                      "PMP revalidation failed (errno=%d)\n", rc);
+       ata_dev_err(dev, "PMP revalidation failed (errno=%d)\n", rc);
        DPRINTK("EXIT, rc=%d\n", rc);
        return rc;
 }
@@ -788,13 +711,14 @@ static int sata_pmp_revalidate_quick(struct ata_device *dev)
 
        err_mask = sata_pmp_read(dev->link, SATA_PMP_GSCR_PROD_ID, &prod_id);
        if (err_mask) {
-               ata_dev_printk(dev, KERN_ERR, "failed to read PMP product ID "
-                              "(Emask=0x%x)\n", err_mask);
+               ata_dev_err(dev,
+                           "failed to read PMP product ID (Emask=0x%x)\n",
+                           err_mask);
                return -EIO;
        }
 
        if (prod_id != dev->gscr[SATA_PMP_GSCR_PROD_ID]) {
-               ata_dev_printk(dev, KERN_ERR, "PMP product ID mismatch\n");
+               ata_dev_err(dev, "PMP product ID mismatch\n");
                /* something weird is going on, request full PMP recovery */
                return -EIO;
        }
@@ -842,26 +766,24 @@ static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
  retry:
        ehc->classes[0] = ATA_DEV_UNKNOWN;
 
-       if (ehc->i.action & ATA_EH_RESET_MASK) {
+       if (ehc->i.action & ATA_EH_RESET) {
                struct ata_link *tlink;
 
-               ata_eh_freeze_port(ap);
-
                /* reset */
-               ehc->i.action = ATA_EH_HARDRESET;
                rc = ata_eh_reset(link, 0, prereset, softreset, hardreset,
                                  postreset);
                if (rc) {
-                       ata_link_printk(link, KERN_ERR,
-                                       "failed to reset PMP, giving up\n");
+                       ata_link_err(link, "failed to reset PMP, giving up\n");
                        goto fail;
                }
 
-               ata_eh_thaw_port(ap);
-
                /* PMP is reset, SErrors cannot be trusted, scan all */
-               ata_port_for_each_link(tlink, ap)
-                       ata_ehi_schedule_probe(&tlink->eh_context.i);
+               ata_for_each_link(tlink, ap, EDGE) {
+                       struct ata_eh_context *ehc = &tlink->eh_context;
+
+                       ehc->i.probe_mask |= ATA_ALL_DEVICES;
+                       ehc->i.action |= ATA_EH_RESET;
+               }
        }
 
        /* If revalidation is requested, revalidate and reconfigure;
@@ -876,32 +798,25 @@ static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
                tries--;
 
                if (rc == -ENODEV) {
-                       ehc->i.probe_mask |= 1;
+                       ehc->i.probe_mask |= ATA_ALL_DEVICES;
                        detach = 1;
                        /* give it just two more chances */
                        tries = min(tries, 2);
                }
 
                if (tries) {
-                       int sleep = ehc->i.flags & ATA_EHI_DID_RESET;
-
                        /* consecutive revalidation failures? speed down */
                        if (reval_failed)
-                               sata_down_spd_limit(link);
+                               sata_down_spd_limit(link, 0);
                        else
                                reval_failed = 1;
 
-                       ata_dev_printk(dev, KERN_WARNING,
-                                      "retrying hardreset%s\n",
-                                      sleep ? " in 5 secs" : "");
-                       if (sleep)
-                               ssleep(5);
-                       ehc->i.action |= ATA_EH_HARDRESET;
+                       ehc->i.action |= ATA_EH_RESET;
                        goto retry;
                } else {
-                       ata_dev_printk(dev, KERN_ERR, "failed to recover PMP "
-                                      "after %d tries, giving up\n",
-                                      ATA_EH_PMP_TRIES);
+                       ata_dev_err(dev,
+                                   "failed to recover PMP after %d tries, giving up\n",
+                                   ATA_EH_PMP_TRIES);
                        goto fail;
                }
        }
@@ -931,7 +846,7 @@ static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
 
        spin_lock_irqsave(ap->lock, flags);
 
-       ata_port_for_each_link(link, ap) {
+       ata_for_each_link(link, ap, EDGE) {
                if (!(link->flags & ATA_LFLAG_DISABLED))
                        continue;
 
@@ -940,16 +855,16 @@ static int sata_pmp_eh_handle_disabled_links(struct ata_port *ap)
                /* Some PMPs require hardreset sequence to get
                 * SError.N working.
                 */
-               if ((link->flags & ATA_LFLAG_HRST_TO_RESUME) &&
-                   (link->eh_context.i.flags & ATA_EHI_RESUME_LINK))
-                       sata_link_hardreset(link, sata_deb_timing_normal,
-                                           jiffies + ATA_TMOUT_INTERNAL_QUICK);
+               sata_link_hardreset(link, sata_deb_timing_normal,
+                               ata_deadline(jiffies, ATA_TMOUT_INTERNAL_QUICK),
+                               NULL, NULL);
 
                /* unconditionally clear SError.N */
                rc = sata_scr_write(link, SCR_ERROR, SERR_PHYRDY_CHG);
                if (rc) {
-                       ata_link_printk(link, KERN_ERR, "failed to clear "
-                                       "SError.N (errno=%d)\n", rc);
+                       ata_link_err(link,
+                                    "failed to clear SError.N (errno=%d)\n",
+                                    rc);
                        return rc;
                }
 
@@ -971,7 +886,7 @@ static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
 
        /* disable this link */
        if (!(link->flags & ATA_LFLAG_DISABLED)) {
-               ata_link_printk(link, KERN_WARNING,
+               ata_link_warn(link,
                        "failed to recover link after %d tries, disabling\n",
                        ATA_EH_PMP_LINK_TRIES);
 
@@ -989,14 +904,6 @@ static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
 /**
  *     sata_pmp_eh_recover - recover PMP-enabled port
  *     @ap: ATA port to recover
- *     @prereset: prereset method (can be NULL)
- *     @softreset: softreset method
- *     @hardreset: hardreset method
- *     @postreset: postreset method (can be NULL)
- *     @pmp_prereset: PMP prereset method (can be NULL)
- *     @pmp_softreset: PMP softreset method (can be NULL)
- *     @pmp_hardreset: PMP hardreset method (can be NULL)
- *     @pmp_postreset: PMP postreset method (can be NULL)
  *
  *     Drive EH recovery operation for PMP enabled port @ap.  This
  *     function recovers host and PMP ports with proper retrials and
@@ -1009,16 +916,14 @@ static int sata_pmp_handle_link_fail(struct ata_link *link, int *link_tries)
  *     RETURNS:
  *     0 on success, -errno on failure.
  */
-static int sata_pmp_eh_recover(struct ata_port *ap,
-               ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
-               ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,
-               ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,
-               ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset)
+static int sata_pmp_eh_recover(struct ata_port *ap)
 {
+       struct ata_port_operations *ops = ap->ops;
        int pmp_tries, link_tries[SATA_PMP_MAX_PORTS];
        struct ata_link *pmp_link = &ap->link;
        struct ata_device *pmp_dev = pmp_link->device;
        struct ata_eh_context *pmp_ehc = &pmp_link->eh_context;
+       u32 *gscr = pmp_dev->gscr;
        struct ata_link *link;
        struct ata_device *dev;
        unsigned int err_mask;
@@ -1026,16 +931,16 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
        int cnt, rc;
 
        pmp_tries = ATA_EH_PMP_TRIES;
-       ata_port_for_each_link(link, ap)
+       ata_for_each_link(link, ap, EDGE)
                link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
 
  retry:
        /* PMP attached? */
-       if (!ap->nr_pmp_links) {
-               rc = ata_eh_recover(ap, prereset, softreset, hardreset,
-                                   postreset, NULL);
+       if (!sata_pmp_attached(ap)) {
+               rc = ata_eh_recover(ap, ops->prereset, ops->softreset,
+                                   ops->hardreset, ops->postreset, NULL);
                if (rc) {
-                       ata_link_for_each_dev(dev, &ap->link)
+                       ata_for_each_dev(dev, &ap->link, ALL)
                                ata_dev_disable(dev);
                        return rc;
                }
@@ -1044,47 +949,74 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
                        return 0;
 
                /* new PMP online */
-               ata_port_for_each_link(link, ap)
+               ata_for_each_link(link, ap, EDGE)
                        link_tries[link->pmp] = ATA_EH_PMP_LINK_TRIES;
 
                /* fall through */
        }
 
        /* recover pmp */
-       rc = sata_pmp_eh_recover_pmp(ap, prereset, softreset, hardreset,
-                                    postreset);
+       rc = sata_pmp_eh_recover_pmp(ap, ops->prereset, ops->softreset,
+                                    ops->hardreset, ops->postreset);
        if (rc)
                goto pmp_fail;
 
+       /* PHY event notification can disturb reset and other recovery
+        * operations.  Turn it off.
+        */
+       if (gscr[SATA_PMP_GSCR_FEAT_EN] & SATA_PMP_FEAT_NOTIFY) {
+               gscr[SATA_PMP_GSCR_FEAT_EN] &= ~SATA_PMP_FEAT_NOTIFY;
+
+               err_mask = sata_pmp_write(pmp_link, SATA_PMP_GSCR_FEAT_EN,
+                                         gscr[SATA_PMP_GSCR_FEAT_EN]);
+               if (err_mask) {
+                       ata_link_warn(pmp_link,
+                               "failed to disable NOTIFY (err_mask=0x%x)\n",
+                               err_mask);
+                       goto pmp_fail;
+               }
+       }
+
        /* handle disabled links */
        rc = sata_pmp_eh_handle_disabled_links(ap);
        if (rc)
                goto pmp_fail;
 
        /* recover links */
-       rc = ata_eh_recover(ap, pmp_prereset, pmp_softreset, pmp_hardreset,
-                           pmp_postreset, &link);
+       rc = ata_eh_recover(ap, ops->pmp_prereset, ops->pmp_softreset,
+                           ops->pmp_hardreset, ops->pmp_postreset, &link);
        if (rc)
                goto link_fail;
 
-       /* Connection status might have changed while resetting other
-        * links, check SATA_PMP_GSCR_ERROR before returning.
-        */
-
        /* clear SNotification */
        rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
        if (rc == 0)
                sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
 
+       /*
+        * If LPM is active on any fan-out port, hotplug wouldn't
+        * work.  Return w/ PHY event notification disabled.
+        */
+       ata_for_each_link(link, ap, EDGE)
+               if (link->lpm_policy > ATA_LPM_MAX_POWER)
+                       return 0;
+
+       /*
+        * Connection status might have changed while resetting other
+        * links, enable notification and check SATA_PMP_GSCR_ERROR
+        * before returning.
+        */
+
        /* enable notification */
        if (pmp_dev->flags & ATA_DFLAG_AN) {
-               pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN] |= SATA_PMP_FEAT_NOTIFY;
+               gscr[SATA_PMP_GSCR_FEAT_EN] |= SATA_PMP_FEAT_NOTIFY;
 
-               err_mask = sata_pmp_write(pmp_dev->link, SATA_PMP_GSCR_FEAT_EN,
-                                         pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN]);
+               err_mask = sata_pmp_write(pmp_link, SATA_PMP_GSCR_FEAT_EN,
+                                         gscr[SATA_PMP_GSCR_FEAT_EN]);
                if (err_mask) {
-                       ata_dev_printk(pmp_dev, KERN_ERR, "failed to write "
-                                      "PMP_FEAT_EN (Emask=0x%x)\n", err_mask);
+                       ata_dev_err(pmp_dev,
+                                   "failed to write PMP_FEAT_EN (Emask=0x%x)\n",
+                                   err_mask);
                        rc = -EIO;
                        goto pmp_fail;
                }
@@ -1093,14 +1025,15 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
        /* check GSCR_ERROR */
        err_mask = sata_pmp_read(pmp_link, SATA_PMP_GSCR_ERROR, &gscr_error);
        if (err_mask) {
-               ata_dev_printk(pmp_dev, KERN_ERR, "failed to read "
-                              "PMP_GSCR_ERROR (Emask=0x%x)\n", err_mask);
+               ata_dev_err(pmp_dev,
+                           "failed to read PMP_GSCR_ERROR (Emask=0x%x)\n",
+                           err_mask);
                rc = -EIO;
                goto pmp_fail;
        }
 
        cnt = 0;
-       ata_port_for_each_link(link, ap) {
+       ata_for_each_link(link, ap, EDGE) {
                if (!(gscr_error & (1 << link->pmp)))
                        continue;
 
@@ -1108,17 +1041,16 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
                        ata_ehi_hotplugged(&link->eh_context.i);
                        cnt++;
                } else {
-                       ata_link_printk(link, KERN_WARNING,
-                               "PHY status changed but maxed out on retries, "
-                               "giving up\n");
-                       ata_link_printk(link, KERN_WARNING,
-                               "Manully issue scan to resume this link\n");
+                       ata_link_warn(link,
+                               "PHY status changed but maxed out on retries, giving up\n");
+                       ata_link_warn(link,
+                               "Manually issue scan to resume this link\n");
                }
        }
 
        if (cnt) {
-               ata_port_printk(ap, KERN_INFO, "PMP SError.N set for some "
-                               "ports, repeating recovery\n");
+               ata_port_info(ap,
+                       "PMP SError.N set for some ports, repeating recovery\n");
                goto retry;
        }
 
@@ -1126,7 +1058,7 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
 
  link_fail:
        if (sata_pmp_handle_link_fail(link, link_tries)) {
-               pmp_ehc->i.action |= ATA_EH_HARDRESET;
+               pmp_ehc->i.action |= ATA_EH_RESET;
                goto retry;
        }
 
@@ -1138,20 +1070,16 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
        if (ap->pflags & ATA_PFLAG_UNLOADING)
                return rc;
 
-       if (!ap->nr_pmp_links)
+       if (!sata_pmp_attached(ap))
                goto retry;
 
        if (--pmp_tries) {
-               ata_port_printk(ap, KERN_WARNING,
-                               "failed to recover PMP, retrying in 5 secs\n");
-               pmp_ehc->i.action |= ATA_EH_HARDRESET;
-               ssleep(5);
+               pmp_ehc->i.action |= ATA_EH_RESET;
                goto retry;
        }
 
-       ata_port_printk(ap, KERN_ERR,
-                       "failed to recover PMP after %d tries, giving up\n",
-                       ATA_EH_PMP_TRIES);
+       ata_port_err(ap, "failed to recover PMP after %d tries, giving up\n",
+                    ATA_EH_PMP_TRIES);
        sata_pmp_detach(pmp_dev);
        ata_dev_disable(pmp_dev);
 
@@ -1159,16 +1087,8 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
 }
 
 /**
- *     sata_pmp_do_eh - do standard error handling for PMP-enabled host
+ *     sata_pmp_error_handler - do standard error handling for PMP-enabled host
  *     @ap: host port to handle error for
- *     @prereset: prereset method (can be NULL)
- *     @softreset: softreset method
- *     @hardreset: hardreset method
- *     @postreset: postreset method (can be NULL)
- *     @pmp_prereset: PMP prereset method (can be NULL)
- *     @pmp_softreset: PMP softreset method (can be NULL)
- *     @pmp_hardreset: PMP hardreset method (can be NULL)
- *     @pmp_postreset: PMP postreset method (can be NULL)
  *
  *     Perform standard error handling sequence for PMP-enabled host
  *     @ap.
@@ -1176,16 +1096,14 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
  *     LOCKING:
  *     Kernel thread context (may sleep).
  */
-void sata_pmp_do_eh(struct ata_port *ap,
-               ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
-               ata_reset_fn_t hardreset, ata_postreset_fn_t postreset,
-               ata_prereset_fn_t pmp_prereset, ata_reset_fn_t pmp_softreset,
-               ata_reset_fn_t pmp_hardreset, ata_postreset_fn_t pmp_postreset)
+void sata_pmp_error_handler(struct ata_port *ap)
 {
        ata_eh_autopsy(ap);
        ata_eh_report(ap);
-       sata_pmp_eh_recover(ap, prereset, softreset, hardreset, postreset,
-                           pmp_prereset, pmp_softreset, pmp_hardreset,
-                           pmp_postreset);
+       sata_pmp_eh_recover(ap);
        ata_eh_finish(ap);
 }
+
+EXPORT_SYMBOL_GPL(sata_pmp_port_ops);
+EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch);
+EXPORT_SYMBOL_GPL(sata_pmp_error_handler);