[SCSI] zfcp: Cleanup function parameters for sbal value.
[linux-2.6.git] / drivers / ata / libata-pmp.c
index f6c4b11..224faab 100644 (file)
@@ -9,35 +9,52 @@
 
 #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
  *     @reg: register to read
  *     @r_val: resulting value
  *
- *     Wrapper around ap->ops->pmp_read to make it easier to call and
- *     nomarlize error return value.
+ *     Read PMP register.
  *
  *     LOCKING:
  *     Kernel thread context (may sleep).
  *
  *     RETURNS:
- *     0 on success, -errno on failure.
+ *     0 on success, AC_ERR_* mask on failure.
  */
-static int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
+static unsigned int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
 {
        struct ata_port *ap = link->ap;
        struct ata_device *pmp_dev = ap->link.device;
-       int rc;
-
-       might_sleep();
-
-       rc = ap->ops->pmp_read(pmp_dev, link->pmp, reg, r_val);
-       if (rc)
-               rc = -EIO;
-       return rc;
+       struct ata_taskfile tf;
+       unsigned int err_mask;
+
+       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 | 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_RW_TIMEOUT);
+       if (err_mask)
+               return err_mask;
+
+       *r_val = tf.nsect | tf.lbal << 8 | tf.lbam << 16 | tf.lbah << 24;
+       return 0;
 }
 
 /**
@@ -46,27 +63,33 @@ static int sata_pmp_read(struct ata_link *link, int reg, u32 *r_val)
  *     @reg: register to write
  *     @r_val: value to write
  *
- *     Wrapper around ap->ops->pmp_write to make it easier to call
- *     and nomarlize error return value.
+ *     Write PMP register.
  *
  *     LOCKING:
  *     Kernel thread context (may sleep).
  *
  *     RETURNS:
- *     0 on success, -errno on failure.
+ *     0 on success, AC_ERR_* mask on failure.
  */
-static int sata_pmp_write(struct ata_link *link, int reg, u32 val)
+static unsigned int sata_pmp_write(struct ata_link *link, int reg, u32 val)
 {
        struct ata_port *ap = link->ap;
        struct ata_device *pmp_dev = ap->link.device;
-       int rc;
-
-       might_sleep();
-
-       rc = ap->ops->pmp_write(pmp_dev, link->pmp, reg, val);
-       if (rc)
-               rc = -EIO;
-       return rc;
+       struct ata_taskfile tf;
+
+       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 | ATA_TFLAG_LBA48;
+       tf.feature = reg;
+       tf.device = link->pmp;
+       tf.nsect = val & 0xff;
+       tf.lbal = (val >> 8) & 0xff;
+       tf.lbam = (val >> 16) & 0xff;
+       tf.lbah = (val >> 24) & 0xff;
+
+       return ata_exec_internal(pmp_dev, &tf, NULL, DMA_NONE, NULL, 0,
+                                SATA_PMP_RW_TIMEOUT);
 }
 
 /**
@@ -100,71 +123,6 @@ int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc)
 }
 
 /**
- *     sata_pmp_read_init_tf - initialize TF for PMP read
- *     @tf: taskfile to initialize
- *     @dev: PMP dev
- *     @pmp: port multiplier port number
- *     @reg: register to read
- *
- *     Initialize @tf for PMP read command.
- *
- *     LOCKING:
- *     None.
- */
-void sata_pmp_read_init_tf(struct ata_taskfile *tf,
-                          struct ata_device *dev, int pmp, int reg)
-{
-       ata_tf_init(dev, tf);
-       tf->command = ATA_CMD_PMP_READ;
-       tf->protocol = ATA_PROT_NODATA;
-       tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
-       tf->feature = reg;
-       tf->device = pmp;
-}
-
-/**
- *     sata_pmp_read_val - extract PMP read result from TF
- *     @tf: target TF
- *
- *     Determine PMP read result from @tf.
- *
- *     LOCKING:
- *     None.
- */
-u32 sata_pmp_read_val(const struct ata_taskfile *tf)
-{
-       return tf->nsect | tf->lbal << 8 | tf->lbam << 16 | tf->lbah << 24;
-}
-
-/**
- *     sata_pmp_read_init_tf - initialize TF for PMP write
- *     @tf: taskfile to initialize
- *     @dev: PMP dev
- *     @pmp: port multiplier port number
- *     @reg: register to read
- *     @val: value to write
- *
- *     Initialize @tf for PMP write command.
- *
- *     LOCKING:
- *     None.
- */
-void sata_pmp_write_init_tf(struct ata_taskfile *tf,
-                           struct ata_device *dev, int pmp, int reg, u32 val)
-{
-       ata_tf_init(dev, tf);
-       tf->command = ATA_CMD_PMP_WRITE;
-       tf->protocol = ATA_PROT_NODATA;
-       tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
-       tf->feature = reg;
-       tf->device = pmp;
-       tf->nsect = val & 0xff;
-       tf->lbal = (val >> 8) & 0xff;
-       tf->lbam = (val >> 16) & 0xff;
-       tf->lbah = (val >> 24) & 0xff;
-}
-
-/**
  *     sata_pmp_scr_read - read PSCR
  *     @link: ATA link to read PSCR for
  *     @reg: PSCR to read
@@ -181,10 +139,18 @@ void sata_pmp_write_init_tf(struct ata_taskfile *tf,
  */
 int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
 {
+       unsigned int err_mask;
+
        if (reg > SATA_PMP_PSCR_CONTROL)
                return -EINVAL;
 
-       return sata_pmp_read(link, reg, 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);
+               return -EIO;
+       }
+       return 0;
 }
 
 /**
@@ -204,147 +170,21 @@ int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *r_val)
  */
 int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
 {
+       unsigned int err_mask;
+
        if (reg > SATA_PMP_PSCR_CONTROL)
                return -EINVAL;
 
-       return sata_pmp_write(link, reg, 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;
+       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);
+               return -EIO;
        }
-
        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
@@ -361,16 +201,17 @@ void sata_pmp_std_postreset(struct ata_link *link, unsigned int *class)
 static int sata_pmp_read_gscr(struct ata_device *dev, u32 *gscr)
 {
        static const int gscr_to_read[] = { 0, 1, 2, 32, 33, 64, 96 };
-       int i, rc;
+       int i;
 
        for (i = 0; i < ARRAY_SIZE(gscr_to_read); i++) {
                int reg = gscr_to_read[i];
+               unsigned int err_mask;
 
-               rc = sata_pmp_read(dev->link, reg, &gscr[reg]);
-               if (rc) {
-                       ata_dev_printk(dev, KERN_ERR, "failed to read "
-                                      "PMP GSCR[%d] (errno=%d)\n", reg, rc);
-                       return rc;
+               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);
+                       return -EIO;
                }
        }
 
@@ -381,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))
@@ -388,10 +231,15 @@ 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;
 
@@ -408,20 +256,34 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
                dev->flags |= ATA_DFLAG_AN;
 
        /* monitor SERR_PHYRDY_CHG on fan-out ports */
-       rc = sata_pmp_write(dev->link, SATA_PMP_GSCR_ERROR_EN, SERR_PHYRDY_CHG);
-       if (rc) {
+       err_mask = sata_pmp_write(dev->link, SATA_PMP_GSCR_ERROR_EN,
+                                 SERR_PHYRDY_CHG);
+       if (err_mask) {
+               rc = -EIO;
                reason = "failed to write GSCR_ERROR_EN";
                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;
 
-               rc = sata_pmp_write(dev->link, SATA_PMP_GSCR_FEAT_EN,
-                                   gscr[SATA_PMP_GSCR_FEAT_EN]);
-               if (rc) {
-                       reason = "failed to write GSCR_FEAT_EN";
+               err_mask = sata_pmp_read(&ap->link, PMP_GSCR_SII_POL, &reg);
+               if (err_mask) {
+                       rc = -EIO;
+                       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;
                }
        }
@@ -429,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]);
@@ -447,7 +307,8 @@ static int sata_pmp_configure(struct ata_device *dev, int print_info)
 
  fail:
        ata_dev_printk(dev, KERN_ERR,
-                      "failed to configure Port Multiplier (%s)\n", reason);
+                      "failed to configure Port Multiplier (%s, Emask=0x%x)\n",
+                      reason, err_mask);
        return rc;
 }
 
@@ -473,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;
@@ -490,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)
@@ -505,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;
@@ -520,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;
 
@@ -553,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;
        }
 }
 
@@ -585,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;
@@ -634,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);
@@ -671,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);
@@ -812,13 +657,14 @@ static int sata_pmp_revalidate(struct ata_device *dev, unsigned int new_class)
  */
 static int sata_pmp_revalidate_quick(struct ata_device *dev)
 {
+       unsigned int err_mask;
        u32 prod_id;
-       int rc;
 
-       rc = sata_pmp_read(dev->link, SATA_PMP_GSCR_PROD_ID, &prod_id);
-       if (rc) {
-               ata_dev_printk(dev, KERN_ERR, "failed to read PMP product ID\n");
-               return rc;
+       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);
+               return -EIO;
        }
 
        if (prod_id != dev->gscr[SATA_PMP_GSCR_PROD_ID]) {
@@ -870,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) {
@@ -885,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;
@@ -904,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 "
@@ -959,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;
 
@@ -968,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);
@@ -1017,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
@@ -1037,32 +866,31 @@ 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;
        u32 gscr_error, sntf;
        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;
                }
@@ -1071,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;
 
@@ -1105,27 +949,29 @@ 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;
-
-               rc = sata_pmp_write(pmp_dev->link, SATA_PMP_GSCR_FEAT_EN,
-                                   pmp_dev->gscr[SATA_PMP_GSCR_FEAT_EN]);
-               if (rc) {
-                       ata_dev_printk(pmp_dev, KERN_ERR,
-                                      "failed to write PMP_FEAT_EN\n");
+               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_dev_printk(pmp_dev, KERN_ERR, "failed to write "
+                                      "PMP_FEAT_EN (Emask=0x%x)\n", err_mask);
+                       rc = -EIO;
                        goto pmp_fail;
                }
        }
 
        /* check GSCR_ERROR */
-       rc = sata_pmp_read(pmp_link, SATA_PMP_GSCR_ERROR, &gscr_error);
-       if (rc) {
-               ata_dev_printk(pmp_dev, KERN_ERR,
-                              "failed to read PMP_GSCR_ERROR\n");
+       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);
+               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;
 
@@ -1151,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;
        }
 
@@ -1163,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;
        }
 
@@ -1184,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.
@@ -1201,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);