[SCSI] lpfc 8.3.22: Add support for PCI Adapter Failure

Periodically poll adapter registers to detect pci adapter failure
(reads return -1). On failure, take port offline, set error indicators
and wake up worker threads. Threads will take adapter offline.

Signed-off-by: Alex Iannicelli <alex.iannicelli@emulex.com>
Signed-off-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>

1 files changed, 138 insertions, 46 deletions

diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 84234a4c54ce..3218c184be6f 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -3477,7 +3477,8 @@ lpfc_sli_brdready_s3(struct lpfc_hba *phba, uint32_t mask)
         int retval = 0;
 
         /* Read the HBA Host Status Register */
-        status = readl(phba->HSregaddr);
+        if (lpfc_readl(phba->HSregaddr, &status))
+                return 1;
 
         /*
          * Check status register every 100ms for 5 retries, then every
@@ -3502,7 +3503,10 @@ lpfc_sli_brdready_s3(struct lpfc_hba *phba, uint32_t mask)
                         lpfc_sli_brdrestart(phba);
                 }
                 /* Read the HBA Host Status Register */
-                status = readl(phba->HSregaddr);
+                if (lpfc_readl(phba->HSregaddr, &status)) {
+                        retval = 1;
+                        break;
+                }
         }
 
         /* Check to see if any errors occurred during init */
@@ -3584,7 +3588,7 @@ void lpfc_reset_barrier(struct lpfc_hba *phba)
         uint32_t __iomem *resp_buf;
         uint32_t __iomem *mbox_buf;
         volatile uint32_t mbox;
-        uint32_t hc_copy;
+        uint32_t hc_copy, ha_copy, resp_data;
         int  i;
         uint8_t hdrtype;
 
@@ -3601,12 +3605,15 @@ void lpfc_reset_barrier(struct lpfc_hba *phba)
         resp_buf = phba->MBslimaddr;
 
         /* Disable the error attention */
-        hc_copy = readl(phba->HCregaddr);
+        if (lpfc_readl(phba->HCregaddr, &hc_copy))
+                return;
         writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
         readl(phba->HCregaddr); /* flush */
         phba->link_flag |= LS_IGNORE_ERATT;
 
-        if (readl(phba->HAregaddr) & HA_ERATT) {
+        if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                return;
+        if (ha_copy & HA_ERATT) {
                 /* Clear Chip error bit */
                 writel(HA_ERATT, phba->HAregaddr);
                 phba->pport->stopped = 1;
@@ -3620,11 +3627,18 @@ void lpfc_reset_barrier(struct lpfc_hba *phba)
         mbox_buf = phba->MBslimaddr;
         writel(mbox, mbox_buf);
 
-        for (i = 0;
-             readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN) && i < 50; i++)
-                mdelay(1);
-
-        if (readl(resp_buf + 1) != ~(BARRIER_TEST_PATTERN)) {
+        for (i = 0; i < 50; i++) {
+                if (lpfc_readl((resp_buf + 1), &resp_data))
+                        return;
+                if (resp_data != ~(BARRIER_TEST_PATTERN))
+                        mdelay(1);
+                else
+                        break;
+        }
+        resp_data = 0;
+        if (lpfc_readl((resp_buf + 1), &resp_data))
+                return;
+        if (resp_data  != ~(BARRIER_TEST_PATTERN)) {
                 if (phba->sli.sli_flag & LPFC_SLI_ACTIVE ||
                     phba->pport->stopped)
                         goto restore_hc;
@@ -3633,13 +3647,26 @@ void lpfc_reset_barrier(struct lpfc_hba *phba)
         }
 
         ((MAILBOX_t *)&mbox)->mbxOwner = OWN_HOST;
-        for (i = 0; readl(resp_buf) != mbox &&  i < 500; i++)
-                mdelay(1);
+        resp_data = 0;
+        for (i = 0; i < 500; i++) {
+                if (lpfc_readl(resp_buf, &resp_data))
+                        return;
+                if (resp_data != mbox)
+                        mdelay(1);
+                else
+                        break;
+        }
 
 clear_errat:
 
-        while (!(readl(phba->HAregaddr) & HA_ERATT) && ++i < 500)
-                mdelay(1);
+        while (++i < 500) {
+                if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                        return;
+                if (!(ha_copy & HA_ERATT))
+                        mdelay(1);
+                else
+                        break;
+        }
 
         if (readl(phba->HAregaddr) & HA_ERATT) {
                 writel(HA_ERATT, phba->HAregaddr);
@@ -3686,7 +3713,11 @@ lpfc_sli_brdkill(struct lpfc_hba *phba)
 
         /* Disable the error attention */
         spin_lock_irq(&phba->hbalock);
-        status = readl(phba->HCregaddr);
+        if (lpfc_readl(phba->HCregaddr, &status)) {
+                spin_unlock_irq(&phba->hbalock);
+                mempool_free(pmb, phba->mbox_mem_pool);
+                return 1;
+        }
         status &= ~HC_ERINT_ENA;
         writel(status, phba->HCregaddr);
         readl(phba->HCregaddr); /* flush */
@@ -3720,11 +3751,12 @@ lpfc_sli_brdkill(struct lpfc_hba *phba)
          * 3 seconds we still set HBA_ERROR state because the status of the
          * board is now undefined.
          */
-        ha_copy = readl(phba->HAregaddr);
-
+        if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                return 1;
         while ((i++ < 30) && !(ha_copy & HA_ERATT)) {
                 mdelay(100);
-                ha_copy = readl(phba->HAregaddr);
+                if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                        return 1;
         }
 
         del_timer_sync(&psli->mbox_tmo);
@@ -4018,7 +4050,8 @@ lpfc_sli_chipset_init(struct lpfc_hba *phba)
         uint32_t status, i = 0;
 
         /* Read the HBA Host Status Register */
-        status = readl(phba->HSregaddr);
+        if (lpfc_readl(phba->HSregaddr, &status))
+                return -EIO;
 
         /* Check status register to see what current state is */
         i = 0;
@@ -4073,7 +4106,8 @@ lpfc_sli_chipset_init(struct lpfc_hba *phba)
                         lpfc_sli_brdrestart(phba);
                 }
                 /* Read the HBA Host Status Register */
-                status = readl(phba->HSregaddr);
+                if (lpfc_readl(phba->HSregaddr, &status))
+                        return -EIO;
         }
 
         /* Check to see if any errors occurred during init */
@@ -5136,7 +5170,7 @@ lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
         MAILBOX_t *mb;
         struct lpfc_sli *psli = &phba->sli;
         uint32_t status, evtctr;
-        uint32_t ha_copy;
+        uint32_t ha_copy, hc_copy;
         int i;
         unsigned long timeout;
         unsigned long drvr_flag = 0;
@@ -5202,15 +5236,17 @@ lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
                 goto out_not_finished;
         }
 
-        if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT &&
-            !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
-                spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+        if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT) {
+                if (lpfc_readl(phba->HCregaddr, &hc_copy) ||
+                        !(hc_copy & HC_MBINT_ENA)) {
+                        spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                                 "(%d):2528 Mailbox command x%x cannot "
                                 "issue Data: x%x x%x\n",
                                 pmbox->vport ? pmbox->vport->vpi : 0,
                                 pmbox->u.mb.mbxCommand, psli->sli_flag, flag);
-                goto out_not_finished;
+                        goto out_not_finished;
+                }
         }
 
         if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {
@@ -5408,11 +5444,19 @@ lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
                         word0 = le32_to_cpu(word0);
                 } else {
                         /* First read mbox status word */
-                        word0 = readl(phba->MBslimaddr);
+                        if (lpfc_readl(phba->MBslimaddr, &word0)) {
+                                spin_unlock_irqrestore(&phba->hbalock,
+                                                       drvr_flag);
+                                goto out_not_finished;
+                        }
                 }
 
                 /* Read the HBA Host Attention Register */
-                ha_copy = readl(phba->HAregaddr);
+                if (lpfc_readl(phba->HAregaddr, &ha_copy)) {
+                        spin_unlock_irqrestore(&phba->hbalock,
+                                                       drvr_flag);
+                        goto out_not_finished;
+                }
                 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
                                                              mb->mbxCommand) *
                                            1000) + jiffies;
@@ -5463,7 +5507,11 @@ lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
                                 word0 = readl(phba->MBslimaddr);
                         }
                         /* Read the HBA Host Attention Register */
-                        ha_copy = readl(phba->HAregaddr);
+                        if (lpfc_readl(phba->HAregaddr, &ha_copy)) {
+                                spin_unlock_irqrestore(&phba->hbalock,
+                                                       drvr_flag);
+                                goto out_not_finished;
+                        }
                 }
 
                 if (psli->sli_flag & LPFC_SLI_ACTIVE) {
@@ -8194,7 +8242,8 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
         piocb->iocb_flag &= ~LPFC_IO_WAKE;
 
         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
-                creg_val = readl(phba->HCregaddr);
+                if (lpfc_readl(phba->HCregaddr, &creg_val))
+                        return IOCB_ERROR;
                 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
                 writel(creg_val, phba->HCregaddr);
                 readl(phba->HCregaddr); /* flush */
@@ -8236,7 +8285,8 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
         }
 
         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
-                creg_val = readl(phba->HCregaddr);
+                if (lpfc_readl(phba->HCregaddr, &creg_val))
+                        return IOCB_ERROR;
                 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
                 writel(creg_val, phba->HCregaddr);
                 readl(phba->HCregaddr); /* flush */
@@ -8387,10 +8437,13 @@ lpfc_sli_eratt_read(struct lpfc_hba *phba)
         uint32_t ha_copy;
 
         /* Read chip Host Attention (HA) register */
-        ha_copy = readl(phba->HAregaddr);
+        if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                goto unplug_err;
+
         if (ha_copy & HA_ERATT) {
                 /* Read host status register to retrieve error event */
-                lpfc_sli_read_hs(phba);
+                if (lpfc_sli_read_hs(phba))
+                        goto unplug_err;
 
                 /* Check if there is a deferred error condition is active */
                 if ((HS_FFER1 & phba->work_hs) &&
@@ -8409,6 +8462,15 @@ lpfc_sli_eratt_read(struct lpfc_hba *phba)
                 return 1;
         }
         return 0;
+
+unplug_err:
+        /* Set the driver HS work bitmap */
+        phba->work_hs |= UNPLUG_ERR;
+        /* Set the driver HA work bitmap */
+        phba->work_ha |= HA_ERATT;
+        /* Indicate polling handles this ERATT */
+        phba->hba_flag |= HBA_ERATT_HANDLED;
+        return 1;
 }
 
 /**
@@ -8436,8 +8498,15 @@ lpfc_sli4_eratt_read(struct lpfc_hba *phba)
         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
         switch (if_type) {
         case LPFC_SLI_INTF_IF_TYPE_0:
-                uerr_sta_lo = readl(phba->sli4_hba.u.if_type0.UERRLOregaddr);
-                uerr_sta_hi = readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
+                if (lpfc_readl(phba->sli4_hba.u.if_type0.UERRLOregaddr,
+                        &uerr_sta_lo) ||
+                        lpfc_readl(phba->sli4_hba.u.if_type0.UERRHIregaddr,
+                        &uerr_sta_hi)) {
+                        phba->work_hs |= UNPLUG_ERR;
+                        phba->work_ha |= HA_ERATT;
+                        phba->hba_flag |= HBA_ERATT_HANDLED;
+                        return 1;
+                }
                 if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||
                     (~phba->sli4_hba.ue_mask_hi & uerr_sta_hi)) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8456,9 +8525,15 @@ lpfc_sli4_eratt_read(struct lpfc_hba *phba)
                 }
                 break;
         case LPFC_SLI_INTF_IF_TYPE_2:
-                portstat_reg.word0 =
-                        readl(phba->sli4_hba.u.if_type2.STATUSregaddr);
-                portsmphr = readl(phba->sli4_hba.PSMPHRregaddr);
+                if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
+                        &portstat_reg.word0) ||
+                        lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
+                        &portsmphr)){
+                        phba->work_hs |= UNPLUG_ERR;
+                        phba->work_ha |= HA_ERATT;
+                        phba->hba_flag |= HBA_ERATT_HANDLED;
+                        return 1;
+                }
                 if (bf_get(lpfc_sliport_status_err, &portstat_reg)) {
                         phba->work_status[0] =
                                 readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
@@ -8639,7 +8714,8 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                         return IRQ_NONE;
                 /* Need to read HA REG for slow-path events */
                 spin_lock_irqsave(&phba->hbalock, iflag);
-                ha_copy = readl(phba->HAregaddr);
+                if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                        goto unplug_error;
                 /* If somebody is waiting to handle an eratt don't process it
                  * here. The brdkill function will do this.
                  */
@@ -8665,7 +8741,9 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                 }
 
                 /* Clear up only attention source related to slow-path */
-                hc_copy = readl(phba->HCregaddr);
+                if (lpfc_readl(phba->HCregaddr, &hc_copy))
+                        goto unplug_error;
+
                 writel(hc_copy & ~(HC_MBINT_ENA | HC_R2INT_ENA |
                         HC_LAINT_ENA | HC_ERINT_ENA),
                         phba->HCregaddr);
@@ -8688,7 +8766,8 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                                  */
                                 spin_lock_irqsave(&phba->hbalock, iflag);
                                 phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
-                                control = readl(phba->HCregaddr);
+                                if (lpfc_readl(phba->HCregaddr, &control))
+                                        goto unplug_error;
                                 control &= ~HC_LAINT_ENA;
                                 writel(control, phba->HCregaddr);
                                 readl(phba->HCregaddr); /* flush */
@@ -8708,7 +8787,8 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                         status >>= (4*LPFC_ELS_RING);
                         if (status & HA_RXMASK) {
                                 spin_lock_irqsave(&phba->hbalock, iflag);
-                                control = readl(phba->HCregaddr);
+                                if (lpfc_readl(phba->HCregaddr, &control))
+                                        goto unplug_error;
 
                                 lpfc_debugfs_slow_ring_trc(phba,
                                 "ISR slow ring:   ctl:x%x stat:x%x isrcnt:x%x",
@@ -8741,7 +8821,8 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                 }
                 spin_lock_irqsave(&phba->hbalock, iflag);
                 if (work_ha_copy & HA_ERATT) {
-                        lpfc_sli_read_hs(phba);
+                        if (lpfc_sli_read_hs(phba))
+                                goto unplug_error;
                         /*
                          * Check if there is a deferred error condition
                          * is active
@@ -8872,6 +8953,9 @@ send_current_mbox:
                 lpfc_worker_wake_up(phba);
         }
         return IRQ_HANDLED;
+unplug_error:
+        spin_unlock_irqrestore(&phba->hbalock, iflag);
+        return IRQ_HANDLED;
 
 } /* lpfc_sli_sp_intr_handler */
 
@@ -8919,7 +9003,8 @@ lpfc_sli_fp_intr_handler(int irq, void *dev_id)
                 if (lpfc_intr_state_check(phba))
                         return IRQ_NONE;
                 /* Need to read HA REG for FCP ring and other ring events */
-                ha_copy = readl(phba->HAregaddr);
+                if (lpfc_readl(phba->HAregaddr, &ha_copy))
+                        return IRQ_HANDLED;
                 /* Clear up only attention source related to fast-path */
                 spin_lock_irqsave(&phba->hbalock, iflag);
                 /*
@@ -9004,7 +9089,11 @@ lpfc_sli_intr_handler(int irq, void *dev_id)
                 return IRQ_NONE;
 
         spin_lock(&phba->hbalock);
-        phba->ha_copy = readl(phba->HAregaddr);
+        if (lpfc_readl(phba->HAregaddr, &phba->ha_copy)) {
+                spin_unlock(&phba->hbalock);
+                return IRQ_HANDLED;
+        }
+
         if (unlikely(!phba->ha_copy)) {
                 spin_unlock(&phba->hbalock);
                 return IRQ_NONE;
@@ -9026,7 +9115,10 @@ lpfc_sli_intr_handler(int irq, void *dev_id)
         }
 
         /* Clear attention sources except link and error attentions */
-        hc_copy = readl(phba->HCregaddr);
+        if (lpfc_readl(phba->HCregaddr, &hc_copy)) {
+                spin_unlock(&phba->hbalock);
+                return IRQ_HANDLED;
+        }
         writel(hc_copy & ~(HC_MBINT_ENA | HC_R0INT_ENA | HC_R1INT_ENA
                 | HC_R2INT_ENA | HC_LAINT_ENA | HC_ERINT_ENA),
                 phba->HCregaddr);