1 files changed, 150 insertions, 90 deletions

diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 23a27592388c..e0e4d8d18244 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -293,7 +293,9 @@ lpfc_sli4_eq_release(struct lpfc_queue *q, bool arm)
         }
         bf_set(lpfc_eqcq_doorbell_num_released, &doorbell, released);
         bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_EVENT);
-        bf_set(lpfc_eqcq_doorbell_eqid, &doorbell, q->queue_id);
+        bf_set(lpfc_eqcq_doorbell_eqid_hi, &doorbell,
+                        (q->queue_id >> LPFC_EQID_HI_FIELD_SHIFT));
+        bf_set(lpfc_eqcq_doorbell_eqid_lo, &doorbell, q->queue_id);
         writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
         /* PCI read to flush PCI pipeline on re-arming for INTx mode */
         if ((q->phba->intr_type == INTx) && (arm == LPFC_QUEUE_REARM))
@@ -372,7 +374,9 @@ lpfc_sli4_cq_release(struct lpfc_queue *q, bool arm)
                 bf_set(lpfc_eqcq_doorbell_arm, &doorbell, 1);
         bf_set(lpfc_eqcq_doorbell_num_released, &doorbell, released);
         bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_COMPLETION);
-        bf_set(lpfc_eqcq_doorbell_cqid, &doorbell, q->queue_id);
+        bf_set(lpfc_eqcq_doorbell_cqid_hi, &doorbell,
+                        (q->queue_id >> LPFC_CQID_HI_FIELD_SHIFT));
+        bf_set(lpfc_eqcq_doorbell_cqid_lo, &doorbell, q->queue_id);
         writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
         return released;
 }
@@ -554,81 +558,6 @@ __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
 }
 
 /**
- * __lpfc_set_rrq_active - set RRQ active bit in the ndlp's xri_bitmap.
- * @phba: Pointer to HBA context object.
- * @ndlp: nodelist pointer for this target.
- * @xritag: xri used in this exchange.
- * @rxid: Remote Exchange ID.
- * @send_rrq: Flag used to determine if we should send rrq els cmd.
- *
- * This function is called with hbalock held.
- * The active bit is set in the ndlp's active rrq xri_bitmap. Allocates an
- * rrq struct and adds it to the active_rrq_list.
- *
- * returns  0 for rrq slot for this xri
- *         < 0  Were not able to get rrq mem or invalid parameter.
- **/
-static int
-__lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
-                uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
-{
-        struct lpfc_node_rrq *rrq;
-        int empty;
-        uint32_t did = 0;
-
-
-        if (!ndlp)
-                return -EINVAL;
-
-        if (!phba->cfg_enable_rrq)
-                return -EINVAL;
-
-        if (phba->pport->load_flag & FC_UNLOADING) {
-                phba->hba_flag &= ~HBA_RRQ_ACTIVE;
-                goto out;
-        }
-        did = ndlp->nlp_DID;
-
-        /*
-         * set the active bit even if there is no mem available.
-         */
-        if (NLP_CHK_FREE_REQ(ndlp))
-                goto out;
-
-        if (ndlp->vport && (ndlp->vport->load_flag & FC_UNLOADING))
-                goto out;
-
-        if (test_and_set_bit(xritag, ndlp->active_rrqs.xri_bitmap))
-                goto out;
-
-        rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
-        if (rrq) {
-                rrq->send_rrq = send_rrq;
-                rrq->xritag = xritag;
-                rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
-                rrq->ndlp = ndlp;
-                rrq->nlp_DID = ndlp->nlp_DID;
-                rrq->vport = ndlp->vport;
-                rrq->rxid = rxid;
-                empty = list_empty(&phba->active_rrq_list);
-                rrq->send_rrq = send_rrq;
-                list_add_tail(&rrq->list, &phba->active_rrq_list);
-                if (!(phba->hba_flag & HBA_RRQ_ACTIVE)) {
-                        phba->hba_flag |= HBA_RRQ_ACTIVE;
-                        if (empty)
-                                lpfc_worker_wake_up(phba);
-                }
-                return 0;
-        }
-out:
-        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                        "2921 Can't set rrq active xri:0x%x rxid:0x%x"
-                        " DID:0x%x Send:%d\n",
-                        xritag, rxid, did, send_rrq);
-        return -EINVAL;
-}
-
-/**
  * lpfc_clr_rrq_active - Clears RRQ active bit in xri_bitmap.
  * @phba: Pointer to HBA context object.
  * @xritag: xri used in this exchange.
@@ -856,15 +785,68 @@ lpfc_test_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
  **/
 int
 lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
-                        uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
+                    uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
 {
-        int ret;
         unsigned long iflags;
+        struct lpfc_node_rrq *rrq;
+        int empty;
+
+        if (!ndlp)
+                return -EINVAL;
+
+        if (!phba->cfg_enable_rrq)
+                return -EINVAL;
 
         spin_lock_irqsave(&phba->hbalock, iflags);
-        ret = __lpfc_set_rrq_active(phba, ndlp, xritag, rxid, send_rrq);
+        if (phba->pport->load_flag & FC_UNLOADING) {
+                phba->hba_flag &= ~HBA_RRQ_ACTIVE;
+                goto out;
+        }
+
+        /*
+         * set the active bit even if there is no mem available.
+         */
+        if (NLP_CHK_FREE_REQ(ndlp))
+                goto out;
+
+        if (ndlp->vport && (ndlp->vport->load_flag & FC_UNLOADING))
+                goto out;
+
+        if (test_and_set_bit(xritag, ndlp->active_rrqs.xri_bitmap))
+                goto out;
+
         spin_unlock_irqrestore(&phba->hbalock, iflags);
-        return ret;
+        rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
+        if (!rrq) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                "3155 Unable to allocate RRQ xri:0x%x rxid:0x%x"
+                                " DID:0x%x Send:%d\n",
+                                xritag, rxid, ndlp->nlp_DID, send_rrq);
+                return -EINVAL;
+        }
+        rrq->send_rrq = send_rrq;
+        rrq->xritag = xritag;
+        rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
+        rrq->ndlp = ndlp;
+        rrq->nlp_DID = ndlp->nlp_DID;
+        rrq->vport = ndlp->vport;
+        rrq->rxid = rxid;
+        rrq->send_rrq = send_rrq;
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        empty = list_empty(&phba->active_rrq_list);
+        list_add_tail(&rrq->list, &phba->active_rrq_list);
+        phba->hba_flag |= HBA_RRQ_ACTIVE;
+        if (empty)
+                lpfc_worker_wake_up(phba);
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        return 0;
+out:
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "2921 Can't set rrq active xri:0x%x rxid:0x%x"
+                        " DID:0x%x Send:%d\n",
+                        xritag, rxid, ndlp->nlp_DID, send_rrq);
+        return -EINVAL;
 }
 
 /**
@@ -5596,6 +5578,8 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba)
                 for (i = 0; i < count; i++)
                         phba->sli4_hba.rpi_ids[i] = base + i;
 
+                lpfc_sli4_node_prep(phba);
+
                 /* VPIs. */
                 count = phba->sli4_hba.max_cfg_param.max_vpi;
                 base = phba->sli4_hba.max_cfg_param.vpi_base;
@@ -7555,6 +7539,8 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
 
         sgl  = (struct sli4_sge *)sglq->sgl;
         icmd = &piocbq->iocb;
+        if (icmd->ulpCommand == CMD_XMIT_BLS_RSP64_CX)
+                return sglq->sli4_xritag;
         if (icmd->un.genreq64.bdl.bdeFlags == BUFF_TYPE_BLP_64) {
                 numBdes = icmd->un.genreq64.bdl.bdeSize /
                                 sizeof(struct ulp_bde64);
@@ -7756,6 +7742,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
                         if (pcmd && (*pcmd == ELS_CMD_FLOGI ||
                                 *pcmd == ELS_CMD_SCR ||
+                                *pcmd == ELS_CMD_FDISC ||
                                 *pcmd == ELS_CMD_PLOGI)) {
                                 bf_set(els_req64_sp, &wqe->els_req, 1);
                                 bf_set(els_req64_sid, &wqe->els_req,
@@ -7763,7 +7750,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                                 bf_set(wqe_ct, &wqe->els_req.wqe_com, 1);
                                 bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
                                         phba->vpi_ids[phba->pport->vpi]);
-                        } else if (iocbq->context1) {
+                        } else if (pcmd && iocbq->context1) {
                                 bf_set(wqe_ct, &wqe->els_req.wqe_com, 0);
                                 bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
                                         phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
@@ -7830,12 +7817,16 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lnk, &wqe->fcp_iwrite.wqe_com, iocbq->iocb.ulpXS);
                 /* Always open the exchange */
                 bf_set(wqe_xc, &wqe->fcp_iwrite.wqe_com, 0);
-                bf_set(wqe_dbde, &wqe->fcp_iwrite.wqe_com, 1);
                 bf_set(wqe_iod, &wqe->fcp_iwrite.wqe_com, LPFC_WQE_IOD_WRITE);
                 bf_set(wqe_lenloc, &wqe->fcp_iwrite.wqe_com,
                        LPFC_WQE_LENLOC_WORD4);
                 bf_set(wqe_ebde_cnt, &wqe->fcp_iwrite.wqe_com, 0);
                 bf_set(wqe_pu, &wqe->fcp_iwrite.wqe_com, iocbq->iocb.ulpPU);
+                if (iocbq->iocb_flag & LPFC_IO_DIF) {
+                        iocbq->iocb_flag &= ~LPFC_IO_DIF;
+                        bf_set(wqe_dif, &wqe->generic.wqe_com, 1);
+                }
+                bf_set(wqe_dbde, &wqe->fcp_iwrite.wqe_com, 1);
                 break;
         case CMD_FCP_IREAD64_CR:
                 /* word3 iocb=iotag wqe=payload_offset_len */
@@ -7849,12 +7840,16 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lnk, &wqe->fcp_iread.wqe_com, iocbq->iocb.ulpXS);
                 /* Always open the exchange */
                 bf_set(wqe_xc, &wqe->fcp_iread.wqe_com, 0);
-                bf_set(wqe_dbde, &wqe->fcp_iread.wqe_com, 1);
                 bf_set(wqe_iod, &wqe->fcp_iread.wqe_com, LPFC_WQE_IOD_READ);
                 bf_set(wqe_lenloc, &wqe->fcp_iread.wqe_com,
                        LPFC_WQE_LENLOC_WORD4);
                 bf_set(wqe_ebde_cnt, &wqe->fcp_iread.wqe_com, 0);
                 bf_set(wqe_pu, &wqe->fcp_iread.wqe_com, iocbq->iocb.ulpPU);
+                if (iocbq->iocb_flag & LPFC_IO_DIF) {
+                        iocbq->iocb_flag &= ~LPFC_IO_DIF;
+                        bf_set(wqe_dif, &wqe->generic.wqe_com, 1);
+                }
+                bf_set(wqe_dbde, &wqe->fcp_iread.wqe_com, 1);
                 break;
         case CMD_FCP_ICMND64_CR:
                 /* word3 iocb=IO_TAG wqe=reserved */
@@ -7982,6 +7977,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 xritag = 0;
                 break;
         case CMD_XMIT_BLS_RSP64_CX:
+                ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 /* As BLS ABTS RSP WQE is very different from other WQEs,
                  * we re-construct this WQE here based on information in
                  * iocbq from scratch.
@@ -8008,8 +8004,15 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 }
                 bf_set(xmit_bls_rsp64_seqcnthi, &wqe->xmit_bls_rsp, 0xffff);
                 bf_set(wqe_xmit_bls_pt, &wqe->xmit_bls_rsp.wqe_dest, 0x1);
+
+                /* Use CT=VPI */
+                bf_set(wqe_els_did, &wqe->xmit_bls_rsp.wqe_dest,
+                        ndlp->nlp_DID);
+                bf_set(xmit_bls_rsp64_temprpi, &wqe->xmit_bls_rsp,
+                        iocbq->iocb.ulpContext);
+                bf_set(wqe_ct, &wqe->xmit_bls_rsp.wqe_com, 1);
                 bf_set(wqe_ctxt_tag, &wqe->xmit_bls_rsp.wqe_com,
-                       iocbq->iocb.ulpContext);
+                        phba->vpi_ids[phba->pport->vpi]);
                 bf_set(wqe_qosd, &wqe->xmit_bls_rsp.wqe_com, 1);
                 bf_set(wqe_lenloc, &wqe->xmit_bls_rsp.wqe_com,
                        LPFC_WQE_LENLOC_NONE);
@@ -8073,8 +8076,7 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
 
         if (piocb->sli4_xritag == NO_XRI) {
                 if (piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
-                    piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN ||
-                    piocb->iocb.ulpCommand == CMD_XMIT_BLS_RSP64_CX)
+                    piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
                         sglq = NULL;
                 else {
                         if (pring->txq_cnt) {
@@ -8384,10 +8386,13 @@ lpfc_sli4_abts_err_handler(struct lpfc_hba *phba,
 {
         struct lpfc_vport *vport;
 
-        if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
+        if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
                                 "3115 Node Context not found, driver "
                                 "ignoring abts err event\n");
+                return;
+        }
+
         vport = ndlp->vport;
         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
                         "3116 Port generated FCP XRI ABORT event on "
@@ -10653,12 +10658,14 @@ lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
                               struct lpfc_wcqe_complete *wcqe)
 {
         unsigned long iflags;
+        uint32_t status;
         size_t offset = offsetof(struct lpfc_iocbq, iocb);
 
         memcpy((char *)pIocbIn + offset, (char *)pIocbOut + offset,
                sizeof(struct lpfc_iocbq) - offset);
         /* Map WCQE parameters into irspiocb parameters */
-        pIocbIn->iocb.ulpStatus = bf_get(lpfc_wcqe_c_status, wcqe);
+        status = bf_get(lpfc_wcqe_c_status, wcqe);
+        pIocbIn->iocb.ulpStatus = (status & LPFC_IOCB_STATUS_MASK);
         if (pIocbOut->iocb_flag & LPFC_IO_FCP)
                 if (pIocbIn->iocb.ulpStatus == IOSTAT_FCP_RSP_ERROR)
                         pIocbIn->iocb.un.fcpi.fcpi_parm =
@@ -10671,6 +10678,44 @@ lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
                 pIocbIn->iocb.un.genreq64.bdl.bdeSize = wcqe->total_data_placed;
         }
 
+        /* Convert BG errors for completion status */
+        if (status == CQE_STATUS_DI_ERROR) {
+                pIocbIn->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
+
+                if (bf_get(lpfc_wcqe_c_bg_edir, wcqe))
+                        pIocbIn->iocb.un.ulpWord[4] = IOERR_RX_DMA_FAILED;
+                else
+                        pIocbIn->iocb.un.ulpWord[4] = IOERR_TX_DMA_FAILED;
+
+                pIocbIn->iocb.unsli3.sli3_bg.bgstat = 0;
+                if (bf_get(lpfc_wcqe_c_bg_ge, wcqe)) /* Guard Check failed */
+                        pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
+                                BGS_GUARD_ERR_MASK;
+                if (bf_get(lpfc_wcqe_c_bg_ae, wcqe)) /* App Tag Check failed */
+                        pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
+                                BGS_APPTAG_ERR_MASK;
+                if (bf_get(lpfc_wcqe_c_bg_re, wcqe)) /* Ref Tag Check failed */
+                        pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
+                                BGS_REFTAG_ERR_MASK;
+
+                /* Check to see if there was any good data before the error */
+                if (bf_get(lpfc_wcqe_c_bg_tdpv, wcqe)) {
+                        pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
+                                BGS_HI_WATER_MARK_PRESENT_MASK;
+                        pIocbIn->iocb.unsli3.sli3_bg.bghm =
+                                wcqe->total_data_placed;
+                }
+
+                /*
+                * Set ALL the error bits to indicate we don't know what
+                * type of error it is.
+                */
+                if (!pIocbIn->iocb.unsli3.sli3_bg.bgstat)
+                        pIocbIn->iocb.unsli3.sli3_bg.bgstat |=
+                                (BGS_REFTAG_ERR_MASK | BGS_APPTAG_ERR_MASK |
+                                BGS_GUARD_ERR_MASK);
+        }
+
         /* Pick up HBA exchange busy condition */
         if (bf_get(lpfc_wcqe_c_xb, wcqe)) {
                 spin_lock_irqsave(&phba->hbalock, iflags);
@@ -14042,6 +14087,13 @@ lpfc_sli4_seq_abort_rsp_cmpl(struct lpfc_hba *phba,
 {
         if (cmd_iocbq)
                 lpfc_sli_release_iocbq(phba, cmd_iocbq);
+
+        /* Failure means BLS ABORT RSP did not get delivered to remote node*/
+        if (rsp_iocbq && rsp_iocbq->iocb.ulpStatus)
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                        "3154 BLS ABORT RSP failed, data:  x%x/x%x\n",
+                        rsp_iocbq->iocb.ulpStatus,
+                        rsp_iocbq->iocb.un.ulpWord[4]);
 }
 
 /**
@@ -14748,7 +14800,8 @@ lpfc_sli4_remove_rpis(struct lpfc_hba *phba)
  * provided rpi via a bitmask.
  **/
 int
-lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp)
+lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp,
+        void (*cmpl)(struct lpfc_hba *, LPFC_MBOXQ_t *), void *arg)
 {
         LPFC_MBOXQ_t *mboxq;
         struct lpfc_hba *phba = ndlp->phba;
@@ -14761,6 +14814,13 @@ lpfc_sli4_resume_rpi(struct lpfc_nodelist *ndlp)
 
         /* Post all rpi memory regions to the port. */
         lpfc_resume_rpi(mboxq, ndlp);
+        if (cmpl) {
+                mboxq->mbox_cmpl = cmpl;
+                mboxq->context1 = arg;
+                mboxq->context2 = ndlp;
+        } else
+                mboxq->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        mboxq->vport = ndlp->vport;
         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
         if (rc == MBX_NOT_FINISHED) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,