Merge tag 'scsi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull first round of SCSI updates from James Bottomley:
 "This is a large set of updates, mostly for drivers (qla2xxx [including
  support for new 83xx based card], qla4xxx, mpt2sas, bfa, zfcp, hpsa,
  be2iscsi, isci, lpfc, ipr, ibmvfc, ibmvscsi, megaraid_sas).

  There's also a rework for tape adding virtually unlimited numbers of
  tape drives plus a set of dif fixes for sd and a fix for a live lock
  on hot remove of SCSI devices.

  This round includes a signed tag pull of isci-for-3.6

  Signed-off-by: James Bottomley <JBottomley@Parallels.com>"

Fix up trivial conflict in drivers/scsi/qla2xxx/qla_nx.c due to new PCI
helper function use in a function that was removed by this pull.

* tag 'scsi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (198 commits)
  [SCSI] st: remove st_mutex
  [SCSI] sd: Ensure we correctly disable devices with unknown protection type
  [SCSI] hpsa: gen8plus Smart Array IDs
  [SCSI] qla4xxx: Update driver version to 5.03.00-k1
  [SCSI] qla4xxx: Disable generating pause frames for ISP83XX
  [SCSI] qla4xxx: Fix double clearing of risc_intr for ISP83XX
  [SCSI] qla4xxx: IDC implementation for Loopback
  [SCSI] qla4xxx: update copyrights in LICENSE.qla4xxx
  [SCSI] qla4xxx: Fix panic while rmmod
  [SCSI] qla4xxx: Fail probe_adapter if IRQ allocation fails
  [SCSI] qla4xxx: Prevent MSI/MSI-X falling back to INTx for ISP82XX
  [SCSI] qla4xxx: Update idc reg in case of PCI AER
  [SCSI] qla4xxx: Fix double IDC locking in qla4_8xxx_error_recovery
  [SCSI] qla4xxx: Clear interrupt while unloading driver for ISP83XX
  [SCSI] qla4xxx: Print correct IDC version
  [SCSI] qla4xxx: Added new mbox cmd to pass driver version to FW
  [SCSI] scsi_dh_alua: Enable STPG for unavailable ports
  [SCSI] scsi_remove_target: fix softlockup regression on hot remove
  [SCSI] ibmvscsi: Fix host config length field overflow
  [SCSI] ibmvscsi: Remove backend abstraction
  ...

2 files changed, 51 insertions, 20 deletions

diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 3492aa73d3a6..3cc7096cfda7 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -5273,16 +5273,20 @@ bool ata_link_offline(struct ata_link *link)
 #ifdef CONFIG_PM
 static int ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
                                unsigned int action, unsigned int ehi_flags,
-                               int wait)
+                               int *async)
 {
         struct ata_link *link;
         unsigned long flags;
-        int rc;
+        int rc = 0;
 
         /* Previous resume operation might still be in
          * progress.  Wait for PM_PENDING to clear.
          */
         if (ap->pflags & ATA_PFLAG_PM_PENDING) {
+                if (async) {
+                        *async = -EAGAIN;
+                        return 0;
+                }
                 ata_port_wait_eh(ap);
                 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
         }
@@ -5291,10 +5295,10 @@ static int ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
         spin_lock_irqsave(ap->lock, flags);
 
         ap->pm_mesg = mesg;
-        if (wait) {
-                rc = 0;
+        if (async)
+                ap->pm_result = async;
+        else
                 ap->pm_result = &rc;
-        }
 
         ap->pflags |= ATA_PFLAG_PM_PENDING;
         ata_for_each_link(link, ap, HOST_FIRST) {
@@ -5307,7 +5311,7 @@ static int ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
         spin_unlock_irqrestore(ap->lock, flags);
 
         /* wait and check result */
-        if (wait) {
+        if (!async) {
                 ata_port_wait_eh(ap);
                 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
         }
@@ -5315,9 +5319,8 @@ static int ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
         return rc;
 }
 
-static int ata_port_suspend_common(struct device *dev, pm_message_t mesg)
+static int __ata_port_suspend_common(struct ata_port *ap, pm_message_t mesg, int *async)
 {
-        struct ata_port *ap = to_ata_port(dev);
         unsigned int ehi_flags = ATA_EHI_QUIET;
         int rc;
 
@@ -5332,10 +5335,17 @@ static int ata_port_suspend_common(struct device *dev, pm_message_t mesg)
         if (mesg.event == PM_EVENT_SUSPEND)
                 ehi_flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_NO_RECOVERY;
 
-        rc = ata_port_request_pm(ap, mesg, 0, ehi_flags, 1);
+        rc = ata_port_request_pm(ap, mesg, 0, ehi_flags, async);
         return rc;
 }
 
+static int ata_port_suspend_common(struct device *dev, pm_message_t mesg)
+{
+        struct ata_port *ap = to_ata_port(dev);
+
+        return __ata_port_suspend_common(ap, mesg, NULL);
+}
+
 static int ata_port_suspend(struct device *dev)
 {
         if (pm_runtime_suspended(dev))
@@ -5360,16 +5370,22 @@ static int ata_port_poweroff(struct device *dev)
         return ata_port_suspend_common(dev, PMSG_HIBERNATE);
 }
 
-static int ata_port_resume_common(struct device *dev)
+static int __ata_port_resume_common(struct ata_port *ap, int *async)
 {
-        struct ata_port *ap = to_ata_port(dev);
         int rc;
 
         rc = ata_port_request_pm(ap, PMSG_ON, ATA_EH_RESET,
-                ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 1);
+                ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, async);
         return rc;
 }
 
+static int ata_port_resume_common(struct device *dev)
+{
+        struct ata_port *ap = to_ata_port(dev);
+
+        return __ata_port_resume_common(ap, NULL);
+}
+
 static int ata_port_resume(struct device *dev)
 {
         int rc;
@@ -5402,6 +5418,24 @@ static const struct dev_pm_ops ata_port_pm_ops = {
         .runtime_idle = ata_port_runtime_idle,
 };
 
+/* sas ports don't participate in pm runtime management of ata_ports,
+ * and need to resume ata devices at the domain level, not the per-port
+ * level. sas suspend/resume is async to allow parallel port recovery
+ * since sas has multiple ata_port instances per Scsi_Host.
+ */
+int ata_sas_port_async_suspend(struct ata_port *ap, int *async)
+{
+        return __ata_port_suspend_common(ap, PMSG_SUSPEND, async);
+}
+EXPORT_SYMBOL_GPL(ata_sas_port_async_suspend);
+
+int ata_sas_port_async_resume(struct ata_port *ap, int *async)
+{
+        return __ata_port_resume_common(ap, async);
+}
+EXPORT_SYMBOL_GPL(ata_sas_port_async_resume);
+
+
 /**
  *      ata_host_suspend - suspend host
  *      @host: host to suspend
@@ -5947,24 +5981,18 @@ int ata_host_start(struct ata_host *host)
 }
 
 /**
- *      ata_sas_host_init - Initialize a host struct
+ *      ata_sas_host_init - Initialize a host struct for sas (ipr, libsas)
  *      @host:  host to initialize
  *      @dev:   device host is attached to
- *      @flags: host flags
  *      @ops:   port_ops
  *
- *      LOCKING:
- *      PCI/etc. bus probe sem.
- *
  */
-/* KILLME - the only user left is ipr */
 void ata_host_init(struct ata_host *host, struct device *dev,
-                   unsigned long flags, struct ata_port_operations *ops)
+                   struct ata_port_operations *ops)
 {
         spin_lock_init(&host->lock);
         mutex_init(&host->eh_mutex);
         host->dev = dev;
-        host->flags = flags;
         host->ops = ops;
 }
 
@@ -6408,6 +6436,7 @@ static int __init ata_parse_force_one(char **cur,
                 { "nohrst",     .lflags         = ATA_LFLAG_NO_HRST },
                 { "nosrst",     .lflags         = ATA_LFLAG_NO_SRST },
                 { "norst",      .lflags         = ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST },
+                { "rstonce",    .lflags         = ATA_LFLAG_RST_ONCE },
         };
         char *start = *cur, *p = *cur;
         char *id, *val, *endp;
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 26598941e1b3..e60437cd0d19 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -2625,6 +2625,8 @@ int ata_eh_reset(struct ata_link *link, int classify,
          */
         while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
                 max_tries++;
+        if (link->flags & ATA_LFLAG_RST_ONCE)
+                max_tries = 1;
         if (link->flags & ATA_LFLAG_NO_HRST)
                 hardreset = NULL;
         if (link->flags & ATA_LFLAG_NO_SRST)