Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6

1 files changed, 196 insertions, 21 deletions

diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index e2c08c5d83fb..7b785ade8b07 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -886,6 +886,182 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
         return rc;
 }
 
+static void lpfc_sli_rsp_pointers_error(struct lpfc_hba * phba,
+                                        struct lpfc_sli_ring * pring)
+{
+        struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
+        /*
+         * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
+         * rsp ring <portRspMax>
+         */
+        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                        "%d:0312 Ring %d handler: portRspPut %d "
+                        "is bigger then rsp ring %d\n",
+                        phba->brd_no, pring->ringno,
+                        le32_to_cpu(pgp->rspPutInx),
+                        pring->numRiocb);
+
+        phba->hba_state = LPFC_HBA_ERROR;
+
+        /*
+         * All error attention handlers are posted to
+         * worker thread
+         */
+        phba->work_ha |= HA_ERATT;
+        phba->work_hs = HS_FFER3;
+        if (phba->work_wait)
+                wake_up(phba->work_wait);
+
+        return;
+}
+
+void lpfc_sli_poll_fcp_ring(struct lpfc_hba * phba)
+{
+        struct lpfc_sli      * psli   = &phba->sli;
+        struct lpfc_sli_ring * pring = &psli->ring[LPFC_FCP_RING];
+        IOCB_t *irsp = NULL;
+        IOCB_t *entry = NULL;
+        struct lpfc_iocbq *cmdiocbq = NULL;
+        struct lpfc_iocbq rspiocbq;
+        struct lpfc_pgp *pgp;
+        uint32_t status;
+        uint32_t portRspPut, portRspMax;
+        int type;
+        uint32_t rsp_cmpl = 0;
+        void __iomem *to_slim;
+        uint32_t ha_copy;
+
+        pring->stats.iocb_event++;
+
+        /* The driver assumes SLI-2 mode */
+        pgp =  &phba->slim2p->mbx.us.s2.port[pring->ringno];
+
+        /*
+         * The next available response entry should never exceed the maximum
+         * entries.  If it does, treat it as an adapter hardware error.
+         */
+        portRspMax = pring->numRiocb;
+        portRspPut = le32_to_cpu(pgp->rspPutInx);
+        if (unlikely(portRspPut >= portRspMax)) {
+                lpfc_sli_rsp_pointers_error(phba, pring);
+                return;
+        }
+
+        rmb();
+        while (pring->rspidx != portRspPut) {
+
+                entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx);
+
+                if (++pring->rspidx >= portRspMax)
+                        pring->rspidx = 0;
+
+                lpfc_sli_pcimem_bcopy((uint32_t *) entry,
+                                      (uint32_t *) &rspiocbq.iocb,
+                                      sizeof (IOCB_t));
+                irsp = &rspiocbq.iocb;
+                type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
+                pring->stats.iocb_rsp++;
+                rsp_cmpl++;
+
+                if (unlikely(irsp->ulpStatus)) {
+                        /* Rsp ring <ringno> error: IOCB */
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                                        "%d:0326 Rsp Ring %d error: IOCB Data: "
+                                        "x%x x%x x%x x%x x%x x%x x%x x%x\n",
+                                        phba->brd_no, pring->ringno,
+                                        irsp->un.ulpWord[0],
+                                        irsp->un.ulpWord[1],
+                                        irsp->un.ulpWord[2],
+                                        irsp->un.ulpWord[3],
+                                        irsp->un.ulpWord[4],
+                                        irsp->un.ulpWord[5],
+                                        *(((uint32_t *) irsp) + 6),
+                                        *(((uint32_t *) irsp) + 7));
+                }
+
+                switch (type) {
+                case LPFC_ABORT_IOCB:
+                case LPFC_SOL_IOCB:
+                        /*
+                         * Idle exchange closed via ABTS from port.  No iocb
+                         * resources need to be recovered.
+                         */
+                        if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
+                                printk(KERN_INFO "%s: IOCB cmd 0x%x processed."
+                                       " Skipping completion\n", __FUNCTION__,
+                                       irsp->ulpCommand);
+                                break;
+                        }
+
+                        cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
+                                                         &rspiocbq);
+                        if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
+                                (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
+                                                      &rspiocbq);
+                        }
+                        break;
+                default:
+                        if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
+                                char adaptermsg[LPFC_MAX_ADPTMSG];
+                                memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
+                                memcpy(&adaptermsg[0], (uint8_t *) irsp,
+                                       MAX_MSG_DATA);
+                                dev_warn(&((phba->pcidev)->dev), "lpfc%d: %s",
+                                         phba->brd_no, adaptermsg);
+                        } else {
+                                /* Unknown IOCB command */
+                                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                                "%d:0321 Unknown IOCB command "
+                                                "Data: x%x, x%x x%x x%x x%x\n",
+                                                phba->brd_no, type,
+                                                irsp->ulpCommand,
+                                                irsp->ulpStatus,
+                                                irsp->ulpIoTag,
+                                                irsp->ulpContext);
+                        }
+                        break;
+                }
+
+                /*
+                 * The response IOCB has been processed.  Update the ring
+                 * pointer in SLIM.  If the port response put pointer has not
+                 * been updated, sync the pgp->rspPutInx and fetch the new port
+                 * response put pointer.
+                 */
+                to_slim = phba->MBslimaddr +
+                        (SLIMOFF + (pring->ringno * 2) + 1) * 4;
+                writeb(pring->rspidx, to_slim);
+
+                if (pring->rspidx == portRspPut)
+                        portRspPut = le32_to_cpu(pgp->rspPutInx);
+        }
+
+        ha_copy = readl(phba->HAregaddr);
+        ha_copy >>= (LPFC_FCP_RING * 4);
+
+        if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
+                pring->stats.iocb_rsp_full++;
+                status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
+                writel(status, phba->CAregaddr);
+                readl(phba->CAregaddr);
+        }
+        if ((ha_copy & HA_R0CE_RSP) &&
+            (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
+                pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
+                pring->stats.iocb_cmd_empty++;
+
+                /* Force update of the local copy of cmdGetInx */
+                pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
+                lpfc_sli_resume_iocb(phba, pring);
+
+                if ((pring->lpfc_sli_cmd_available))
+                        (pring->lpfc_sli_cmd_available) (phba, pring);
+
+        }
+
+        return;
+}
+
 /*
  * This routine presumes LPFC_FCP_RING handling and doesn't bother
  * to check it explicitly.
@@ -917,24 +1093,7 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba,
         portRspMax = pring->numRiocb;
         portRspPut = le32_to_cpu(pgp->rspPutInx);
         if (unlikely(portRspPut >= portRspMax)) {
-                /*
-                 * Ring <ringno> handler: portRspPut <portRspPut> is bigger then
-                 * rsp ring <portRspMax>
-                 */
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "%d:0312 Ring %d handler: portRspPut %d "
-                                "is bigger then rsp ring %d\n",
-                                phba->brd_no, pring->ringno, portRspPut,
-                                portRspMax);
-
-                phba->hba_state = LPFC_HBA_ERROR;
-
-                /* All error attention handlers are posted to worker thread */
-                phba->work_ha |= HA_ERATT;
-                phba->work_hs = HS_FFER3;
-                if (phba->work_wait)
-                        wake_up(phba->work_wait);
-
+                lpfc_sli_rsp_pointers_error(phba, pring);
                 spin_unlock_irqrestore(phba->host->host_lock, iflag);
                 return 1;
         }
@@ -947,6 +1106,10 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba,
                  * network byte order and pci byte orders are different.
                  */
                 entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx);
+
+                if (++pring->rspidx >= portRspMax)
+                        pring->rspidx = 0;
+
                 lpfc_sli_pcimem_bcopy((uint32_t *) entry,
                                       (uint32_t *) &rspiocbq.iocb,
                                       sizeof (IOCB_t));
@@ -1020,9 +1183,6 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba,
                  * been updated, sync the pgp->rspPutInx and fetch the new port
                  * response put pointer.
                  */
-                if (++pring->rspidx >= portRspMax)
-                        pring->rspidx = 0;
-
                 to_slim = phba->MBslimaddr +
                         (SLIMOFF + (pring->ringno * 2) + 1) * 4;
                 writel(pring->rspidx, to_slim);
@@ -2615,6 +2775,7 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba,
         DECLARE_WAIT_QUEUE_HEAD(done_q);
         long timeleft, timeout_req = 0;
         int retval = IOCB_SUCCESS;
+        uint32_t creg_val;
 
         /*
          * If the caller has provided a response iocbq buffer, then context2
@@ -2630,6 +2791,13 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba,
         piocb->context_un.wait_queue = &done_q;
         piocb->iocb_flag &= ~LPFC_IO_WAKE;
 
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
+        }
+
         retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
         if (retval == IOCB_SUCCESS) {
                 timeout_req = timeout * HZ;
@@ -2663,6 +2831,13 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba,
                 retval = IOCB_ERROR;
         }
 
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
+        }
+
         if (prspiocbq)
                 piocb->context2 = NULL;