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

Pull final round of SCSI updates from James Bottomley:
 "Sorry for the delay in this patch which was mostly caused by getting
  the merger of the mpt2/mpt3sas driver, which was seen as an essential
  item of maintenance work to do before the drivers diverge too much.
  Unfortunately, this caused a compile failure (detected by linux-next),
  which then had to be fixed up and incubated.

  In addition to the mpt2/3sas rework, there are updates from pm80xx,
  lpfc, bnx2fc, hpsa, ipr, aacraid, megaraid_sas, storvsc and ufs plus
  an assortment of changes including some year 2038 issues, a fix for a
  remove before detach issue in some drivers and a couple of other minor
  issues"

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (141 commits)
  mpt3sas: fix inline markers on non inline function declarations
  sd: Clear PS bit before Mode Select.
  ibmvscsi: set max_lun to 32
  ibmvscsi: display default value for max_id, max_lun and max_channel.
  mptfusion: don't allow negative bytes in kbuf_alloc_2_sgl()
  scsi: pmcraid: replace struct timeval with ktime_get_real_seconds()
  mvumi: 64bit value for seconds_since1970
  be2iscsi: Fix bogus WARN_ON length check
  scsi_scan: don't dump trace when scsi_prep_async_scan() is called twice
  mpt3sas: Bump mpt3sas driver version to 09.102.00.00
  mpt3sas: Single driver module which supports both SAS 2.0 & SAS 3.0 HBAs
  mpt2sas, mpt3sas: Update the driver versions
  mpt3sas: setpci reset kernel oops fix
  mpt3sas: Added OEM Gen2 PnP ID branding names
  mpt3sas: Refcount fw_events and fix unsafe list usage
  mpt3sas: Refcount sas_device objects and fix unsafe list usage
  mpt3sas: sysfs attribute to report Backup Rail Monitor Status
  mpt3sas: Ported WarpDrive product SSS6200 support
  mpt3sas: fix for driver fails EEH, recovery from injected pci bus error
  mpt3sas: Manage MSI-X vectors according to HBA device type
  ...

1 files changed, 82 insertions, 31 deletions

diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 4da574925284..a1f90fe849c9 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -1270,13 +1270,12 @@ retry_next:
 static int _aac_reset_adapter(struct aac_dev *aac, int forced)
 {
         int index, quirks;
-        int retval, i;
+        int retval;
         struct Scsi_Host *host;
         struct scsi_device *dev;
         struct scsi_cmnd *command;
         struct scsi_cmnd *command_list;
         int jafo = 0;
-        int cpu;
 
         /*
          * Assumptions:
@@ -1339,35 +1338,7 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
         aac->comm_phys = 0;
         kfree(aac->queues);
         aac->queues = NULL;
-        cpu = cpumask_first(cpu_online_mask);
-        if (aac->pdev->device == PMC_DEVICE_S6 ||
-            aac->pdev->device == PMC_DEVICE_S7 ||
-            aac->pdev->device == PMC_DEVICE_S8 ||
-            aac->pdev->device == PMC_DEVICE_S9) {
-                if (aac->max_msix > 1) {
-                        for (i = 0; i < aac->max_msix; i++) {
-                                if (irq_set_affinity_hint(
-                                    aac->msixentry[i].vector,
-                                    NULL)) {
-                                        printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n",
-                                                aac->name,
-                                                aac->id,
-                                                cpu);
-                                }
-                                cpu = cpumask_next(cpu,
-                                                cpu_online_mask);
-                                free_irq(aac->msixentry[i].vector,
-                                         &(aac->aac_msix[i]));
-                        }
-                        pci_disable_msix(aac->pdev);
-                } else {
-                        free_irq(aac->pdev->irq, &(aac->aac_msix[0]));
-                }
-        } else {
-                free_irq(aac->pdev->irq, aac);
-        }
-        if (aac->msi)
-                pci_disable_msi(aac->pdev);
+        aac_free_irq(aac);
         kfree(aac->fsa_dev);
         aac->fsa_dev = NULL;
         quirks = aac_get_driver_ident(index)->quirks;
@@ -1978,3 +1949,83 @@ int aac_command_thread(void *data)
         dev->aif_thread = 0;
         return 0;
 }
+
+int aac_acquire_irq(struct aac_dev *dev)
+{
+        int i;
+        int j;
+        int ret = 0;
+        int cpu;
+
+        cpu = cpumask_first(cpu_online_mask);
+        if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
+                for (i = 0; i < dev->max_msix; i++) {
+                        dev->aac_msix[i].vector_no = i;
+                        dev->aac_msix[i].dev = dev;
+                        if (request_irq(dev->msixentry[i].vector,
+                                        dev->a_ops.adapter_intr,
+                                        0, "aacraid", &(dev->aac_msix[i]))) {
+                                printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
+                                                dev->name, dev->id, i);
+                                for (j = 0 ; j < i ; j++)
+                                        free_irq(dev->msixentry[j].vector,
+                                                 &(dev->aac_msix[j]));
+                                pci_disable_msix(dev->pdev);
+                                ret = -1;
+                        }
+                        if (irq_set_affinity_hint(dev->msixentry[i].vector,
+                                                        get_cpu_mask(cpu))) {
+                                printk(KERN_ERR "%s%d: Failed to set IRQ affinity for cpu %d\n",
+                                            dev->name, dev->id, cpu);
+                        }
+                        cpu = cpumask_next(cpu, cpu_online_mask);
+                }
+        } else {
+                dev->aac_msix[0].vector_no = 0;
+                dev->aac_msix[0].dev = dev;
+
+                if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
+                        IRQF_SHARED, "aacraid",
+                        &(dev->aac_msix[0])) < 0) {
+                        if (dev->msi)
+                                pci_disable_msi(dev->pdev);
+                        printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
+                                        dev->name, dev->id);
+                        ret = -1;
+                }
+        }
+        return ret;
+}
+
+void aac_free_irq(struct aac_dev *dev)
+{
+        int i;
+        int cpu;
+
+        cpu = cpumask_first(cpu_online_mask);
+        if (dev->pdev->device == PMC_DEVICE_S6 ||
+            dev->pdev->device == PMC_DEVICE_S7 ||
+            dev->pdev->device == PMC_DEVICE_S8 ||
+            dev->pdev->device == PMC_DEVICE_S9) {
+                if (dev->max_msix > 1) {
+                        for (i = 0; i < dev->max_msix; i++) {
+                                if (irq_set_affinity_hint(
+                                        dev->msixentry[i].vector, NULL)) {
+                                        printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n",
+                                            dev->name, dev->id, cpu);
+                                }
+                                cpu = cpumask_next(cpu, cpu_online_mask);
+                                free_irq(dev->msixentry[i].vector,
+                                                &(dev->aac_msix[i]));
+                        }
+                } else {
+                        free_irq(dev->pdev->irq, &(dev->aac_msix[0]));
+                }
+        } else {
+                free_irq(dev->pdev->irq, dev);
+        }
+        if (dev->msi)
+                pci_disable_msi(dev->pdev);
+        else if (dev->max_msix > 1)
+                pci_disable_msix(dev->pdev);
+}