12 files changed, 463 insertions, 104 deletions

diff --git a/drivers/scsi/lpfc/Makefile b/drivers/scsi/lpfc/Makefile
index fe5d396aca73..e2516ba8ebfa 100644
--- a/drivers/scsi/lpfc/Makefile
+++ b/drivers/scsi/lpfc/Makefile
@@ -22,7 +22,9 @@
 ccflags-$(GCOV) := -fprofile-arcs -ftest-coverage
 ccflags-$(GCOV) += -O0
 
+ifdef WARNINGS_BECOME_ERRORS
 ccflags-y += -Werror
+endif
 
 obj-$(CONFIG_SCSI_LPFC) := lpfc.o
 
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index e5da6da20f8a..a65c05a8d488 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -96,6 +96,10 @@ struct lpfc_sli2_slim;
 /* queue dump line buffer size */
 #define LPFC_LBUF_SZ            128
 
+/* mailbox system shutdown options */
+#define LPFC_MBX_NO_WAIT        0
+#define LPFC_MBX_WAIT           1
+
 enum lpfc_polling_flags {
         ENABLE_FCP_RING_POLLING = 0x1,
         DISABLE_FCP_RING_INT    = 0x2
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 5eb2bc116183..adef5bb2100e 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -3617,6 +3617,91 @@ lpfc_sriov_nr_virtfn_init(struct lpfc_hba *phba, int val)
 static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR,
                    lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store);
 
+/**
+ * lpfc_fcp_imax_store
+ *
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: string with the number of fast-path FCP interrupts per second.
+ * @count: unused variable.
+ *
+ * Description:
+ * If val is in a valid range [636,651042], then set the adapter's
+ * maximum number of fast-path FCP interrupts per second.
+ *
+ * Returns:
+ * length of the buf on success if val is in range the intended mode
+ * is supported.
+ * -EINVAL if val out of range or intended mode is not supported.
+ **/
+static ssize_t
+lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
+                         const char *buf, size_t count)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        int val = 0, i;
+
+        /* Sanity check on user data */
+        if (!isdigit(buf[0]))
+                return -EINVAL;
+        if (sscanf(buf, "%i", &val) != 1)
+                return -EINVAL;
+
+        /* Value range is [636,651042] */
+        if (val < LPFC_MIM_IMAX || val > LPFC_DMULT_CONST)
+                return -EINVAL;
+
+        phba->cfg_fcp_imax = (uint32_t)val;
+        for (i = 0; i < phba->cfg_fcp_eq_count; i += LPFC_MAX_EQ_DELAY)
+                lpfc_modify_fcp_eq_delay(phba, i);
+
+        return strlen(buf);
+}
+
+/*
+# lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
+#
+# Value range is [636,651042]. Default value is 10000.
+*/
+static int lpfc_fcp_imax = LPFC_FP_DEF_IMAX;
+module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(lpfc_fcp_imax,
+            "Set the maximum number of fast-path FCP interrupts per second");
+lpfc_param_show(fcp_imax)
+
+/**
+ * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
+ * @phba: lpfc_hba pointer.
+ * @val: link speed value.
+ *
+ * Description:
+ * If val is in a valid range [636,651042], then initialize the adapter's
+ * maximum number of fast-path FCP interrupts per second.
+ *
+ * Returns:
+ * zero if val saved.
+ * -EINVAL val out of range
+ **/
+static int
+lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
+{
+        if (val >= LPFC_MIM_IMAX && val <= LPFC_DMULT_CONST) {
+                phba->cfg_fcp_imax = val;
+                return 0;
+        }
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "3016 fcp_imax: %d out of range, using default\n", val);
+        phba->cfg_fcp_imax = LPFC_FP_DEF_IMAX;
+
+        return 0;
+}
+
+static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR,
+                   lpfc_fcp_imax_show, lpfc_fcp_imax_store);
+
 /*
 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
 # Value range is [2,3]. Default value is 3.
@@ -3758,14 +3843,6 @@ LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
             "MSI-X (2), if possible");
 
 /*
-# lpfc_fcp_imax: Set the maximum number of fast-path FCP interrupts per second
-#
-# Value range is [636,651042]. Default value is 10000.
-*/
-LPFC_ATTR_R(fcp_imax, LPFC_FP_DEF_IMAX, LPFC_MIM_IMAX, LPFC_DMULT_CONST,
-            "Set the maximum number of fast-path FCP interrupts per second");
-
-/*
 # lpfc_fcp_wq_count: Set the number of fast-path FCP work queues
 #
 # Value range is [1,31]. Default value is 4.
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 9b2a16f3bc79..8a2a514a2553 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -183,7 +183,7 @@ int lpfc_post_buffer(struct lpfc_hba *, struct lpfc_sli_ring *, int);
 void lpfc_decode_firmware_rev(struct lpfc_hba *, char *, int);
 int lpfc_online(struct lpfc_hba *);
 void lpfc_unblock_mgmt_io(struct lpfc_hba *);
-void lpfc_offline_prep(struct lpfc_hba *);
+void lpfc_offline_prep(struct lpfc_hba *, int);
 void lpfc_offline(struct lpfc_hba *);
 void lpfc_reset_hba(struct lpfc_hba *);
 
@@ -273,7 +273,7 @@ int lpfc_sli_host_down(struct lpfc_vport *);
 int lpfc_sli_hba_down(struct lpfc_hba *);
 int lpfc_sli_issue_mbox(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t);
 int lpfc_sli_handle_mb_event(struct lpfc_hba *);
-void lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *);
+void lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *, int);
 int lpfc_sli_check_eratt(struct lpfc_hba *);
 void lpfc_sli_handle_slow_ring_event(struct lpfc_hba *,
                                     struct lpfc_sli_ring *, uint32_t);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.h b/drivers/scsi/lpfc/lpfc_debugfs.h
index 616c400dae14..afe368fd1b98 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.h
+++ b/drivers/scsi/lpfc/lpfc_debugfs.h
@@ -395,8 +395,13 @@ lpfc_debug_dump_fcp_cq(struct lpfc_hba *phba, int fcp_wqidx)
         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++)
                 if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid)
                         break;
-        if (fcp_cqidx >= phba->cfg_fcp_eq_count)
-                return;
+        if (phba->intr_type == MSIX) {
+                if (fcp_cqidx >= phba->cfg_fcp_eq_count)
+                        return;
+        } else {
+                if (fcp_cqidx > 0)
+                        return;
+        }
 
         printk(KERN_ERR "FCP CQ: WQ[Idx:%d|Qid%d]->CQ[Idx%d|Qid%d]:\n",
                 fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
@@ -426,8 +431,13 @@ lpfc_debug_dump_fcp_eq(struct lpfc_hba *phba, int fcp_wqidx)
         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++)
                 if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid)
                         break;
-        if (fcp_cqidx >= phba->cfg_fcp_eq_count)
-                return;
+        if (phba->intr_type == MSIX) {
+                if (fcp_cqidx >= phba->cfg_fcp_eq_count)
+                        return;
+        } else {
+                if (fcp_cqidx > 0)
+                        return;
+        }
 
         if (phba->cfg_fcp_eq_count == 0) {
                 fcp_eqidx = -1;
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 5bb269e224f6..9b4f92941dce 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -530,7 +530,7 @@ lpfc_work_list_done(struct lpfc_hba *phba)
                         break;
                 case LPFC_EVT_OFFLINE_PREP:
                         if (phba->link_state >= LPFC_LINK_DOWN)
-                                lpfc_offline_prep(phba);
+                                lpfc_offline_prep(phba, LPFC_MBX_WAIT);
                         *(int *)(evtp->evt_arg1) = 0;
                         complete((struct completion *)(evtp->evt_arg2));
                         break;
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index f1946dfda5b4..953603a7a43c 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -874,6 +874,7 @@ struct mbox_header {
 #define LPFC_MBOX_OPCODE_MQ_CREATE                      0x15
 #define LPFC_MBOX_OPCODE_GET_CNTL_ATTRIBUTES            0x20
 #define LPFC_MBOX_OPCODE_NOP                            0x21
+#define LPFC_MBOX_OPCODE_MODIFY_EQ_DELAY                0x29
 #define LPFC_MBOX_OPCODE_MQ_DESTROY                     0x35
 #define LPFC_MBOX_OPCODE_CQ_DESTROY                     0x36
 #define LPFC_MBOX_OPCODE_EQ_DESTROY                     0x37
@@ -940,6 +941,13 @@ struct eq_context {
         uint32_t reserved3;
 };
 
+struct eq_delay_info {
+        uint32_t eq_id;
+        uint32_t phase;
+        uint32_t delay_multi;
+};
+#define LPFC_MAX_EQ_DELAY       8
+
 struct sgl_page_pairs {
         uint32_t sgl_pg0_addr_lo;
         uint32_t sgl_pg0_addr_hi;
@@ -1002,6 +1010,19 @@ struct lpfc_mbx_eq_create {
         } u;
 };
 
+struct lpfc_mbx_modify_eq_delay {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t num_eq;
+                        struct eq_delay_info eq[LPFC_MAX_EQ_DELAY];
+                } request;
+                struct {
+                        uint32_t word0;
+                } response;
+        } u;
+};
+
 struct lpfc_mbx_eq_destroy {
         struct mbox_header header;
         union {
@@ -2875,6 +2896,7 @@ struct lpfc_mqe {
                 struct lpfc_mbx_mq_create mq_create;
                 struct lpfc_mbx_mq_create_ext mq_create_ext;
                 struct lpfc_mbx_eq_create eq_create;
+                struct lpfc_mbx_modify_eq_delay eq_delay;
                 struct lpfc_mbx_cq_create cq_create;
                 struct lpfc_mbx_wq_create wq_create;
                 struct lpfc_mbx_rq_create rq_create;
@@ -3084,6 +3106,28 @@ struct lpfc_acqe_fc_la {
 #define LPFC_FC_LA_EVENT_TYPE_SHARED_LINK       0x2
 };
 
+struct lpfc_acqe_misconfigured_event {
+        struct {
+        uint32_t word0;
+#define lpfc_sli_misconfigured_port0_SHIFT      0
+#define lpfc_sli_misconfigured_port0_MASK       0x000000FF
+#define lpfc_sli_misconfigured_port0_WORD       word0
+#define lpfc_sli_misconfigured_port1_SHIFT      8
+#define lpfc_sli_misconfigured_port1_MASK       0x000000FF
+#define lpfc_sli_misconfigured_port1_WORD       word0
+#define lpfc_sli_misconfigured_port2_SHIFT      16
+#define lpfc_sli_misconfigured_port2_MASK       0x000000FF
+#define lpfc_sli_misconfigured_port2_WORD       word0
+#define lpfc_sli_misconfigured_port3_SHIFT      24
+#define lpfc_sli_misconfigured_port3_MASK       0x000000FF
+#define lpfc_sli_misconfigured_port3_WORD       word0
+        } theEvent;
+#define LPFC_SLI_EVENT_STATUS_VALID                     0x00
+#define LPFC_SLI_EVENT_STATUS_NOT_PRESENT       0x01
+#define LPFC_SLI_EVENT_STATUS_WRONG_TYPE        0x02
+#define LPFC_SLI_EVENT_STATUS_UNSUPPORTED       0x03
+};
+
 struct lpfc_acqe_sli {
         uint32_t event_data1;
         uint32_t event_data2;
@@ -3094,6 +3138,7 @@ struct lpfc_acqe_sli {
 #define LPFC_SLI_EVENT_TYPE_NORM_TEMP           0x3
 #define LPFC_SLI_EVENT_TYPE_NVLOG_POST          0x4
 #define LPFC_SLI_EVENT_TYPE_DIAG_DUMP           0x5
+#define LPFC_SLI_EVENT_TYPE_MISCONFIGURED       0x9
 };
 
 /*
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 411ed48d79da..45c15208be9f 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -73,6 +73,8 @@ static int lpfc_hba_down_post_s4(struct lpfc_hba *phba);
 static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *);
 static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *);
 static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *);
+static void lpfc_sli4_disable_intr(struct lpfc_hba *);
+static uint32_t lpfc_sli4_enable_intr(struct lpfc_hba *, uint32_t);
 
 static struct scsi_transport_template *lpfc_transport_template = NULL;
 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
@@ -1169,7 +1171,7 @@ lpfc_offline_eratt(struct lpfc_hba *phba)
         spin_lock_irq(&phba->hbalock);
         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
         spin_unlock_irq(&phba->hbalock);
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
 
         lpfc_offline(phba);
         lpfc_reset_barrier(phba);
@@ -1193,7 +1195,7 @@ lpfc_offline_eratt(struct lpfc_hba *phba)
 static void
 lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
 {
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
         lpfc_offline(phba);
         lpfc_sli4_brdreset(phba);
         lpfc_hba_down_post(phba);
@@ -1251,7 +1253,7 @@ lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
          * There was a firmware error. Take the hba offline and then
          * attempt to restart it.
          */
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
 
         /* Wait for the ER1 bit to clear.*/
@@ -1372,7 +1374,7 @@ lpfc_handle_eratt_s3(struct lpfc_hba *phba)
                  * There was a firmware error.  Take the hba offline and then
                  * attempt to restart it.
                  */
-                lpfc_offline_prep(phba);
+                lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
                 lpfc_offline(phba);
                 lpfc_sli_brdrestart(phba);
                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
@@ -1428,6 +1430,54 @@ lpfc_handle_eratt_s3(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg
+ * @phba: pointer to lpfc hba data structure.
+ * @mbx_action: flag for mailbox shutdown action.
+ *
+ * This routine is invoked to perform an SLI4 port PCI function reset in
+ * response to port status register polling attention. It waits for port
+ * status register (ERR, RDY, RN) bits before proceeding with function reset.
+ * During this process, interrupt vectors are freed and later requested
+ * for handling possible port resource change.
+ **/
+static int
+lpfc_sli4_port_sta_fn_reset(struct lpfc_hba *phba, int mbx_action)
+{
+        int rc;
+        uint32_t intr_mode;
+
+        /*
+         * On error status condition, driver need to wait for port
+         * ready before performing reset.
+         */
+        rc = lpfc_sli4_pdev_status_reg_wait(phba);
+        if (!rc) {
+                /* need reset: attempt for port recovery */
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2887 Reset Needed: Attempting Port "
+                                "Recovery...\n");
+                lpfc_offline_prep(phba, mbx_action);
+                lpfc_offline(phba);
+                /* release interrupt for possible resource change */
+                lpfc_sli4_disable_intr(phba);
+                lpfc_sli_brdrestart(phba);
+                /* request and enable interrupt */
+                intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
+                if (intr_mode == LPFC_INTR_ERROR) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "3175 Failed to enable interrupt\n");
+                        return -EIO;
+                } else {
+                        phba->intr_mode = intr_mode;
+                }
+                rc = lpfc_online(phba);
+                if (rc == 0)
+                        lpfc_unblock_mgmt_io(phba);
+        }
+        return rc;
+}
+
+/**
  * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
  * @phba: pointer to lpfc hba data structure.
  *
@@ -1506,30 +1556,18 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba)
                          reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON)
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                         "3145 Port Down: Provisioning\n");
-                /*
-                 * On error status condition, driver need to wait for port
-                 * ready before performing reset.
-                 */
-                rc = lpfc_sli4_pdev_status_reg_wait(phba);
-                if (!rc) {
-                        /* need reset: attempt for port recovery */
-                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                        "2887 Reset Needed: Attempting Port "
-                                        "Recovery...\n");
-                        lpfc_offline_prep(phba);
-                        lpfc_offline(phba);
-                        lpfc_sli_brdrestart(phba);
-                        if (lpfc_online(phba) == 0) {
-                                lpfc_unblock_mgmt_io(phba);
-                                /* don't report event on forced debug dump */
-                                if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
-                                    reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
-                                        return;
-                                else
-                                        break;
-                        }
-                        /* fall through for not able to recover */
+
+                /* Check port status register for function reset */
+                rc = lpfc_sli4_port_sta_fn_reset(phba, LPFC_MBX_NO_WAIT);
+                if (rc == 0) {
+                        /* don't report event on forced debug dump */
+                        if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
+                            reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
+                                return;
+                        else
+                                break;
                 }
+                /* fall through for not able to recover */
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "3152 Unrecoverable error, bring the port "
                                 "offline\n");
@@ -2494,15 +2532,19 @@ lpfc_stop_hba_timers(struct lpfc_hba *phba)
  * driver prepares the HBA interface for online or offline.
  **/
 static void
-lpfc_block_mgmt_io(struct lpfc_hba * phba)
+lpfc_block_mgmt_io(struct lpfc_hba *phba, int mbx_action)
 {
         unsigned long iflag;
         uint8_t actcmd = MBX_HEARTBEAT;
         unsigned long timeout;
 
-        timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
         spin_lock_irqsave(&phba->hbalock, iflag);
         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
+        spin_unlock_irqrestore(&phba->hbalock, iflag);
+        if (mbx_action == LPFC_MBX_NO_WAIT)
+                return;
+        timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
+        spin_lock_irqsave(&phba->hbalock, iflag);
         if (phba->sli.mbox_active) {
                 actcmd = phba->sli.mbox_active->u.mb.mbxCommand;
                 /* Determine how long we might wait for the active mailbox
@@ -2592,7 +2634,7 @@ lpfc_online(struct lpfc_hba *phba)
         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
                         "0458 Bring Adapter online\n");
 
-        lpfc_block_mgmt_io(phba);
+        lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
 
         if (!lpfc_sli_queue_setup(phba)) {
                 lpfc_unblock_mgmt_io(phba);
@@ -2660,7 +2702,7 @@ lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
  * queue to make it ready to be brought offline.
  **/
 void
-lpfc_offline_prep(struct lpfc_hba * phba)
+lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action)
 {
         struct lpfc_vport *vport = phba->pport;
         struct lpfc_nodelist  *ndlp, *next_ndlp;
@@ -2671,7 +2713,7 @@ lpfc_offline_prep(struct lpfc_hba * phba)
         if (vport->fc_flag & FC_OFFLINE_MODE)
                 return;
 
-        lpfc_block_mgmt_io(phba);
+        lpfc_block_mgmt_io(phba, mbx_action);
 
         lpfc_linkdown(phba);
 
@@ -2718,7 +2760,7 @@ lpfc_offline_prep(struct lpfc_hba * phba)
         }
         lpfc_destroy_vport_work_array(phba, vports);
 
-        lpfc_sli_mbox_sys_shutdown(phba);
+        lpfc_sli_mbox_sys_shutdown(phba, mbx_action);
 }
 
 /**
@@ -3684,12 +3726,76 @@ out_free_pmb:
 static void
 lpfc_sli4_async_sli_evt(struct lpfc_hba *phba, struct lpfc_acqe_sli *acqe_sli)
 {
-        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                        "2901 Async SLI event - Event Data1:x%08x Event Data2:"
-                        "x%08x SLI Event Type:%d",
-                        acqe_sli->event_data1, acqe_sli->event_data2,
-                        bf_get(lpfc_trailer_type, acqe_sli));
-        return;
+        char port_name;
+        char message[80];
+        uint8_t status;
+        struct lpfc_acqe_misconfigured_event *misconfigured;
+
+        /* special case misconfigured event as it contains data for all ports */
+        if ((bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+                 LPFC_SLI_INTF_IF_TYPE_2) ||
+                (bf_get(lpfc_trailer_type, acqe_sli) !=
+                        LPFC_SLI_EVENT_TYPE_MISCONFIGURED)) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                "2901 Async SLI event - Event Data1:x%08x Event Data2:"
+                                "x%08x SLI Event Type:%d\n",
+                                acqe_sli->event_data1, acqe_sli->event_data2,
+                                bf_get(lpfc_trailer_type, acqe_sli));
+                return;
+        }
+
+        port_name = phba->Port[0];
+        if (port_name == 0x00)
+                port_name = '?'; /* get port name is empty */
+
+        misconfigured = (struct lpfc_acqe_misconfigured_event *)
+                                        &acqe_sli->event_data1;
+
+        /* fetch the status for this port */
+        switch (phba->sli4_hba.lnk_info.lnk_no) {
+        case LPFC_LINK_NUMBER_0:
+                status = bf_get(lpfc_sli_misconfigured_port0,
+                                        &misconfigured->theEvent);
+                break;
+        case LPFC_LINK_NUMBER_1:
+                status = bf_get(lpfc_sli_misconfigured_port1,
+                                        &misconfigured->theEvent);
+                break;
+        case LPFC_LINK_NUMBER_2:
+                status = bf_get(lpfc_sli_misconfigured_port2,
+                                        &misconfigured->theEvent);
+                break;
+        case LPFC_LINK_NUMBER_3:
+                status = bf_get(lpfc_sli_misconfigured_port3,
+                                        &misconfigured->theEvent);
+                break;
+        default:
+                status = ~LPFC_SLI_EVENT_STATUS_VALID;
+                break;
+        }
+
+        switch (status) {
+        case LPFC_SLI_EVENT_STATUS_VALID:
+                return; /* no message if the sfp is okay */
+        case LPFC_SLI_EVENT_STATUS_NOT_PRESENT:
+                sprintf(message, "Not installed");
+                break;
+        case LPFC_SLI_EVENT_STATUS_WRONG_TYPE:
+                sprintf(message,
+                        "Optics of two types installed");
+                break;
+        case LPFC_SLI_EVENT_STATUS_UNSUPPORTED:
+                sprintf(message, "Incompatible optics");
+                break;
+        default:
+                /* firmware is reporting a status we don't know about */
+                sprintf(message, "Unknown event status x%02x", status);
+                break;
+        }
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                        "3176 Misconfigured Physical Port - "
+                        "Port Name %c %s\n", port_name, message);
 }
 
 /**
@@ -4312,7 +4418,7 @@ lpfc_reset_hba(struct lpfc_hba *phba)
                 phba->link_state = LPFC_HBA_ERROR;
                 return;
         }
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
         lpfc_sli_brdrestart(phba);
         lpfc_online(phba);
@@ -5514,14 +5620,45 @@ lpfc_destroy_shost(struct lpfc_hba *phba)
 static void
 lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
 {
+        uint32_t old_mask;
+        uint32_t old_guard;
+
         int pagecnt = 10;
         if (lpfc_prot_mask && lpfc_prot_guard) {
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
                                 "1478 Registering BlockGuard with the "
                                 "SCSI layer\n");
-                scsi_host_set_prot(shost, lpfc_prot_mask);
-                scsi_host_set_guard(shost, lpfc_prot_guard);
+
+                old_mask = lpfc_prot_mask;
+                old_guard = lpfc_prot_guard;
+
+                /* Only allow supported values */
+                lpfc_prot_mask &= (SHOST_DIF_TYPE1_PROTECTION |
+                        SHOST_DIX_TYPE0_PROTECTION |
+                        SHOST_DIX_TYPE1_PROTECTION);
+                lpfc_prot_guard &= (SHOST_DIX_GUARD_IP | SHOST_DIX_GUARD_CRC);
+
+                /* DIF Type 1 protection for profiles AST1/C1 is end to end */
+                if (lpfc_prot_mask == SHOST_DIX_TYPE1_PROTECTION)
+                        lpfc_prot_mask |= SHOST_DIF_TYPE1_PROTECTION;
+
+                if (lpfc_prot_mask && lpfc_prot_guard) {
+                        if ((old_mask != lpfc_prot_mask) ||
+                                (old_guard != lpfc_prot_guard))
+                                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "1475 Registering BlockGuard with the "
+                                        "SCSI layer: mask %d  guard %d\n",
+                                        lpfc_prot_mask, lpfc_prot_guard);
+
+                        scsi_host_set_prot(shost, lpfc_prot_mask);
+                        scsi_host_set_guard(shost, lpfc_prot_guard);
+                } else
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "1479 Not Registering BlockGuard with the SCSI "
+                                "layer, Bad protection parameters: %d %d\n",
+                                old_mask, old_guard);
         }
+
         if (!_dump_buf_data) {
                 while (pagecnt) {
                         spin_lock_init(&_dump_buf_lock);
@@ -8859,7 +8996,7 @@ lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg)
                         "0473 PCI device Power Management suspend.\n");
 
         /* Bring down the device */
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
         kthread_stop(phba->worker_thread);
 
@@ -8985,7 +9122,7 @@ lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
                         "2710 PCI channel disable preparing for reset\n");
 
         /* Block any management I/Os to the device */
-        lpfc_block_mgmt_io(phba);
+        lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
 
         /* Block all SCSI devices' I/Os on the host */
         lpfc_scsi_dev_block(phba);
@@ -9129,7 +9266,7 @@ lpfc_io_slot_reset_s3(struct pci_dev *pdev)
                 phba->intr_mode = intr_mode;
 
         /* Take device offline, it will perform cleanup */
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
         lpfc_sli_brdrestart(phba);
 
@@ -9603,7 +9740,7 @@ lpfc_pci_suspend_one_s4(struct pci_dev *pdev, pm_message_t msg)
                         "2843 PCI device Power Management suspend.\n");
 
         /* Bring down the device */
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
         kthread_stop(phba->worker_thread);
 
@@ -9729,7 +9866,7 @@ lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
                         "2826 PCI channel disable preparing for reset\n");
 
         /* Block any management I/Os to the device */
-        lpfc_block_mgmt_io(phba);
+        lpfc_block_mgmt_io(phba, LPFC_MBX_NO_WAIT);
 
         /* Block all SCSI devices' I/Os on the host */
         lpfc_scsi_dev_block(phba);
@@ -9902,7 +10039,7 @@ lpfc_io_resume_s4(struct pci_dev *pdev)
          */
         if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) {
                 /* Perform device reset */
-                lpfc_offline_prep(phba);
+                lpfc_offline_prep(phba, LPFC_MBX_WAIT);
                 lpfc_offline(phba);
                 lpfc_sli_brdrestart(phba);
                 /* Bring the device back online */
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 66e09069f281..925975d2d765 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -4275,10 +4275,8 @@ lpfc_queuecommand_lck(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
          * Catch race where our node has transitioned, but the
          * transport is still transitioning.
          */
-        if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
-                cmnd->result = ScsiResult(DID_IMM_RETRY, 0);
-                goto out_fail_command;
-        }
+        if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
+                goto out_tgt_busy;
         if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth)
                 goto out_tgt_busy;
 
@@ -4412,12 +4410,12 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         struct lpfc_iocbq *abtsiocb;
         struct lpfc_scsi_buf *lpfc_cmd;
         IOCB_t *cmd, *icmd;
-        int ret = SUCCESS;
+        int ret = SUCCESS, status = 0;
         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
 
-        ret = fc_block_scsi_eh(cmnd);
-        if (ret)
-                return ret;
+        status = fc_block_scsi_eh(cmnd);
+        if (status)
+                return status;
 
         spin_lock_irq(&phba->hbalock);
         /* driver queued commands are in process of being flushed */
@@ -4435,7 +4433,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "2873 SCSI Layer I/O Abort Request IO CMPL Status "
                          "x%x ID %d LUN %d\n",
-                         ret, cmnd->device->id, cmnd->device->lun);
+                         SUCCESS, cmnd->device->id, cmnd->device->lun);
                 return SUCCESS;
         }
 
@@ -4762,7 +4760,7 @@ lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
         unsigned tgt_id = cmnd->device->id;
         unsigned int lun_id = cmnd->device->lun;
         struct lpfc_scsi_event_header scsi_event;
-        int status;
+        int status, ret = SUCCESS;
 
         if (!rdata) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
@@ -4803,9 +4801,9 @@ lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
          * So, continue on.
          * We will report success if all the i/o aborts successfully.
          */
-        status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
+        ret = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
                                                 LPFC_CTX_LUN);
-        return status;
+        return ret;
 }
 
 /**
@@ -4829,7 +4827,7 @@ lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
         unsigned tgt_id = cmnd->device->id;
         unsigned int lun_id = cmnd->device->lun;
         struct lpfc_scsi_event_header scsi_event;
-        int status;
+        int status, ret = SUCCESS;
 
         if (!rdata) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
@@ -4870,9 +4868,9 @@ lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
          * So, continue on.
          * We will report success if all the i/o aborts successfully.
          */
-        status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
-                                        LPFC_CTX_TGT);
-        return status;
+        ret = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
+                                          LPFC_CTX_TGT);
+        return ret;
 }
 
 /**
@@ -4982,7 +4980,7 @@ lpfc_host_reset_handler(struct scsi_cmnd *cmnd)
         struct lpfc_hba *phba = vport->phba;
         int rc, ret = SUCCESS;
 
-        lpfc_offline_prep(phba);
+        lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
         rc = lpfc_sli_brdrestart(phba);
         if (rc)
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index b4720a109817..9cbd20b1328b 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -8984,7 +8984,7 @@ lpfc_sli_hba_down(struct lpfc_hba *phba)
         int i;
 
         /* Shutdown the mailbox command sub-system */
-        lpfc_sli_mbox_sys_shutdown(phba);
+        lpfc_sli_mbox_sys_shutdown(phba, LPFC_MBX_WAIT);
 
         lpfc_hba_down_prep(phba);
 
@@ -9996,11 +9996,17 @@ lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
  * sub-system flush routine to gracefully bring down mailbox sub-system.
  **/
 void
-lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba)
+lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba, int mbx_action)
 {
         struct lpfc_sli *psli = &phba->sli;
         unsigned long timeout;
 
+        if (mbx_action == LPFC_MBX_NO_WAIT) {
+                /* delay 100ms for port state */
+                msleep(100);
+                lpfc_sli_mbox_sys_flush(phba);
+                return;
+        }
         timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
 
         spin_lock_irq(&phba->hbalock);
@@ -12042,6 +12048,83 @@ out_fail:
 }
 
 /**
+ * lpfc_modify_fcp_eq_delay - Modify Delay Multiplier on FCP EQs
+ * @phba: HBA structure that indicates port to create a queue on.
+ * @startq: The starting FCP EQ to modify
+ *
+ * This function sends an MODIFY_EQ_DELAY mailbox command to the HBA.
+ *
+ * The @phba struct is used to send mailbox command to HBA. The @startq
+ * is used to get the starting FCP EQ to change.
+ * This function is asynchronous and will wait for the mailbox
+ * command to finish before continuing.
+ *
+ * On success this function will return a zero. If unable to allocate enough
+ * memory this function will return -ENOMEM. If the queue create mailbox command
+ * fails this function will return -ENXIO.
+ **/
+uint32_t
+lpfc_modify_fcp_eq_delay(struct lpfc_hba *phba, uint16_t startq)
+{
+        struct lpfc_mbx_modify_eq_delay *eq_delay;
+        LPFC_MBOXQ_t *mbox;
+        struct lpfc_queue *eq;
+        int cnt, rc, length, status = 0;
+        uint32_t shdr_status, shdr_add_status;
+        int fcp_eqidx;
+        union lpfc_sli4_cfg_shdr *shdr;
+        uint16_t dmult;
+
+        if (startq >= phba->cfg_fcp_eq_count)
+                return 0;
+
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return -ENOMEM;
+        length = (sizeof(struct lpfc_mbx_modify_eq_delay) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
+                         LPFC_MBOX_OPCODE_MODIFY_EQ_DELAY,
+                         length, LPFC_SLI4_MBX_EMBED);
+        eq_delay = &mbox->u.mqe.un.eq_delay;
+
+        /* Calculate delay multiper from maximum interrupt per second */
+        dmult = LPFC_DMULT_CONST/phba->cfg_fcp_imax - 1;
+
+        cnt = 0;
+        for (fcp_eqidx = startq; fcp_eqidx < phba->cfg_fcp_eq_count;
+            fcp_eqidx++) {
+                eq = phba->sli4_hba.fp_eq[fcp_eqidx];
+                if (!eq)
+                        continue;
+                eq_delay->u.request.eq[cnt].eq_id = eq->queue_id;
+                eq_delay->u.request.eq[cnt].phase = 0;
+                eq_delay->u.request.eq[cnt].delay_multi = dmult;
+                cnt++;
+                if (cnt >= LPFC_MAX_EQ_DELAY)
+                        break;
+        }
+        eq_delay->u.request.num_eq = cnt;
+
+        mbox->vport = phba->pport;
+        mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        mbox->context1 = NULL;
+        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+        shdr = (union lpfc_sli4_cfg_shdr *) &eq_delay->header.cfg_shdr;
+        shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
+        if (shdr_status || shdr_add_status || rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2512 MODIFY_EQ_DELAY mailbox failed with "
+                                "status x%x add_status x%x, mbx status x%x\n",
+                                shdr_status, shdr_add_status, rc);
+                status = -ENXIO;
+        }
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return status;
+}
+
+/**
  * lpfc_eq_create - Create an Event Queue on the HBA
  * @phba: HBA structure that indicates port to create a queue on.
  * @eq: The queue structure to use to create the event queue.
@@ -12228,8 +12311,10 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0361 Unsupported CQ count. (%d)\n",
                                 cq->entry_count);
-                if (cq->entry_count < 256)
-                        return -EINVAL;
+                if (cq->entry_count < 256) {
+                        status = -EINVAL;
+                        goto out;
+                }
                 /* otherwise default to smallest count (drop through) */
         case 256:
                 bf_set(lpfc_cq_context_count, &cq_create->u.request.context,
@@ -12420,8 +12505,10 @@ lpfc_mq_create(struct lpfc_hba *phba, struct lpfc_queue *mq,
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0362 Unsupported MQ count. (%d)\n",
                                 mq->entry_count);
-                if (mq->entry_count < 16)
-                        return -EINVAL;
+                if (mq->entry_count < 16) {
+                        status = -EINVAL;
+                        goto out;
+                }
                 /* otherwise default to smallest count (drop through) */
         case 16:
                 bf_set(lpfc_mq_context_ring_size,
@@ -12710,8 +12797,10 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "2535 Unsupported RQ count. (%d)\n",
                                         hrq->entry_count);
-                        if (hrq->entry_count < 512)
-                                return -EINVAL;
+                        if (hrq->entry_count < 512) {
+                                status = -EINVAL;
+                                goto out;
+                        }
                         /* otherwise default to smallest count (drop through) */
                 case 512:
                         bf_set(lpfc_rq_context_rqe_count,
@@ -12791,8 +12880,10 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "2536 Unsupported RQ count. (%d)\n",
                                         drq->entry_count);
-                        if (drq->entry_count < 512)
-                                return -EINVAL;
+                        if (drq->entry_count < 512) {
+                                status = -EINVAL;
+                                goto out;
+                        }
                         /* otherwise default to smallest count (drop through) */
                 case 512:
                         bf_set(lpfc_rq_context_rqe_count,
@@ -15855,24 +15946,18 @@ lpfc_drain_txq(struct lpfc_hba *phba)
                 spin_lock_irqsave(&phba->hbalock, iflags);
 
                 piocbq = lpfc_sli_ringtx_get(phba, pring);
+                if (!piocbq) {
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2823 txq empty and txq_cnt is %d\n ",
+                                pring->txq_cnt);
+                        break;
+                }
                 sglq = __lpfc_sli_get_sglq(phba, piocbq);
                 if (!sglq) {
                         __lpfc_sli_ringtx_put(phba, pring, piocbq);
                         spin_unlock_irqrestore(&phba->hbalock, iflags);
                         break;
-                } else {
-                        if (!piocbq) {
-                                /* The txq_cnt out of sync. This should
-                                 * never happen
-                                 */
-                                sglq = __lpfc_clear_active_sglq(phba,
-                                                 sglq->sli4_lxritag);
-                                spin_unlock_irqrestore(&phba->hbalock, iflags);
-                                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                        "2823 txq empty and txq_cnt is %d\n ",
-                                        pring->txq_cnt);
-                                break;
-                        }
                 }
 
                 /* The xri and iocb resources secured,
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index a4a77080091b..ec756118c5c1 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -598,6 +598,7 @@ struct lpfc_queue *lpfc_sli4_queue_alloc(struct lpfc_hba *, uint32_t,
                         uint32_t);
 void lpfc_sli4_queue_free(struct lpfc_queue *);
 uint32_t lpfc_eq_create(struct lpfc_hba *, struct lpfc_queue *, uint16_t);
+uint32_t lpfc_modify_fcp_eq_delay(struct lpfc_hba *, uint16_t);
 uint32_t lpfc_cq_create(struct lpfc_hba *, struct lpfc_queue *,
                         struct lpfc_queue *, uint32_t, uint32_t);
 int32_t lpfc_mq_create(struct lpfc_hba *, struct lpfc_queue *,
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 59c57a409981..4704e5b5088e 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -18,7 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.31"
+#define LPFC_DRIVER_VERSION "8.3.32"
 #define LPFC_DRIVER_NAME                "lpfc"
 #define LPFC_SP_DRIVER_HANDLER_NAME     "lpfc:sp"
 #define LPFC_FP_DRIVER_HANDLER_NAME     "lpfc:fp"