[SCSI] zfcp: Cleanup function parameters for sbal value.
[linux-2.6.git] / drivers / ata / libata-pmp.c
index c0c4dbc..224faab 100644 (file)
@@ -9,8 +9,17 @@
 
 #include <linux/kernel.h>
 #include <linux/libata.h>
+#include <linux/slab.h>
 #include "libata.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
  *     @link: link to read PMP register for
@@ -35,12 +44,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 +80,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 +89,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);
 }
 
 /**
@@ -176,140 +185,6 @@ int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
 }
 
 /**
- *     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
- *
- *     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.
- *
- *     LOCKING:
- *     Kernel thread context (may sleep)
- *
- *     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)
- */
-void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class)
-{
-       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");
-}
-
-/**
  *     sata_pmp_read_gscr - read GSCR block of SATA PMP
  *     @dev: PMP device
  *     @gscr: buffer to read GSCR block into
@@ -347,6 +222,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 +231,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,15 +264,26 @@ 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;
                }
        }
@@ -399,9 +291,7 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
        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_spec_rev_str(gscr), vendor, devid,
                               sata_pmp_gscr_rev(gscr),
                               nr_ports, gscr[SATA_PMP_GSCR_FEAT_EN],
                               gscr[SATA_PMP_GSCR_FEAT]);
@@ -444,9 +334,8 @@ 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;
@@ -461,13 +350,13 @@ 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;
-
-                       /* class code report is unreliable */
+               ata_for_each_link(link, ap, EDGE) {
+                       /* 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,10 +365,7 @@ 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) {
                        /* class code report is unreliable */
                        if (link->pmp < 2)
                                link->flags |= ATA_LFLAG_ASSUME_ATA;
@@ -491,18 +377,13 @@ 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) {
+                       /* 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 +405,6 @@ 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;
        }
 }
 
@@ -556,7 +430,7 @@ int sata_pmp_attach(struct ata_device *dev)
        int rc;
 
        /* is it hanging off the right place? */
-       if (!(ap->flags & ATA_FLAG_PMP)) {
+       if (!sata_pmp_supported(ap)) {
                ata_dev_printk(dev, KERN_ERR,
                               "host does not support Port Multiplier\n");
                return -EINVAL;
@@ -605,7 +479,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);
@@ -642,7 +516,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);
@@ -842,13 +716,10 @@ 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) {
@@ -857,11 +728,13 @@ static int sata_pmp_eh_recover_pmp(struct ata_port *ap,
                        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,27 +749,20 @@ 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 "
@@ -931,7 +797,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,10 +806,9 @@ 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);
@@ -989,14 +854,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 +866,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 +881,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,26 +899,42 @@ 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_printk(pmp_link, KERN_WARNING,
+                               "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;
 
@@ -1078,10 +949,10 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
 
        /* 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);
@@ -1100,7 +971,7 @@ static int sata_pmp_eh_recover(struct ata_port *ap,
        }
 
        cnt = 0;
-       ata_port_for_each_link(link, ap) {
+       ata_for_each_link(link, ap, EDGE) {
                if (!(gscr_error & (1 << link->pmp)))
                        continue;
 
@@ -1126,7 +997,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,14 +1009,11 @@ 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;
        }
 
@@ -1159,16 +1027,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 +1036,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);