10 files changed, 318 insertions, 49 deletions

diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index b92aec989d60..82134d20e2d8 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -2629,7 +2629,7 @@ static int lpfcdiag_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
                                 rspiocbq,
                                 (phba->fc_ratov * 2)
                                 + LPFC_DRVR_TIMEOUT);
-        if (iocb_stat) {
+        if ((iocb_stat != IOCB_SUCCESS) || (rsp->ulpStatus != IOSTAT_SUCCESS)) {
                 ret_val = -EIO;
                 goto err_get_xri_exit;
         }
@@ -3204,8 +3204,9 @@ lpfc_bsg_diag_loopback_run(struct fc_bsg_job *job)
                                              rspiocbq, (phba->fc_ratov * 2) +
                                              LPFC_DRVR_TIMEOUT);
 
-        if ((iocb_stat != IOCB_SUCCESS) || ((phba->sli_rev < LPFC_SLI_REV4) &&
-                                           (rsp->ulpStatus != IOCB_SUCCESS))) {
+        if ((iocb_stat != IOCB_SUCCESS) ||
+            ((phba->sli_rev < LPFC_SLI_REV4) &&
+             (rsp->ulpStatus != IOSTAT_SUCCESS))) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
                                 "3126 Failed loopback test issue iocb: "
                                 "iocb_stat:x%x\n", iocb_stat);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 02e8cd923d0a..da61d8dc0449 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -280,7 +280,7 @@ lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb)
                 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context3;
                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
                 kfree(buf_ptr);
-                ctiocb->context1 = NULL;
+                ctiocb->context3 = NULL;
         }
         lpfc_sli_release_iocbq(phba, ctiocb);
         return 0;
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 7801601aa5d9..883ea2d9f237 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -4171,8 +4171,6 @@ lpfc_initialize_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         NLP_INT_NODE_ACT(ndlp);
         atomic_set(&ndlp->cmd_pending, 0);
         ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
-        if (vport->phba->sli_rev == LPFC_SLI_REV4)
-                ndlp->nlp_rpi = lpfc_sli4_alloc_rpi(vport->phba);
 }
 
 struct lpfc_nodelist *
@@ -4217,6 +4215,9 @@ lpfc_enable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         lpfc_initialize_node(vport, ndlp, did);
 
         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
+        if (vport->phba->sli_rev == LPFC_SLI_REV4)
+                ndlp->nlp_rpi = lpfc_sli4_alloc_rpi(vport->phba);
+
 
         if (state != NLP_STE_UNUSED_NODE)
                 lpfc_nlp_set_state(vport, ndlp, state);
@@ -5617,6 +5618,9 @@ lpfc_nlp_init(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 
         lpfc_initialize_node(vport, ndlp, did);
         INIT_LIST_HEAD(&ndlp->nlp_listp);
+        if (vport->phba->sli_rev == LPFC_SLI_REV4)
+                ndlp->nlp_rpi = lpfc_sli4_alloc_rpi(vport->phba);
+
 
         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
                 "node init:       did:x%x",
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 086c3f28caa6..5464b116d328 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -3439,7 +3439,8 @@ struct els_request64_wqe {
 #define els_req64_hopcnt_SHIFT      24
 #define els_req64_hopcnt_MASK       0x000000ff
 #define els_req64_hopcnt_WORD       word13
-        uint32_t reserved[2];
+        uint32_t word14;
+        uint32_t max_response_payload_len;
 };
 
 struct xmit_els_rsp64_wqe {
@@ -3554,7 +3555,8 @@ struct gen_req64_wqe {
         uint32_t relative_offset;
         struct wqe_rctl_dfctl wge_ctl; /* word 5 */
         struct wqe_common wqe_com;     /* words 6-11 */
-        uint32_t rsvd_12_15[4];
+        uint32_t rsvd_12_14[3];
+        uint32_t max_response_payload_len;
 };
 
 struct create_xri_wqe {
@@ -3584,7 +3586,13 @@ struct abort_cmd_wqe {
 
 struct fcp_iwrite64_wqe {
         struct ulp_bde64 bde;
-        uint32_t payload_offset_len;
+        uint32_t word3;
+#define cmd_buff_len_SHIFT  16
+#define cmd_buff_len_MASK  0x00000ffff
+#define cmd_buff_len_WORD  word3
+#define payload_offset_len_SHIFT 0
+#define payload_offset_len_MASK 0x0000ffff
+#define payload_offset_len_WORD word3
         uint32_t total_xfer_len;
         uint32_t initial_xfer_len;
         struct wqe_common wqe_com;     /* words 6-11 */
@@ -3594,7 +3602,13 @@ struct fcp_iwrite64_wqe {
 
 struct fcp_iread64_wqe {
         struct ulp_bde64 bde;
-        uint32_t payload_offset_len;   /* word 3 */
+        uint32_t word3;
+#define cmd_buff_len_SHIFT  16
+#define cmd_buff_len_MASK  0x00000ffff
+#define cmd_buff_len_WORD  word3
+#define payload_offset_len_SHIFT 0
+#define payload_offset_len_MASK 0x0000ffff
+#define payload_offset_len_WORD word3
         uint32_t total_xfer_len;       /* word 4 */
         uint32_t rsrvd5;               /* word 5 */
         struct wqe_common wqe_com;     /* words 6-11 */
@@ -3604,7 +3618,13 @@ struct fcp_iread64_wqe {
 
 struct fcp_icmnd64_wqe {
         struct ulp_bde64 bde;          /* words 0-2 */
-        uint32_t rsrvd3;               /* word 3 */
+        uint32_t word3;
+#define cmd_buff_len_SHIFT  16
+#define cmd_buff_len_MASK  0x00000ffff
+#define cmd_buff_len_WORD  word3
+#define payload_offset_len_SHIFT 0
+#define payload_offset_len_MASK 0x0000ffff
+#define payload_offset_len_WORD word3
         uint32_t rsrvd4;               /* word 4 */
         uint32_t rsrvd5;               /* word 5 */
         struct wqe_common wqe_com;     /* words 6-11 */
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 647f5bfb3bd3..ca6bf2af7ce8 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -4545,7 +4545,7 @@ lpfc_enable_pci_dev(struct lpfc_hba *phba)
         pci_save_state(pdev);
 
         /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
-        if (pci_find_capability(pdev, PCI_CAP_ID_EXP))
+        if (pci_is_pcie(pdev))
                 pdev->needs_freset = 1;
 
         return 0;
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index c913e8cc3b26..b2ede05a5f0a 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -1012,20 +1012,25 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                         break;
                 }
 
-                /* Allocate iotag for psb->cur_iocbq. */
-                iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
-                if (iotag == 0) {
+
+                lxri = lpfc_sli4_next_xritag(phba);
+                if (lxri == NO_XRI) {
                         pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
-                                psb->data, psb->dma_handle);
+                              psb->data, psb->dma_handle);
                         kfree(psb);
                         break;
                 }
 
-                lxri = lpfc_sli4_next_xritag(phba);
-                if (lxri == NO_XRI) {
+                /* Allocate iotag for psb->cur_iocbq. */
+                iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
+                if (iotag == 0) {
                         pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
-                              psb->data, psb->dma_handle);
+                                psb->data, psb->dma_handle);
                         kfree(psb);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+                                        "3368 Failed to allocated IOTAG for"
+                                        " XRI:0x%x\n", lxri);
+                        lpfc_sli4_free_xri(phba, lxri);
                         break;
                 }
                 psb->cur_iocbq.sli4_lxritag = lxri;
@@ -4485,9 +4490,7 @@ lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
                 piocb->ulpContext =
                   vport->phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
         }
-        if (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) {
-                piocb->ulpFCP2Rcvy = 1;
-        }
+        piocb->ulpFCP2Rcvy = (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) ? 1 : 0;
         piocb->ulpClass = (ndlp->nlp_fcp_info & 0x0f);
 
         /* ulpTimeout is only one byte */
@@ -4981,6 +4984,73 @@ lpfc_taskmgmt_name(uint8_t task_mgmt_cmd)
         }
 }
 
+
+/**
+ * lpfc_check_fcp_rsp - check the returned fcp_rsp to see if task failed
+ * @vport: The virtual port for which this call is being executed.
+ * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
+ *
+ * This routine checks the FCP RSP INFO to see if the tsk mgmt command succeded
+ *
+ * Return code :
+ *   0x2003 - Error
+ *   0x2002 - Success
+ **/
+static int
+lpfc_check_fcp_rsp(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd)
+{
+        struct fcp_rsp *fcprsp = lpfc_cmd->fcp_rsp;
+        uint32_t rsp_info;
+        uint32_t rsp_len;
+        uint8_t  rsp_info_code;
+        int ret = FAILED;
+
+
+        if (fcprsp == NULL)
+                lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                                 "0703 fcp_rsp is missing\n");
+        else {
+                rsp_info = fcprsp->rspStatus2;
+                rsp_len = be32_to_cpu(fcprsp->rspRspLen);
+                rsp_info_code = fcprsp->rspInfo3;
+
+
+                lpfc_printf_vlog(vport, KERN_INFO,
+                                 LOG_FCP,
+                                 "0706 fcp_rsp valid 0x%x,"
+                                 " rsp len=%d code 0x%x\n",
+                                 rsp_info,
+                                 rsp_len, rsp_info_code);
+
+                if ((fcprsp->rspStatus2&RSP_LEN_VALID) && (rsp_len == 8)) {
+                        switch (rsp_info_code) {
+                        case RSP_NO_FAILURE:
+                                lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                                                 "0715 Task Mgmt No Failure\n");
+                                ret = SUCCESS;
+                                break;
+                        case RSP_TM_NOT_SUPPORTED: /* TM rejected */
+                                lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                                                 "0716 Task Mgmt Target "
+                                                "reject\n");
+                                break;
+                        case RSP_TM_NOT_COMPLETED: /* TM failed */
+                                lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                                                 "0717 Task Mgmt Target "
+                                                "failed TM\n");
+                                break;
+                        case RSP_TM_INVALID_LU: /* TM to invalid LU! */
+                                lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                                                 "0718 Task Mgmt to invalid "
+                                                "LUN\n");
+                                break;
+                        }
+                }
+        }
+        return ret;
+}
+
+
 /**
  * lpfc_send_taskmgmt - Generic SCSI Task Mgmt Handler
  * @vport: The virtual port for which this call is being executed.
@@ -5042,12 +5112,8 @@ lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
 
         status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
                                           iocbq, iocbqrsp, lpfc_cmd->timeout);
-        if (status != IOCB_SUCCESS) {
-                if (status == IOCB_TIMEDOUT) {
-                        ret = TIMEOUT_ERROR;
-                } else
-                        ret = FAILED;
-                lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
+        if ((status != IOCB_SUCCESS) ||
+            (iocbqrsp->iocb.ulpStatus != IOSTAT_SUCCESS)) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
                          "0727 TMF %s to TGT %d LUN %d failed (%d, %d) "
                          "iocb_flag x%x\n",
@@ -5055,9 +5121,21 @@ lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
                          tgt_id, lun_id, iocbqrsp->iocb.ulpStatus,
                          iocbqrsp->iocb.un.ulpWord[4],
                          iocbq->iocb_flag);
-        } else if (status == IOCB_BUSY)
-                ret = FAILED;
-        else
+                /* if ulpStatus != IOCB_SUCCESS, then status == IOCB_SUCCESS */
+                if (status == IOCB_SUCCESS) {
+                        if (iocbqrsp->iocb.ulpStatus == IOSTAT_FCP_RSP_ERROR)
+                                /* Something in the FCP_RSP was invalid.
+                                 * Check conditions */
+                                ret = lpfc_check_fcp_rsp(vport, lpfc_cmd);
+                        else
+                                ret = FAILED;
+                } else if (status == IOCB_TIMEDOUT) {
+                        ret = TIMEOUT_ERROR;
+                } else {
+                        ret = FAILED;
+                }
+                lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
+        } else
                 ret = SUCCESS;
 
         lpfc_sli_release_iocbq(phba, iocbqrsp);
@@ -5181,7 +5259,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, ret = SUCCESS;
+        int status;
 
         if (!rdata) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
@@ -5222,9 +5300,11 @@ lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
          * So, continue on.
          * We will report success if all the i/o aborts successfully.
          */
-        ret = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
+        if (status == SUCCESS)
+                status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
                                                 LPFC_CTX_LUN);
-        return ret;
+
+        return status;
 }
 
 /**
@@ -5248,7 +5328,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, ret = SUCCESS;
+        int status;
 
         if (!rdata) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
@@ -5289,9 +5369,10 @@ lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
          * So, continue on.
          * We will report success if all the i/o aborts successfully.
          */
-        ret = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
+        if (status == SUCCESS)
+                status = lpfc_reset_flush_io_context(vport, tgt_id, lun_id,
                                           LPFC_CTX_TGT);
-        return ret;
+        return status;
 }
 
 /**
diff --git a/drivers/scsi/lpfc/lpfc_scsi.h b/drivers/scsi/lpfc/lpfc_scsi.h
index b1d9f7fcb911..852ff7def493 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.h
+++ b/drivers/scsi/lpfc/lpfc_scsi.h
@@ -73,6 +73,7 @@ struct fcp_rsp {
 #define RSP_RO_MISMATCH_ERR  0x03
 #define RSP_TM_NOT_SUPPORTED 0x04       /* Task mgmt function not supported */
 #define RSP_TM_NOT_COMPLETED 0x05       /* Task mgmt function not performed */
+#define RSP_TM_INVALID_LU    0x09       /* Task mgmt function to invalid LU */
 
         uint32_t rspInfoRsvd;   /* FCP_RSP_INFO bytes 4-7 (reserved) */
 
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 612f48973ff2..8f580fda443f 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -71,6 +71,8 @@ static int lpfc_sli4_post_els_sgl_list(struct lpfc_hba *, struct list_head *,
                                        int);
 static void lpfc_sli4_hba_handle_eqe(struct lpfc_hba *, struct lpfc_eqe *,
                         uint32_t);
+static bool lpfc_sli4_mbox_completions_pending(struct lpfc_hba *phba);
+static bool lpfc_sli4_process_missed_mbox_completions(struct lpfc_hba *phba);
 
 static IOCB_t *
 lpfc_get_iocb_from_iocbq(struct lpfc_iocbq *iocbq)
@@ -6566,6 +6568,108 @@ lpfc_mbox_timeout(unsigned long ptr)
         return;
 }
 
+/**
+ * lpfc_sli4_mbox_completions_pending - check to see if any mailbox completions
+ *                                    are pending
+ * @phba: Pointer to HBA context object.
+ *
+ * This function checks if any mailbox completions are present on the mailbox
+ * completion queue.
+ **/
+bool
+lpfc_sli4_mbox_completions_pending(struct lpfc_hba *phba)
+{
+
+        uint32_t idx;
+        struct lpfc_queue *mcq;
+        struct lpfc_mcqe *mcqe;
+        bool pending_completions = false;
+
+        if (unlikely(!phba) || (phba->sli_rev != LPFC_SLI_REV4))
+                return false;
+
+        /* Check for completions on mailbox completion queue */
+
+        mcq = phba->sli4_hba.mbx_cq;
+        idx = mcq->hba_index;
+        while (bf_get_le32(lpfc_cqe_valid, mcq->qe[idx].cqe)) {
+                mcqe = (struct lpfc_mcqe *)mcq->qe[idx].cqe;
+                if (bf_get_le32(lpfc_trailer_completed, mcqe) &&
+                    (!bf_get_le32(lpfc_trailer_async, mcqe))) {
+                        pending_completions = true;
+                        break;
+                }
+                idx = (idx + 1) % mcq->entry_count;
+                if (mcq->hba_index == idx)
+                        break;
+        }
+        return pending_completions;
+
+}
+
+/**
+ * lpfc_sli4_process_missed_mbox_completions - process mbox completions
+ *                                            that were missed.
+ * @phba: Pointer to HBA context object.
+ *
+ * For sli4, it is possible to miss an interrupt. As such mbox completions
+ * maybe missed causing erroneous mailbox timeouts to occur. This function
+ * checks to see if mbox completions are on the mailbox completion queue
+ * and will process all the completions associated with the eq for the
+ * mailbox completion queue.
+ **/
+bool
+lpfc_sli4_process_missed_mbox_completions(struct lpfc_hba *phba)
+{
+
+        uint32_t eqidx;
+        struct lpfc_queue *fpeq = NULL;
+        struct lpfc_eqe *eqe;
+        bool mbox_pending;
+
+        if (unlikely(!phba) || (phba->sli_rev != LPFC_SLI_REV4))
+                return false;
+
+        /* Find the eq associated with the mcq */
+
+        if (phba->sli4_hba.hba_eq)
+                for (eqidx = 0; eqidx < phba->cfg_fcp_io_channel; eqidx++)
+                        if (phba->sli4_hba.hba_eq[eqidx]->queue_id ==
+                            phba->sli4_hba.mbx_cq->assoc_qid) {
+                                fpeq = phba->sli4_hba.hba_eq[eqidx];
+                                break;
+                        }
+        if (!fpeq)
+                return false;
+
+        /* Turn off interrupts from this EQ */
+
+        lpfc_sli4_eq_clr_intr(fpeq);
+
+        /* Check to see if a mbox completion is pending */
+
+        mbox_pending = lpfc_sli4_mbox_completions_pending(phba);
+
+        /*
+         * If a mbox completion is pending, process all the events on EQ
+         * associated with the mbox completion queue (this could include
+         * mailbox commands, async events, els commands, receive queue data
+         * and fcp commands)
+         */
+
+        if (mbox_pending)
+                while ((eqe = lpfc_sli4_eq_get(fpeq))) {
+                        lpfc_sli4_hba_handle_eqe(phba, eqe, eqidx);
+                        fpeq->EQ_processed++;
+                }
+
+        /* Always clear and re-arm the EQ */
+
+        lpfc_sli4_eq_release(fpeq, LPFC_QUEUE_REARM);
+
+        return mbox_pending;
+
+}
 
 /**
  * lpfc_mbox_timeout_handler - Worker thread function to handle mailbox timeout
@@ -6583,6 +6687,10 @@ lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
         struct lpfc_sli *psli = &phba->sli;
         struct lpfc_sli_ring *pring;
 
+        /* If the mailbox completed, process the completion and return */
+        if (lpfc_sli4_process_missed_mbox_completions(phba))
+                return;
+
         /* Check the pmbox pointer first.  There is a race condition
          * between the mbox timeout handler getting executed in the
          * worklist and the mailbox actually completing. When this
@@ -7077,6 +7185,10 @@ lpfc_sli4_async_mbox_block(struct lpfc_hba *phba)
                                                 1000) + jiffies;
         spin_unlock_irq(&phba->hbalock);
 
+        /* Make sure the mailbox is really active */
+        if (timeout)
+                lpfc_sli4_process_missed_mbox_completions(phba);
+
         /* Wait for the outstnading mailbox command to complete */
         while (phba->sli.mbox_active) {
                 /* Check active mailbox complete status every 2ms */
@@ -8076,6 +8188,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_qosd, &wqe->els_req.wqe_com, 1);
                 bf_set(wqe_lenloc, &wqe->els_req.wqe_com, LPFC_WQE_LENLOC_NONE);
                 bf_set(wqe_ebde_cnt, &wqe->els_req.wqe_com, 0);
+                wqe->els_req.max_response_payload_len = total_len - xmit_len;
                 break;
         case CMD_XMIT_SEQUENCE64_CX:
                 bf_set(wqe_ctxt_tag, &wqe->xmit_sequence.wqe_com,
@@ -8120,8 +8233,10 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 command_type = FCP_COMMAND_DATA_OUT;
                 /* word3 iocb=iotag wqe=payload_offset_len */
                 /* Add the FCP_CMD and FCP_RSP sizes to get the offset */
-                wqe->fcp_iwrite.payload_offset_len =
-                        xmit_len + sizeof(struct fcp_rsp);
+                bf_set(payload_offset_len, &wqe->fcp_iwrite,
+                       xmit_len + sizeof(struct fcp_rsp));
+                bf_set(cmd_buff_len, &wqe->fcp_iwrite,
+                       0);
                 /* word4 iocb=parameter wqe=total_xfer_length memcpy */
                 /* word5 iocb=initial_xfer_len wqe=initial_xfer_len memcpy */
                 bf_set(wqe_erp, &wqe->fcp_iwrite.wqe_com,
@@ -8139,8 +8254,10 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
         case CMD_FCP_IREAD64_CR:
                 /* word3 iocb=iotag wqe=payload_offset_len */
                 /* Add the FCP_CMD and FCP_RSP sizes to get the offset */
-                wqe->fcp_iread.payload_offset_len =
-                        xmit_len + sizeof(struct fcp_rsp);
+                bf_set(payload_offset_len, &wqe->fcp_iread,
+                       xmit_len + sizeof(struct fcp_rsp));
+                bf_set(cmd_buff_len, &wqe->fcp_iread,
+                       0);
                 /* word4 iocb=parameter wqe=total_xfer_length memcpy */
                 /* word5 iocb=initial_xfer_len wqe=initial_xfer_len memcpy */
                 bf_set(wqe_erp, &wqe->fcp_iread.wqe_com,
@@ -8156,8 +8273,13 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_dbde, &wqe->fcp_iread.wqe_com, 1);
                 break;
         case CMD_FCP_ICMND64_CR:
+                /* word3 iocb=iotag wqe=payload_offset_len */
+                /* Add the FCP_CMD and FCP_RSP sizes to get the offset */
+                bf_set(payload_offset_len, &wqe->fcp_icmd,
+                       xmit_len + sizeof(struct fcp_rsp));
+                bf_set(cmd_buff_len, &wqe->fcp_icmd,
+                       0);
                 /* word3 iocb=IO_TAG wqe=reserved */
-                wqe->fcp_icmd.rsrvd3 = 0;
                 bf_set(wqe_pu, &wqe->fcp_icmd.wqe_com, 0);
                 /* Always open the exchange */
                 bf_set(wqe_xc, &wqe->fcp_icmd.wqe_com, 0);
@@ -8203,6 +8325,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_qosd, &wqe->gen_req.wqe_com, 1);
                 bf_set(wqe_lenloc, &wqe->gen_req.wqe_com, LPFC_WQE_LENLOC_NONE);
                 bf_set(wqe_ebde_cnt, &wqe->gen_req.wqe_com, 0);
+                wqe->gen_req.max_response_payload_len = total_len - xmit_len;
                 command_type = OTHER_COMMAND;
                 break;
         case CMD_XMIT_ELS_RSP64_CX:
@@ -10073,6 +10196,11 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
                 if (iocb_completed) {
                         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
                                         "0331 IOCB wake signaled\n");
+                        /* Note: we are not indicating if the IOCB has a success
+                         * status or not - that's for the caller to check.
+                         * IOCB_SUCCESS means just that the command was sent and
+                         * completed. Not that it completed successfully.
+                         * */
                 } else if (timeleft == 0) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "0338 IOCB wait timeout error - no "
@@ -11074,8 +11202,11 @@ lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
                               struct lpfc_iocbq *pIocbOut,
                               struct lpfc_wcqe_complete *wcqe)
 {
+        int numBdes, i;
         unsigned long iflags;
-        uint32_t status;
+        uint32_t status, max_response;
+        struct lpfc_dmabuf *dmabuf;
+        struct ulp_bde64 *bpl, bde;
         size_t offset = offsetof(struct lpfc_iocbq, iocb);
 
         memcpy((char *)pIocbIn + offset, (char *)pIocbOut + offset,
@@ -11092,7 +11223,36 @@ lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
                         pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
         else {
                 pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
-                pIocbIn->iocb.un.genreq64.bdl.bdeSize = wcqe->total_data_placed;
+                switch (pIocbOut->iocb.ulpCommand) {
+                case CMD_ELS_REQUEST64_CR:
+                        dmabuf = (struct lpfc_dmabuf *)pIocbOut->context3;
+                        bpl  = (struct ulp_bde64 *)dmabuf->virt;
+                        bde.tus.w = le32_to_cpu(bpl[1].tus.w);
+                        max_response = bde.tus.f.bdeSize;
+                        break;
+                case CMD_GEN_REQUEST64_CR:
+                        max_response = 0;
+                        if (!pIocbOut->context3)
+                                break;
+                        numBdes = pIocbOut->iocb.un.genreq64.bdl.bdeSize/
+                                        sizeof(struct ulp_bde64);
+                        dmabuf = (struct lpfc_dmabuf *)pIocbOut->context3;
+                        bpl = (struct ulp_bde64 *)dmabuf->virt;
+                        for (i = 0; i < numBdes; i++) {
+                                bde.tus.w = le32_to_cpu(bpl[i].tus.w);
+                                if (bde.tus.f.bdeFlags != BUFF_TYPE_BDE_64)
+                                        max_response += bde.tus.f.bdeSize;
+                        }
+                        break;
+                default:
+                        max_response = wcqe->total_data_placed;
+                        break;
+                }
+                if (max_response < wcqe->total_data_placed)
+                        pIocbIn->iocb.un.genreq64.bdl.bdeSize = max_response;
+                else
+                        pIocbIn->iocb.un.genreq64.bdl.bdeSize =
+                                wcqe->total_data_placed;
         }
 
         /* Convert BG errors for completion status */
@@ -15098,6 +15258,7 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
         uint16_t max_rpi, rpi_limit;
         uint16_t rpi_remaining, lrpi = 0;
         struct lpfc_rpi_hdr *rpi_hdr;
+        unsigned long iflag;
 
         max_rpi = phba->sli4_hba.max_cfg_param.max_rpi;
         rpi_limit = phba->sli4_hba.next_rpi;
@@ -15106,7 +15267,7 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
          * Fetch the next logical rpi.  Because this index is logical,
          * the  driver starts at 0 each time.
          */
-        spin_lock_irq(&phba->hbalock);
+        spin_lock_irqsave(&phba->hbalock, iflag);
         rpi = find_next_zero_bit(phba->sli4_hba.rpi_bmask, rpi_limit, 0);
         if (rpi >= rpi_limit)
                 rpi = LPFC_RPI_ALLOC_ERROR;
@@ -15122,7 +15283,7 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
          */
         if ((rpi == LPFC_RPI_ALLOC_ERROR) &&
             (phba->sli4_hba.rpi_count >= max_rpi)) {
-                spin_unlock_irq(&phba->hbalock);
+                spin_unlock_irqrestore(&phba->hbalock, iflag);
                 return rpi;
         }
 
@@ -15131,7 +15292,7 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
          * extents.
          */
         if (!phba->sli4_hba.rpi_hdrs_in_use) {
-                spin_unlock_irq(&phba->hbalock);
+                spin_unlock_irqrestore(&phba->hbalock, iflag);
                 return rpi;
         }
 
@@ -15142,7 +15303,7 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
          * how many are supported max by the device.
          */
         rpi_remaining = phba->sli4_hba.next_rpi - phba->sli4_hba.rpi_count;
-        spin_unlock_irq(&phba->hbalock);
+        spin_unlock_irqrestore(&phba->hbalock, iflag);
         if (rpi_remaining < LPFC_RPI_LOW_WATER_MARK) {
                 rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
                 if (!rpi_hdr) {
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index 85120b77aa0e..298c8cd1a89d 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -673,6 +673,7 @@ void lpfc_sli4_queue_unset(struct lpfc_hba *);
 int lpfc_sli4_post_sgl(struct lpfc_hba *, dma_addr_t, dma_addr_t, uint16_t);
 int lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *);
 uint16_t lpfc_sli4_next_xritag(struct lpfc_hba *);
+void lpfc_sli4_free_xri(struct lpfc_hba *, int);
 int lpfc_sli4_post_async_mbox(struct lpfc_hba *);
 int lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *, struct list_head *, int);
 struct lpfc_cq_event *__lpfc_sli4_cq_event_alloc(struct lpfc_hba *);
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index f58f18342bc3..e3094c4e143b 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.42"
+#define LPFC_DRIVER_VERSION "8.3.43"
 #define LPFC_DRIVER_NAME                "lpfc"
 
 /* Used for SLI 2/3 */