Lines Matching defs:phba
47 #define LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag) \
48 lpfc_printf_log(phba, \
53 phba->brd_no, \
55 phba->hba_state, \
69 lpfc_sli_get_iocbq(struct lpfc_hba * phba)
71 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
79 lpfc_sli_release_iocbq(struct lpfc_hba * phba, struct lpfc_iocbq * iocbq)
87 list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
169 lpfc_sli_ring_map(struct lpfc_hba * phba, LPFC_MBOXQ_t *pmb)
171 struct lpfc_sli *psli = &phba->sli;
176 phba->hba_state = LPFC_INIT_MBX_CMDS;
177 lpfc_config_ring(phba, i, pmb);
178 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
180 lpfc_printf_log(phba,
186 phba->brd_no,
190 phba->hba_state = LPFC_HBA_ERROR;
198 lpfc_sli_ringtxcmpl_put(struct lpfc_hba * phba,
204 mod_timer(&phba->els_tmofunc,
205 jiffies + HZ * (phba->fc_ratov << 1));
211 lpfc_sli_ringtx_get(struct lpfc_hba * phba, struct lpfc_sli_ring * pring)
231 lpfc_sli_next_iocb_slot (struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
233 struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
246 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
249 phba->brd_no, pring->ringno,
252 phba->hba_state = LPFC_HBA_ERROR;
257 phba->work_ha |= HA_ERATT;
258 phba->work_hs = HS_FFER3;
259 if (phba->work_wait)
260 wake_up(phba->work_wait);
275 lpfc_sli_next_iotag(struct lpfc_hba * phba, struct lpfc_iocbq * iocbq)
280 struct lpfc_sli *psli = &phba->sli;
283 spin_lock_irq(phba->host->host_lock);
288 spin_unlock_irq(phba->host->host_lock);
295 spin_unlock_irq(phba->host->host_lock);
301 spin_lock_irq(phba->host->host_lock);
310 spin_unlock_irq(phba->host->host_lock);
314 spin_unlock_irq(phba->host->host_lock);
325 spin_unlock_irq(phba->host->host_lock);
331 spin_unlock_irq(phba->host->host_lock);
333 lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
335 phba->brd_no, psli->last_iotag);
341 lpfc_sli_submit_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
362 lpfc_sli_ringtxcmpl_put(phba, pring, nextiocb);
364 lpfc_sli_release_iocbq(phba, nextiocb);
371 writel(pring->cmdidx, phba->MBslimaddr
376 lpfc_sli_update_full_ring(struct lpfc_hba * phba,
389 writel((CA_R0ATT|CA_R0CE_REQ) << (ringno*4), phba->CAregaddr);
390 readl(phba->CAregaddr); /* flush */
396 lpfc_sli_update_ring(struct lpfc_hba * phba,
405 writel(CA_R0ATT << (ringno * 4), phba->CAregaddr);
406 readl(phba->CAregaddr); /* flush */
410 lpfc_sli_resume_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring)
423 (phba->hba_state > LPFC_LINK_DOWN) &&
424 (pring->ringno != phba->sli.fcp_ring ||
425 phba->sli.sli_flag & LPFC_PROCESS_LA) &&
428 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
429 (nextiocb = lpfc_sli_ringtx_get(phba, pring)))
430 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
433 lpfc_sli_update_ring(phba, pring);
435 lpfc_sli_update_full_ring(phba, pring);
443 lpfc_sli_turn_on_ring(struct lpfc_hba * phba, int ringno)
445 struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[ringno];
448 if (phba->sli.ring[ringno].cmdringaddr) {
449 if (phba->sli.ring[ringno].flag & LPFC_STOP_IOCB_MBX) {
450 phba->sli.ring[ringno].flag &= ~LPFC_STOP_IOCB_MBX;
454 phba->sli.ring[ringno].local_getidx
456 spin_lock_irq(phba->host->host_lock);
457 lpfc_sli_resume_iocb(phba, &phba->sli.ring[ringno]);
458 spin_unlock_irq(phba->host->host_lock);
523 lpfc_sli_wake_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
539 lpfc_sli_def_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
548 lpfc_mbuf_free(phba, mp->virt, mp->phys);
556 if (!(phba->fc_flag & FC_UNLOADING) &&
561 lpfc_unreg_login(phba, rpi, pmb);
563 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
568 mempool_free( pmb, phba->mbox_mem_pool);
573 lpfc_sli_handle_mb_event(struct lpfc_hba * phba)
582 psli = &phba->sli;
584 if (!(phba->sli.sli_flag & LPFC_SLI2_ACTIVE)) {
588 phba->sli.slistat.mbox_event++;
591 if ((pmb = phba->sli.mbox_active)) {
593 mbox = &phba->slim2p->mbx;
610 lpfc_printf_log(phba,
615 phba->brd_no,
619 spin_lock_irq(phba->host->host_lock);
620 phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
621 spin_unlock_irq(phba->host->host_lock);
626 del_timer_sync(&phba->sli.mbox_tmo);
627 phba->work_hba_events &= ~WORKER_MBOX_TMO;
636 lpfc_printf_log(phba,
640 phba->brd_no,
642 phba->hba_state = LPFC_HBA_ERROR;
643 phba->work_hs = HS_FFER3;
644 lpfc_handle_eratt(phba);
648 phba->sli.mbox_active = NULL;
650 phba->sli.slistat.mbox_stat_err++;
653 lpfc_printf_log(phba,
658 phba->brd_no,
662 phba->hba_state);
665 spin_lock_irq(phba->host->host_lock);
666 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
667 spin_unlock_irq(phba->host->host_lock);
668 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
675 lpfc_printf_log(phba,
680 phba->brd_no,
695 pmb->mbox_cmpl(phba,pmb);
702 spin_lock_irq(phba->host->host_lock);
703 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
706 if ((pmb = lpfc_mbox_get(phba))) {
707 spin_unlock_irq(phba->host->host_lock);
708 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
711 pmb->mbox_cmpl(phba,pmb);
716 spin_unlock_irq(phba->host->host_lock);
718 for (i = 0; i < phba->sli.num_rings; i++)
719 lpfc_sli_turn_on_ring(phba, i);
727 lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
759 (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
773 (phba, pring, saveq);
783 lpfc_printf_log(phba,
788 phba->brd_no,
797 lpfc_sli_iocbq_lookup(struct lpfc_hba * phba,
806 if (iotag != 0 && iotag <= phba->sli.last_iotag) {
807 cmd_iocb = phba->sli.iocbq_lookup[iotag];
813 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
816 phba->brd_no, iotag,
817 phba->sli.last_iotag,
823 lpfc_sli_process_sol_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
831 spin_lock_irqsave(phba->host->host_lock, iflag);
832 cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring, saveq);
848 spin_unlock_irqrestore(phba->host->host_lock,
850 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
851 spin_lock_irqsave(phba->host->host_lock, iflag);
854 spin_unlock_irqrestore(phba->host->host_lock,
856 (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
857 spin_lock_irqsave(phba->host->host_lock, iflag);
860 lpfc_sli_release_iocbq(phba, cmdiocbp);
872 lpfc_printf_log(phba,
877 phba->brd_no,
887 spin_unlock_irqrestore(phba->host->host_lock, iflag);
891 static void lpfc_sli_rsp_pointers_error(struct lpfc_hba * phba,
894 struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
899 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
902 phba->brd_no, pring->ringno,
906 phba->hba_state = LPFC_HBA_ERROR;
912 phba->work_ha |= HA_ERATT;
913 phba->work_hs = HS_FFER3;
914 if (phba->work_wait)
915 wake_up(phba->work_wait);
920 void lpfc_sli_poll_fcp_ring(struct lpfc_hba * phba)
922 struct lpfc_sli * psli = &phba->sli;
939 pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
948 lpfc_sli_rsp_pointers_error(phba, pring);
970 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
973 phba->brd_no, pring->ringno,
992 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
995 " completion", phba->brd_no,
1000 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1003 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1013 dev_warn(&((phba->pcidev)->dev), "lpfc%d: %s",
1014 phba->brd_no, adaptermsg);
1017 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1020 phba->brd_no, type,
1035 to_slim = phba->MBslimaddr +
1043 ha_copy = readl(phba->HAregaddr);
1049 writel(status, phba->CAregaddr);
1050 readl(phba->CAregaddr);
1059 lpfc_sli_resume_iocb(phba, pring);
1062 (pring->lpfc_sli_cmd_available) (phba, pring);
1074 lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba,
1077 struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
1090 spin_lock_irqsave(phba->host->host_lock, iflag);
1100 lpfc_sli_rsp_pointers_error(phba, pring);
1101 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1129 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1132 phba->brd_no, pring->ringno,
1148 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1151 " completion\n", phba->brd_no,
1156 cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
1159 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1160 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1164 phba->host->host_lock, iflag);
1165 (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
1167 spin_lock_irqsave(phba->host->host_lock,
1173 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1174 lpfc_sli_process_unsol_iocb(phba, pring, &rspiocbq);
1175 spin_lock_irqsave(phba->host->host_lock, iflag);
1183 dev_warn(&((phba->pcidev)->dev), "lpfc%d: %s",
1184 phba->brd_no, adaptermsg);
1187 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1190 phba->brd_no, type, irsp->ulpCommand,
1203 to_slim = phba->MBslimaddr +
1214 writel(status, phba->CAregaddr);
1215 readl(phba->CAregaddr);
1223 lpfc_sli_resume_iocb(phba, pring);
1226 (pring->lpfc_sli_cmd_available) (phba, pring);
1230 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1236 lpfc_sli_handle_slow_ring_event(struct lpfc_hba * phba,
1245 struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno];
1254 spin_lock_irqsave(phba->host->host_lock, iflag);
1268 lpfc_printf_log(phba,
1273 phba->brd_no,
1276 phba->hba_state = LPFC_HBA_ERROR;
1277 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1279 phba->work_hs = HS_FFER3;
1280 lpfc_handle_eratt(phba);
1301 rspiocbp = lpfc_sli_get_iocbq(phba);
1314 to_slim = phba->MBslimaddr + (SLIMOFF + (pring->ringno * 2)
1342 lpfc_printf_log(phba,
1347 phba->brd_no,
1368 spin_unlock_irqrestore(phba->host->host_lock,
1370 rc = lpfc_sli_process_sol_iocb(phba, pring,
1372 spin_lock_irqsave(phba->host->host_lock, iflag);
1374 spin_unlock_irqrestore(phba->host->host_lock,
1376 rc = lpfc_sli_process_unsol_iocb(phba, pring,
1378 spin_lock_irqsave(phba->host->host_lock, iflag);
1382 lpfc_sli_iocbq_lookup(phba, pring,
1388 phba->host->host_lock,
1390 (cmdiocbp->iocb_cmpl) (phba,
1393 phba->host->host_lock,
1396 lpfc_sli_release_iocbq(phba,
1408 dev_warn(&((phba->pcidev)->dev),
1410 phba->brd_no, adaptermsg);
1413 lpfc_printf_log(phba,
1418 phba->brd_no,
1433 lpfc_sli_release_iocbq(phba,
1437 lpfc_sli_release_iocbq(phba, saveq);
1456 writel(status, phba->CAregaddr);
1457 readl(phba->CAregaddr); /* flush */
1465 lpfc_sli_resume_iocb(phba, pring);
1468 (pring->lpfc_sli_cmd_available) (phba, pring);
1472 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1477 lpfc_sli_abort_iocb_ring(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
1489 spin_lock_irq(phba->host->host_lock);
1495 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
1497 spin_unlock_irq(phba->host->host_lock);
1507 (iocb->iocb_cmpl) (phba, iocb, iocb);
1509 lpfc_sli_release_iocbq(phba, iocb);
1516 lpfc_sli_brdready(struct lpfc_hba * phba, uint32_t mask)
1523 status = readl(phba->HSregaddr);
1543 phba->hba_state = LPFC_STATE_UNKNOWN; /* Do post */
1544 lpfc_sli_brdrestart(phba);
1547 status = readl(phba->HSregaddr);
1552 phba->hba_state = LPFC_HBA_ERROR;
1561 void lpfc_reset_barrier(struct lpfc_hba * phba)
1570 pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype);
1572 (FC_JEDEC_ID(phba->vpd.rev.biuRev) != HELIOS_JEDEC_ID &&
1573 FC_JEDEC_ID(phba->vpd.rev.biuRev) != THOR_JEDEC_ID))
1580 resp_buf = phba->MBslimaddr;
1583 hc_copy = readl(phba->HCregaddr);
1584 writel((hc_copy & ~HC_ERINT_ENA), phba->HCregaddr);
1585 readl(phba->HCregaddr); /* flush */
1586 phba->fc_flag |= FC_IGNORE_ERATT;
1588 if (readl(phba->HAregaddr) & HA_ERATT) {
1590 writel(HA_ERATT, phba->HAregaddr);
1591 phba->stopped = 1;
1599 mbox_buf = phba->MBslimaddr;
1607 if (phba->sli.sli_flag & LPFC_SLI2_ACTIVE ||
1608 phba->stopped)
1620 while (!(readl(phba->HAregaddr) & HA_ERATT) && ++i < 500)
1623 if (readl(phba->HAregaddr) & HA_ERATT) {
1624 writel(HA_ERATT, phba->HAregaddr);
1625 phba->stopped = 1;
1629 phba->fc_flag &= ~FC_IGNORE_ERATT;
1630 writel(hc_copy, phba->HCregaddr);
1631 readl(phba->HCregaddr); /* flush */
1635 lpfc_sli_brdkill(struct lpfc_hba * phba)
1644 psli = &phba->sli;
1647 lpfc_printf_log(phba,
1651 phba->brd_no,
1652 phba->hba_state,
1655 if ((pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
1660 spin_lock_irq(phba->host->host_lock);
1661 status = readl(phba->HCregaddr);
1663 writel(status, phba->HCregaddr);
1664 readl(phba->HCregaddr); /* flush */
1665 phba->fc_flag |= FC_IGNORE_ERATT;
1666 spin_unlock_irq(phba->host->host_lock);
1668 lpfc_kill_board(phba, pmb);
1670 retval = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
1674 mempool_free(pmb, phba->mbox_mem_pool);
1675 spin_lock_irq(phba->host->host_lock);
1676 phba->fc_flag &= ~FC_IGNORE_ERATT;
1677 spin_unlock_irq(phba->host->host_lock);
1683 mempool_free(pmb, phba->mbox_mem_pool);
1690 ha_copy = readl(phba->HAregaddr);
1694 ha_copy = readl(phba->HAregaddr);
1699 writel(HA_ERATT, phba->HAregaddr);
1700 phba->stopped = 1;
1702 spin_lock_irq(phba->host->host_lock);
1704 phba->fc_flag &= ~FC_IGNORE_ERATT;
1705 spin_unlock_irq(phba->host->host_lock);
1708 lpfc_hba_down_post(phba);
1709 phba->hba_state = LPFC_HBA_ERROR;
1715 lpfc_sli_brdreset(struct lpfc_hba * phba)
1722 psli = &phba->sli;
1725 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1726 "%d:0325 Reset HBA Data: x%x x%x\n", phba->brd_no,
1727 phba->hba_state, psli->sli_flag);
1730 phba->fc_eventTag = 0;
1731 phba->fc_myDID = 0;
1732 phba->fc_prevDID = 0;
1735 pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value);
1736 pci_write_config_word(phba->pcidev, PCI_COMMAND,
1742 writel(HC_INITFF, phba->HCregaddr);
1744 readl(phba->HCregaddr); /* flush */
1745 writel(0, phba->HCregaddr);
1746 readl(phba->HCregaddr); /* flush */
1749 pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
1762 phba->hba_state = LPFC_WARM_START;
1767 lpfc_sli_brdrestart(struct lpfc_hba * phba)
1775 spin_lock_irq(phba->host->host_lock);
1777 psli = &phba->sli;
1780 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
1781 "%d:0337 Restart HBA Data: x%x x%x\n", phba->brd_no,
1782 phba->hba_state, psli->sli_flag);
1789 lpfc_reset_barrier(phba);
1791 to_slim = phba->MBslimaddr;
1796 if (phba->hba_state) {
1803 to_slim = phba->MBslimaddr + sizeof (uint32_t);
1807 lpfc_sli_brdreset(phba);
1808 phba->stopped = 0;
1809 phba->hba_state = LPFC_INIT_START;
1811 spin_unlock_irq(phba->host->host_lock);
1821 lpfc_hba_down_post(phba);
1827 lpfc_sli_chipset_init(struct lpfc_hba *phba)
1832 status = readl(phba->HSregaddr);
1845 lpfc_printf_log(phba,
1850 phba->brd_no,
1852 phba->hba_state = LPFC_HBA_ERROR;
1861 lpfc_printf_log(phba,
1866 phba->brd_no,
1868 phba->hba_state = LPFC_HBA_ERROR;
1881 phba->hba_state = LPFC_STATE_UNKNOWN; /* Do post */
1882 lpfc_sli_brdrestart(phba);
1885 status = readl(phba->HSregaddr);
1892 lpfc_printf_log(phba,
1897 phba->brd_no,
1899 phba->hba_state = LPFC_HBA_ERROR;
1904 writel(0, phba->HCregaddr);
1905 readl(phba->HCregaddr); /* flush */
1908 writel(0xffffffff, phba->HAregaddr);
1909 readl(phba->HAregaddr); /* flush */
1914 lpfc_sli_hba_setup(struct lpfc_hba * phba)
1919 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1921 phba->hba_state = LPFC_HBA_ERROR;
1926 spin_lock_irq(phba->host->host_lock);
1927 phba->sli.sli_flag |= LPFC_SLI_MBOX_ACTIVE;
1928 spin_unlock_irq(phba->host->host_lock);
1929 phba->hba_state = LPFC_STATE_UNKNOWN;
1930 lpfc_sli_brdrestart(phba);
1932 rc = lpfc_sli_chipset_init(phba);
1936 spin_lock_irq(phba->host->host_lock);
1937 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
1938 spin_unlock_irq(phba->host->host_lock);
1946 rc = lpfc_config_port_prep(phba);
1948 phba->hba_state = 0;
1954 phba->hba_state = LPFC_INIT_MBX_CMDS;
1955 lpfc_config_port(phba, pmb);
1956 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
1960 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1963 phba->brd_no, pmb->mb.mbxCommand,
1965 phba->sli.sli_flag &= ~LPFC_SLI2_ACTIVE;
1971 rc = lpfc_sli_ring_map(phba, pmb);
1976 phba->sli.sli_flag |= LPFC_PROCESS_LA;
1978 rc = lpfc_config_port_post(phba);
1984 phba->hba_state = LPFC_HBA_ERROR;
1986 mempool_free(pmb, phba->mbox_mem_pool);
2006 struct lpfc_hba *phba;
2009 phba = (struct lpfc_hba *)ptr;
2010 spin_lock_irqsave(phba->host->host_lock, iflag);
2011 if (!(phba->work_hba_events & WORKER_MBOX_TMO)) {
2012 phba->work_hba_events |= WORKER_MBOX_TMO;
2013 if (phba->work_wait)
2014 wake_up(phba->work_wait);
2016 spin_unlock_irqrestore(phba->host->host_lock, iflag);
2020 lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
2024 struct lpfc_sli *psli = &phba->sli;
2027 spin_lock_irq(phba->host->host_lock);
2028 if (!(phba->work_hba_events & WORKER_MBOX_TMO)) {
2029 spin_unlock_irq(phba->host->host_lock);
2033 pmbox = phba->sli.mbox_active;
2037 lpfc_printf_log(phba,
2041 phba->brd_no,
2043 phba->hba_state,
2044 phba->sli.sli_flag,
2045 phba->sli.mbox_active);
2051 phba->hba_state = LPFC_STATE_UNKNOWN;
2052 phba->work_hba_events &= ~WORKER_MBOX_TMO;
2053 phba->fc_flag |= FC_ESTABLISH_LINK;
2055 spin_unlock_irq(phba->host->host_lock);
2058 lpfc_sli_abort_iocb_ring(phba, pring);
2060 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
2062 phba->brd_no);
2067 lpfc_offline_prep(phba);
2068 lpfc_offline(phba);
2069 lpfc_sli_brdrestart(phba);
2070 if (lpfc_online(phba) == 0) /* Initialize the HBA */
2071 mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);
2072 lpfc_unblock_mgmt_io(phba);
2077 lpfc_sli_issue_mbox(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmbox, uint32_t flag)
2089 if (unlikely(pci_channel_offline(phba->pcidev)))
2092 psli = &phba->sli;
2094 spin_lock_irqsave(phba->host->host_lock, drvr_flag);
2100 if (phba->hba_state == LPFC_HBA_ERROR) {
2101 spin_unlock_irqrestore(phba->host->host_lock, drvr_flag);
2104 LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2109 !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
2110 spin_unlock_irqrestore(phba->host->host_lock, drvr_flag);
2111 LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2122 spin_unlock_irqrestore(phba->host->host_lock,
2126 LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2131 spin_unlock_irqrestore(phba->host->host_lock,
2134 LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag)
2156 lpfc_mbox_put(phba, pmbox);
2159 lpfc_printf_log(phba,
2163 phba->brd_no,
2165 phba->hba_state,
2170 spin_unlock_irqrestore(phba->host->host_lock,
2200 spin_unlock_irqrestore(phba->host->host_lock,
2203 LOG_MBOX_CANNOT_ISSUE_DATA( phba, mb, psli, flag);
2208 (HZ * lpfc_mbox_tmo_val(phba, mb->mbxCommand))));
2212 lpfc_printf_log(phba,
2216 phba->brd_no,
2218 phba->hba_state,
2230 lpfc_sli_pcimem_bcopy(mb, &phba->slim2p->mbx, MAILBOX_CMD_SIZE);
2234 lpfc_sli_pcimem_bcopy(mb, &phba->slim2p->mbx,
2240 to_slim = phba->MBslimaddr + sizeof (uint32_t);
2246 to_slim = phba->MBslimaddr;
2258 writel(CA_MBATT, phba->CAregaddr);
2259 readl(phba->CAregaddr); /* flush */
2271 word0 = *((volatile uint32_t *)&phba->slim2p->mbx);
2275 word0 = readl(phba->MBslimaddr);
2279 ha_copy = readl(phba->HAregaddr);
2281 i = lpfc_mbox_tmo_val(phba, mb->mbxCommand);
2287 (phba->hba_state > LPFC_WARM_START))) {
2290 spin_unlock_irqrestore(phba->host->host_lock,
2301 spin_unlock_irqrestore(phba->host->host_lock,
2306 spin_lock_irqsave(phba->host->host_lock, drvr_flag);
2311 &phba->slim2p->mbx);
2317 slimword0 = readl(phba->MBslimaddr);
2328 word0 = readl(phba->MBslimaddr);
2331 ha_copy = readl(phba->HAregaddr);
2336 lpfc_sli_pcimem_bcopy(&phba->slim2p->mbx, mb,
2340 lpfc_memcpy_from_slim(mb, phba->MBslimaddr,
2345 phba->MBslimaddr + DMP_RSP_OFFSET,
2350 writel(HA_MBATT, phba->HAregaddr);
2351 readl(phba->HAregaddr); /* flush */
2357 spin_unlock_irqrestore(phba->host->host_lock, drvr_flag);
2362 lpfc_sli_ringtx_put(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
2372 lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2377 nextiocb = lpfc_sli_ringtx_get(phba, pring);
2387 lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2394 if (unlikely(pci_channel_offline(phba->pcidev)))
2400 if (unlikely(phba->hba_state < LPFC_LINK_DOWN))
2410 if (unlikely(phba->hba_state == LPFC_LINK_DOWN)) {
2437 } else if (unlikely(pring->ringno == phba->sli.fcp_ring &&
2438 !(phba->sli.sli_flag & LPFC_PROCESS_LA)))
2441 while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&
2442 (nextiocb = lpfc_sli_next_iocb(phba, pring, &piocb)))
2443 lpfc_sli_submit_iocb(phba, pring, iocb, nextiocb);
2446 lpfc_sli_update_ring(phba, pring);
2448 lpfc_sli_update_full_ring(phba, pring);
2461 lpfc_sli_ringtx_put(phba, pring, piocb);
2469 lpfc_extra_ring_setup( struct lpfc_hba *phba)
2474 psli = &phba->sli;
2497 pring->prt[0].rctl = phba->cfg_multi_ring_rctl;
2498 pring->prt[0].type = phba->cfg_multi_ring_type;
2504 lpfc_sli_setup(struct lpfc_hba *phba)
2507 struct lpfc_sli *psli = &phba->sli;
2533 (phba->cfg_hba_queue_depth * 2);
2581 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2584 phba->brd_no, totiocb, MAX_SLI2_IOCB);
2586 if (phba->cfg_multi_ring_support == 2)
2587 lpfc_extra_ring_setup(phba);
2593 lpfc_sli_queue_setup(struct lpfc_hba * phba)
2599 psli = &phba->sli;
2600 spin_lock_irq(phba->host->host_lock);
2614 spin_unlock_irq(phba->host->host_lock);
2619 lpfc_sli_hba_down(struct lpfc_hba * phba)
2630 psli = &phba->sli;
2631 lpfc_hba_down_prep(phba);
2633 spin_lock_irqsave(phba->host->host_lock, flags);
2646 spin_unlock_irqrestore(phba->host->host_lock, flags);
2656 (iocb->iocb_cmpl) (phba, iocb, iocb);
2658 lpfc_sli_release_iocbq(phba, iocb);
2663 spin_lock_irqsave(phba->host->host_lock, flags);
2664 phba->work_hba_events &= ~WORKER_MBOX_TMO;
2669 spin_unlock_irqrestore(phba->host->host_lock, flags);
2670 pmb->mbox_cmpl(phba,pmb);
2671 spin_lock_irqsave(phba->host->host_lock, flags);
2678 while ((pmb = lpfc_mbox_get(phba)) != NULL) {
2681 spin_unlock_irqrestore(phba->host->host_lock, flags);
2682 pmb->mbox_cmpl(phba,pmb);
2683 spin_lock_irqsave(phba->host->host_lock, flags);
2689 spin_unlock_irqrestore(phba->host->host_lock, flags);
2712 lpfc_sli_ringpostbuf_put(struct lpfc_hba * phba, struct lpfc_sli_ring * pring,
2725 lpfc_sli_ringpostbuf_get(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2740 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2743 phba->brd_no, pring->ringno, (unsigned long long)phys,
2749 lpfc_sli_abort_els_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2755 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
2760 spin_lock_irq(phba->host->host_lock);
2766 if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
2767 abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
2769 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2772 phba->brd_no, abort_iocb,
2785 rsp_ab_iocb = lpfc_sli_get_iocbq(phba);
2787 lpfc_sli_release_iocbq(phba, abort_iocb);
2795 spin_unlock_irq(phba->host->host_lock);
2797 (phba, abort_iocb, rsp_ab_iocb);
2798 spin_lock_irq(phba->host->host_lock);
2799 lpfc_sli_release_iocbq(phba, rsp_ab_iocb);
2804 lpfc_sli_release_iocbq(phba, cmdiocb);
2805 spin_unlock_irq(phba->host->host_lock);
2810 lpfc_sli_issue_abort_iotag(struct lpfc_hba * phba,
2830 if (phba->fc_flag & FC_UNLOADING)
2834 abtsiocbp = lpfc_sli_get_iocbq(phba);
2850 if (phba->hba_state >= LPFC_LINK_UP)
2857 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
2860 phba->brd_no, iabt->un.acxri.abortContextTag,
2862 retval = lpfc_sli_issue_iocb(phba, pring, abtsiocbp, 0);
2876 spin_unlock_irq(phba->host->host_lock);
2877 (cmdiocb->iocb_cmpl) (phba, cmdiocb, cmdiocb);
2878 spin_lock_irq(phba->host->host_lock);
2880 lpfc_sli_release_iocbq(phba, cmdiocb);
2931 lpfc_sli_sum_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2937 for (i = 1, sum = 0; i <= phba->sli.last_iotag; i++) {
2938 iocbq = phba->sli.iocbq_lookup[i];
2949 lpfc_sli_abort_fcp_cmpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2954 spin_lock_irqsave(phba->host->host_lock, iflags);
2955 lpfc_sli_release_iocbq(phba, cmdiocb);
2956 spin_unlock_irqrestore(phba->host->host_lock, iflags);
2961 lpfc_sli_abort_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2971 for (i = 1; i <= phba->sli.last_iotag; i++) {
2972 iocbq = phba->sli.iocbq_lookup[i];
2979 abtsiocb = lpfc_sli_get_iocbq(phba);
2992 if (phba->hba_state >= LPFC_LINK_UP)
2999 ret_val = lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0);
3001 lpfc_sli_release_iocbq(phba, abtsiocb);
3011 lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
3018 spin_lock_irqsave(phba->host->host_lock, iflags);
3025 spin_unlock_irqrestore(phba->host->host_lock, iflags);
3038 lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba,
3063 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
3064 creg_val = readl(phba->HCregaddr);
3066 writel(creg_val, phba->HCregaddr);
3067 readl(phba->HCregaddr); /* flush */
3070 retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0);
3073 spin_unlock_irq(phba->host->host_lock);
3077 spin_lock_irq(phba->host->host_lock);
3080 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3082 phba->brd_no);
3084 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3087 phba->brd_no, timeout);
3090 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3092 "Data x%x x%lx\n", phba->brd_no,
3097 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3099 phba->brd_no, retval);
3103 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
3104 creg_val = readl(phba->HCregaddr);
3106 writel(creg_val, phba->HCregaddr);
3107 readl(phba->HCregaddr); /* flush */
3119 lpfc_sli_issue_mbox_wait(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq,
3136 retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
3158 lpfc_sli_flush_mbox_queue(struct lpfc_hba * phba)
3162 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE && !phba->stopped) {
3166 if (lpfc_sli_handle_mb_event(phba) == 0)
3172 return (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) ? 1 : 0;
3178 struct lpfc_hba *phba;
3186 * Get the driver's phba structure from the dev_id and
3189 phba = (struct lpfc_hba *) dev_id;
3191 if (unlikely(!phba))
3195 if (unlikely(pci_channel_offline(phba->pcidev)))
3198 phba->sli.slistat.sli_intr++;
3206 if (unlikely(phba->hba_state < LPFC_LINK_DOWN))
3214 spin_lock(phba->host->host_lock);
3215 ha_copy = readl(phba->HAregaddr);
3219 if (phba->fc_flag & FC_IGNORE_ERATT)
3221 writel((ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
3222 readl(phba->HAregaddr); /* flush */
3223 spin_unlock(phba->host->host_lock);
3228 work_ha_copy = ha_copy & phba->work_ha_mask;
3232 if (phba->sli.sli_flag & LPFC_PROCESS_LA) {
3237 spin_lock(phba->host->host_lock);
3238 phba->sli.sli_flag &= ~LPFC_PROCESS_LA;
3239 control = readl(phba->HCregaddr);
3241 writel(control, phba->HCregaddr);
3242 readl(phba->HCregaddr); /* flush */
3243 spin_unlock(phba->host->host_lock);
3250 for (i = 0; i < phba->sli.num_rings; i++) {
3255 spin_lock(phba->host->host_lock);
3256 control = readl(phba->HCregaddr);
3258 writel(control, phba->HCregaddr);
3259 readl(phba->HCregaddr); /* flush */
3260 spin_unlock(phba->host->host_lock);
3266 phba->hba_state = LPFC_HBA_ERROR;
3272 phba->sli.slistat.err_attn_event++;
3274 phba->work_hs = readl(phba->HSregaddr);
3275 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
3276 phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
3279 writel(HA_ERATT, phba->HAregaddr);
3280 readl(phba->HAregaddr); /* flush */
3281 phba->stopped = 1;
3284 spin_lock(phba->host->host_lock);
3285 phba->work_ha |= work_ha_copy;
3286 if (phba->work_wait)
3287 wake_up(phba->work_wait);
3288 spin_unlock(phba->host->host_lock);
3291 ha_copy &= ~(phba->work_ha_mask);
3301 lpfc_sli_handle_fast_ring_event(phba,
3302 &phba->sli.ring[LPFC_FCP_RING],
3305 if (phba->cfg_multi_ring_support == 2) {
3314 lpfc_sli_handle_fast_ring_event(phba,
3315 &phba->sli.ring[LPFC_EXTRA_RING],