aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorJames Smart <James.Smart@Emulex.Com>2009-05-22 14:50:54 -0400
committerJames Bottomley <James.Bottomley@HansenPartnership.com>2009-06-08 12:18:10 -0400
commit3772a99175f5378b5001e8da364341a8b8226a4a (patch)
treedd710f890c5bc097c874ad1783cd26ea56e88f57 /drivers
parenta366695592ebc9151dd5a248681270f0925d8324 (diff)
[SCSI] lpfc 8.3.2 : Reorganization for SLI4
Preps the organization of the driver so that the bottom half, which interacts with the hardware, can share common code sequences for attachment, detachment, initialization, teardown, etc with new hardware. For very common code sections, which become specific to the interface type, the driver uses an indirect function call. The function is set at initialization. For less common sections, such as initialization, the driver looks at the interface type and calls the routines relative to the interface. Signed-off-by: James Smart <james.smart@emulex.com> Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/scsi/lpfc/lpfc.h72
-rw-r--r--drivers/scsi/lpfc/lpfc_ct.c4
-rw-r--r--drivers/scsi/lpfc/lpfc_debugfs.c17
-rw-r--r--drivers/scsi/lpfc/lpfc_els.c84
-rw-r--r--drivers/scsi/lpfc/lpfc_hbadisc.c69
-rw-r--r--drivers/scsi/lpfc/lpfc_init.c1907
-rw-r--r--drivers/scsi/lpfc/lpfc_scsi.c446
-rw-r--r--drivers/scsi/lpfc/lpfc_sli.c1006
8 files changed, 2517 insertions, 1088 deletions
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 1105f9a111ba..6c24c9aabe7b 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -23,6 +23,13 @@
23 23
24struct lpfc_sli2_slim; 24struct lpfc_sli2_slim;
25 25
26#define LPFC_PCI_DEV_LP 0x1
27#define LPFC_PCI_DEV_OC 0x2
28
29#define LPFC_SLI_REV2 2
30#define LPFC_SLI_REV3 3
31#define LPFC_SLI_REV4 4
32
26#define LPFC_MAX_TARGET 4096 /* max number of targets supported */ 33#define LPFC_MAX_TARGET 4096 /* max number of targets supported */
27#define LPFC_MAX_DISC_THREADS 64 /* max outstanding discovery els 34#define LPFC_MAX_DISC_THREADS 64 /* max outstanding discovery els
28 requests */ 35 requests */
@@ -264,8 +271,8 @@ enum hba_state {
264}; 271};
265 272
266struct lpfc_vport { 273struct lpfc_vport {
267 struct list_head listentry;
268 struct lpfc_hba *phba; 274 struct lpfc_hba *phba;
275 struct list_head listentry;
269 uint8_t port_type; 276 uint8_t port_type;
270#define LPFC_PHYSICAL_PORT 1 277#define LPFC_PHYSICAL_PORT 1
271#define LPFC_NPIV_PORT 2 278#define LPFC_NPIV_PORT 2
@@ -420,8 +427,66 @@ enum intr_type_t {
420}; 427};
421 428
422struct lpfc_hba { 429struct lpfc_hba {
430 /* SCSI interface function jump table entries */
431 int (*lpfc_new_scsi_buf)
432 (struct lpfc_vport *, int);
433 struct lpfc_scsi_buf * (*lpfc_get_scsi_buf)
434 (struct lpfc_hba *);
435 int (*lpfc_scsi_prep_dma_buf)
436 (struct lpfc_hba *, struct lpfc_scsi_buf *);
437 void (*lpfc_scsi_unprep_dma_buf)
438 (struct lpfc_hba *, struct lpfc_scsi_buf *);
439 void (*lpfc_release_scsi_buf)
440 (struct lpfc_hba *, struct lpfc_scsi_buf *);
441 void (*lpfc_rampdown_queue_depth)
442 (struct lpfc_hba *);
443 void (*lpfc_scsi_prep_cmnd)
444 (struct lpfc_vport *, struct lpfc_scsi_buf *,
445 struct lpfc_nodelist *);
446 int (*lpfc_scsi_prep_task_mgmt_cmd)
447 (struct lpfc_vport *, struct lpfc_scsi_buf *,
448 unsigned int, uint8_t);
449
450 /* IOCB interface function jump table entries */
451 int (*__lpfc_sli_issue_iocb)
452 (struct lpfc_hba *, uint32_t,
453 struct lpfc_iocbq *, uint32_t);
454 void (*__lpfc_sli_release_iocbq)(struct lpfc_hba *,
455 struct lpfc_iocbq *);
456 int (*lpfc_hba_down_post)(struct lpfc_hba *phba);
457
458
459 IOCB_t * (*lpfc_get_iocb_from_iocbq)
460 (struct lpfc_iocbq *);
461 void (*lpfc_scsi_cmd_iocb_cmpl)
462 (struct lpfc_hba *, struct lpfc_iocbq *, struct lpfc_iocbq *);
463
464 /* MBOX interface function jump table entries */
465 int (*lpfc_sli_issue_mbox)
466 (struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t);
467 /* Slow-path IOCB process function jump table entries */
468 void (*lpfc_sli_handle_slow_ring_event)
469 (struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
470 uint32_t mask);
471 /* INIT device interface function jump table entries */
472 int (*lpfc_sli_hbq_to_firmware)
473 (struct lpfc_hba *, uint32_t, struct hbq_dmabuf *);
474 int (*lpfc_sli_brdrestart)
475 (struct lpfc_hba *);
476 int (*lpfc_sli_brdready)
477 (struct lpfc_hba *, uint32_t);
478 void (*lpfc_handle_eratt)
479 (struct lpfc_hba *);
480 void (*lpfc_stop_port)
481 (struct lpfc_hba *);
482
483
484 /* SLI4 specific HBA data structure */
485 struct lpfc_sli4_hba sli4_hba;
486
423 struct lpfc_sli sli; 487 struct lpfc_sli sli;
424 uint32_t sli_rev; /* SLI2 or SLI3 */ 488 uint8_t pci_dev_grp; /* lpfc PCI dev group: 0x0, 0x1, 0x2,... */
489 uint32_t sli_rev; /* SLI2, SLI3, or SLI4 */
425 uint32_t sli3_options; /* Mask of enabled SLI3 options */ 490 uint32_t sli3_options; /* Mask of enabled SLI3 options */
426#define LPFC_SLI3_HBQ_ENABLED 0x01 491#define LPFC_SLI3_HBQ_ENABLED 0x01
427#define LPFC_SLI3_NPIV_ENABLED 0x02 492#define LPFC_SLI3_NPIV_ENABLED 0x02
@@ -526,11 +591,12 @@ struct lpfc_hba {
526 unsigned long data_flags; 591 unsigned long data_flags;
527 592
528 uint32_t hbq_in_use; /* HBQs in use flag */ 593 uint32_t hbq_in_use; /* HBQs in use flag */
529 struct list_head hbqbuf_in_list; /* in-fly hbq buffer list */ 594 struct list_head rb_pend_list; /* Received buffers to be processed */
530 uint32_t hbq_count; /* Count of configured HBQs */ 595 uint32_t hbq_count; /* Count of configured HBQs */
531 struct hbq_s hbqs[LPFC_MAX_HBQS]; /* local copy of hbq indicies */ 596 struct hbq_s hbqs[LPFC_MAX_HBQS]; /* local copy of hbq indicies */
532 597
533 unsigned long pci_bar0_map; /* Physical address for PCI BAR0 */ 598 unsigned long pci_bar0_map; /* Physical address for PCI BAR0 */
599 unsigned long pci_bar1_map; /* Physical address for PCI BAR1 */
534 unsigned long pci_bar2_map; /* Physical address for PCI BAR2 */ 600 unsigned long pci_bar2_map; /* Physical address for PCI BAR2 */
535 void __iomem *slim_memmap_p; /* Kernel memory mapped address for 601 void __iomem *slim_memmap_p; /* Kernel memory mapped address for
536 PCI BAR0 */ 602 PCI BAR0 */
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 896c7b0351e5..4164b935ea9f 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -267,8 +267,6 @@ lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
267 uint32_t tmo, uint8_t retry) 267 uint32_t tmo, uint8_t retry)
268{ 268{
269 struct lpfc_hba *phba = vport->phba; 269 struct lpfc_hba *phba = vport->phba;
270 struct lpfc_sli *psli = &phba->sli;
271 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
272 IOCB_t *icmd; 270 IOCB_t *icmd;
273 struct lpfc_iocbq *geniocb; 271 struct lpfc_iocbq *geniocb;
274 int rc; 272 int rc;
@@ -331,7 +329,7 @@ lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
331 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT; 329 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT;
332 geniocb->vport = vport; 330 geniocb->vport = vport;
333 geniocb->retry = retry; 331 geniocb->retry = retry;
334 rc = lpfc_sli_issue_iocb(phba, pring, geniocb, 0); 332 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, geniocb, 0);
335 333
336 if (rc == IOCB_ERROR) { 334 if (rc == IOCB_ERROR) {
337 lpfc_sli_release_iocbq(phba, geniocb); 335 lpfc_sli_release_iocbq(phba, geniocb);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 52be5644e07a..5dd66925f4ca 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -280,6 +280,8 @@ lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
280 struct lpfc_dmabuf *d_buf; 280 struct lpfc_dmabuf *d_buf;
281 struct hbq_dmabuf *hbq_buf; 281 struct hbq_dmabuf *hbq_buf;
282 282
283 if (phba->sli_rev != 3)
284 return 0;
283 cnt = LPFC_HBQINFO_SIZE; 285 cnt = LPFC_HBQINFO_SIZE;
284 spin_lock_irq(&phba->hbalock); 286 spin_lock_irq(&phba->hbalock);
285 287
@@ -489,12 +491,15 @@ lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
489 pring->next_cmdidx, pring->local_getidx, 491 pring->next_cmdidx, pring->local_getidx,
490 pring->flag, pgpp->rspPutInx, pring->numRiocb); 492 pring->flag, pgpp->rspPutInx, pring->numRiocb);
491 } 493 }
492 word0 = readl(phba->HAregaddr); 494
493 word1 = readl(phba->CAregaddr); 495 if (phba->sli_rev <= LPFC_SLI_REV3) {
494 word2 = readl(phba->HSregaddr); 496 word0 = readl(phba->HAregaddr);
495 word3 = readl(phba->HCregaddr); 497 word1 = readl(phba->CAregaddr);
496 len += snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x HC:%08x\n", 498 word2 = readl(phba->HSregaddr);
497 word0, word1, word2, word3); 499 word3 = readl(phba->HCregaddr);
500 len += snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x "
501 "HC:%08x\n", word0, word1, word2, word3);
502 }
498 spin_unlock_irq(&phba->hbalock); 503 spin_unlock_irq(&phba->hbalock);
499 return len; 504 return len;
500} 505}
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index b8b34cf5c3d2..8c5c3aea4a19 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -84,7 +84,8 @@ lpfc_els_chk_latt(struct lpfc_vport *vport)
84 uint32_t ha_copy; 84 uint32_t ha_copy;
85 85
86 if (vport->port_state >= LPFC_VPORT_READY || 86 if (vport->port_state >= LPFC_VPORT_READY ||
87 phba->link_state == LPFC_LINK_DOWN) 87 phba->link_state == LPFC_LINK_DOWN ||
88 phba->sli_rev > LPFC_SLI_REV3)
88 return 0; 89 return 0;
89 90
90 /* Read the HBA Host Attention Register */ 91 /* Read the HBA Host Attention Register */
@@ -305,7 +306,7 @@ els_iocb_free_pcmb_exit:
305 * 0 - successfully issued fabric registration login for @vport 306 * 0 - successfully issued fabric registration login for @vport
306 * -ENXIO -- failed to issue fabric registration login for @vport 307 * -ENXIO -- failed to issue fabric registration login for @vport
307 **/ 308 **/
308static int 309int
309lpfc_issue_fabric_reglogin(struct lpfc_vport *vport) 310lpfc_issue_fabric_reglogin(struct lpfc_vport *vport)
310{ 311{
311 struct lpfc_hba *phba = vport->phba; 312 struct lpfc_hba *phba = vport->phba;
@@ -345,8 +346,7 @@ lpfc_issue_fabric_reglogin(struct lpfc_vport *vport)
345 err = 4; 346 err = 4;
346 goto fail; 347 goto fail;
347 } 348 }
348 rc = lpfc_reg_login(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox, 349 rc = lpfc_reg_rpi(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox, 0);
349 0);
350 if (rc) { 350 if (rc) {
351 err = 5; 351 err = 5;
352 goto fail_free_mbox; 352 goto fail_free_mbox;
@@ -1350,14 +1350,12 @@ lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
1350 IOCB_t *icmd; 1350 IOCB_t *icmd;
1351 struct lpfc_nodelist *ndlp; 1351 struct lpfc_nodelist *ndlp;
1352 struct lpfc_iocbq *elsiocb; 1352 struct lpfc_iocbq *elsiocb;
1353 struct lpfc_sli_ring *pring;
1354 struct lpfc_sli *psli; 1353 struct lpfc_sli *psli;
1355 uint8_t *pcmd; 1354 uint8_t *pcmd;
1356 uint16_t cmdsize; 1355 uint16_t cmdsize;
1357 int ret; 1356 int ret;
1358 1357
1359 psli = &phba->sli; 1358 psli = &phba->sli;
1360 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1361 1359
1362 ndlp = lpfc_findnode_did(vport, did); 1360 ndlp = lpfc_findnode_did(vport, did);
1363 if (ndlp && !NLP_CHK_NODE_ACT(ndlp)) 1361 if (ndlp && !NLP_CHK_NODE_ACT(ndlp))
@@ -1391,7 +1389,7 @@ lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
1391 1389
1392 phba->fc_stat.elsXmitPLOGI++; 1390 phba->fc_stat.elsXmitPLOGI++;
1393 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi; 1391 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
1394 ret = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 1392 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
1395 1393
1396 if (ret == IOCB_ERROR) { 1394 if (ret == IOCB_ERROR) {
1397 lpfc_els_free_iocb(phba, elsiocb); 1395 lpfc_els_free_iocb(phba, elsiocb);
@@ -1501,14 +1499,9 @@ lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1501 PRLI *npr; 1499 PRLI *npr;
1502 IOCB_t *icmd; 1500 IOCB_t *icmd;
1503 struct lpfc_iocbq *elsiocb; 1501 struct lpfc_iocbq *elsiocb;
1504 struct lpfc_sli_ring *pring;
1505 struct lpfc_sli *psli;
1506 uint8_t *pcmd; 1502 uint8_t *pcmd;
1507 uint16_t cmdsize; 1503 uint16_t cmdsize;
1508 1504
1509 psli = &phba->sli;
1510 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1511
1512 cmdsize = (sizeof(uint32_t) + sizeof(PRLI)); 1505 cmdsize = (sizeof(uint32_t) + sizeof(PRLI));
1513 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp, 1506 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1514 ndlp->nlp_DID, ELS_CMD_PRLI); 1507 ndlp->nlp_DID, ELS_CMD_PRLI);
@@ -1550,7 +1543,8 @@ lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1550 spin_lock_irq(shost->host_lock); 1543 spin_lock_irq(shost->host_lock);
1551 ndlp->nlp_flag |= NLP_PRLI_SND; 1544 ndlp->nlp_flag |= NLP_PRLI_SND;
1552 spin_unlock_irq(shost->host_lock); 1545 spin_unlock_irq(shost->host_lock);
1553 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1546 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) ==
1547 IOCB_ERROR) {
1554 spin_lock_irq(shost->host_lock); 1548 spin_lock_irq(shost->host_lock);
1555 ndlp->nlp_flag &= ~NLP_PRLI_SND; 1549 ndlp->nlp_flag &= ~NLP_PRLI_SND;
1556 spin_unlock_irq(shost->host_lock); 1550 spin_unlock_irq(shost->host_lock);
@@ -1788,8 +1782,6 @@ lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1788 ADISC *ap; 1782 ADISC *ap;
1789 IOCB_t *icmd; 1783 IOCB_t *icmd;
1790 struct lpfc_iocbq *elsiocb; 1784 struct lpfc_iocbq *elsiocb;
1791 struct lpfc_sli *psli = &phba->sli;
1792 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
1793 uint8_t *pcmd; 1785 uint8_t *pcmd;
1794 uint16_t cmdsize; 1786 uint16_t cmdsize;
1795 1787
@@ -1822,7 +1814,8 @@ lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1822 spin_lock_irq(shost->host_lock); 1814 spin_lock_irq(shost->host_lock);
1823 ndlp->nlp_flag |= NLP_ADISC_SND; 1815 ndlp->nlp_flag |= NLP_ADISC_SND;
1824 spin_unlock_irq(shost->host_lock); 1816 spin_unlock_irq(shost->host_lock);
1825 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1817 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) ==
1818 IOCB_ERROR) {
1826 spin_lock_irq(shost->host_lock); 1819 spin_lock_irq(shost->host_lock);
1827 ndlp->nlp_flag &= ~NLP_ADISC_SND; 1820 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1828 spin_unlock_irq(shost->host_lock); 1821 spin_unlock_irq(shost->host_lock);
@@ -1937,15 +1930,10 @@ lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1937 struct lpfc_hba *phba = vport->phba; 1930 struct lpfc_hba *phba = vport->phba;
1938 IOCB_t *icmd; 1931 IOCB_t *icmd;
1939 struct lpfc_iocbq *elsiocb; 1932 struct lpfc_iocbq *elsiocb;
1940 struct lpfc_sli_ring *pring;
1941 struct lpfc_sli *psli;
1942 uint8_t *pcmd; 1933 uint8_t *pcmd;
1943 uint16_t cmdsize; 1934 uint16_t cmdsize;
1944 int rc; 1935 int rc;
1945 1936
1946 psli = &phba->sli;
1947 pring = &psli->ring[LPFC_ELS_RING];
1948
1949 spin_lock_irq(shost->host_lock); 1937 spin_lock_irq(shost->host_lock);
1950 if (ndlp->nlp_flag & NLP_LOGO_SND) { 1938 if (ndlp->nlp_flag & NLP_LOGO_SND) {
1951 spin_unlock_irq(shost->host_lock); 1939 spin_unlock_irq(shost->host_lock);
@@ -1978,7 +1966,7 @@ lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1978 spin_lock_irq(shost->host_lock); 1966 spin_lock_irq(shost->host_lock);
1979 ndlp->nlp_flag |= NLP_LOGO_SND; 1967 ndlp->nlp_flag |= NLP_LOGO_SND;
1980 spin_unlock_irq(shost->host_lock); 1968 spin_unlock_irq(shost->host_lock);
1981 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 1969 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
1982 1970
1983 if (rc == IOCB_ERROR) { 1971 if (rc == IOCB_ERROR) {
1984 spin_lock_irq(shost->host_lock); 1972 spin_lock_irq(shost->host_lock);
@@ -2058,14 +2046,12 @@ lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
2058 struct lpfc_hba *phba = vport->phba; 2046 struct lpfc_hba *phba = vport->phba;
2059 IOCB_t *icmd; 2047 IOCB_t *icmd;
2060 struct lpfc_iocbq *elsiocb; 2048 struct lpfc_iocbq *elsiocb;
2061 struct lpfc_sli_ring *pring;
2062 struct lpfc_sli *psli; 2049 struct lpfc_sli *psli;
2063 uint8_t *pcmd; 2050 uint8_t *pcmd;
2064 uint16_t cmdsize; 2051 uint16_t cmdsize;
2065 struct lpfc_nodelist *ndlp; 2052 struct lpfc_nodelist *ndlp;
2066 2053
2067 psli = &phba->sli; 2054 psli = &phba->sli;
2068 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2069 cmdsize = (sizeof(uint32_t) + sizeof(SCR)); 2055 cmdsize = (sizeof(uint32_t) + sizeof(SCR));
2070 2056
2071 ndlp = lpfc_findnode_did(vport, nportid); 2057 ndlp = lpfc_findnode_did(vport, nportid);
@@ -2108,7 +2094,8 @@ lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
2108 2094
2109 phba->fc_stat.elsXmitSCR++; 2095 phba->fc_stat.elsXmitSCR++;
2110 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd; 2096 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
2111 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 2097 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) ==
2098 IOCB_ERROR) {
2112 /* The additional lpfc_nlp_put will cause the following 2099 /* The additional lpfc_nlp_put will cause the following
2113 * lpfc_els_free_iocb routine to trigger the rlease of 2100 * lpfc_els_free_iocb routine to trigger the rlease of
2114 * the node. 2101 * the node.
@@ -2152,7 +2139,6 @@ lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
2152 struct lpfc_hba *phba = vport->phba; 2139 struct lpfc_hba *phba = vport->phba;
2153 IOCB_t *icmd; 2140 IOCB_t *icmd;
2154 struct lpfc_iocbq *elsiocb; 2141 struct lpfc_iocbq *elsiocb;
2155 struct lpfc_sli_ring *pring;
2156 struct lpfc_sli *psli; 2142 struct lpfc_sli *psli;
2157 FARP *fp; 2143 FARP *fp;
2158 uint8_t *pcmd; 2144 uint8_t *pcmd;
@@ -2162,7 +2148,6 @@ lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
2162 struct lpfc_nodelist *ndlp; 2148 struct lpfc_nodelist *ndlp;
2163 2149
2164 psli = &phba->sli; 2150 psli = &phba->sli;
2165 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2166 cmdsize = (sizeof(uint32_t) + sizeof(FARP)); 2151 cmdsize = (sizeof(uint32_t) + sizeof(FARP));
2167 2152
2168 ndlp = lpfc_findnode_did(vport, nportid); 2153 ndlp = lpfc_findnode_did(vport, nportid);
@@ -2219,7 +2204,8 @@ lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
2219 2204
2220 phba->fc_stat.elsXmitFARPR++; 2205 phba->fc_stat.elsXmitFARPR++;
2221 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd; 2206 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
2222 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 2207 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) ==
2208 IOCB_ERROR) {
2223 /* The additional lpfc_nlp_put will cause the following 2209 /* The additional lpfc_nlp_put will cause the following
2224 * lpfc_els_free_iocb routine to trigger the release of 2210 * lpfc_els_free_iocb routine to trigger the release of
2225 * the node. 2211 * the node.
@@ -2961,6 +2947,7 @@ lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2961 */ 2947 */
2962 lpfc_nlp_not_used(ndlp); 2948 lpfc_nlp_not_used(ndlp);
2963 } 2949 }
2950
2964 return; 2951 return;
2965} 2952}
2966 2953
@@ -3170,7 +3157,6 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
3170 IOCB_t *icmd; 3157 IOCB_t *icmd;
3171 IOCB_t *oldcmd; 3158 IOCB_t *oldcmd;
3172 struct lpfc_iocbq *elsiocb; 3159 struct lpfc_iocbq *elsiocb;
3173 struct lpfc_sli_ring *pring;
3174 struct lpfc_sli *psli; 3160 struct lpfc_sli *psli;
3175 uint8_t *pcmd; 3161 uint8_t *pcmd;
3176 uint16_t cmdsize; 3162 uint16_t cmdsize;
@@ -3178,7 +3164,6 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
3178 ELS_PKT *els_pkt_ptr; 3164 ELS_PKT *els_pkt_ptr;
3179 3165
3180 psli = &phba->sli; 3166 psli = &phba->sli;
3181 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
3182 oldcmd = &oldiocb->iocb; 3167 oldcmd = &oldiocb->iocb;
3183 3168
3184 switch (flag) { 3169 switch (flag) {
@@ -3266,7 +3251,7 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
3266 } 3251 }
3267 3252
3268 phba->fc_stat.elsXmitACC++; 3253 phba->fc_stat.elsXmitACC++;
3269 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 3254 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3270 if (rc == IOCB_ERROR) { 3255 if (rc == IOCB_ERROR) {
3271 lpfc_els_free_iocb(phba, elsiocb); 3256 lpfc_els_free_iocb(phba, elsiocb);
3272 return 1; 3257 return 1;
@@ -3305,15 +3290,12 @@ lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
3305 IOCB_t *icmd; 3290 IOCB_t *icmd;
3306 IOCB_t *oldcmd; 3291 IOCB_t *oldcmd;
3307 struct lpfc_iocbq *elsiocb; 3292 struct lpfc_iocbq *elsiocb;
3308 struct lpfc_sli_ring *pring;
3309 struct lpfc_sli *psli; 3293 struct lpfc_sli *psli;
3310 uint8_t *pcmd; 3294 uint8_t *pcmd;
3311 uint16_t cmdsize; 3295 uint16_t cmdsize;
3312 int rc; 3296 int rc;
3313 3297
3314 psli = &phba->sli; 3298 psli = &phba->sli;
3315 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
3316
3317 cmdsize = 2 * sizeof(uint32_t); 3299 cmdsize = 2 * sizeof(uint32_t);
3318 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp, 3300 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
3319 ndlp->nlp_DID, ELS_CMD_LS_RJT); 3301 ndlp->nlp_DID, ELS_CMD_LS_RJT);
@@ -3346,7 +3328,7 @@ lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
3346 3328
3347 phba->fc_stat.elsXmitLSRJT++; 3329 phba->fc_stat.elsXmitLSRJT++;
3348 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp; 3330 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3349 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 3331 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3350 3332
3351 if (rc == IOCB_ERROR) { 3333 if (rc == IOCB_ERROR) {
3352 lpfc_els_free_iocb(phba, elsiocb); 3334 lpfc_els_free_iocb(phba, elsiocb);
@@ -3379,8 +3361,6 @@ lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
3379 struct lpfc_nodelist *ndlp) 3361 struct lpfc_nodelist *ndlp)
3380{ 3362{
3381 struct lpfc_hba *phba = vport->phba; 3363 struct lpfc_hba *phba = vport->phba;
3382 struct lpfc_sli *psli = &phba->sli;
3383 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
3384 ADISC *ap; 3364 ADISC *ap;
3385 IOCB_t *icmd, *oldcmd; 3365 IOCB_t *icmd, *oldcmd;
3386 struct lpfc_iocbq *elsiocb; 3366 struct lpfc_iocbq *elsiocb;
@@ -3422,7 +3402,7 @@ lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
3422 3402
3423 phba->fc_stat.elsXmitACC++; 3403 phba->fc_stat.elsXmitACC++;
3424 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp; 3404 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3425 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 3405 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3426 if (rc == IOCB_ERROR) { 3406 if (rc == IOCB_ERROR) {
3427 lpfc_els_free_iocb(phba, elsiocb); 3407 lpfc_els_free_iocb(phba, elsiocb);
3428 return 1; 3408 return 1;
@@ -3459,14 +3439,12 @@ lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
3459 IOCB_t *icmd; 3439 IOCB_t *icmd;
3460 IOCB_t *oldcmd; 3440 IOCB_t *oldcmd;
3461 struct lpfc_iocbq *elsiocb; 3441 struct lpfc_iocbq *elsiocb;
3462 struct lpfc_sli_ring *pring;
3463 struct lpfc_sli *psli; 3442 struct lpfc_sli *psli;
3464 uint8_t *pcmd; 3443 uint8_t *pcmd;
3465 uint16_t cmdsize; 3444 uint16_t cmdsize;
3466 int rc; 3445 int rc;
3467 3446
3468 psli = &phba->sli; 3447 psli = &phba->sli;
3469 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
3470 3448
3471 cmdsize = sizeof(uint32_t) + sizeof(PRLI); 3449 cmdsize = sizeof(uint32_t) + sizeof(PRLI);
3472 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp, 3450 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
@@ -3520,7 +3498,7 @@ lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
3520 phba->fc_stat.elsXmitACC++; 3498 phba->fc_stat.elsXmitACC++;
3521 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp; 3499 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3522 3500
3523 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 3501 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3524 if (rc == IOCB_ERROR) { 3502 if (rc == IOCB_ERROR) {
3525 lpfc_els_free_iocb(phba, elsiocb); 3503 lpfc_els_free_iocb(phba, elsiocb);
3526 return 1; 3504 return 1;
@@ -3562,15 +3540,12 @@ lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
3562 RNID *rn; 3540 RNID *rn;
3563 IOCB_t *icmd, *oldcmd; 3541 IOCB_t *icmd, *oldcmd;
3564 struct lpfc_iocbq *elsiocb; 3542 struct lpfc_iocbq *elsiocb;
3565 struct lpfc_sli_ring *pring;
3566 struct lpfc_sli *psli; 3543 struct lpfc_sli *psli;
3567 uint8_t *pcmd; 3544 uint8_t *pcmd;
3568 uint16_t cmdsize; 3545 uint16_t cmdsize;
3569 int rc; 3546 int rc;
3570 3547
3571 psli = &phba->sli; 3548 psli = &phba->sli;
3572 pring = &psli->ring[LPFC_ELS_RING];
3573
3574 cmdsize = sizeof(uint32_t) + sizeof(uint32_t) 3549 cmdsize = sizeof(uint32_t) + sizeof(uint32_t)
3575 + (2 * sizeof(struct lpfc_name)); 3550 + (2 * sizeof(struct lpfc_name));
3576 if (format) 3551 if (format)
@@ -3626,7 +3601,7 @@ lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
3626 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl, 3601 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
3627 * it could be freed */ 3602 * it could be freed */
3628 3603
3629 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 3604 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3630 if (rc == IOCB_ERROR) { 3605 if (rc == IOCB_ERROR) {
3631 lpfc_els_free_iocb(phba, elsiocb); 3606 lpfc_els_free_iocb(phba, elsiocb);
3632 return 1; 3607 return 1;
@@ -4440,8 +4415,6 @@ lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
4440static void 4415static void
4441lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 4416lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
4442{ 4417{
4443 struct lpfc_sli *psli = &phba->sli;
4444 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
4445 MAILBOX_t *mb; 4418 MAILBOX_t *mb;
4446 IOCB_t *icmd; 4419 IOCB_t *icmd;
4447 RPS_RSP *rps_rsp; 4420 RPS_RSP *rps_rsp;
@@ -4507,7 +4480,7 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
4507 ndlp->nlp_rpi); 4480 ndlp->nlp_rpi);
4508 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp; 4481 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
4509 phba->fc_stat.elsXmitACC++; 4482 phba->fc_stat.elsXmitACC++;
4510 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) 4483 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) == IOCB_ERROR)
4511 lpfc_els_free_iocb(phba, elsiocb); 4484 lpfc_els_free_iocb(phba, elsiocb);
4512 return; 4485 return;
4513} 4486}
@@ -4616,8 +4589,6 @@ lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
4616 IOCB_t *icmd, *oldcmd; 4589 IOCB_t *icmd, *oldcmd;
4617 RPL_RSP rpl_rsp; 4590 RPL_RSP rpl_rsp;
4618 struct lpfc_iocbq *elsiocb; 4591 struct lpfc_iocbq *elsiocb;
4619 struct lpfc_sli *psli = &phba->sli;
4620 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
4621 uint8_t *pcmd; 4592 uint8_t *pcmd;
4622 4593
4623 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp, 4594 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
@@ -4654,7 +4625,8 @@ lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
4654 ndlp->nlp_rpi); 4625 ndlp->nlp_rpi);
4655 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp; 4626 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
4656 phba->fc_stat.elsXmitACC++; 4627 phba->fc_stat.elsXmitACC++;
4657 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 4628 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) ==
4629 IOCB_ERROR) {
4658 lpfc_els_free_iocb(phba, elsiocb); 4630 lpfc_els_free_iocb(phba, elsiocb);
4659 return 1; 4631 return 1;
4660 } 4632 }
@@ -6139,7 +6111,6 @@ lpfc_issue_els_npiv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
6139{ 6111{
6140 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 6112 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6141 struct lpfc_hba *phba = vport->phba; 6113 struct lpfc_hba *phba = vport->phba;
6142 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
6143 IOCB_t *icmd; 6114 IOCB_t *icmd;
6144 struct lpfc_iocbq *elsiocb; 6115 struct lpfc_iocbq *elsiocb;
6145 uint8_t *pcmd; 6116 uint8_t *pcmd;
@@ -6169,7 +6140,8 @@ lpfc_issue_els_npiv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
6169 spin_lock_irq(shost->host_lock); 6140 spin_lock_irq(shost->host_lock);
6170 ndlp->nlp_flag |= NLP_LOGO_SND; 6141 ndlp->nlp_flag |= NLP_LOGO_SND;
6171 spin_unlock_irq(shost->host_lock); 6142 spin_unlock_irq(shost->host_lock);
6172 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 6143 if (lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0) ==
6144 IOCB_ERROR) {
6173 spin_lock_irq(shost->host_lock); 6145 spin_lock_irq(shost->host_lock);
6174 ndlp->nlp_flag &= ~NLP_LOGO_SND; 6146 ndlp->nlp_flag &= ~NLP_LOGO_SND;
6175 spin_unlock_irq(shost->host_lock); 6147 spin_unlock_irq(shost->host_lock);
@@ -6224,7 +6196,6 @@ lpfc_resume_fabric_iocbs(struct lpfc_hba *phba)
6224 struct lpfc_iocbq *iocb; 6196 struct lpfc_iocbq *iocb;
6225 unsigned long iflags; 6197 unsigned long iflags;
6226 int ret; 6198 int ret;
6227 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
6228 IOCB_t *cmd; 6199 IOCB_t *cmd;
6229 6200
6230repeat: 6201repeat:
@@ -6248,7 +6219,7 @@ repeat:
6248 "Fabric sched1: ste:x%x", 6219 "Fabric sched1: ste:x%x",
6249 iocb->vport->port_state, 0, 0); 6220 iocb->vport->port_state, 0, 0);
6250 6221
6251 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0); 6222 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, iocb, 0);
6252 6223
6253 if (ret == IOCB_ERROR) { 6224 if (ret == IOCB_ERROR) {
6254 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl; 6225 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
@@ -6394,7 +6365,6 @@ static int
6394lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb) 6365lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb)
6395{ 6366{
6396 unsigned long iflags; 6367 unsigned long iflags;
6397 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
6398 int ready; 6368 int ready;
6399 int ret; 6369 int ret;
6400 6370
@@ -6418,7 +6388,7 @@ lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb)
6418 "Fabric sched2: ste:x%x", 6388 "Fabric sched2: ste:x%x",
6419 iocb->vport->port_state, 0, 0); 6389 iocb->vport->port_state, 0, 0);
6420 6390
6421 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0); 6391 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, iocb, 0);
6422 6392
6423 if (ret == IOCB_ERROR) { 6393 if (ret == IOCB_ERROR) {
6424 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl; 6394 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index e764ce0bf704..25fc96c9081f 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -555,23 +555,24 @@ lpfc_work_done(struct lpfc_hba *phba)
555 /* 555 /*
556 * Turn on Ring interrupts 556 * Turn on Ring interrupts
557 */ 557 */
558 spin_lock_irq(&phba->hbalock); 558 if (phba->sli_rev <= LPFC_SLI_REV3) {
559 control = readl(phba->HCregaddr); 559 spin_lock_irq(&phba->hbalock);
560 if (!(control & (HC_R0INT_ENA << LPFC_ELS_RING))) { 560 control = readl(phba->HCregaddr);
561 lpfc_debugfs_slow_ring_trc(phba, 561 if (!(control & (HC_R0INT_ENA << LPFC_ELS_RING))) {
562 "WRK Enable ring: cntl:x%x hacopy:x%x", 562 lpfc_debugfs_slow_ring_trc(phba,
563 control, ha_copy, 0); 563 "WRK Enable ring: cntl:x%x hacopy:x%x",
564 564 control, ha_copy, 0);
565 control |= (HC_R0INT_ENA << LPFC_ELS_RING); 565
566 writel(control, phba->HCregaddr); 566 control |= (HC_R0INT_ENA << LPFC_ELS_RING);
567 readl(phba->HCregaddr); /* flush */ 567 writel(control, phba->HCregaddr);
568 } 568 readl(phba->HCregaddr); /* flush */
569 else { 569 } else {
570 lpfc_debugfs_slow_ring_trc(phba, 570 lpfc_debugfs_slow_ring_trc(phba,
571 "WRK Ring ok: cntl:x%x hacopy:x%x", 571 "WRK Ring ok: cntl:x%x hacopy:x%x",
572 control, ha_copy, 0); 572 control, ha_copy, 0);
573 }
574 spin_unlock_irq(&phba->hbalock);
573 } 575 }
574 spin_unlock_irq(&phba->hbalock);
575 } 576 }
576 lpfc_work_list_done(phba); 577 lpfc_work_list_done(phba);
577} 578}
@@ -689,7 +690,7 @@ lpfc_port_link_failure(struct lpfc_vport *vport)
689 lpfc_can_disctmo(vport); 690 lpfc_can_disctmo(vport);
690} 691}
691 692
692static void 693void
693lpfc_linkdown_port(struct lpfc_vport *vport) 694lpfc_linkdown_port(struct lpfc_vport *vport)
694{ 695{
695 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 696 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
@@ -1147,10 +1148,12 @@ lpfc_enable_la(struct lpfc_hba *phba)
1147 struct lpfc_sli *psli = &phba->sli; 1148 struct lpfc_sli *psli = &phba->sli;
1148 spin_lock_irq(&phba->hbalock); 1149 spin_lock_irq(&phba->hbalock);
1149 psli->sli_flag |= LPFC_PROCESS_LA; 1150 psli->sli_flag |= LPFC_PROCESS_LA;
1150 control = readl(phba->HCregaddr); 1151 if (phba->sli_rev <= LPFC_SLI_REV3) {
1151 control |= HC_LAINT_ENA; 1152 control = readl(phba->HCregaddr);
1152 writel(control, phba->HCregaddr); 1153 control |= HC_LAINT_ENA;
1153 readl(phba->HCregaddr); /* flush */ 1154 writel(control, phba->HCregaddr);
1155 readl(phba->HCregaddr); /* flush */
1156 }
1154 spin_unlock_irq(&phba->hbalock); 1157 spin_unlock_irq(&phba->hbalock);
1155} 1158}
1156 1159
@@ -2919,11 +2922,13 @@ restart_disc:
2919 * set port_state to PORT_READY if SLI2. 2922 * set port_state to PORT_READY if SLI2.
2920 * cmpl_reg_vpi will set port_state to READY for SLI3. 2923 * cmpl_reg_vpi will set port_state to READY for SLI3.
2921 */ 2924 */
2922 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) 2925 if (phba->sli_rev < LPFC_SLI_REV4) {
2923 lpfc_issue_reg_vpi(phba, vport); 2926 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2924 else { /* NPIV Not enabled */ 2927 lpfc_issue_reg_vpi(phba, vport);
2925 lpfc_issue_clear_la(phba, vport); 2928 else { /* NPIV Not enabled */
2926 vport->port_state = LPFC_VPORT_READY; 2929 lpfc_issue_clear_la(phba, vport);
2930 vport->port_state = LPFC_VPORT_READY;
2931 }
2927 } 2932 }
2928 2933
2929 /* Setup and issue mailbox INITIALIZE LINK command */ 2934 /* Setup and issue mailbox INITIALIZE LINK command */
@@ -2959,11 +2964,13 @@ restart_disc:
2959 * set port_state to PORT_READY if SLI2. 2964 * set port_state to PORT_READY if SLI2.
2960 * cmpl_reg_vpi will set port_state to READY for SLI3. 2965 * cmpl_reg_vpi will set port_state to READY for SLI3.
2961 */ 2966 */
2962 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) 2967 if (phba->sli_rev < LPFC_SLI_REV4) {
2963 lpfc_issue_reg_vpi(phba, vport); 2968 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2964 else { /* NPIV Not enabled */ 2969 lpfc_issue_reg_vpi(phba, vport);
2965 lpfc_issue_clear_la(phba, vport); 2970 else { /* NPIV Not enabled */
2966 vport->port_state = LPFC_VPORT_READY; 2971 lpfc_issue_clear_la(phba, vport);
2972 vport->port_state = LPFC_VPORT_READY;
2973 }
2967 } 2974 }
2968 break; 2975 break;
2969 2976
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 86d1bdcbf2d8..3f06ce2becf5 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -571,16 +571,20 @@ lpfc_hba_down_prep(struct lpfc_hba *phba)
571{ 571{
572 struct lpfc_vport **vports; 572 struct lpfc_vport **vports;
573 int i; 573 int i;
574 /* Disable interrupts */ 574
575 writel(0, phba->HCregaddr); 575 if (phba->sli_rev <= LPFC_SLI_REV3) {
576 readl(phba->HCregaddr); /* flush */ 576 /* Disable interrupts */
577 writel(0, phba->HCregaddr);
578 readl(phba->HCregaddr); /* flush */
579 }
577 580
578 if (phba->pport->load_flag & FC_UNLOADING) 581 if (phba->pport->load_flag & FC_UNLOADING)
579 lpfc_cleanup_discovery_resources(phba->pport); 582 lpfc_cleanup_discovery_resources(phba->pport);
580 else { 583 else {
581 vports = lpfc_create_vport_work_array(phba); 584 vports = lpfc_create_vport_work_array(phba);
582 if (vports != NULL) 585 if (vports != NULL)
583 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) 586 for (i = 0; i <= phba->max_vports &&
587 vports[i] != NULL; i++)
584 lpfc_cleanup_discovery_resources(vports[i]); 588 lpfc_cleanup_discovery_resources(vports[i]);
585 lpfc_destroy_vport_work_array(phba, vports); 589 lpfc_destroy_vport_work_array(phba, vports);
586 } 590 }
@@ -588,7 +592,7 @@ lpfc_hba_down_prep(struct lpfc_hba *phba)
588} 592}
589 593
590/** 594/**
591 * lpfc_hba_down_post - Perform lpfc uninitialization after HBA reset 595 * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
592 * @phba: pointer to lpfc HBA data structure. 596 * @phba: pointer to lpfc HBA data structure.
593 * 597 *
594 * This routine will do uninitialization after the HBA is reset when bring 598 * This routine will do uninitialization after the HBA is reset when bring
@@ -598,8 +602,8 @@ lpfc_hba_down_prep(struct lpfc_hba *phba)
598 * 0 - sucess. 602 * 0 - sucess.
599 * Any other value - error. 603 * Any other value - error.
600 **/ 604 **/
601int 605static int
602lpfc_hba_down_post(struct lpfc_hba *phba) 606lpfc_hba_down_post_s3(struct lpfc_hba *phba)
603{ 607{
604 struct lpfc_sli *psli = &phba->sli; 608 struct lpfc_sli *psli = &phba->sli;
605 struct lpfc_sli_ring *pring; 609 struct lpfc_sli_ring *pring;
@@ -909,13 +913,30 @@ lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
909 if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING))) 913 if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING)))
910 phba->work_hs = old_host_status & ~HS_FFER1; 914 phba->work_hs = old_host_status & ~HS_FFER1;
911 915
916 spin_lock_irq(&phba->hbalock);
912 phba->hba_flag &= ~DEFER_ERATT; 917 phba->hba_flag &= ~DEFER_ERATT;
918 spin_unlock_irq(&phba->hbalock);
913 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8); 919 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
914 phba->work_status[1] = readl(phba->MBslimaddr + 0xac); 920 phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
915} 921}
916 922
923static void
924lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba)
925{
926 struct lpfc_board_event_header board_event;
927 struct Scsi_Host *shost;
928
929 board_event.event_type = FC_REG_BOARD_EVENT;
930 board_event.subcategory = LPFC_EVENT_PORTINTERR;
931 shost = lpfc_shost_from_vport(phba->pport);
932 fc_host_post_vendor_event(shost, fc_get_event_number(),
933 sizeof(board_event),
934 (char *) &board_event,
935 LPFC_NL_VENDOR_ID);
936}
937
917/** 938/**
918 * lpfc_handle_eratt - The HBA hardware error handler 939 * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
919 * @phba: pointer to lpfc hba data structure. 940 * @phba: pointer to lpfc hba data structure.
920 * 941 *
921 * This routine is invoked to handle the following HBA hardware error 942 * This routine is invoked to handle the following HBA hardware error
@@ -924,8 +945,8 @@ lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
924 * 2 - DMA ring index out of range 945 * 2 - DMA ring index out of range
925 * 3 - Mailbox command came back as unknown 946 * 3 - Mailbox command came back as unknown
926 **/ 947 **/
927void 948static void
928lpfc_handle_eratt(struct lpfc_hba *phba) 949lpfc_handle_eratt_s3(struct lpfc_hba *phba)
929{ 950{
930 struct lpfc_vport *vport = phba->pport; 951 struct lpfc_vport *vport = phba->pport;
931 struct lpfc_sli *psli = &phba->sli; 952 struct lpfc_sli *psli = &phba->sli;
@@ -934,24 +955,23 @@ lpfc_handle_eratt(struct lpfc_hba *phba)
934 unsigned long temperature; 955 unsigned long temperature;
935 struct temp_event temp_event_data; 956 struct temp_event temp_event_data;
936 struct Scsi_Host *shost; 957 struct Scsi_Host *shost;
937 struct lpfc_board_event_header board_event;
938 958
939 /* If the pci channel is offline, ignore possible errors, 959 /* If the pci channel is offline, ignore possible errors,
940 * since we cannot communicate with the pci card anyway. */ 960 * since we cannot communicate with the pci card anyway.
941 if (pci_channel_offline(phba->pcidev)) 961 */
962 if (pci_channel_offline(phba->pcidev)) {
963 spin_lock_irq(&phba->hbalock);
964 phba->hba_flag &= ~DEFER_ERATT;
965 spin_unlock_irq(&phba->hbalock);
942 return; 966 return;
967 }
968
943 /* If resets are disabled then leave the HBA alone and return */ 969 /* If resets are disabled then leave the HBA alone and return */
944 if (!phba->cfg_enable_hba_reset) 970 if (!phba->cfg_enable_hba_reset)
945 return; 971 return;
946 972
947 /* Send an internal error event to mgmt application */ 973 /* Send an internal error event to mgmt application */
948 board_event.event_type = FC_REG_BOARD_EVENT; 974 lpfc_board_errevt_to_mgmt(phba);
949 board_event.subcategory = LPFC_EVENT_PORTINTERR;
950 shost = lpfc_shost_from_vport(phba->pport);
951 fc_host_post_vendor_event(shost, fc_get_event_number(),
952 sizeof(board_event),
953 (char *) &board_event,
954 LPFC_NL_VENDOR_ID);
955 975
956 if (phba->hba_flag & DEFER_ERATT) 976 if (phba->hba_flag & DEFER_ERATT)
957 lpfc_handle_deferred_eratt(phba); 977 lpfc_handle_deferred_eratt(phba);
@@ -1137,7 +1157,7 @@ lpfc_handle_latt_err_exit:
1137 * 0 - pointer to the VPD passed in is NULL 1157 * 0 - pointer to the VPD passed in is NULL
1138 * 1 - success 1158 * 1 - success
1139 **/ 1159 **/
1140static int 1160int
1141lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len) 1161lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1142{ 1162{
1143 uint8_t lenlo, lenhi; 1163 uint8_t lenlo, lenhi;
@@ -1533,7 +1553,8 @@ lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
1533 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN; 1553 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
1534 icmd->ulpLe = 1; 1554 icmd->ulpLe = 1;
1535 1555
1536 if (lpfc_sli_issue_iocb(phba, pring, iocb, 0) == IOCB_ERROR) { 1556 if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) ==
1557 IOCB_ERROR) {
1537 lpfc_mbuf_free(phba, mp1->virt, mp1->phys); 1558 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1538 kfree(mp1); 1559 kfree(mp1);
1539 cnt++; 1560 cnt++;
@@ -1761,7 +1782,6 @@ lpfc_cleanup(struct lpfc_vport *vport)
1761 * Lets wait for this to happen, if needed. 1782 * Lets wait for this to happen, if needed.
1762 */ 1783 */
1763 while (!list_empty(&vport->fc_nodes)) { 1784 while (!list_empty(&vport->fc_nodes)) {
1764
1765 if (i++ > 3000) { 1785 if (i++ > 3000) {
1766 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 1786 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1767 "0233 Nodelist not empty\n"); 1787 "0233 Nodelist not empty\n");
@@ -1782,7 +1802,6 @@ lpfc_cleanup(struct lpfc_vport *vport)
1782 /* Wait for any activity on ndlps to settle */ 1802 /* Wait for any activity on ndlps to settle */
1783 msleep(10); 1803 msleep(10);
1784 } 1804 }
1785 return;
1786} 1805}
1787 1806
1788/** 1807/**
@@ -1803,22 +1822,36 @@ lpfc_stop_vport_timers(struct lpfc_vport *vport)
1803} 1822}
1804 1823
1805/** 1824/**
1806 * lpfc_stop_phba_timers - Stop all the timers associated with an HBA 1825 * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
1807 * @phba: pointer to lpfc hba data structure. 1826 * @phba: pointer to lpfc hba data structure.
1808 * 1827 *
1809 * This routine stops all the timers associated with a HBA. This function is 1828 * This routine stops all the timers associated with a HBA. This function is
1810 * invoked before either putting a HBA offline or unloading the driver. 1829 * invoked before either putting a HBA offline or unloading the driver.
1811 **/ 1830 **/
1812static void 1831void
1813lpfc_stop_phba_timers(struct lpfc_hba *phba) 1832lpfc_stop_hba_timers(struct lpfc_hba *phba)
1814{ 1833{
1815 del_timer_sync(&phba->fcp_poll_timer);
1816 lpfc_stop_vport_timers(phba->pport); 1834 lpfc_stop_vport_timers(phba->pport);
1817 del_timer_sync(&phba->sli.mbox_tmo); 1835 del_timer_sync(&phba->sli.mbox_tmo);
1818 del_timer_sync(&phba->fabric_block_timer); 1836 del_timer_sync(&phba->fabric_block_timer);
1819 phba->hb_outstanding = 0;
1820 del_timer_sync(&phba->hb_tmofunc);
1821 del_timer_sync(&phba->eratt_poll); 1837 del_timer_sync(&phba->eratt_poll);
1838 del_timer_sync(&phba->hb_tmofunc);
1839 phba->hb_outstanding = 0;
1840
1841 switch (phba->pci_dev_grp) {
1842 case LPFC_PCI_DEV_LP:
1843 /* Stop any LightPulse device specific driver timers */
1844 del_timer_sync(&phba->fcp_poll_timer);
1845 break;
1846 case LPFC_PCI_DEV_OC:
1847 /* Stop any OneConnect device sepcific driver timers */
1848 break;
1849 default:
1850 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1851 "0297 Invalid device group (x%x)\n",
1852 phba->pci_dev_grp);
1853 break;
1854 }
1822 return; 1855 return;
1823} 1856}
1824 1857
@@ -2509,9 +2542,8 @@ lpfc_disable_msi(struct lpfc_hba *phba)
2509 * 2542 *
2510 * This routine it invoked to log the currently used active interrupt mode 2543 * This routine it invoked to log the currently used active interrupt mode
2511 * to the device. 2544 * to the device.
2512 */ 2545 **/
2513static void 2546static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
2514lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
2515{ 2547{
2516 switch (intr_mode) { 2548 switch (intr_mode) {
2517 case 0: 2549 case 0:
@@ -2534,228 +2566,671 @@ lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
2534 return; 2566 return;
2535} 2567}
2536 2568
2569/**
2570 * lpfc_enable_pci_dev - Enable a generic PCI device.
2571 * @phba: pointer to lpfc hba data structure.
2572 *
2573 * This routine is invoked to enable the PCI device that is common to all
2574 * PCI devices.
2575 *
2576 * Return codes
2577 * 0 - sucessful
2578 * other values - error
2579 **/
2580static int
2581lpfc_enable_pci_dev(struct lpfc_hba *phba)
2582{
2583 struct pci_dev *pdev;
2584 int bars;
2585
2586 /* Obtain PCI device reference */
2587 if (!phba->pcidev)
2588 goto out_error;
2589 else
2590 pdev = phba->pcidev;
2591 /* Select PCI BARs */
2592 bars = pci_select_bars(pdev, IORESOURCE_MEM);
2593 /* Enable PCI device */
2594 if (pci_enable_device_mem(pdev))
2595 goto out_error;
2596 /* Request PCI resource for the device */
2597 if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME))
2598 goto out_disable_device;
2599 /* Set up device as PCI master and save state for EEH */
2600 pci_set_master(pdev);
2601 pci_try_set_mwi(pdev);
2602 pci_save_state(pdev);
2603
2604 return 0;
2605
2606out_disable_device:
2607 pci_disable_device(pdev);
2608out_error:
2609 return -ENODEV;
2610}
2611
2612/**
2613 * lpfc_disable_pci_dev - Disable a generic PCI device.
2614 * @phba: pointer to lpfc hba data structure.
2615 *
2616 * This routine is invoked to disable the PCI device that is common to all
2617 * PCI devices.
2618 **/
2537static void 2619static void
2538lpfc_stop_port(struct lpfc_hba *phba) 2620lpfc_disable_pci_dev(struct lpfc_hba *phba)
2539{ 2621{
2540 /* Clear all interrupt enable conditions */ 2622 struct pci_dev *pdev;
2541 writel(0, phba->HCregaddr); 2623 int bars;
2542 readl(phba->HCregaddr); /* flush */
2543 /* Clear all pending interrupts */
2544 writel(0xffffffff, phba->HAregaddr);
2545 readl(phba->HAregaddr); /* flush */
2546 2624
2547 /* Reset some HBA SLI setup states */ 2625 /* Obtain PCI device reference */
2548 lpfc_stop_phba_timers(phba); 2626 if (!phba->pcidev)
2549 phba->pport->work_port_events = 0; 2627 return;
2628 else
2629 pdev = phba->pcidev;
2630 /* Select PCI BARs */
2631 bars = pci_select_bars(pdev, IORESOURCE_MEM);
2632 /* Release PCI resource and disable PCI device */
2633 pci_release_selected_regions(pdev, bars);
2634 pci_disable_device(pdev);
2635 /* Null out PCI private reference to driver */
2636 pci_set_drvdata(pdev, NULL);
2550 2637
2551 return; 2638 return;
2552} 2639}
2553 2640
2554/** 2641/**
2555 * lpfc_enable_intr - Enable device interrupt 2642 * lpfc_reset_hba - Reset a hba
2556 * @phba: pointer to lpfc hba data structure. 2643 * @phba: pointer to lpfc hba data structure.
2557 * 2644 *
2558 * This routine is invoked to enable device interrupt and associate driver's 2645 * This routine is invoked to reset a hba device. It brings the HBA
2559 * interrupt handler(s) to interrupt vector(s). Depends on the interrupt 2646 * offline, performs a board restart, and then brings the board back
2560 * mode configured to the driver, the driver will try to fallback from the 2647 * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
2561 * configured interrupt mode to an interrupt mode which is supported by the 2648 * on outstanding mailbox commands.
2562 * platform, kernel, and device in the order of: MSI-X -> MSI -> IRQ. 2649 **/
2650void
2651lpfc_reset_hba(struct lpfc_hba *phba)
2652{
2653 /* If resets are disabled then set error state and return. */
2654 if (!phba->cfg_enable_hba_reset) {
2655 phba->link_state = LPFC_HBA_ERROR;
2656 return;
2657 }
2658 lpfc_offline_prep(phba);
2659 lpfc_offline(phba);
2660 lpfc_sli_brdrestart(phba);
2661 lpfc_online(phba);
2662 lpfc_unblock_mgmt_io(phba);
2663}
2664
2665/**
2666 * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev.
2667 * @phba: pointer to lpfc hba data structure.
2668 *
2669 * This routine is invoked to set up the driver internal resources specific to
2670 * support the SLI-3 HBA device it attached to.
2563 * 2671 *
2564 * Return codes 2672 * Return codes
2565 * 0 - sucessful 2673 * 0 - sucessful
2566 * other values - error 2674 * other values - error
2567 **/ 2675 **/
2568static uint32_t 2676static int
2569lpfc_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode) 2677lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
2570{ 2678{
2571 uint32_t intr_mode = LPFC_INTR_ERROR; 2679 struct lpfc_sli *psli;
2572 int retval;
2573 2680
2574 if (cfg_mode == 2) { 2681 /*
2575 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */ 2682 * Initialize timers used by driver
2576 retval = lpfc_sli_config_port(phba, 3); 2683 */
2577 if (!retval) { 2684
2578 /* Now, try to enable MSI-X interrupt mode */ 2685 /* Heartbeat timer */
2579 retval = lpfc_enable_msix(phba); 2686 init_timer(&phba->hb_tmofunc);
2580 if (!retval) { 2687 phba->hb_tmofunc.function = lpfc_hb_timeout;
2581 /* Indicate initialization to MSI-X mode */ 2688 phba->hb_tmofunc.data = (unsigned long)phba;
2582 phba->intr_type = MSIX; 2689
2583 intr_mode = 2; 2690 psli = &phba->sli;
2584 } 2691 /* MBOX heartbeat timer */
2585 } 2692 init_timer(&psli->mbox_tmo);
2693 psli->mbox_tmo.function = lpfc_mbox_timeout;
2694 psli->mbox_tmo.data = (unsigned long) phba;
2695 /* FCP polling mode timer */
2696 init_timer(&phba->fcp_poll_timer);
2697 phba->fcp_poll_timer.function = lpfc_poll_timeout;
2698 phba->fcp_poll_timer.data = (unsigned long) phba;
2699 /* Fabric block timer */
2700 init_timer(&phba->fabric_block_timer);
2701 phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
2702 phba->fabric_block_timer.data = (unsigned long) phba;
2703 /* EA polling mode timer */
2704 init_timer(&phba->eratt_poll);
2705 phba->eratt_poll.function = lpfc_poll_eratt;
2706 phba->eratt_poll.data = (unsigned long) phba;
2707
2708 /* Host attention work mask setup */
2709 phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
2710 phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
2711
2712 /* Get all the module params for configuring this host */
2713 lpfc_get_cfgparam(phba);
2714 /*
2715 * Since the sg_tablesize is module parameter, the sg_dma_buf_size
2716 * used to create the sg_dma_buf_pool must be dynamically calculated.
2717 * 2 segments are added since the IOCB needs a command and response bde.
2718 */
2719 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
2720 sizeof(struct fcp_rsp) +
2721 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
2722
2723 if (phba->cfg_enable_bg) {
2724 phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT;
2725 phba->cfg_sg_dma_buf_size +=
2726 phba->cfg_prot_sg_seg_cnt * sizeof(struct ulp_bde64);
2586 } 2727 }
2587 2728
2588 /* Fallback to MSI if MSI-X initialization failed */ 2729 /* Also reinitialize the host templates with new values. */
2589 if (cfg_mode >= 1 && phba->intr_type == NONE) { 2730 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2590 retval = lpfc_enable_msi(phba); 2731 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
2591 if (!retval) { 2732
2592 /* Indicate initialization to MSI mode */ 2733 phba->max_vpi = LPFC_MAX_VPI;
2593 phba->intr_type = MSI; 2734 /* This will be set to correct value after config_port mbox */
2594 intr_mode = 1; 2735 phba->max_vports = 0;
2595 } 2736
2737 /*
2738 * Initialize the SLI Layer to run with lpfc HBAs.
2739 */
2740 lpfc_sli_setup(phba);
2741 lpfc_sli_queue_setup(phba);
2742
2743 /* Allocate device driver memory */
2744 if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
2745 return -ENOMEM;
2746
2747 return 0;
2748}
2749
2750/**
2751 * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
2752 * @phba: pointer to lpfc hba data structure.
2753 *
2754 * This routine is invoked to unset the driver internal resources set up
2755 * specific for supporting the SLI-3 HBA device it attached to.
2756 **/
2757static void
2758lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
2759{
2760 /* Free device driver memory allocated */
2761 lpfc_mem_free_all(phba);
2762
2763 return;
2764}
2765
2766/**
2767 * lpfc_init_api_table_setup - Set up init api fucntion jump table
2768 * @phba: The hba struct for which this call is being executed.
2769 * @dev_grp: The HBA PCI-Device group number.
2770 *
2771 * This routine sets up the device INIT interface API function jump table
2772 * in @phba struct.
2773 *
2774 * Returns: 0 - success, -ENODEV - failure.
2775 **/
2776int
2777lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
2778{
2779 switch (dev_grp) {
2780 case LPFC_PCI_DEV_LP:
2781 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
2782 phba->lpfc_handle_eratt = lpfc_handle_eratt_s3;
2783 phba->lpfc_stop_port = lpfc_stop_port_s3;
2784 break;
2785 default:
2786 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2787 "1431 Invalid HBA PCI-device group: 0x%x\n",
2788 dev_grp);
2789 return -ENODEV;
2790 break;
2596 } 2791 }
2792 return 0;
2793}
2597 2794
2598 /* Fallback to INTx if both MSI-X/MSI initalization failed */ 2795/**
2599 if (phba->intr_type == NONE) { 2796 * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
2600 retval = request_irq(phba->pcidev->irq, lpfc_intr_handler, 2797 * @phba: pointer to lpfc hba data structure.
2601 IRQF_SHARED, LPFC_DRIVER_NAME, phba); 2798 *
2602 if (!retval) { 2799 * This routine is invoked to set up the driver internal resources before the
2603 /* Indicate initialization to INTx mode */ 2800 * device specific resource setup to support the HBA device it attached to.
2604 phba->intr_type = INTx; 2801 *
2605 intr_mode = 0; 2802 * Return codes
2606 } 2803 * 0 - sucessful
2804 * other values - error
2805 **/
2806static int
2807lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
2808{
2809 /*
2810 * Driver resources common to all SLI revisions
2811 */
2812 atomic_set(&phba->fast_event_count, 0);
2813 spin_lock_init(&phba->hbalock);
2814
2815 /* Initialize ndlp management spinlock */
2816 spin_lock_init(&phba->ndlp_lock);
2817
2818 INIT_LIST_HEAD(&phba->port_list);
2819 INIT_LIST_HEAD(&phba->work_list);
2820 init_waitqueue_head(&phba->wait_4_mlo_m_q);
2821
2822 /* Initialize the wait queue head for the kernel thread */
2823 init_waitqueue_head(&phba->work_waitq);
2824
2825 /* Initialize the scsi buffer list used by driver for scsi IO */
2826 spin_lock_init(&phba->scsi_buf_list_lock);
2827 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
2828
2829 /* Initialize the fabric iocb list */
2830 INIT_LIST_HEAD(&phba->fabric_iocb_list);
2831
2832 /* Initialize list to save ELS buffers */
2833 INIT_LIST_HEAD(&phba->elsbuf);
2834
2835 /* Initialize FCF connection rec list */
2836 INIT_LIST_HEAD(&phba->fcf_conn_rec_list);
2837
2838 return 0;
2839}
2840
2841/**
2842 * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
2843 * @phba: pointer to lpfc hba data structure.
2844 *
2845 * This routine is invoked to set up the driver internal resources after the
2846 * device specific resource setup to support the HBA device it attached to.
2847 *
2848 * Return codes
2849 * 0 - sucessful
2850 * other values - error
2851 **/
2852static int
2853lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba)
2854{
2855 int error;
2856
2857 /* Startup the kernel thread for this host adapter. */
2858 phba->worker_thread = kthread_run(lpfc_do_work, phba,
2859 "lpfc_worker_%d", phba->brd_no);
2860 if (IS_ERR(phba->worker_thread)) {
2861 error = PTR_ERR(phba->worker_thread);
2862 return error;
2607 } 2863 }
2608 return intr_mode; 2864
2865 return 0;
2609} 2866}
2610 2867
2611/** 2868/**
2612 * lpfc_disable_intr - Disable device interrupt 2869 * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
2613 * @phba: pointer to lpfc hba data structure. 2870 * @phba: pointer to lpfc hba data structure.
2614 * 2871 *
2615 * This routine is invoked to disable device interrupt and disassociate the 2872 * This routine is invoked to unset the driver internal resources set up after
2616 * driver's interrupt handler(s) from interrupt vector(s). Depending on the 2873 * the device specific resource setup for supporting the HBA device it
2617 * interrupt mode, the driver will release the interrupt vector(s) for the 2874 * attached to.
2618 * message signaled interrupt.
2619 **/ 2875 **/
2620static void 2876static void
2621lpfc_disable_intr(struct lpfc_hba *phba) 2877lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba)
2622{ 2878{
2623 /* Disable the currently initialized interrupt mode */ 2879 /* Stop kernel worker thread */
2624 if (phba->intr_type == MSIX) 2880 kthread_stop(phba->worker_thread);
2625 lpfc_disable_msix(phba); 2881}
2626 else if (phba->intr_type == MSI)
2627 lpfc_disable_msi(phba);
2628 else if (phba->intr_type == INTx)
2629 free_irq(phba->pcidev->irq, phba);
2630 2882
2631 /* Reset interrupt management states */ 2883/**
2632 phba->intr_type = NONE; 2884 * lpfc_free_iocb_list - Free iocb list.
2633 phba->sli.slistat.sli_intr = 0; 2885 * @phba: pointer to lpfc hba data structure.
2886 *
2887 * This routine is invoked to free the driver's IOCB list and memory.
2888 **/
2889static void
2890lpfc_free_iocb_list(struct lpfc_hba *phba)
2891{
2892 struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
2893
2894 spin_lock_irq(&phba->hbalock);
2895 list_for_each_entry_safe(iocbq_entry, iocbq_next,
2896 &phba->lpfc_iocb_list, list) {
2897 list_del(&iocbq_entry->list);
2898 kfree(iocbq_entry);
2899 phba->total_iocbq_bufs--;
2900 }
2901 spin_unlock_irq(&phba->hbalock);
2634 2902
2635 return; 2903 return;
2636} 2904}
2637 2905
2638/** 2906/**
2639 * lpfc_pci_probe_one - lpfc PCI probe func to register device to PCI subsystem 2907 * lpfc_init_iocb_list - Allocate and initialize iocb list.
2640 * @pdev: pointer to PCI device 2908 * @phba: pointer to lpfc hba data structure.
2641 * @pid: pointer to PCI device identifier
2642 * 2909 *
2643 * This routine is to be registered to the kernel's PCI subsystem. When an 2910 * This routine is invoked to allocate and initizlize the driver's IOCB
2644 * Emulex HBA is presented in PCI bus, the kernel PCI subsystem looks at 2911 * list and set up the IOCB tag array accordingly.
2645 * PCI device-specific information of the device and driver to see if the
2646 * driver state that it can support this kind of device. If the match is
2647 * successful, the driver core invokes this routine. If this routine
2648 * determines it can claim the HBA, it does all the initialization that it
2649 * needs to do to handle the HBA properly.
2650 * 2912 *
2651 * Return code 2913 * Return codes
2652 * 0 - driver can claim the device 2914 * 0 - sucessful
2653 * negative value - driver can not claim the device 2915 * other values - error
2654 **/ 2916 **/
2655static int __devinit 2917static int
2656lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid) 2918lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
2657{ 2919{
2658 struct lpfc_vport *vport = NULL; 2920 struct lpfc_iocbq *iocbq_entry = NULL;
2659 struct lpfc_hba *phba;
2660 struct lpfc_sli *psli;
2661 struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
2662 struct Scsi_Host *shost = NULL;
2663 void *ptr;
2664 unsigned long bar0map_len, bar2map_len;
2665 int error = -ENODEV, retval;
2666 int i, hbq_count;
2667 uint16_t iotag; 2921 uint16_t iotag;
2668 uint32_t cfg_mode, intr_mode; 2922 int i;
2669 int bars = pci_select_bars(pdev, IORESOURCE_MEM);
2670 struct lpfc_adapter_event_header adapter_event;
2671 2923
2672 if (pci_enable_device_mem(pdev)) 2924 /* Initialize and populate the iocb list per host. */
2673 goto out; 2925 INIT_LIST_HEAD(&phba->lpfc_iocb_list);
2674 if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME)) 2926 for (i = 0; i < iocb_count; i++) {
2675 goto out_disable_device; 2927 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
2928 if (iocbq_entry == NULL) {
2929 printk(KERN_ERR "%s: only allocated %d iocbs of "
2930 "expected %d count. Unloading driver.\n",
2931 __func__, i, LPFC_IOCB_LIST_CNT);
2932 goto out_free_iocbq;
2933 }
2676 2934
2677 phba = kzalloc(sizeof (struct lpfc_hba), GFP_KERNEL); 2935 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
2678 if (!phba) 2936 if (iotag == 0) {
2679 goto out_release_regions; 2937 kfree(iocbq_entry);
2938 printk(KERN_ERR "%s: failed to allocate IOTAG. "
2939 "Unloading driver.\n", __func__);
2940 goto out_free_iocbq;
2941 }
2942 iocbq_entry->sli4_xritag = NO_XRI;
2680 2943
2681 atomic_set(&phba->fast_event_count, 0); 2944 spin_lock_irq(&phba->hbalock);
2682 spin_lock_init(&phba->hbalock); 2945 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
2946 phba->total_iocbq_bufs++;
2947 spin_unlock_irq(&phba->hbalock);
2948 }
2683 2949
2684 /* Initialize ndlp management spinlock */ 2950 return 0;
2685 spin_lock_init(&phba->ndlp_lock); 2951
2952out_free_iocbq:
2953 lpfc_free_iocb_list(phba);
2686 2954
2955 return -ENOMEM;
2956}
2957
2958/**
2959 * lpfc_hba_alloc - Allocate driver hba data structure for a device.
2960 * @pdev: pointer to pci device data structure.
2961 *
2962 * This routine is invoked to allocate the driver hba data structure for an
2963 * HBA device. If the allocation is successful, the phba reference to the
2964 * PCI device data structure is set.
2965 *
2966 * Return codes
2967 * pointer to @phba - sucessful
2968 * NULL - error
2969 **/
2970static struct lpfc_hba *
2971lpfc_hba_alloc(struct pci_dev *pdev)
2972{
2973 struct lpfc_hba *phba;
2974
2975 /* Allocate memory for HBA structure */
2976 phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL);
2977 if (!phba) {
2978 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2979 "1417 Failed to allocate hba struct.\n");
2980 return NULL;
2981 }
2982
2983 /* Set reference to PCI device in HBA structure */
2687 phba->pcidev = pdev; 2984 phba->pcidev = pdev;
2688 2985
2689 /* Assign an unused board number */ 2986 /* Assign an unused board number */
2690 if ((phba->brd_no = lpfc_get_instance()) < 0) 2987 phba->brd_no = lpfc_get_instance();
2691 goto out_free_phba; 2988 if (phba->brd_no < 0) {
2989 kfree(phba);
2990 return NULL;
2991 }
2992
2993 return phba;
2994}
2995
2996/**
2997 * lpfc_hba_free - Free driver hba data structure with a device.
2998 * @phba: pointer to lpfc hba data structure.
2999 *
3000 * This routine is invoked to free the driver hba data structure with an
3001 * HBA device.
3002 **/
3003static void
3004lpfc_hba_free(struct lpfc_hba *phba)
3005{
3006 /* Release the driver assigned board number */
3007 idr_remove(&lpfc_hba_index, phba->brd_no);
3008
3009 kfree(phba);
3010 return;
3011}
3012
3013/**
3014 * lpfc_create_shost - Create hba physical port with associated scsi host.
3015 * @phba: pointer to lpfc hba data structure.
3016 *
3017 * This routine is invoked to create HBA physical port and associate a SCSI
3018 * host with it.
3019 *
3020 * Return codes
3021 * 0 - sucessful
3022 * other values - error
3023 **/
3024static int
3025lpfc_create_shost(struct lpfc_hba *phba)
3026{
3027 struct lpfc_vport *vport;
3028 struct Scsi_Host *shost;
3029
3030 /* Initialize HBA FC structure */
3031 phba->fc_edtov = FF_DEF_EDTOV;
3032 phba->fc_ratov = FF_DEF_RATOV;
3033 phba->fc_altov = FF_DEF_ALTOV;
3034 phba->fc_arbtov = FF_DEF_ARBTOV;
3035
3036 vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
3037 if (!vport)
3038 return -ENODEV;
3039
3040 shost = lpfc_shost_from_vport(vport);
3041 phba->pport = vport;
3042 lpfc_debugfs_initialize(vport);
3043 /* Put reference to SCSI host to driver's device private data */
3044 pci_set_drvdata(phba->pcidev, shost);
3045
3046 return 0;
3047}
3048
3049/**
3050 * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
3051 * @phba: pointer to lpfc hba data structure.
3052 *
3053 * This routine is invoked to destroy HBA physical port and the associated
3054 * SCSI host.
3055 **/
3056static void
3057lpfc_destroy_shost(struct lpfc_hba *phba)
3058{
3059 struct lpfc_vport *vport = phba->pport;
3060
3061 /* Destroy physical port that associated with the SCSI host */
3062 destroy_port(vport);
3063
3064 return;
3065}
3066
3067/**
3068 * lpfc_setup_bg - Setup Block guard structures and debug areas.
3069 * @phba: pointer to lpfc hba data structure.
3070 * @shost: the shost to be used to detect Block guard settings.
3071 *
3072 * This routine sets up the local Block guard protocol settings for @shost.
3073 * This routine also allocates memory for debugging bg buffers.
3074 **/
3075static void
3076lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
3077{
3078 int pagecnt = 10;
3079 if (lpfc_prot_mask && lpfc_prot_guard) {
3080 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3081 "1478 Registering BlockGuard with the "
3082 "SCSI layer\n");
3083 scsi_host_set_prot(shost, lpfc_prot_mask);
3084 scsi_host_set_guard(shost, lpfc_prot_guard);
3085 }
3086 if (!_dump_buf_data) {
3087 while (pagecnt) {
3088 spin_lock_init(&_dump_buf_lock);
3089 _dump_buf_data =
3090 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
3091 if (_dump_buf_data) {
3092 printk(KERN_ERR "BLKGRD allocated %d pages for "
3093 "_dump_buf_data at 0x%p\n",
3094 (1 << pagecnt), _dump_buf_data);
3095 _dump_buf_data_order = pagecnt;
3096 memset(_dump_buf_data, 0,
3097 ((1 << PAGE_SHIFT) << pagecnt));
3098 break;
3099 } else
3100 --pagecnt;
3101 }
3102 if (!_dump_buf_data_order)
3103 printk(KERN_ERR "BLKGRD ERROR unable to allocate "
3104 "memory for hexdump\n");
3105 } else
3106 printk(KERN_ERR "BLKGRD already allocated _dump_buf_data=0x%p"
3107 "\n", _dump_buf_data);
3108 if (!_dump_buf_dif) {
3109 while (pagecnt) {
3110 _dump_buf_dif =
3111 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
3112 if (_dump_buf_dif) {
3113 printk(KERN_ERR "BLKGRD allocated %d pages for "
3114 "_dump_buf_dif at 0x%p\n",
3115 (1 << pagecnt), _dump_buf_dif);
3116 _dump_buf_dif_order = pagecnt;
3117 memset(_dump_buf_dif, 0,
3118 ((1 << PAGE_SHIFT) << pagecnt));
3119 break;
3120 } else
3121 --pagecnt;
3122 }
3123 if (!_dump_buf_dif_order)
3124 printk(KERN_ERR "BLKGRD ERROR unable to allocate "
3125 "memory for hexdump\n");
3126 } else
3127 printk(KERN_ERR "BLKGRD already allocated _dump_buf_dif=0x%p\n",
3128 _dump_buf_dif);
3129}
3130
3131/**
3132 * lpfc_post_init_setup - Perform necessary device post initialization setup.
3133 * @phba: pointer to lpfc hba data structure.
3134 *
3135 * This routine is invoked to perform all the necessary post initialization
3136 * setup for the device.
3137 **/
3138static void
3139lpfc_post_init_setup(struct lpfc_hba *phba)
3140{
3141 struct Scsi_Host *shost;
3142 struct lpfc_adapter_event_header adapter_event;
3143
3144 /* Get the default values for Model Name and Description */
3145 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
2692 3146
2693 INIT_LIST_HEAD(&phba->port_list);
2694 init_waitqueue_head(&phba->wait_4_mlo_m_q);
2695 /* 3147 /*
2696 * Get all the module params for configuring this host and then 3148 * hba setup may have changed the hba_queue_depth so we need to
2697 * establish the host. 3149 * adjust the value of can_queue.
2698 */ 3150 */
2699 lpfc_get_cfgparam(phba); 3151 shost = pci_get_drvdata(phba->pcidev);
2700 phba->max_vpi = LPFC_MAX_VPI; 3152 shost->can_queue = phba->cfg_hba_queue_depth - 10;
3153 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
3154 lpfc_setup_bg(phba, shost);
2701 3155
2702 /* Initialize timers used by driver */ 3156 lpfc_host_attrib_init(shost);
2703 init_timer(&phba->hb_tmofunc);
2704 phba->hb_tmofunc.function = lpfc_hb_timeout;
2705 phba->hb_tmofunc.data = (unsigned long)phba;
2706 3157
2707 psli = &phba->sli; 3158 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
2708 init_timer(&psli->mbox_tmo); 3159 spin_lock_irq(shost->host_lock);
2709 psli->mbox_tmo.function = lpfc_mbox_timeout; 3160 lpfc_poll_start_timer(phba);
2710 psli->mbox_tmo.data = (unsigned long) phba; 3161 spin_unlock_irq(shost->host_lock);
2711 init_timer(&phba->fcp_poll_timer); 3162 }
2712 phba->fcp_poll_timer.function = lpfc_poll_timeout;
2713 phba->fcp_poll_timer.data = (unsigned long) phba;
2714 init_timer(&phba->fabric_block_timer);
2715 phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
2716 phba->fabric_block_timer.data = (unsigned long) phba;
2717 init_timer(&phba->eratt_poll);
2718 phba->eratt_poll.function = lpfc_poll_eratt;
2719 phba->eratt_poll.data = (unsigned long) phba;
2720 3163
2721 pci_set_master(pdev); 3164 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2722 pci_save_state(pdev); 3165 "0428 Perform SCSI scan\n");
2723 pci_try_set_mwi(pdev); 3166 /* Send board arrival event to upper layer */
3167 adapter_event.event_type = FC_REG_ADAPTER_EVENT;
3168 adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
3169 fc_host_post_vendor_event(shost, fc_get_event_number(),
3170 sizeof(adapter_event),
3171 (char *) &adapter_event,
3172 LPFC_NL_VENDOR_ID);
3173 return;
3174}
3175
3176/**
3177 * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
3178 * @phba: pointer to lpfc hba data structure.
3179 *
3180 * This routine is invoked to set up the PCI device memory space for device
3181 * with SLI-3 interface spec.
3182 *
3183 * Return codes
3184 * 0 - sucessful
3185 * other values - error
3186 **/
3187static int
3188lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
3189{
3190 struct pci_dev *pdev;
3191 unsigned long bar0map_len, bar2map_len;
3192 int i, hbq_count;
3193 void *ptr;
3194 int error = -ENODEV;
2724 3195
2725 if (pci_set_dma_mask(phba->pcidev, DMA_BIT_MASK(64)) != 0) 3196 /* Obtain PCI device reference */
2726 if (pci_set_dma_mask(phba->pcidev, DMA_BIT_MASK(32)) != 0) 3197 if (!phba->pcidev)
2727 goto out_idr_remove; 3198 return error;
3199 else
3200 pdev = phba->pcidev;
2728 3201
2729 /* 3202 /* Set the device DMA mask size */
2730 * Get the bus address of Bar0 and Bar2 and the number of bytes 3203 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0)
3204 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
3205 return error;
3206
3207 /* Get the bus address of Bar0 and Bar2 and the number of bytes
2731 * required by each mapping. 3208 * required by each mapping.
2732 */ 3209 */
2733 phba->pci_bar0_map = pci_resource_start(phba->pcidev, 0); 3210 phba->pci_bar0_map = pci_resource_start(pdev, 0);
2734 bar0map_len = pci_resource_len(phba->pcidev, 0); 3211 bar0map_len = pci_resource_len(pdev, 0);
2735 3212
2736 phba->pci_bar2_map = pci_resource_start(phba->pcidev, 2); 3213 phba->pci_bar2_map = pci_resource_start(pdev, 2);
2737 bar2map_len = pci_resource_len(phba->pcidev, 2); 3214 bar2map_len = pci_resource_len(pdev, 2);
2738 3215
2739 /* Map HBA SLIM to a kernel virtual address. */ 3216 /* Map HBA SLIM to a kernel virtual address. */
2740 phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len); 3217 phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
2741 if (!phba->slim_memmap_p) { 3218 if (!phba->slim_memmap_p) {
2742 error = -ENODEV;
2743 dev_printk(KERN_ERR, &pdev->dev, 3219 dev_printk(KERN_ERR, &pdev->dev,
2744 "ioremap failed for SLIM memory.\n"); 3220 "ioremap failed for SLIM memory.\n");
2745 goto out_idr_remove; 3221 goto out;
2746 } 3222 }
2747 3223
2748 /* Map HBA Control Registers to a kernel virtual address. */ 3224 /* Map HBA Control Registers to a kernel virtual address. */
2749 phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len); 3225 phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
2750 if (!phba->ctrl_regs_memmap_p) { 3226 if (!phba->ctrl_regs_memmap_p) {
2751 error = -ENODEV;
2752 dev_printk(KERN_ERR, &pdev->dev, 3227 dev_printk(KERN_ERR, &pdev->dev,
2753 "ioremap failed for HBA control registers.\n"); 3228 "ioremap failed for HBA control registers.\n");
2754 goto out_iounmap_slim; 3229 goto out_iounmap_slim;
2755 } 3230 }
2756 3231
2757 /* Allocate memory for SLI-2 structures */ 3232 /* Allocate memory for SLI-2 structures */
2758 phba->slim2p.virt = dma_alloc_coherent(&phba->pcidev->dev, 3233 phba->slim2p.virt = dma_alloc_coherent(&pdev->dev,
2759 SLI2_SLIM_SIZE, 3234 SLI2_SLIM_SIZE,
2760 &phba->slim2p.phys, 3235 &phba->slim2p.phys,
2761 GFP_KERNEL); 3236 GFP_KERNEL);
@@ -2768,7 +3243,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
2768 phba->IOCBs = (phba->slim2p.virt + 3243 phba->IOCBs = (phba->slim2p.virt +
2769 offsetof(struct lpfc_sli2_slim, IOCBs)); 3244 offsetof(struct lpfc_sli2_slim, IOCBs));
2770 3245
2771 phba->hbqslimp.virt = dma_alloc_coherent(&phba->pcidev->dev, 3246 phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev,
2772 lpfc_sli_hbq_size(), 3247 lpfc_sli_hbq_size(),
2773 &phba->hbqslimp.phys, 3248 &phba->hbqslimp.phys,
2774 GFP_KERNEL); 3249 GFP_KERNEL);
@@ -2784,115 +3259,487 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
2784 sizeof(struct lpfc_hbq_entry)); 3259 sizeof(struct lpfc_hbq_entry));
2785 } 3260 }
2786 phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc; 3261 phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
2787 phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free; 3262 phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free;
2788 3263
2789 memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size()); 3264 memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
2790 3265
2791 INIT_LIST_HEAD(&phba->hbqbuf_in_list); 3266 INIT_LIST_HEAD(&phba->rb_pend_list);
2792 3267
2793 /* Initialize the SLI Layer to run with lpfc HBAs. */ 3268 phba->MBslimaddr = phba->slim_memmap_p;
2794 lpfc_sli_setup(phba); 3269 phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
2795 lpfc_sli_queue_setup(phba); 3270 phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
3271 phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
3272 phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
3273
3274 return 0;
3275
3276out_free_slim:
3277 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
3278 phba->slim2p.virt, phba->slim2p.phys);
3279out_iounmap:
3280 iounmap(phba->ctrl_regs_memmap_p);
3281out_iounmap_slim:
3282 iounmap(phba->slim_memmap_p);
3283out:
3284 return error;
3285}
3286
3287/**
3288 * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
3289 * @phba: pointer to lpfc hba data structure.
3290 *
3291 * This routine is invoked to unset the PCI device memory space for device
3292 * with SLI-3 interface spec.
3293 **/
3294static void
3295lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
3296{
3297 struct pci_dev *pdev;
3298
3299 /* Obtain PCI device reference */
3300 if (!phba->pcidev)
3301 return;
3302 else
3303 pdev = phba->pcidev;
3304
3305 /* Free coherent DMA memory allocated */
3306 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
3307 phba->hbqslimp.virt, phba->hbqslimp.phys);
3308 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
3309 phba->slim2p.virt, phba->slim2p.phys);
3310
3311 /* I/O memory unmap */
3312 iounmap(phba->ctrl_regs_memmap_p);
3313 iounmap(phba->slim_memmap_p);
3314
3315 return;
3316}
3317
3318/**
3319 * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device
3320 * @phba: pointer to lpfc hba data structure.
3321 *
3322 * This routine is invoked to enable the MSI-X interrupt vectors to device
3323 * with SLI-3 interface specs. The kernel function pci_enable_msix() is
3324 * called to enable the MSI-X vectors. Note that pci_enable_msix(), once
3325 * invoked, enables either all or nothing, depending on the current
3326 * availability of PCI vector resources. The device driver is responsible
3327 * for calling the individual request_irq() to register each MSI-X vector
3328 * with a interrupt handler, which is done in this function. Note that
3329 * later when device is unloading, the driver should always call free_irq()
3330 * on all MSI-X vectors it has done request_irq() on before calling
3331 * pci_disable_msix(). Failure to do so results in a BUG_ON() and a device
3332 * will be left with MSI-X enabled and leaks its vectors.
3333 *
3334 * Return codes
3335 * 0 - sucessful
3336 * other values - error
3337 **/
3338static int
3339lpfc_sli_enable_msix(struct lpfc_hba *phba)
3340{
3341 int rc, i;
3342 LPFC_MBOXQ_t *pmb;
3343
3344 /* Set up MSI-X multi-message vectors */
3345 for (i = 0; i < LPFC_MSIX_VECTORS; i++)
3346 phba->msix_entries[i].entry = i;
2796 3347
2797 retval = lpfc_mem_alloc(phba); 3348 /* Configure MSI-X capability structure */
2798 if (retval) { 3349 rc = pci_enable_msix(phba->pcidev, phba->msix_entries,
2799 error = retval; 3350 ARRAY_SIZE(phba->msix_entries));
2800 goto out_free_hbqslimp; 3351 if (rc) {
3352 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3353 "0420 PCI enable MSI-X failed (%d)\n", rc);
3354 goto msi_fail_out;
2801 } 3355 }
3356 for (i = 0; i < LPFC_MSIX_VECTORS; i++)
3357 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3358 "0477 MSI-X entry[%d]: vector=x%x "
3359 "message=%d\n", i,
3360 phba->msix_entries[i].vector,
3361 phba->msix_entries[i].entry);
3362 /*
3363 * Assign MSI-X vectors to interrupt handlers
3364 */
2802 3365
2803 /* Initialize and populate the iocb list per host. */ 3366 /* vector-0 is associated to slow-path handler */
2804 INIT_LIST_HEAD(&phba->lpfc_iocb_list); 3367 rc = request_irq(phba->msix_entries[0].vector,
2805 for (i = 0; i < LPFC_IOCB_LIST_CNT; i++) { 3368 &lpfc_sli_sp_intr_handler, IRQF_SHARED,
2806 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL); 3369 LPFC_SP_DRIVER_HANDLER_NAME, phba);
2807 if (iocbq_entry == NULL) { 3370 if (rc) {
2808 printk(KERN_ERR "%s: only allocated %d iocbs of " 3371 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2809 "expected %d count. Unloading driver.\n", 3372 "0421 MSI-X slow-path request_irq failed "
2810 __func__, i, LPFC_IOCB_LIST_CNT); 3373 "(%d)\n", rc);
2811 error = -ENOMEM; 3374 goto msi_fail_out;
2812 goto out_free_iocbq; 3375 }
3376
3377 /* vector-1 is associated to fast-path handler */
3378 rc = request_irq(phba->msix_entries[1].vector,
3379 &lpfc_sli_fp_intr_handler, IRQF_SHARED,
3380 LPFC_FP_DRIVER_HANDLER_NAME, phba);
3381
3382 if (rc) {
3383 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3384 "0429 MSI-X fast-path request_irq failed "
3385 "(%d)\n", rc);
3386 goto irq_fail_out;
3387 }
3388
3389 /*
3390 * Configure HBA MSI-X attention conditions to messages
3391 */
3392 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3393
3394 if (!pmb) {
3395 rc = -ENOMEM;
3396 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3397 "0474 Unable to allocate memory for issuing "
3398 "MBOX_CONFIG_MSI command\n");
3399 goto mem_fail_out;
3400 }
3401 rc = lpfc_config_msi(phba, pmb);
3402 if (rc)
3403 goto mbx_fail_out;
3404 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
3405 if (rc != MBX_SUCCESS) {
3406 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
3407 "0351 Config MSI mailbox command failed, "
3408 "mbxCmd x%x, mbxStatus x%x\n",
3409 pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus);
3410 goto mbx_fail_out;
3411 }
3412
3413 /* Free memory allocated for mailbox command */
3414 mempool_free(pmb, phba->mbox_mem_pool);
3415 return rc;
3416
3417mbx_fail_out:
3418 /* Free memory allocated for mailbox command */
3419 mempool_free(pmb, phba->mbox_mem_pool);
3420
3421mem_fail_out:
3422 /* free the irq already requested */
3423 free_irq(phba->msix_entries[1].vector, phba);
3424
3425irq_fail_out:
3426 /* free the irq already requested */
3427 free_irq(phba->msix_entries[0].vector, phba);
3428
3429msi_fail_out:
3430 /* Unconfigure MSI-X capability structure */
3431 pci_disable_msix(phba->pcidev);
3432 return rc;
3433}
3434
3435/**
3436 * lpfc_sli_disable_msix - Disable MSI-X interrupt mode on SLI-3 device.
3437 * @phba: pointer to lpfc hba data structure.
3438 *
3439 * This routine is invoked to release the MSI-X vectors and then disable the
3440 * MSI-X interrupt mode to device with SLI-3 interface spec.
3441 **/
3442static void
3443lpfc_sli_disable_msix(struct lpfc_hba *phba)
3444{
3445 int i;
3446
3447 /* Free up MSI-X multi-message vectors */
3448 for (i = 0; i < LPFC_MSIX_VECTORS; i++)
3449 free_irq(phba->msix_entries[i].vector, phba);
3450 /* Disable MSI-X */
3451 pci_disable_msix(phba->pcidev);
3452
3453 return;
3454}
3455
3456/**
3457 * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device.
3458 * @phba: pointer to lpfc hba data structure.
3459 *
3460 * This routine is invoked to enable the MSI interrupt mode to device with
3461 * SLI-3 interface spec. The kernel function pci_enable_msi() is called to
3462 * enable the MSI vector. The device driver is responsible for calling the
3463 * request_irq() to register MSI vector with a interrupt the handler, which
3464 * is done in this function.
3465 *
3466 * Return codes
3467 * 0 - sucessful
3468 * other values - error
3469 */
3470static int
3471lpfc_sli_enable_msi(struct lpfc_hba *phba)
3472{
3473 int rc;
3474
3475 rc = pci_enable_msi(phba->pcidev);
3476 if (!rc)
3477 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3478 "0462 PCI enable MSI mode success.\n");
3479 else {
3480 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3481 "0471 PCI enable MSI mode failed (%d)\n", rc);
3482 return rc;
3483 }
3484
3485 rc = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
3486 IRQF_SHARED, LPFC_DRIVER_NAME, phba);
3487 if (rc) {
3488 pci_disable_msi(phba->pcidev);
3489 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3490 "0478 MSI request_irq failed (%d)\n", rc);
3491 }
3492 return rc;
3493}
3494
3495/**
3496 * lpfc_sli_disable_msi - Disable MSI interrupt mode to SLI-3 device.
3497 * @phba: pointer to lpfc hba data structure.
3498 *
3499 * This routine is invoked to disable the MSI interrupt mode to device with
3500 * SLI-3 interface spec. The driver calls free_irq() on MSI vector it has
3501 * done request_irq() on before calling pci_disable_msi(). Failure to do so
3502 * results in a BUG_ON() and a device will be left with MSI enabled and leaks
3503 * its vector.
3504 */
3505static void
3506lpfc_sli_disable_msi(struct lpfc_hba *phba)
3507{
3508 free_irq(phba->pcidev->irq, phba);
3509 pci_disable_msi(phba->pcidev);
3510 return;
3511}
3512
3513/**
3514 * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
3515 * @phba: pointer to lpfc hba data structure.
3516 *
3517 * This routine is invoked to enable device interrupt and associate driver's
3518 * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
3519 * spec. Depends on the interrupt mode configured to the driver, the driver
3520 * will try to fallback from the configured interrupt mode to an interrupt
3521 * mode which is supported by the platform, kernel, and device in the order
3522 * of:
3523 * MSI-X -> MSI -> IRQ.
3524 *
3525 * Return codes
3526 * 0 - sucessful
3527 * other values - error
3528 **/
3529static uint32_t
3530lpfc_sli_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
3531{
3532 uint32_t intr_mode = LPFC_INTR_ERROR;
3533 int retval;
3534
3535 if (cfg_mode == 2) {
3536 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
3537 retval = lpfc_sli_config_port(phba, LPFC_SLI_REV3);
3538 if (!retval) {
3539 /* Now, try to enable MSI-X interrupt mode */
3540 retval = lpfc_sli_enable_msix(phba);
3541 if (!retval) {
3542 /* Indicate initialization to MSI-X mode */
3543 phba->intr_type = MSIX;
3544 intr_mode = 2;
3545 }
2813 } 3546 }
3547 }
2814 3548
2815 iotag = lpfc_sli_next_iotag(phba, iocbq_entry); 3549 /* Fallback to MSI if MSI-X initialization failed */
2816 if (iotag == 0) { 3550 if (cfg_mode >= 1 && phba->intr_type == NONE) {
2817 kfree (iocbq_entry); 3551 retval = lpfc_sli_enable_msi(phba);
2818 printk(KERN_ERR "%s: failed to allocate IOTAG. " 3552 if (!retval) {
2819 "Unloading driver.\n", 3553 /* Indicate initialization to MSI mode */
2820 __func__); 3554 phba->intr_type = MSI;
2821 error = -ENOMEM; 3555 intr_mode = 1;
2822 goto out_free_iocbq;
2823 } 3556 }
3557 }
2824 3558
2825 spin_lock_irq(&phba->hbalock); 3559 /* Fallback to INTx if both MSI-X/MSI initalization failed */
2826 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list); 3560 if (phba->intr_type == NONE) {
2827 phba->total_iocbq_bufs++; 3561 retval = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
2828 spin_unlock_irq(&phba->hbalock); 3562 IRQF_SHARED, LPFC_DRIVER_NAME, phba);
3563 if (!retval) {
3564 /* Indicate initialization to INTx mode */
3565 phba->intr_type = INTx;
3566 intr_mode = 0;
3567 }
2829 } 3568 }
3569 return intr_mode;
3570}
2830 3571
2831 /* Initialize HBA structure */ 3572/**
2832 phba->fc_edtov = FF_DEF_EDTOV; 3573 * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device.
2833 phba->fc_ratov = FF_DEF_RATOV; 3574 * @phba: pointer to lpfc hba data structure.
2834 phba->fc_altov = FF_DEF_ALTOV; 3575 *
2835 phba->fc_arbtov = FF_DEF_ARBTOV; 3576 * This routine is invoked to disable device interrupt and disassociate the
3577 * driver's interrupt handler(s) from interrupt vector(s) to device with
3578 * SLI-3 interface spec. Depending on the interrupt mode, the driver will
3579 * release the interrupt vector(s) for the message signaled interrupt.
3580 **/
3581static void
3582lpfc_sli_disable_intr(struct lpfc_hba *phba)
3583{
3584 /* Disable the currently initialized interrupt mode */
3585 if (phba->intr_type == MSIX)
3586 lpfc_sli_disable_msix(phba);
3587 else if (phba->intr_type == MSI)
3588 lpfc_sli_disable_msi(phba);
3589 else if (phba->intr_type == INTx)
3590 free_irq(phba->pcidev->irq, phba);
2836 3591
2837 INIT_LIST_HEAD(&phba->work_list); 3592 /* Reset interrupt management states */
2838 phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT); 3593 phba->intr_type = NONE;
2839 phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4)); 3594 phba->sli.slistat.sli_intr = 0;
2840 3595
2841 /* Initialize the wait queue head for the kernel thread */ 3596 return;
2842 init_waitqueue_head(&phba->work_waitq); 3597}
2843 3598
2844 /* Startup the kernel thread for this host adapter. */ 3599/**
2845 phba->worker_thread = kthread_run(lpfc_do_work, phba, 3600 * lpfc_unset_hba - Unset SLI3 hba device initialization
2846 "lpfc_worker_%d", phba->brd_no); 3601 * @phba: pointer to lpfc hba data structure.
2847 if (IS_ERR(phba->worker_thread)) { 3602 *
2848 error = PTR_ERR(phba->worker_thread); 3603 * This routine is invoked to unset the HBA device initialization steps to
2849 goto out_free_iocbq; 3604 * a device with SLI-3 interface spec.
3605 **/
3606static void
3607lpfc_unset_hba(struct lpfc_hba *phba)
3608{
3609 struct lpfc_vport *vport = phba->pport;
3610 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3611
3612 spin_lock_irq(shost->host_lock);
3613 vport->load_flag |= FC_UNLOADING;
3614 spin_unlock_irq(shost->host_lock);
3615
3616 lpfc_stop_hba_timers(phba);
3617
3618 phba->pport->work_port_events = 0;
3619
3620 lpfc_sli_hba_down(phba);
3621
3622 lpfc_sli_brdrestart(phba);
3623
3624 lpfc_sli_disable_intr(phba);
3625
3626 return;
3627}
3628
3629/**
3630 * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
3631 * @pdev: pointer to PCI device
3632 * @pid: pointer to PCI device identifier
3633 *
3634 * This routine is to be called to attach a device with SLI-3 interface spec
3635 * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
3636 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
3637 * information of the device and driver to see if the driver state that it can
3638 * support this kind of device. If the match is successful, the driver core
3639 * invokes this routine. If this routine determines it can claim the HBA, it
3640 * does all the initialization that it needs to do to handle the HBA properly.
3641 *
3642 * Return code
3643 * 0 - driver can claim the device
3644 * negative value - driver can not claim the device
3645 **/
3646static int __devinit
3647lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
3648{
3649 struct lpfc_hba *phba;
3650 struct lpfc_vport *vport = NULL;
3651 int error;
3652 uint32_t cfg_mode, intr_mode;
3653
3654 /* Allocate memory for HBA structure */
3655 phba = lpfc_hba_alloc(pdev);
3656 if (!phba)
3657 return -ENOMEM;
3658
3659 /* Perform generic PCI device enabling operation */
3660 error = lpfc_enable_pci_dev(phba);
3661 if (error) {
3662 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3663 "1401 Failed to enable pci device.\n");
3664 goto out_free_phba;
2850 } 3665 }
2851 3666
2852 /* Initialize the list of scsi buffers used by driver for scsi IO. */ 3667 /* Set up SLI API function jump table for PCI-device group-0 HBAs */
2853 spin_lock_init(&phba->scsi_buf_list_lock); 3668 error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_LP);
2854 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list); 3669 if (error)
3670 goto out_disable_pci_dev;
2855 3671
2856 /* Initialize list of fabric iocbs */ 3672 /* Set up SLI-3 specific device PCI memory space */
2857 INIT_LIST_HEAD(&phba->fabric_iocb_list); 3673 error = lpfc_sli_pci_mem_setup(phba);
3674 if (error) {
3675 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3676 "1402 Failed to set up pci memory space.\n");
3677 goto out_disable_pci_dev;
3678 }
2858 3679
2859 /* Initialize list to save ELS buffers */ 3680 /* Set up phase-1 common device driver resources */
2860 INIT_LIST_HEAD(&phba->elsbuf); 3681 error = lpfc_setup_driver_resource_phase1(phba);
3682 if (error) {
3683 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3684 "1403 Failed to set up driver resource.\n");
3685 goto out_unset_pci_mem_s3;
3686 }
2861 3687
2862 vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev); 3688 /* Set up SLI-3 specific device driver resources */
2863 if (!vport) 3689 error = lpfc_sli_driver_resource_setup(phba);
2864 goto out_kthread_stop; 3690 if (error) {
3691 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3692 "1404 Failed to set up driver resource.\n");
3693 goto out_unset_pci_mem_s3;
3694 }
2865 3695
2866 shost = lpfc_shost_from_vport(vport); 3696 /* Initialize and populate the iocb list per host */
2867 phba->pport = vport; 3697 error = lpfc_init_iocb_list(phba, LPFC_IOCB_LIST_CNT);
2868 lpfc_debugfs_initialize(vport); 3698 if (error) {
3699 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3700 "1405 Failed to initialize iocb list.\n");
3701 goto out_unset_driver_resource_s3;
3702 }
2869 3703
2870 pci_set_drvdata(pdev, shost); 3704 /* Set up common device driver resources */
3705 error = lpfc_setup_driver_resource_phase2(phba);
3706 if (error) {
3707 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3708 "1406 Failed to set up driver resource.\n");
3709 goto out_free_iocb_list;
3710 }
2871 3711
2872 phba->MBslimaddr = phba->slim_memmap_p; 3712 /* Create SCSI host to the physical port */
2873 phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET; 3713 error = lpfc_create_shost(phba);
2874 phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET; 3714 if (error) {
2875 phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET; 3715 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2876 phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET; 3716 "1407 Failed to create scsi host.\n");
3717 goto out_unset_driver_resource;
3718 }
2877 3719
2878 /* Configure sysfs attributes */ 3720 /* Configure sysfs attributes */
2879 if (lpfc_alloc_sysfs_attr(vport)) { 3721 vport = phba->pport;
3722 error = lpfc_alloc_sysfs_attr(vport);
3723 if (error) {
2880 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3724 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2881 "1476 Failed to allocate sysfs attr\n"); 3725 "1476 Failed to allocate sysfs attr\n");
2882 error = -ENOMEM; 3726 goto out_destroy_shost;
2883 goto out_destroy_port;
2884 } 3727 }
2885 3728
3729 /* Now, trying to enable interrupt and bring up the device */
2886 cfg_mode = phba->cfg_use_msi; 3730 cfg_mode = phba->cfg_use_msi;
2887 while (true) { 3731 while (true) {
3732 /* Put device to a known state before enabling interrupt */
3733 lpfc_stop_port(phba);
2888 /* Configure and enable interrupt */ 3734 /* Configure and enable interrupt */
2889 intr_mode = lpfc_enable_intr(phba, cfg_mode); 3735 intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);
2890 if (intr_mode == LPFC_INTR_ERROR) { 3736 if (intr_mode == LPFC_INTR_ERROR) {
2891 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3737 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2892 "0426 Failed to enable interrupt.\n"); 3738 "0431 Failed to enable interrupt.\n");
3739 error = -ENODEV;
2893 goto out_free_sysfs_attr; 3740 goto out_free_sysfs_attr;
2894 } 3741 }
2895 /* HBA SLI setup */ 3742 /* SLI-3 HBA setup */
2896 if (lpfc_sli_hba_setup(phba)) { 3743 if (lpfc_sli_hba_setup(phba)) {
2897 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3744 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2898 "1477 Failed to set up hba\n"); 3745 "1477 Failed to set up hba\n");
@@ -2902,185 +3749,65 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
2902 3749
2903 /* Wait 50ms for the interrupts of previous mailbox commands */ 3750 /* Wait 50ms for the interrupts of previous mailbox commands */
2904 msleep(50); 3751 msleep(50);
2905 /* Check active interrupts received */ 3752 /* Check active interrupts on message signaled interrupts */
2906 if (phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) { 3753 if (intr_mode == 0 ||
3754 phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) {
2907 /* Log the current active interrupt mode */ 3755 /* Log the current active interrupt mode */
2908 phba->intr_mode = intr_mode; 3756 phba->intr_mode = intr_mode;
2909 lpfc_log_intr_mode(phba, intr_mode); 3757 lpfc_log_intr_mode(phba, intr_mode);
2910 break; 3758 break;
2911 } else { 3759 } else {
2912 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 3760 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2913 "0451 Configure interrupt mode (%d) " 3761 "0447 Configure interrupt mode (%d) "
2914 "failed active interrupt test.\n", 3762 "failed active interrupt test.\n",
2915 intr_mode); 3763 intr_mode);
2916 if (intr_mode == 0) {
2917 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2918 "0479 Failed to enable "
2919 "interrupt.\n");
2920 error = -ENODEV;
2921 goto out_remove_device;
2922 }
2923 /* Stop HBA SLI setups */
2924 lpfc_stop_port(phba);
2925 /* Disable the current interrupt mode */ 3764 /* Disable the current interrupt mode */
2926 lpfc_disable_intr(phba); 3765 lpfc_sli_disable_intr(phba);
2927 /* Try next level of interrupt mode */ 3766 /* Try next level of interrupt mode */
2928 cfg_mode = --intr_mode; 3767 cfg_mode = --intr_mode;
2929 } 3768 }
2930 } 3769 }
2931 3770
2932 /* 3771 /* Perform post initialization setup */
2933 * hba setup may have changed the hba_queue_depth so we need to adjust 3772 lpfc_post_init_setup(phba);
2934 * the value of can_queue.
2935 */
2936 shost->can_queue = phba->cfg_hba_queue_depth - 10;
2937 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED) {
2938
2939 if (lpfc_prot_mask && lpfc_prot_guard) {
2940 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2941 "1478 Registering BlockGuard with the "
2942 "SCSI layer\n");
2943 3773
2944 scsi_host_set_prot(shost, lpfc_prot_mask); 3774 /* Check if there are static vports to be created. */
2945 scsi_host_set_guard(shost, lpfc_prot_guard); 3775 lpfc_create_static_vport(phba);
2946 }
2947 }
2948
2949 if (!_dump_buf_data) {
2950 int pagecnt = 10;
2951 while (pagecnt) {
2952 spin_lock_init(&_dump_buf_lock);
2953 _dump_buf_data =
2954 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
2955 if (_dump_buf_data) {
2956 printk(KERN_ERR "BLKGRD allocated %d pages for "
2957 "_dump_buf_data at 0x%p\n",
2958 (1 << pagecnt), _dump_buf_data);
2959 _dump_buf_data_order = pagecnt;
2960 memset(_dump_buf_data, 0, ((1 << PAGE_SHIFT)
2961 << pagecnt));
2962 break;
2963 } else {
2964 --pagecnt;
2965 }
2966
2967 }
2968
2969 if (!_dump_buf_data_order)
2970 printk(KERN_ERR "BLKGRD ERROR unable to allocate "
2971 "memory for hexdump\n");
2972
2973 } else {
2974 printk(KERN_ERR "BLKGRD already allocated _dump_buf_data=0x%p"
2975 "\n", _dump_buf_data);
2976 }
2977
2978
2979 if (!_dump_buf_dif) {
2980 int pagecnt = 10;
2981 while (pagecnt) {
2982 _dump_buf_dif =
2983 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
2984 if (_dump_buf_dif) {
2985 printk(KERN_ERR "BLKGRD allocated %d pages for "
2986 "_dump_buf_dif at 0x%p\n",
2987 (1 << pagecnt), _dump_buf_dif);
2988 _dump_buf_dif_order = pagecnt;
2989 memset(_dump_buf_dif, 0, ((1 << PAGE_SHIFT)
2990 << pagecnt));
2991 break;
2992 } else {
2993 --pagecnt;
2994 }
2995
2996 }
2997
2998 if (!_dump_buf_dif_order)
2999 printk(KERN_ERR "BLKGRD ERROR unable to allocate "
3000 "memory for hexdump\n");
3001
3002 } else {
3003 printk(KERN_ERR "BLKGRD already allocated _dump_buf_dif=0x%p\n",
3004 _dump_buf_dif);
3005 }
3006
3007 lpfc_host_attrib_init(shost);
3008
3009 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
3010 spin_lock_irq(shost->host_lock);
3011 lpfc_poll_start_timer(phba);
3012 spin_unlock_irq(shost->host_lock);
3013 }
3014
3015 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3016 "0428 Perform SCSI scan\n");
3017 /* Send board arrival event to upper layer */
3018 adapter_event.event_type = FC_REG_ADAPTER_EVENT;
3019 adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
3020 fc_host_post_vendor_event(shost, fc_get_event_number(),
3021 sizeof(adapter_event),
3022 (char *) &adapter_event,
3023 LPFC_NL_VENDOR_ID);
3024 3776
3025 return 0; 3777 return 0;
3026 3778
3027out_remove_device: 3779out_remove_device:
3028 spin_lock_irq(shost->host_lock); 3780 lpfc_unset_hba(phba);
3029 vport->load_flag |= FC_UNLOADING;
3030 spin_unlock_irq(shost->host_lock);
3031 lpfc_stop_phba_timers(phba);
3032 phba->pport->work_port_events = 0;
3033 lpfc_disable_intr(phba);
3034 lpfc_sli_hba_down(phba);
3035 lpfc_sli_brdrestart(phba);
3036out_free_sysfs_attr: 3781out_free_sysfs_attr:
3037 lpfc_free_sysfs_attr(vport); 3782 lpfc_free_sysfs_attr(vport);
3038out_destroy_port: 3783out_destroy_shost:
3039 destroy_port(vport); 3784 lpfc_destroy_shost(phba);
3040out_kthread_stop: 3785out_unset_driver_resource:
3041 kthread_stop(phba->worker_thread); 3786 lpfc_unset_driver_resource_phase2(phba);
3042out_free_iocbq: 3787out_free_iocb_list:
3043 list_for_each_entry_safe(iocbq_entry, iocbq_next, 3788 lpfc_free_iocb_list(phba);
3044 &phba->lpfc_iocb_list, list) { 3789out_unset_driver_resource_s3:
3045 kfree(iocbq_entry); 3790 lpfc_sli_driver_resource_unset(phba);
3046 phba->total_iocbq_bufs--; 3791out_unset_pci_mem_s3:
3047 } 3792 lpfc_sli_pci_mem_unset(phba);
3048 lpfc_mem_free(phba); 3793out_disable_pci_dev:
3049out_free_hbqslimp: 3794 lpfc_disable_pci_dev(phba);
3050 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
3051 phba->hbqslimp.virt, phba->hbqslimp.phys);
3052out_free_slim:
3053 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
3054 phba->slim2p.virt, phba->slim2p.phys);
3055out_iounmap:
3056 iounmap(phba->ctrl_regs_memmap_p);
3057out_iounmap_slim:
3058 iounmap(phba->slim_memmap_p);
3059out_idr_remove:
3060 idr_remove(&lpfc_hba_index, phba->brd_no);
3061out_free_phba: 3795out_free_phba:
3062 kfree(phba); 3796 lpfc_hba_free(phba);
3063out_release_regions:
3064 pci_release_selected_regions(pdev, bars);
3065out_disable_device:
3066 pci_disable_device(pdev);
3067out:
3068 pci_set_drvdata(pdev, NULL);
3069 if (shost)
3070 scsi_host_put(shost);
3071 return error; 3797 return error;
3072} 3798}
3073 3799
3074/** 3800/**
3075 * lpfc_pci_remove_one - lpfc PCI func to unregister device from PCI subsystem 3801 * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem.
3076 * @pdev: pointer to PCI device 3802 * @pdev: pointer to PCI device
3077 * 3803 *
3078 * This routine is to be registered to the kernel's PCI subsystem. When an 3804 * This routine is to be called to disattach a device with SLI-3 interface
3079 * Emulex HBA is removed from PCI bus, it performs all the necessary cleanup 3805 * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
3080 * for the HBA device to be removed from the PCI subsystem properly. 3806 * removed from PCI bus, it performs all the necessary cleanup for the HBA
3807 * device to be removed from the PCI subsystem properly.
3081 **/ 3808 **/
3082static void __devexit 3809static void __devexit
3083lpfc_pci_remove_one(struct pci_dev *pdev) 3810lpfc_pci_remove_one_s3(struct pci_dev *pdev)
3084{ 3811{
3085 struct Scsi_Host *shost = pci_get_drvdata(pdev); 3812 struct Scsi_Host *shost = pci_get_drvdata(pdev);
3086 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 3813 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
@@ -3098,7 +3825,7 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
3098 /* Release all the vports against this physical port */ 3825 /* Release all the vports against this physical port */
3099 vports = lpfc_create_vport_work_array(phba); 3826 vports = lpfc_create_vport_work_array(phba);
3100 if (vports != NULL) 3827 if (vports != NULL)
3101 for (i = 1; i <= phba->max_vpi && vports[i] != NULL; i++) 3828 for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
3102 fc_vport_terminate(vports[i]->fc_vport); 3829 fc_vport_terminate(vports[i]->fc_vport);
3103 lpfc_destroy_vport_work_array(phba, vports); 3830 lpfc_destroy_vport_work_array(phba, vports);
3104 3831
@@ -3120,7 +3847,7 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
3120 /* Final cleanup of txcmplq and reset the HBA */ 3847 /* Final cleanup of txcmplq and reset the HBA */
3121 lpfc_sli_brdrestart(phba); 3848 lpfc_sli_brdrestart(phba);
3122 3849
3123 lpfc_stop_phba_timers(phba); 3850 lpfc_stop_hba_timers(phba);
3124 spin_lock_irq(&phba->hbalock); 3851 spin_lock_irq(&phba->hbalock);
3125 list_del_init(&vport->listentry); 3852 list_del_init(&vport->listentry);
3126 spin_unlock_irq(&phba->hbalock); 3853 spin_unlock_irq(&phba->hbalock);
@@ -3128,7 +3855,7 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
3128 lpfc_debugfs_terminate(vport); 3855 lpfc_debugfs_terminate(vport);
3129 3856
3130 /* Disable interrupt */ 3857 /* Disable interrupt */
3131 lpfc_disable_intr(phba); 3858 lpfc_sli_disable_intr(phba);
3132 3859
3133 pci_set_drvdata(pdev, NULL); 3860 pci_set_drvdata(pdev, NULL);
3134 scsi_host_put(shost); 3861 scsi_host_put(shost);
@@ -3138,7 +3865,7 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
3138 * corresponding pools here. 3865 * corresponding pools here.
3139 */ 3866 */
3140 lpfc_scsi_free(phba); 3867 lpfc_scsi_free(phba);
3141 lpfc_mem_free(phba); 3868 lpfc_mem_free_all(phba);
3142 3869
3143 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(), 3870 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
3144 phba->hbqslimp.virt, phba->hbqslimp.phys); 3871 phba->hbqslimp.virt, phba->hbqslimp.phys);
@@ -3151,36 +3878,35 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
3151 iounmap(phba->ctrl_regs_memmap_p); 3878 iounmap(phba->ctrl_regs_memmap_p);
3152 iounmap(phba->slim_memmap_p); 3879 iounmap(phba->slim_memmap_p);
3153 3880
3154 idr_remove(&lpfc_hba_index, phba->brd_no); 3881 lpfc_hba_free(phba);
3155
3156 kfree(phba);
3157 3882
3158 pci_release_selected_regions(pdev, bars); 3883 pci_release_selected_regions(pdev, bars);
3159 pci_disable_device(pdev); 3884 pci_disable_device(pdev);
3160} 3885}
3161 3886
3162/** 3887/**
3163 * lpfc_pci_suspend_one - lpfc PCI func to suspend device for power management 3888 * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt
3164 * @pdev: pointer to PCI device 3889 * @pdev: pointer to PCI device
3165 * @msg: power management message 3890 * @msg: power management message
3166 * 3891 *
3167 * This routine is to be registered to the kernel's PCI subsystem to support 3892 * This routine is to be called from the kernel's PCI subsystem to support
3168 * system Power Management (PM). When PM invokes this method, it quiesces the 3893 * system Power Management (PM) to device with SLI-3 interface spec. When
3169 * device by stopping the driver's worker thread for the device, turning off 3894 * PM invokes this method, it quiesces the device by stopping the driver's
3170 * device's interrupt and DMA, and bring the device offline. Note that as the 3895 * worker thread for the device, turning off device's interrupt and DMA,
3171 * driver implements the minimum PM requirements to a power-aware driver's PM 3896 * and bring the device offline. Note that as the driver implements the
3172 * support for suspend/resume -- all the possible PM messages (SUSPEND, 3897 * minimum PM requirements to a power-aware driver's PM support for the
3173 * HIBERNATE, FREEZE) to the suspend() method call will be treated as SUSPEND 3898 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
3174 * and the driver will fully reinitialize its device during resume() method 3899 * to the suspend() method call will be treated as SUSPEND and the driver will
3175 * call, the driver will set device to PCI_D3hot state in PCI config space 3900 * fully reinitialize its device during resume() method call, the driver will
3176 * instead of setting it according to the @msg provided by the PM. 3901 * set device to PCI_D3hot state in PCI config space instead of setting it
3902 * according to the @msg provided by the PM.
3177 * 3903 *
3178 * Return code 3904 * Return code
3179 * 0 - driver suspended the device 3905 * 0 - driver suspended the device
3180 * Error otherwise 3906 * Error otherwise
3181 **/ 3907 **/
3182static int 3908static int
3183lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg) 3909lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg)
3184{ 3910{
3185 struct Scsi_Host *shost = pci_get_drvdata(pdev); 3911 struct Scsi_Host *shost = pci_get_drvdata(pdev);
3186 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 3912 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
@@ -3194,7 +3920,7 @@ lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
3194 kthread_stop(phba->worker_thread); 3920 kthread_stop(phba->worker_thread);
3195 3921
3196 /* Disable interrupt from device */ 3922 /* Disable interrupt from device */
3197 lpfc_disable_intr(phba); 3923 lpfc_sli_disable_intr(phba);
3198 3924
3199 /* Save device state to PCI config space */ 3925 /* Save device state to PCI config space */
3200 pci_save_state(pdev); 3926 pci_save_state(pdev);
@@ -3204,25 +3930,26 @@ lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
3204} 3930}
3205 3931
3206/** 3932/**
3207 * lpfc_pci_resume_one - lpfc PCI func to resume device for power management 3933 * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt
3208 * @pdev: pointer to PCI device 3934 * @pdev: pointer to PCI device
3209 * 3935 *
3210 * This routine is to be registered to the kernel's PCI subsystem to support 3936 * This routine is to be called from the kernel's PCI subsystem to support
3211 * system Power Management (PM). When PM invokes this method, it restores 3937 * system Power Management (PM) to device with SLI-3 interface spec. When PM
3212 * the device's PCI config space state and fully reinitializes the device 3938 * invokes this method, it restores the device's PCI config space state and
3213 * and brings it online. Note that as the driver implements the minimum PM 3939 * fully reinitializes the device and brings it online. Note that as the
3214 * requirements to a power-aware driver's PM for suspend/resume -- all 3940 * driver implements the minimum PM requirements to a power-aware driver's
3215 * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend() 3941 * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE,
3216 * method call will be treated as SUSPEND and the driver will fully 3942 * FREEZE) to the suspend() method call will be treated as SUSPEND and the
3217 * reinitialize its device during resume() method call, the device will be 3943 * driver will fully reinitialize its device during resume() method call,
3218 * set to PCI_D0 directly in PCI config space before restoring the state. 3944 * the device will be set to PCI_D0 directly in PCI config space before
3945 * restoring the state.
3219 * 3946 *
3220 * Return code 3947 * Return code
3221 * 0 - driver suspended the device 3948 * 0 - driver suspended the device
3222 * Error otherwise 3949 * Error otherwise
3223 **/ 3950 **/
3224static int 3951static int
3225lpfc_pci_resume_one(struct pci_dev *pdev) 3952lpfc_pci_resume_one_s3(struct pci_dev *pdev)
3226{ 3953{
3227 struct Scsi_Host *shost = pci_get_drvdata(pdev); 3954 struct Scsi_Host *shost = pci_get_drvdata(pdev);
3228 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 3955 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
@@ -3250,7 +3977,7 @@ lpfc_pci_resume_one(struct pci_dev *pdev)
3250 } 3977 }
3251 3978
3252 /* Configure and enable interrupt */ 3979 /* Configure and enable interrupt */
3253 intr_mode = lpfc_enable_intr(phba, phba->intr_mode); 3980 intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
3254 if (intr_mode == LPFC_INTR_ERROR) { 3981 if (intr_mode == LPFC_INTR_ERROR) {
3255 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3982 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3256 "0430 PM resume Failed to enable interrupt\n"); 3983 "0430 PM resume Failed to enable interrupt\n");
@@ -3269,23 +3996,24 @@ lpfc_pci_resume_one(struct pci_dev *pdev)
3269} 3996}
3270 3997
3271/** 3998/**
3272 * lpfc_io_error_detected - Driver method for handling PCI I/O error detected 3999 * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
3273 * @pdev: pointer to PCI device. 4000 * @pdev: pointer to PCI device.
3274 * @state: the current PCI connection state. 4001 * @state: the current PCI connection state.
3275 * 4002 *
3276 * This routine is registered to the PCI subsystem for error handling. This 4003 * This routine is called from the PCI subsystem for I/O error handling to
3277 * function is called by the PCI subsystem after a PCI bus error affecting 4004 * device with SLI-3 interface spec. This function is called by the PCI
3278 * this device has been detected. When this function is invoked, it will 4005 * subsystem after a PCI bus error affecting this device has been detected.
3279 * need to stop all the I/Os and interrupt(s) to the device. Once that is 4006 * When this function is invoked, it will need to stop all the I/Os and
3280 * done, it will return PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to 4007 * interrupt(s) to the device. Once that is done, it will return
3281 * perform proper recovery as desired. 4008 * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery
4009 * as desired.
3282 * 4010 *
3283 * Return codes 4011 * Return codes
3284 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery 4012 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
3285 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 4013 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
3286 **/ 4014 **/
3287static pci_ers_result_t lpfc_io_error_detected(struct pci_dev *pdev, 4015static pci_ers_result_t
3288 pci_channel_state_t state) 4016lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state)
3289{ 4017{
3290 struct Scsi_Host *shost = pci_get_drvdata(pdev); 4018 struct Scsi_Host *shost = pci_get_drvdata(pdev);
3291 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 4019 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
@@ -3312,30 +4040,32 @@ static pci_ers_result_t lpfc_io_error_detected(struct pci_dev *pdev,
3312 lpfc_sli_abort_iocb_ring(phba, pring); 4040 lpfc_sli_abort_iocb_ring(phba, pring);
3313 4041
3314 /* Disable interrupt */ 4042 /* Disable interrupt */
3315 lpfc_disable_intr(phba); 4043 lpfc_sli_disable_intr(phba);
3316 4044
3317 /* Request a slot reset. */ 4045 /* Request a slot reset. */
3318 return PCI_ERS_RESULT_NEED_RESET; 4046 return PCI_ERS_RESULT_NEED_RESET;
3319} 4047}
3320 4048
3321/** 4049/**
3322 * lpfc_io_slot_reset - Restart a PCI device from scratch 4050 * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch.
3323 * @pdev: pointer to PCI device. 4051 * @pdev: pointer to PCI device.
3324 * 4052 *
3325 * This routine is registered to the PCI subsystem for error handling. This is 4053 * This routine is called from the PCI subsystem for error handling to
3326 * called after PCI bus has been reset to restart the PCI card from scratch, 4054 * device with SLI-3 interface spec. This is called after PCI bus has been
3327 * as if from a cold-boot. During the PCI subsystem error recovery, after the 4055 * reset to restart the PCI card from scratch, as if from a cold-boot.
3328 * driver returns PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform 4056 * During the PCI subsystem error recovery, after driver returns
3329 * proper error recovery and then call this routine before calling the .resume 4057 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
3330 * method to recover the device. This function will initialize the HBA device, 4058 * recovery and then call this routine before calling the .resume method
3331 * enable the interrupt, but it will just put the HBA to offline state without 4059 * to recover the device. This function will initialize the HBA device,
3332 * passing any I/O traffic. 4060 * enable the interrupt, but it will just put the HBA to offline state
4061 * without passing any I/O traffic.
3333 * 4062 *
3334 * Return codes 4063 * Return codes
3335 * PCI_ERS_RESULT_RECOVERED - the device has been recovered 4064 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
3336 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 4065 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
3337 */ 4066 */
3338static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev) 4067static pci_ers_result_t
4068lpfc_io_slot_reset_s3(struct pci_dev *pdev)
3339{ 4069{
3340 struct Scsi_Host *shost = pci_get_drvdata(pdev); 4070 struct Scsi_Host *shost = pci_get_drvdata(pdev);
3341 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 4071 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
@@ -3354,11 +4084,11 @@ static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
3354 pci_set_master(pdev); 4084 pci_set_master(pdev);
3355 4085
3356 spin_lock_irq(&phba->hbalock); 4086 spin_lock_irq(&phba->hbalock);
3357 psli->sli_flag &= ~LPFC_SLI2_ACTIVE; 4087 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
3358 spin_unlock_irq(&phba->hbalock); 4088 spin_unlock_irq(&phba->hbalock);
3359 4089
3360 /* Configure and enable interrupt */ 4090 /* Configure and enable interrupt */
3361 intr_mode = lpfc_enable_intr(phba, phba->intr_mode); 4091 intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
3362 if (intr_mode == LPFC_INTR_ERROR) { 4092 if (intr_mode == LPFC_INTR_ERROR) {
3363 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4093 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3364 "0427 Cannot re-enable interrupt after " 4094 "0427 Cannot re-enable interrupt after "
@@ -3378,15 +4108,17 @@ static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
3378} 4108}
3379 4109
3380/** 4110/**
3381 * lpfc_io_resume - Resume PCI I/O operation 4111 * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device.
3382 * @pdev: pointer to PCI device 4112 * @pdev: pointer to PCI device
3383 * 4113 *
3384 * This routine is registered to the PCI subsystem for error handling. It is 4114 * This routine is called from the PCI subsystem for error handling to device
3385 * called when kernel error recovery tells the lpfc driver that it is ok to 4115 * with SLI-3 interface spec. It is called when kernel error recovery tells
3386 * resume normal PCI operation after PCI bus error recovery. After this call, 4116 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
3387 * traffic can start to flow from this device again. 4117 * error recovery. After this call, traffic can start to flow from this device
4118 * again.
3388 */ 4119 */
3389static void lpfc_io_resume(struct pci_dev *pdev) 4120static void
4121lpfc_io_resume_s3(struct pci_dev *pdev)
3390{ 4122{
3391 struct Scsi_Host *shost = pci_get_drvdata(pdev); 4123 struct Scsi_Host *shost = pci_get_drvdata(pdev);
3392 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 4124 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
@@ -3394,6 +4126,235 @@ static void lpfc_io_resume(struct pci_dev *pdev)
3394 lpfc_online(phba); 4126 lpfc_online(phba);
3395} 4127}
3396 4128
4129/**
4130 * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem
4131 * @pdev: pointer to PCI device
4132 * @pid: pointer to PCI device identifier
4133 *
4134 * This routine is to be registered to the kernel's PCI subsystem. When an
4135 * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks
4136 * at PCI device-specific information of the device and driver to see if the
4137 * driver state that it can support this kind of device. If the match is
4138 * successful, the driver core invokes this routine. This routine dispatches
4139 * the action to the proper SLI-3 or SLI-4 device probing routine, which will
4140 * do all the initialization that it needs to do to handle the HBA device
4141 * properly.
4142 *
4143 * Return code
4144 * 0 - driver can claim the device
4145 * negative value - driver can not claim the device
4146 **/
4147static int __devinit
4148lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
4149{
4150 int rc;
4151 uint16_t dev_id;
4152
4153 if (pci_read_config_word(pdev, PCI_DEVICE_ID, &dev_id))
4154 return -ENODEV;
4155
4156 switch (dev_id) {
4157 default:
4158 rc = lpfc_pci_probe_one_s3(pdev, pid);
4159 break;
4160 }
4161 return rc;
4162}
4163
4164/**
4165 * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem
4166 * @pdev: pointer to PCI device
4167 *
4168 * This routine is to be registered to the kernel's PCI subsystem. When an
4169 * Emulex HBA is removed from PCI bus, the driver core invokes this routine.
4170 * This routine dispatches the action to the proper SLI-3 or SLI-4 device
4171 * remove routine, which will perform all the necessary cleanup for the
4172 * device to be removed from the PCI subsystem properly.
4173 **/
4174static void __devexit
4175lpfc_pci_remove_one(struct pci_dev *pdev)
4176{
4177 struct Scsi_Host *shost = pci_get_drvdata(pdev);
4178 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
4179
4180 switch (phba->pci_dev_grp) {
4181 case LPFC_PCI_DEV_LP:
4182 lpfc_pci_remove_one_s3(pdev);
4183 break;
4184 default:
4185 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4186 "1424 Invalid PCI device group: 0x%x\n",
4187 phba->pci_dev_grp);
4188 break;
4189 }
4190 return;
4191}
4192
4193/**
4194 * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management
4195 * @pdev: pointer to PCI device
4196 * @msg: power management message
4197 *
4198 * This routine is to be registered to the kernel's PCI subsystem to support
4199 * system Power Management (PM). When PM invokes this method, it dispatches
4200 * the action to the proper SLI-3 or SLI-4 device suspend routine, which will
4201 * suspend the device.
4202 *
4203 * Return code
4204 * 0 - driver suspended the device
4205 * Error otherwise
4206 **/
4207static int
4208lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
4209{
4210 struct Scsi_Host *shost = pci_get_drvdata(pdev);
4211 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
4212 int rc = -ENODEV;
4213
4214 switch (phba->pci_dev_grp) {
4215 case LPFC_PCI_DEV_LP:
4216 rc = lpfc_pci_suspend_one_s3(pdev, msg);
4217 break;
4218 default:
4219 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4220 "1425 Invalid PCI device group: 0x%x\n",
4221 phba->pci_dev_grp);
4222 break;
4223 }
4224 return rc;
4225}
4226
4227/**
4228 * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management
4229 * @pdev: pointer to PCI device
4230 *
4231 * This routine is to be registered to the kernel's PCI subsystem to support
4232 * system Power Management (PM). When PM invokes this method, it dispatches
4233 * the action to the proper SLI-3 or SLI-4 device resume routine, which will
4234 * resume the device.
4235 *
4236 * Return code
4237 * 0 - driver suspended the device
4238 * Error otherwise
4239 **/
4240static int
4241lpfc_pci_resume_one(struct pci_dev *pdev)
4242{
4243 struct Scsi_Host *shost = pci_get_drvdata(pdev);
4244 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
4245 int rc = -ENODEV;
4246
4247 switch (phba->pci_dev_grp) {
4248 case LPFC_PCI_DEV_LP:
4249 rc = lpfc_pci_resume_one_s3(pdev);
4250 break;
4251 default:
4252 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4253 "1426 Invalid PCI device group: 0x%x\n",
4254 phba->pci_dev_grp);
4255 break;
4256 }
4257 return rc;
4258}
4259
4260/**
4261 * lpfc_io_error_detected - lpfc method for handling PCI I/O error
4262 * @pdev: pointer to PCI device.
4263 * @state: the current PCI connection state.
4264 *
4265 * This routine is registered to the PCI subsystem for error handling. This
4266 * function is called by the PCI subsystem after a PCI bus error affecting
4267 * this device has been detected. When this routine is invoked, it dispatches
4268 * the action to the proper SLI-3 or SLI-4 device error detected handling
4269 * routine, which will perform the proper error detected operation.
4270 *
4271 * Return codes
4272 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
4273 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
4274 **/
4275static pci_ers_result_t
4276lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
4277{
4278 struct Scsi_Host *shost = pci_get_drvdata(pdev);
4279 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
4280 pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
4281
4282 switch (phba->pci_dev_grp) {
4283 case LPFC_PCI_DEV_LP:
4284 rc = lpfc_io_error_detected_s3(pdev, state);
4285 break;
4286 default:
4287 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4288 "1427 Invalid PCI device group: 0x%x\n",
4289 phba->pci_dev_grp);
4290 break;
4291 }
4292 return rc;
4293}
4294
4295/**
4296 * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch
4297 * @pdev: pointer to PCI device.
4298 *
4299 * This routine is registered to the PCI subsystem for error handling. This
4300 * function is called after PCI bus has been reset to restart the PCI card
4301 * from scratch, as if from a cold-boot. When this routine is invoked, it
4302 * dispatches the action to the proper SLI-3 or SLI-4 device reset handling
4303 * routine, which will perform the proper device reset.
4304 *
4305 * Return codes
4306 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
4307 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
4308 **/
4309static pci_ers_result_t
4310lpfc_io_slot_reset(struct pci_dev *pdev)
4311{
4312 struct Scsi_Host *shost = pci_get_drvdata(pdev);
4313 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
4314 pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
4315
4316 switch (phba->pci_dev_grp) {
4317 case LPFC_PCI_DEV_LP:
4318 rc = lpfc_io_slot_reset_s3(pdev);
4319 break;
4320 default:
4321 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4322 "1428 Invalid PCI device group: 0x%x\n",
4323 phba->pci_dev_grp);
4324 break;
4325 }
4326 return rc;
4327}
4328
4329/**
4330 * lpfc_io_resume - lpfc method for resuming PCI I/O operation
4331 * @pdev: pointer to PCI device
4332 *
4333 * This routine is registered to the PCI subsystem for error handling. It
4334 * is called when kernel error recovery tells the lpfc driver that it is
4335 * OK to resume normal PCI operation after PCI bus error recovery. When
4336 * this routine is invoked, it dispatches the action to the proper SLI-3
4337 * or SLI-4 device io_resume routine, which will resume the device operation.
4338 **/
4339static void
4340lpfc_io_resume(struct pci_dev *pdev)
4341{
4342 struct Scsi_Host *shost = pci_get_drvdata(pdev);
4343 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
4344
4345 switch (phba->pci_dev_grp) {
4346 case LPFC_PCI_DEV_LP:
4347 lpfc_io_resume_s3(pdev);
4348 break;
4349 default:
4350 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4351 "1429 Invalid PCI device group: 0x%x\n",
4352 phba->pci_dev_grp);
4353 break;
4354 }
4355 return;
4356}
4357
3397static struct pci_device_id lpfc_id_table[] = { 4358static struct pci_device_id lpfc_id_table[] = {
3398 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER, 4359 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER,
3399 PCI_ANY_ID, PCI_ANY_ID, }, 4360 PCI_ANY_ID, PCI_ANY_ID, },
@@ -3469,6 +4430,10 @@ static struct pci_device_id lpfc_id_table[] = {
3469 PCI_ANY_ID, PCI_ANY_ID, }, 4430 PCI_ANY_ID, PCI_ANY_ID, },
3470 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S, 4431 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S,
3471 PCI_ANY_ID, PCI_ANY_ID, }, 4432 PCI_ANY_ID, PCI_ANY_ID, },
4433 {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TIGERSHARK,
4434 PCI_ANY_ID, PCI_ANY_ID, },
4435 {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TIGERSHARK_S,
4436 PCI_ANY_ID, PCI_ANY_ID, },
3472 { 0 } 4437 { 0 }
3473}; 4438};
3474 4439
@@ -3486,7 +4451,7 @@ static struct pci_driver lpfc_driver = {
3486 .probe = lpfc_pci_probe_one, 4451 .probe = lpfc_pci_probe_one,
3487 .remove = __devexit_p(lpfc_pci_remove_one), 4452 .remove = __devexit_p(lpfc_pci_remove_one),
3488 .suspend = lpfc_pci_suspend_one, 4453 .suspend = lpfc_pci_suspend_one,
3489 .resume = lpfc_pci_resume_one, 4454 .resume = lpfc_pci_resume_one,
3490 .err_handler = &lpfc_err_handler, 4455 .err_handler = &lpfc_err_handler,
3491}; 4456};
3492 4457
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 167b66dd34c7..a226c053c0f4 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -438,22 +438,23 @@ lpfc_scsi_dev_block(struct lpfc_hba *phba)
438} 438}
439 439
440/** 440/**
441 * lpfc_new_scsi_buf - Scsi buffer allocator 441 * lpfc_new_scsi_buf_s3 - Scsi buffer allocator for HBA with SLI3 IF spec
442 * @vport: The virtual port for which this call being executed. 442 * @vport: The virtual port for which this call being executed.
443 * @num_to_allocate: The requested number of buffers to allocate.
443 * 444 *
444 * This routine allocates a scsi buffer, which contains all the necessary 445 * This routine allocates a scsi buffer for device with SLI-3 interface spec,
445 * information needed to initiate a SCSI I/O. The non-DMAable buffer region 446 * the scsi buffer contains all the necessary information needed to initiate
446 * contains information to build the IOCB. The DMAable region contains 447 * a SCSI I/O. The non-DMAable buffer region contains information to build
447 * memory for the FCP CMND, FCP RSP, and the initial BPL. In addition to 448 * the IOCB. The DMAable region contains memory for the FCP CMND, FCP RSP,
448 * allocating memory, the FCP CMND and FCP RSP BDEs are setup in the BPL 449 * and the initial BPL. In addition to allocating memory, the FCP CMND and
449 * and the BPL BDE is setup in the IOCB. 450 * FCP RSP BDEs are setup in the BPL and the BPL BDE is setup in the IOCB.
450 * 451 *
451 * Return codes: 452 * Return codes:
452 * NULL - Error 453 * int - number of scsi buffers that were allocated.
453 * Pointer to lpfc_scsi_buf data structure - Success 454 * 0 = failure, less than num_to_alloc is a partial failure.
454 **/ 455 **/
455static struct lpfc_scsi_buf * 456static int
456lpfc_new_scsi_buf(struct lpfc_vport *vport) 457lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc)
457{ 458{
458 struct lpfc_hba *phba = vport->phba; 459 struct lpfc_hba *phba = vport->phba;
459 struct lpfc_scsi_buf *psb; 460 struct lpfc_scsi_buf *psb;
@@ -463,107 +464,134 @@ lpfc_new_scsi_buf(struct lpfc_vport *vport)
463 dma_addr_t pdma_phys_fcp_rsp; 464 dma_addr_t pdma_phys_fcp_rsp;
464 dma_addr_t pdma_phys_bpl; 465 dma_addr_t pdma_phys_bpl;
465 uint16_t iotag; 466 uint16_t iotag;
467 int bcnt;
466 468
467 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL); 469 for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
468 if (!psb) 470 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
469 return NULL; 471 if (!psb)
472 break;
470 473
471 /* 474 /*
472 * Get memory from the pci pool to map the virt space to pci bus space 475 * Get memory from the pci pool to map the virt space to pci
473 * for an I/O. The DMA buffer includes space for the struct fcp_cmnd, 476 * bus space for an I/O. The DMA buffer includes space for the
474 * struct fcp_rsp and the number of bde's necessary to support the 477 * struct fcp_cmnd, struct fcp_rsp and the number of bde's
475 * sg_tablesize. 478 * necessary to support the sg_tablesize.
476 */ 479 */
477 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool, GFP_KERNEL, 480 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool,
478 &psb->dma_handle); 481 GFP_KERNEL, &psb->dma_handle);
479 if (!psb->data) { 482 if (!psb->data) {
480 kfree(psb); 483 kfree(psb);
481 return NULL; 484 break;
482 } 485 }
483 486
484 /* Initialize virtual ptrs to dma_buf region. */ 487 /* Initialize virtual ptrs to dma_buf region. */
485 memset(psb->data, 0, phba->cfg_sg_dma_buf_size); 488 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
486 489
487 /* Allocate iotag for psb->cur_iocbq. */ 490 /* Allocate iotag for psb->cur_iocbq. */
488 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq); 491 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
489 if (iotag == 0) { 492 if (iotag == 0) {
490 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, 493 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
491 psb->data, psb->dma_handle); 494 psb->data, psb->dma_handle);
492 kfree (psb); 495 kfree(psb);
493 return NULL; 496 break;
494 } 497 }
495 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP; 498 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
496 499
497 psb->fcp_cmnd = psb->data; 500 psb->fcp_cmnd = psb->data;
498 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd); 501 psb->fcp_rsp = psb->data + sizeof(struct fcp_cmnd);
499 psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) + 502 psb->fcp_bpl = psb->data + sizeof(struct fcp_cmnd) +
500 sizeof(struct fcp_rsp);
501
502 /* Initialize local short-hand pointers. */
503 bpl = psb->fcp_bpl;
504 pdma_phys_fcp_cmd = psb->dma_handle;
505 pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd);
506 pdma_phys_bpl = psb->dma_handle + sizeof(struct fcp_cmnd) +
507 sizeof(struct fcp_rsp); 503 sizeof(struct fcp_rsp);
508 504
509 /* 505 /* Initialize local short-hand pointers. */
510 * The first two bdes are the FCP_CMD and FCP_RSP. The balance are sg 506 bpl = psb->fcp_bpl;
511 * list bdes. Initialize the first two and leave the rest for 507 pdma_phys_fcp_cmd = psb->dma_handle;
512 * queuecommand. 508 pdma_phys_fcp_rsp = psb->dma_handle + sizeof(struct fcp_cmnd);
513 */ 509 pdma_phys_bpl = psb->dma_handle + sizeof(struct fcp_cmnd) +
514 bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd)); 510 sizeof(struct fcp_rsp);
515 bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd)); 511
516 bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd); 512 /*
517 bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64; 513 * The first two bdes are the FCP_CMD and FCP_RSP. The balance
518 bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w); 514 * are sg list bdes. Initialize the first two and leave the
519 515 * rest for queuecommand.
520 /* Setup the physical region for the FCP RSP */ 516 */
521 bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp)); 517 bpl[0].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_cmd));
522 bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp)); 518 bpl[0].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_cmd));
523 bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp); 519 bpl[0].tus.f.bdeSize = sizeof(struct fcp_cmnd);
524 bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64; 520 bpl[0].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
525 bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w); 521 bpl[0].tus.w = le32_to_cpu(bpl[0].tus.w);
522
523 /* Setup the physical region for the FCP RSP */
524 bpl[1].addrHigh = le32_to_cpu(putPaddrHigh(pdma_phys_fcp_rsp));
525 bpl[1].addrLow = le32_to_cpu(putPaddrLow(pdma_phys_fcp_rsp));
526 bpl[1].tus.f.bdeSize = sizeof(struct fcp_rsp);
527 bpl[1].tus.f.bdeFlags = BUFF_TYPE_BDE_64;
528 bpl[1].tus.w = le32_to_cpu(bpl[1].tus.w);
529
530 /*
531 * Since the IOCB for the FCP I/O is built into this
532 * lpfc_scsi_buf, initialize it with all known data now.
533 */
534 iocb = &psb->cur_iocbq.iocb;
535 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
536 if ((phba->sli_rev == 3) &&
537 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
538 /* fill in immediate fcp command BDE */
539 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED;
540 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
541 iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t,
542 unsli3.fcp_ext.icd);
543 iocb->un.fcpi64.bdl.addrHigh = 0;
544 iocb->ulpBdeCount = 0;
545 iocb->ulpLe = 0;
546 /* fill in responce BDE */
547 iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags =
548 BUFF_TYPE_BDE_64;
549 iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize =
550 sizeof(struct fcp_rsp);
551 iocb->unsli3.fcp_ext.rbde.addrLow =
552 putPaddrLow(pdma_phys_fcp_rsp);
553 iocb->unsli3.fcp_ext.rbde.addrHigh =
554 putPaddrHigh(pdma_phys_fcp_rsp);
555 } else {
556 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
557 iocb->un.fcpi64.bdl.bdeSize =
558 (2 * sizeof(struct ulp_bde64));
559 iocb->un.fcpi64.bdl.addrLow =
560 putPaddrLow(pdma_phys_bpl);
561 iocb->un.fcpi64.bdl.addrHigh =
562 putPaddrHigh(pdma_phys_bpl);
563 iocb->ulpBdeCount = 1;
564 iocb->ulpLe = 1;
565 }
566 iocb->ulpClass = CLASS3;
567 psb->status = IOSTAT_SUCCESS;
526 568
527 /*
528 * Since the IOCB for the FCP I/O is built into this lpfc_scsi_buf,
529 * initialize it with all known data now.
530 */
531 iocb = &psb->cur_iocbq.iocb;
532 iocb->un.fcpi64.bdl.ulpIoTag32 = 0;
533 if ((phba->sli_rev == 3) &&
534 !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
535 /* fill in immediate fcp command BDE */
536 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BDE_IMMED;
537 iocb->un.fcpi64.bdl.bdeSize = sizeof(struct fcp_cmnd);
538 iocb->un.fcpi64.bdl.addrLow = offsetof(IOCB_t,
539 unsli3.fcp_ext.icd);
540 iocb->un.fcpi64.bdl.addrHigh = 0;
541 iocb->ulpBdeCount = 0;
542 iocb->ulpLe = 0;
543 /* fill in responce BDE */
544 iocb->unsli3.fcp_ext.rbde.tus.f.bdeFlags = BUFF_TYPE_BDE_64;
545 iocb->unsli3.fcp_ext.rbde.tus.f.bdeSize =
546 sizeof(struct fcp_rsp);
547 iocb->unsli3.fcp_ext.rbde.addrLow =
548 putPaddrLow(pdma_phys_fcp_rsp);
549 iocb->unsli3.fcp_ext.rbde.addrHigh =
550 putPaddrHigh(pdma_phys_fcp_rsp);
551 } else {
552 iocb->un.fcpi64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
553 iocb->un.fcpi64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
554 iocb->un.fcpi64.bdl.addrLow = putPaddrLow(pdma_phys_bpl);
555 iocb->un.fcpi64.bdl.addrHigh = putPaddrHigh(pdma_phys_bpl);
556 iocb->ulpBdeCount = 1;
557 iocb->ulpLe = 1;
558 } 569 }
559 iocb->ulpClass = CLASS3;
560 570
561 return psb; 571 return bcnt;
562} 572}
563 573
564/** 574/**
565 * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list list of Hba 575 * lpfc_new_scsi_buf - Wrapper funciton for scsi buffer allocator
566 * @phba: The Hba for which this call is being executed. 576 * @vport: The virtual port for which this call being executed.
577 * @num_to_allocate: The requested number of buffers to allocate.
578 *
579 * This routine wraps the actual SCSI buffer allocator function pointer from
580 * the lpfc_hba struct.
581 *
582 * Return codes:
583 * int - number of scsi buffers that were allocated.
584 * 0 = failure, less than num_to_alloc is a partial failure.
585 **/
586static inline int
587lpfc_new_scsi_buf(struct lpfc_vport *vport, int num_to_alloc)
588{
589 return vport->phba->lpfc_new_scsi_buf(vport, num_to_alloc);
590}
591
592/**
593 * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
594 * @phba: The HBA for which this call is being executed.
567 * 595 *
568 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list 596 * This routine removes a scsi buffer from head of @phba lpfc_scsi_buf_list list
569 * and returns to caller. 597 * and returns to caller.
@@ -591,7 +619,7 @@ lpfc_get_scsi_buf(struct lpfc_hba * phba)
591} 619}
592 620
593/** 621/**
594 * lpfc_release_scsi_buf - Return a scsi buffer back to hba's lpfc_scsi_buf_list 622 * lpfc_release_scsi_buf - Return a scsi buffer back to hba scsi buf list
595 * @phba: The Hba for which this call is being executed. 623 * @phba: The Hba for which this call is being executed.
596 * @psb: The scsi buffer which is being released. 624 * @psb: The scsi buffer which is being released.
597 * 625 *
@@ -599,7 +627,7 @@ lpfc_get_scsi_buf(struct lpfc_hba * phba)
599 * lpfc_scsi_buf_list list. 627 * lpfc_scsi_buf_list list.
600 **/ 628 **/
601static void 629static void
602lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb) 630lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
603{ 631{
604 unsigned long iflag = 0; 632 unsigned long iflag = 0;
605 633
@@ -610,21 +638,36 @@ lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
610} 638}
611 639
612/** 640/**
613 * lpfc_scsi_prep_dma_buf - Routine to do DMA mapping for scsi buffer 641 * lpfc_release_scsi_buf: Return a scsi buffer back to hba scsi buf list.
642 * @phba: The Hba for which this call is being executed.
643 * @psb: The scsi buffer which is being released.
644 *
645 * This routine releases @psb scsi buffer by adding it to tail of @phba
646 * lpfc_scsi_buf_list list.
647 **/
648static void
649lpfc_release_scsi_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
650{
651
652 phba->lpfc_release_scsi_buf(phba, psb);
653}
654
655/**
656 * lpfc_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
614 * @phba: The Hba for which this call is being executed. 657 * @phba: The Hba for which this call is being executed.
615 * @lpfc_cmd: The scsi buffer which is going to be mapped. 658 * @lpfc_cmd: The scsi buffer which is going to be mapped.
616 * 659 *
617 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd 660 * This routine does the pci dma mapping for scatter-gather list of scsi cmnd
618 * field of @lpfc_cmd. This routine scans through sg elements and format the 661 * field of @lpfc_cmd for device with SLI-3 interface spec. This routine scans
619 * bdea. This routine also initializes all IOCB fields which are dependent on 662 * through sg elements and format the bdea. This routine also initializes all
620 * scsi command request buffer. 663 * IOCB fields which are dependent on scsi command request buffer.
621 * 664 *
622 * Return codes: 665 * Return codes:
623 * 1 - Error 666 * 1 - Error
624 * 0 - Success 667 * 0 - Success
625 **/ 668 **/
626static int 669static int
627lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd) 670lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
628{ 671{
629 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd; 672 struct scsi_cmnd *scsi_cmnd = lpfc_cmd->pCmd;
630 struct scatterlist *sgel = NULL; 673 struct scatterlist *sgel = NULL;
@@ -1412,6 +1455,24 @@ out:
1412} 1455}
1413 1456
1414/** 1457/**
1458 * lpfc_scsi_prep_dma_buf - Wrapper function for DMA mapping of scsi buffer
1459 * @phba: The Hba for which this call is being executed.
1460 * @lpfc_cmd: The scsi buffer which is going to be mapped.
1461 *
1462 * This routine wraps the actual DMA mapping function pointer from the
1463 * lpfc_hba struct.
1464 *
1465 * Return codes:
1466 * 1 - Error
1467 * 0 - Success
1468 **/
1469static inline int
1470lpfc_scsi_prep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
1471{
1472 return phba->lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
1473}
1474
1475/**
1415 * lpfc_send_scsi_error_event - Posts an event when there is SCSI error 1476 * lpfc_send_scsi_error_event - Posts an event when there is SCSI error
1416 * @phba: Pointer to hba context object. 1477 * @phba: Pointer to hba context object.
1417 * @vport: Pointer to vport object. 1478 * @vport: Pointer to vport object.
@@ -1504,15 +1565,15 @@ lpfc_send_scsi_error_event(struct lpfc_hba *phba, struct lpfc_vport *vport,
1504} 1565}
1505 1566
1506/** 1567/**
1507 * lpfc_scsi_unprep_dma_buf - Routine to un-map DMA mapping of scatter gather 1568 * lpfc_scsi_unprep_dma_buf_s3 - Un-map DMA mapping of SG-list for SLI3 dev
1508 * @phba: The Hba for which this call is being executed. 1569 * @phba: The HBA for which this call is being executed.
1509 * @psb: The scsi buffer which is going to be un-mapped. 1570 * @psb: The scsi buffer which is going to be un-mapped.
1510 * 1571 *
1511 * This routine does DMA un-mapping of scatter gather list of scsi command 1572 * This routine does DMA un-mapping of scatter gather list of scsi command
1512 * field of @lpfc_cmd. 1573 * field of @lpfc_cmd for device with SLI-3 interface spec.
1513 **/ 1574 **/
1514static void 1575static void
1515lpfc_scsi_unprep_dma_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb) 1576lpfc_scsi_unprep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1516{ 1577{
1517 /* 1578 /*
1518 * There are only two special cases to consider. (1) the scsi command 1579 * There are only two special cases to consider. (1) the scsi command
@@ -1529,6 +1590,20 @@ lpfc_scsi_unprep_dma_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb)
1529} 1590}
1530 1591
1531/** 1592/**
1593 * lpfc_scsi_unprep_dma_buf - Wrapper function for unmap DMA mapping of SG-list
1594 * @phba: The Hba for which this call is being executed.
1595 * @psb: The scsi buffer which is going to be un-mapped.
1596 *
1597 * This routine does DMA un-mapping of scatter gather list of scsi command
1598 * field of @lpfc_cmd for device with SLI-4 interface spec.
1599 **/
1600static void
1601lpfc_scsi_unprep_dma_buf(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
1602{
1603 phba->lpfc_scsi_unprep_dma_buf(phba, psb);
1604}
1605
1606/**
1532 * lpfc_handler_fcp_err - FCP response handler 1607 * lpfc_handler_fcp_err - FCP response handler
1533 * @vport: The virtual port for which this call is being executed. 1608 * @vport: The virtual port for which this call is being executed.
1534 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure. 1609 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
@@ -1676,7 +1751,7 @@ lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
1676 * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine 1751 * lpfc_scsi_cmd_iocb_cmpl - Scsi cmnd IOCB completion routine
1677 * @phba: The Hba for which this call is being executed. 1752 * @phba: The Hba for which this call is being executed.
1678 * @pIocbIn: The command IOCBQ for the scsi cmnd. 1753 * @pIocbIn: The command IOCBQ for the scsi cmnd.
1679 * @pIocbOut: The response IOCBQ for the scsi cmnd . 1754 * @pIocbOut: The response IOCBQ for the scsi cmnd.
1680 * 1755 *
1681 * This routine assigns scsi command result by looking into response IOCB 1756 * This routine assigns scsi command result by looking into response IOCB
1682 * status field appropriately. This routine handles QUEUE FULL condition as 1757 * status field appropriately. This routine handles QUEUE FULL condition as
@@ -1957,16 +2032,16 @@ lpfc_fcpcmd_to_iocb(uint8_t *data, struct fcp_cmnd *fcp_cmnd)
1957} 2032}
1958 2033
1959/** 2034/**
1960 * lpfc_scsi_prep_cmnd - Routine to convert scsi cmnd to FCP information unit 2035 * lpfc_scsi_prep_cmnd_s3 - Convert scsi cmnd to FCP infor unit for SLI3 dev
1961 * @vport: The virtual port for which this call is being executed. 2036 * @vport: The virtual port for which this call is being executed.
1962 * @lpfc_cmd: The scsi command which needs to send. 2037 * @lpfc_cmd: The scsi command which needs to send.
1963 * @pnode: Pointer to lpfc_nodelist. 2038 * @pnode: Pointer to lpfc_nodelist.
1964 * 2039 *
1965 * This routine initializes fcp_cmnd and iocb data structure from scsi command 2040 * This routine initializes fcp_cmnd and iocb data structure from scsi command
1966 * to transfer. 2041 * to transfer for device with SLI3 interface spec.
1967 **/ 2042 **/
1968static void 2043static void
1969lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd, 2044lpfc_scsi_prep_cmnd_s3(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
1970 struct lpfc_nodelist *pnode) 2045 struct lpfc_nodelist *pnode)
1971{ 2046{
1972 struct lpfc_hba *phba = vport->phba; 2047 struct lpfc_hba *phba = vport->phba;
@@ -2013,8 +2088,11 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
2013 if (scsi_sg_count(scsi_cmnd)) { 2088 if (scsi_sg_count(scsi_cmnd)) {
2014 if (datadir == DMA_TO_DEVICE) { 2089 if (datadir == DMA_TO_DEVICE) {
2015 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR; 2090 iocb_cmd->ulpCommand = CMD_FCP_IWRITE64_CR;
2016 iocb_cmd->un.fcpi.fcpi_parm = 0; 2091 if (phba->sli_rev < LPFC_SLI_REV4) {
2017 iocb_cmd->ulpPU = 0; 2092 iocb_cmd->un.fcpi.fcpi_parm = 0;
2093 iocb_cmd->ulpPU = 0;
2094 } else
2095 iocb_cmd->ulpPU = PARM_READ_CHECK;
2018 fcp_cmnd->fcpCntl3 = WRITE_DATA; 2096 fcp_cmnd->fcpCntl3 = WRITE_DATA;
2019 phba->fc4OutputRequests++; 2097 phba->fc4OutputRequests++;
2020 } else { 2098 } else {
@@ -2051,20 +2129,37 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
2051} 2129}
2052 2130
2053/** 2131/**
2054 * lpfc_scsi_prep_task_mgmt_cmnd - Convert scsi TM cmnd to FCP information unit 2132 * lpfc_scsi_prep_cmnd - Wrapper func for convert scsi cmnd to FCP info unit
2133 * @vport: The virtual port for which this call is being executed.
2134 * @lpfc_cmd: The scsi command which needs to send.
2135 * @pnode: Pointer to lpfc_nodelist.
2136 *
2137 * This routine wraps the actual convert SCSI cmnd function pointer from
2138 * the lpfc_hba struct.
2139 **/
2140static inline void
2141lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
2142 struct lpfc_nodelist *pnode)
2143{
2144 vport->phba->lpfc_scsi_prep_cmnd(vport, lpfc_cmd, pnode);
2145}
2146
2147/**
2148 * lpfc_scsi_prep_task_mgmt_cmnd_s3 - Convert SLI3 scsi TM cmd to FCP info unit
2055 * @vport: The virtual port for which this call is being executed. 2149 * @vport: The virtual port for which this call is being executed.
2056 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure. 2150 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
2057 * @lun: Logical unit number. 2151 * @lun: Logical unit number.
2058 * @task_mgmt_cmd: SCSI task management command. 2152 * @task_mgmt_cmd: SCSI task management command.
2059 * 2153 *
2060 * This routine creates FCP information unit corresponding to @task_mgmt_cmd. 2154 * This routine creates FCP information unit corresponding to @task_mgmt_cmd
2155 * for device with SLI-3 interface spec.
2061 * 2156 *
2062 * Return codes: 2157 * Return codes:
2063 * 0 - Error 2158 * 0 - Error
2064 * 1 - Success 2159 * 1 - Success
2065 **/ 2160 **/
2066static int 2161static int
2067lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport, 2162lpfc_scsi_prep_task_mgmt_cmd_s3(struct lpfc_vport *vport,
2068 struct lpfc_scsi_buf *lpfc_cmd, 2163 struct lpfc_scsi_buf *lpfc_cmd,
2069 unsigned int lun, 2164 unsigned int lun,
2070 uint8_t task_mgmt_cmd) 2165 uint8_t task_mgmt_cmd)
@@ -2114,6 +2209,67 @@ lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
2114} 2209}
2115 2210
2116/** 2211/**
2212 * lpfc_scsi_prep_task_mgmt_cmnd - Wrapper func convert scsi TM cmd to FCP info
2213 * @vport: The virtual port for which this call is being executed.
2214 * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
2215 * @lun: Logical unit number.
2216 * @task_mgmt_cmd: SCSI task management command.
2217 *
2218 * This routine wraps the actual convert SCSI TM to FCP information unit
2219 * function pointer from the lpfc_hba struct.
2220 *
2221 * Return codes:
2222 * 0 - Error
2223 * 1 - Success
2224 **/
2225static inline int
2226lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
2227 struct lpfc_scsi_buf *lpfc_cmd,
2228 unsigned int lun,
2229 uint8_t task_mgmt_cmd)
2230{
2231 struct lpfc_hba *phba = vport->phba;
2232
2233 return phba->lpfc_scsi_prep_task_mgmt_cmd(vport, lpfc_cmd, lun,
2234 task_mgmt_cmd);
2235}
2236
2237/**
2238 * lpfc_scsi_api_table_setup - Set up scsi api fucntion jump table
2239 * @phba: The hba struct for which this call is being executed.
2240 * @dev_grp: The HBA PCI-Device group number.
2241 *
2242 * This routine sets up the SCSI interface API function jump table in @phba
2243 * struct.
2244 * Returns: 0 - success, -ENODEV - failure.
2245 **/
2246int
2247lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
2248{
2249
2250 switch (dev_grp) {
2251 case LPFC_PCI_DEV_LP:
2252 phba->lpfc_new_scsi_buf = lpfc_new_scsi_buf_s3;
2253 phba->lpfc_scsi_prep_dma_buf = lpfc_scsi_prep_dma_buf_s3;
2254 phba->lpfc_scsi_prep_cmnd = lpfc_scsi_prep_cmnd_s3;
2255 phba->lpfc_scsi_unprep_dma_buf = lpfc_scsi_unprep_dma_buf_s3;
2256 phba->lpfc_scsi_prep_task_mgmt_cmd =
2257 lpfc_scsi_prep_task_mgmt_cmd_s3;
2258 phba->lpfc_release_scsi_buf = lpfc_release_scsi_buf_s3;
2259 break;
2260 default:
2261 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2262 "1418 Invalid HBA PCI-device group: 0x%x\n",
2263 dev_grp);
2264 return -ENODEV;
2265 break;
2266 }
2267 phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf;
2268 phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
2269 return 0;
2270}
2271
2272/**
2117 * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command 2273 * lpfc_taskmgmt_def_cmpl - IOCB completion routine for task management command
2118 * @phba: The Hba for which this call is being executed. 2274 * @phba: The Hba for which this call is being executed.
2119 * @cmdiocbq: Pointer to lpfc_iocbq data structure. 2275 * @cmdiocbq: Pointer to lpfc_iocbq data structure.
@@ -2178,9 +2334,8 @@ lpfc_scsi_tgt_reset(struct lpfc_scsi_buf *lpfc_cmd, struct lpfc_vport *vport,
2178 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP, 2334 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
2179 "0702 Issue Target Reset to TGT %d Data: x%x x%x\n", 2335 "0702 Issue Target Reset to TGT %d Data: x%x x%x\n",
2180 tgt_id, rdata->pnode->nlp_rpi, rdata->pnode->nlp_flag); 2336 tgt_id, rdata->pnode->nlp_rpi, rdata->pnode->nlp_flag);
2181 status = lpfc_sli_issue_iocb_wait(phba, 2337 status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
2182 &phba->sli.ring[phba->sli.fcp_ring], 2338 iocbq, iocbqrsp, lpfc_cmd->timeout);
2183 iocbq, iocbqrsp, lpfc_cmd->timeout);
2184 if (status != IOCB_SUCCESS) { 2339 if (status != IOCB_SUCCESS) {
2185 if (status == IOCB_TIMEDOUT) { 2340 if (status == IOCB_TIMEDOUT) {
2186 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl; 2341 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
@@ -2305,7 +2460,6 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
2305 struct Scsi_Host *shost = cmnd->device->host; 2460 struct Scsi_Host *shost = cmnd->device->host;
2306 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2461 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2307 struct lpfc_hba *phba = vport->phba; 2462 struct lpfc_hba *phba = vport->phba;
2308 struct lpfc_sli *psli = &phba->sli;
2309 struct lpfc_rport_data *rdata = cmnd->device->hostdata; 2463 struct lpfc_rport_data *rdata = cmnd->device->hostdata;
2310 struct lpfc_nodelist *ndlp = rdata->pnode; 2464 struct lpfc_nodelist *ndlp = rdata->pnode;
2311 struct lpfc_scsi_buf *lpfc_cmd; 2465 struct lpfc_scsi_buf *lpfc_cmd;
@@ -2427,7 +2581,7 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
2427 lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp); 2581 lpfc_scsi_prep_cmnd(vport, lpfc_cmd, ndlp);
2428 2582
2429 atomic_inc(&ndlp->cmd_pending); 2583 atomic_inc(&ndlp->cmd_pending);
2430 err = lpfc_sli_issue_iocb(phba, &phba->sli.ring[psli->fcp_ring], 2584 err = lpfc_sli_issue_iocb(phba, LPFC_FCP_RING,
2431 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB); 2585 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
2432 if (err) { 2586 if (err) {
2433 atomic_dec(&ndlp->cmd_pending); 2587 atomic_dec(&ndlp->cmd_pending);
@@ -2490,7 +2644,6 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
2490 struct Scsi_Host *shost = cmnd->device->host; 2644 struct Scsi_Host *shost = cmnd->device->host;
2491 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2645 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2492 struct lpfc_hba *phba = vport->phba; 2646 struct lpfc_hba *phba = vport->phba;
2493 struct lpfc_sli_ring *pring = &phba->sli.ring[phba->sli.fcp_ring];
2494 struct lpfc_iocbq *iocb; 2647 struct lpfc_iocbq *iocb;
2495 struct lpfc_iocbq *abtsiocb; 2648 struct lpfc_iocbq *abtsiocb;
2496 struct lpfc_scsi_buf *lpfc_cmd; 2649 struct lpfc_scsi_buf *lpfc_cmd;
@@ -2531,7 +2684,10 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
2531 icmd = &abtsiocb->iocb; 2684 icmd = &abtsiocb->iocb;
2532 icmd->un.acxri.abortType = ABORT_TYPE_ABTS; 2685 icmd->un.acxri.abortType = ABORT_TYPE_ABTS;
2533 icmd->un.acxri.abortContextTag = cmd->ulpContext; 2686 icmd->un.acxri.abortContextTag = cmd->ulpContext;
2534 icmd->un.acxri.abortIoTag = cmd->ulpIoTag; 2687 if (phba->sli_rev == LPFC_SLI_REV4)
2688 icmd->un.acxri.abortIoTag = iocb->sli4_xritag;
2689 else
2690 icmd->un.acxri.abortIoTag = cmd->ulpIoTag;
2535 2691
2536 icmd->ulpLe = 1; 2692 icmd->ulpLe = 1;
2537 icmd->ulpClass = cmd->ulpClass; 2693 icmd->ulpClass = cmd->ulpClass;
@@ -2542,7 +2698,8 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
2542 2698
2543 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl; 2699 abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
2544 abtsiocb->vport = vport; 2700 abtsiocb->vport = vport;
2545 if (lpfc_sli_issue_iocb(phba, pring, abtsiocb, 0) == IOCB_ERROR) { 2701 if (lpfc_sli_issue_iocb(phba, LPFC_FCP_RING, abtsiocb, 0) ==
2702 IOCB_ERROR) {
2546 lpfc_sli_release_iocbq(phba, abtsiocb); 2703 lpfc_sli_release_iocbq(phba, abtsiocb);
2547 ret = FAILED; 2704 ret = FAILED;
2548 goto out; 2705 goto out;
@@ -2668,8 +2825,7 @@ lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
2668 "0703 Issue target reset to TGT %d LUN %d " 2825 "0703 Issue target reset to TGT %d LUN %d "
2669 "rpi x%x nlp_flag x%x\n", cmnd->device->id, 2826 "rpi x%x nlp_flag x%x\n", cmnd->device->id,
2670 cmnd->device->lun, pnode->nlp_rpi, pnode->nlp_flag); 2827 cmnd->device->lun, pnode->nlp_rpi, pnode->nlp_flag);
2671 status = lpfc_sli_issue_iocb_wait(phba, 2828 status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
2672 &phba->sli.ring[phba->sli.fcp_ring],
2673 iocbq, iocbqrsp, lpfc_cmd->timeout); 2829 iocbq, iocbqrsp, lpfc_cmd->timeout);
2674 if (status == IOCB_TIMEDOUT) { 2830 if (status == IOCB_TIMEDOUT) {
2675 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl; 2831 iocbq->iocb_cmpl = lpfc_tskmgmt_def_cmpl;
@@ -2825,11 +2981,10 @@ lpfc_slave_alloc(struct scsi_device *sdev)
2825{ 2981{
2826 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata; 2982 struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
2827 struct lpfc_hba *phba = vport->phba; 2983 struct lpfc_hba *phba = vport->phba;
2828 struct lpfc_scsi_buf *scsi_buf = NULL;
2829 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 2984 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
2830 uint32_t total = 0, i; 2985 uint32_t total = 0;
2831 uint32_t num_to_alloc = 0; 2986 uint32_t num_to_alloc = 0;
2832 unsigned long flags; 2987 int num_allocated = 0;
2833 2988
2834 if (!rport || fc_remote_port_chkready(rport)) 2989 if (!rport || fc_remote_port_chkready(rport))
2835 return -ENXIO; 2990 return -ENXIO;
@@ -2863,20 +3018,13 @@ lpfc_slave_alloc(struct scsi_device *sdev)
2863 (phba->cfg_hba_queue_depth - total)); 3018 (phba->cfg_hba_queue_depth - total));
2864 num_to_alloc = phba->cfg_hba_queue_depth - total; 3019 num_to_alloc = phba->cfg_hba_queue_depth - total;
2865 } 3020 }
2866 3021 num_allocated = lpfc_new_scsi_buf(vport, num_to_alloc);
2867 for (i = 0; i < num_to_alloc; i++) { 3022 if (num_to_alloc != num_allocated) {
2868 scsi_buf = lpfc_new_scsi_buf(vport); 3023 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
2869 if (!scsi_buf) { 3024 "0708 Allocation request of %d "
2870 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 3025 "command buffers did not succeed. "
2871 "0706 Failed to allocate " 3026 "Allocated %d buffers.\n",
2872 "command buffer\n"); 3027 num_to_alloc, num_allocated);
2873 break;
2874 }
2875
2876 spin_lock_irqsave(&phba->scsi_buf_list_lock, flags);
2877 phba->total_scsi_bufs++;
2878 list_add_tail(&scsi_buf->list, &phba->lpfc_scsi_buf_list);
2879 spin_unlock_irqrestore(&phba->scsi_buf_list_lock, flags);
2880 } 3028 }
2881 return 0; 3029 return 0;
2882} 3030}
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index eb5c75c45ba4..e2d07d97fa8b 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -142,7 +142,7 @@ lpfc_sli_get_iocbq(struct lpfc_hba *phba)
142} 142}
143 143
144/** 144/**
145 * __lpfc_sli_release_iocbq - Release iocb to the iocb pool 145 * __lpfc_sli_release_iocbq_s3 - Release iocb to the iocb pool
146 * @phba: Pointer to HBA context object. 146 * @phba: Pointer to HBA context object.
147 * @iocbq: Pointer to driver iocb object. 147 * @iocbq: Pointer to driver iocb object.
148 * 148 *
@@ -152,7 +152,7 @@ lpfc_sli_get_iocbq(struct lpfc_hba *phba)
152 * clears all other fields of the iocb object when it is freed. 152 * clears all other fields of the iocb object when it is freed.
153 **/ 153 **/
154static void 154static void
155__lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq) 155__lpfc_sli_release_iocbq_s3(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
156{ 156{
157 size_t start_clean = offsetof(struct lpfc_iocbq, iocb); 157 size_t start_clean = offsetof(struct lpfc_iocbq, iocb);
158 158
@@ -160,10 +160,27 @@ __lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
160 * Clean all volatile data fields, preserve iotag and node struct. 160 * Clean all volatile data fields, preserve iotag and node struct.
161 */ 161 */
162 memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean); 162 memset((char*)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
163 iocbq->sli4_xritag = NO_XRI;
163 list_add_tail(&iocbq->list, &phba->lpfc_iocb_list); 164 list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
164} 165}
165 166
166/** 167/**
168 * __lpfc_sli_release_iocbq - Release iocb to the iocb pool
169 * @phba: Pointer to HBA context object.
170 * @iocbq: Pointer to driver iocb object.
171 *
172 * This function is called with hbalock held to release driver
173 * iocb object to the iocb pool. The iotag in the iocb object
174 * does not change for each use of the iocb object. This function
175 * clears all other fields of the iocb object when it is freed.
176 **/
177static void
178__lpfc_sli_release_iocbq(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
179{
180 phba->__lpfc_sli_release_iocbq(phba, iocbq);
181}
182
183/**
167 * lpfc_sli_release_iocbq - Release iocb to the iocb pool 184 * lpfc_sli_release_iocbq - Release iocb to the iocb pool
168 * @phba: Pointer to HBA context object. 185 * @phba: Pointer to HBA context object.
169 * @iocbq: Pointer to driver iocb object. 186 * @iocbq: Pointer to driver iocb object.
@@ -779,8 +796,8 @@ lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
779 phba->hbqs[i].buffer_count = 0; 796 phba->hbqs[i].buffer_count = 0;
780 } 797 }
781 /* Return all HBQ buffer that are in-fly */ 798 /* Return all HBQ buffer that are in-fly */
782 list_for_each_entry_safe(dmabuf, next_dmabuf, 799 list_for_each_entry_safe(dmabuf, next_dmabuf, &phba->rb_pend_list,
783 &phba->hbqbuf_in_list, list) { 800 list) {
784 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf); 801 hbq_buf = container_of(dmabuf, struct hbq_dmabuf, dbuf);
785 list_del(&hbq_buf->dbuf.list); 802 list_del(&hbq_buf->dbuf.list);
786 if (hbq_buf->tag == -1) { 803 if (hbq_buf->tag == -1) {
@@ -814,10 +831,28 @@ lpfc_sli_hbqbuf_free_all(struct lpfc_hba *phba)
814 * pointer to the hbq entry if it successfully post the buffer 831 * pointer to the hbq entry if it successfully post the buffer
815 * else it will return NULL. 832 * else it will return NULL.
816 **/ 833 **/
817static struct lpfc_hbq_entry * 834static int
818lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno, 835lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
819 struct hbq_dmabuf *hbq_buf) 836 struct hbq_dmabuf *hbq_buf)
820{ 837{
838 return phba->lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buf);
839}
840
841/**
842 * lpfc_sli_hbq_to_firmware_s3 - Post the hbq buffer to SLI3 firmware
843 * @phba: Pointer to HBA context object.
844 * @hbqno: HBQ number.
845 * @hbq_buf: Pointer to HBQ buffer.
846 *
847 * This function is called with the hbalock held to post a hbq buffer to the
848 * firmware. If the function finds an empty slot in the HBQ, it will post the
849 * buffer and place it on the hbq_buffer_list. The function will return zero if
850 * it successfully post the buffer else it will return an error.
851 **/
852static int
853lpfc_sli_hbq_to_firmware_s3(struct lpfc_hba *phba, uint32_t hbqno,
854 struct hbq_dmabuf *hbq_buf)
855{
821 struct lpfc_hbq_entry *hbqe; 856 struct lpfc_hbq_entry *hbqe;
822 dma_addr_t physaddr = hbq_buf->dbuf.phys; 857 dma_addr_t physaddr = hbq_buf->dbuf.phys;
823 858
@@ -838,8 +873,9 @@ lpfc_sli_hbq_to_firmware(struct lpfc_hba *phba, uint32_t hbqno,
838 /* flush */ 873 /* flush */
839 readl(phba->hbq_put + hbqno); 874 readl(phba->hbq_put + hbqno);
840 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list); 875 list_add_tail(&hbq_buf->dbuf.list, &hbqp->hbq_buffer_list);
841 } 876 return 0;
842 return hbqe; 877 } else
878 return -ENOMEM;
843} 879}
844 880
845/* HBQ for ELS and CT traffic. */ 881/* HBQ for ELS and CT traffic. */
@@ -914,7 +950,7 @@ lpfc_sli_hbqbuf_fill_hbqs(struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)
914 dbuf.list); 950 dbuf.list);
915 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count | 951 hbq_buffer->tag = (phba->hbqs[hbqno].buffer_count |
916 (hbqno << 16)); 952 (hbqno << 16));
917 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) { 953 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {
918 phba->hbqs[hbqno].buffer_count++; 954 phba->hbqs[hbqno].buffer_count++;
919 posted++; 955 posted++;
920 } else 956 } else
@@ -965,6 +1001,25 @@ lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
965} 1001}
966 1002
967/** 1003/**
1004 * lpfc_sli_hbqbuf_get - Remove the first hbq off of an hbq list
1005 * @phba: Pointer to HBA context object.
1006 * @hbqno: HBQ number.
1007 *
1008 * This function removes the first hbq buffer on an hbq list and returns a
1009 * pointer to that buffer. If it finds no buffers on the list it returns NULL.
1010 **/
1011static struct hbq_dmabuf *
1012lpfc_sli_hbqbuf_get(struct list_head *rb_list)
1013{
1014 struct lpfc_dmabuf *d_buf;
1015
1016 list_remove_head(rb_list, d_buf, struct lpfc_dmabuf, list);
1017 if (!d_buf)
1018 return NULL;
1019 return container_of(d_buf, struct hbq_dmabuf, dbuf);
1020}
1021
1022/**
968 * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag 1023 * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag
969 * @phba: Pointer to HBA context object. 1024 * @phba: Pointer to HBA context object.
970 * @tag: Tag of the hbq buffer. 1025 * @tag: Tag of the hbq buffer.
@@ -985,12 +1040,15 @@ lpfc_sli_hbqbuf_find(struct lpfc_hba *phba, uint32_t tag)
985 if (hbqno >= LPFC_MAX_HBQS) 1040 if (hbqno >= LPFC_MAX_HBQS)
986 return NULL; 1041 return NULL;
987 1042
1043 spin_lock_irq(&phba->hbalock);
988 list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) { 1044 list_for_each_entry(d_buf, &phba->hbqs[hbqno].hbq_buffer_list, list) {
989 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf); 1045 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
990 if (hbq_buf->tag == tag) { 1046 if (hbq_buf->tag == tag) {
1047 spin_unlock_irq(&phba->hbalock);
991 return hbq_buf; 1048 return hbq_buf;
992 } 1049 }
993 } 1050 }
1051 spin_unlock_irq(&phba->hbalock);
994 lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT, 1052 lpfc_printf_log(phba, KERN_ERR, LOG_SLI | LOG_VPORT,
995 "1803 Bad hbq tag. Data: x%x x%x\n", 1053 "1803 Bad hbq tag. Data: x%x x%x\n",
996 tag, phba->hbqs[tag >> 16].buffer_count); 1054 tag, phba->hbqs[tag >> 16].buffer_count);
@@ -1013,9 +1071,8 @@ lpfc_sli_free_hbq(struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)
1013 1071
1014 if (hbq_buffer) { 1072 if (hbq_buffer) {
1015 hbqno = hbq_buffer->tag >> 16; 1073 hbqno = hbq_buffer->tag >> 16;
1016 if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) { 1074 if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer))
1017 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer); 1075 (phba->hbqs[hbqno].hbq_free_buffer)(phba, hbq_buffer);
1018 }
1019 } 1076 }
1020} 1077}
1021 1078
@@ -1317,6 +1374,45 @@ lpfc_sli_get_buff(struct lpfc_hba *phba,
1317 return &hbq_entry->dbuf; 1374 return &hbq_entry->dbuf;
1318} 1375}
1319 1376
1377/**
1378 * lpfc_complete_unsol_iocb - Complete an unsolicited sequence
1379 * @phba: Pointer to HBA context object.
1380 * @pring: Pointer to driver SLI ring object.
1381 * @saveq: Pointer to the iocbq struct representing the sequence starting frame.
1382 * @fch_r_ctl: the r_ctl for the first frame of the sequence.
1383 * @fch_type: the type for the first frame of the sequence.
1384 *
1385 * This function is called with no lock held. This function uses the r_ctl and
1386 * type of the received sequence to find the correct callback function to call
1387 * to process the sequence.
1388 **/
1389static int
1390lpfc_complete_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1391 struct lpfc_iocbq *saveq, uint32_t fch_r_ctl,
1392 uint32_t fch_type)
1393{
1394 int i;
1395
1396 /* unSolicited Responses */
1397 if (pring->prt[0].profile) {
1398 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
1399 (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
1400 saveq);
1401 return 1;
1402 }
1403 /* We must search, based on rctl / type
1404 for the right routine */
1405 for (i = 0; i < pring->num_mask; i++) {
1406 if ((pring->prt[i].rctl == fch_r_ctl) &&
1407 (pring->prt[i].type == fch_type)) {
1408 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
1409 (pring->prt[i].lpfc_sli_rcv_unsol_event)
1410 (phba, pring, saveq);
1411 return 1;
1412 }
1413 }
1414 return 0;
1415}
1320 1416
1321/** 1417/**
1322 * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler 1418 * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler
@@ -1339,7 +1435,7 @@ lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1339 IOCB_t * irsp; 1435 IOCB_t * irsp;
1340 WORD5 * w5p; 1436 WORD5 * w5p;
1341 uint32_t Rctl, Type; 1437 uint32_t Rctl, Type;
1342 uint32_t match, i; 1438 uint32_t match;
1343 struct lpfc_iocbq *iocbq; 1439 struct lpfc_iocbq *iocbq;
1344 struct lpfc_dmabuf *dmzbuf; 1440 struct lpfc_dmabuf *dmzbuf;
1345 1441
@@ -1482,35 +1578,12 @@ lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
1482 } 1578 }
1483 } 1579 }
1484 1580
1485 /* unSolicited Responses */ 1581 if (!lpfc_complete_unsol_iocb(phba, pring, saveq, Rctl, Type))
1486 if (pring->prt[0].profile) {
1487 if (pring->prt[0].lpfc_sli_rcv_unsol_event)
1488 (pring->prt[0].lpfc_sli_rcv_unsol_event) (phba, pring,
1489 saveq);
1490 match = 1;
1491 } else {
1492 /* We must search, based on rctl / type
1493 for the right routine */
1494 for (i = 0; i < pring->num_mask; i++) {
1495 if ((pring->prt[i].rctl == Rctl)
1496 && (pring->prt[i].type == Type)) {
1497 if (pring->prt[i].lpfc_sli_rcv_unsol_event)
1498 (pring->prt[i].lpfc_sli_rcv_unsol_event)
1499 (phba, pring, saveq);
1500 match = 1;
1501 break;
1502 }
1503 }
1504 }
1505 if (match == 0) {
1506 /* Unexpected Rctl / Type received */
1507 /* Ring <ringno> handler: unexpected
1508 Rctl <Rctl> Type <Type> received */
1509 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI, 1582 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
1510 "0313 Ring %d handler: unexpected Rctl x%x " 1583 "0313 Ring %d handler: unexpected Rctl x%x "
1511 "Type x%x received\n", 1584 "Type x%x received\n",
1512 pring->ringno, Rctl, Type); 1585 pring->ringno, Rctl, Type);
1513 } 1586
1514 return 1; 1587 return 1;
1515} 1588}
1516 1589
@@ -1552,6 +1625,37 @@ lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
1552} 1625}
1553 1626
1554/** 1627/**
1628 * lpfc_sli_iocbq_lookup_by_tag - Find command iocb for the iotag
1629 * @phba: Pointer to HBA context object.
1630 * @pring: Pointer to driver SLI ring object.
1631 * @iotag: IOCB tag.
1632 *
1633 * This function looks up the iocb_lookup table to get the command iocb
1634 * corresponding to the given iotag. This function is called with the
1635 * hbalock held.
1636 * This function returns the command iocb object if it finds the command
1637 * iocb else returns NULL.
1638 **/
1639static struct lpfc_iocbq *
1640lpfc_sli_iocbq_lookup_by_tag(struct lpfc_hba *phba,
1641 struct lpfc_sli_ring *pring, uint16_t iotag)
1642{
1643 struct lpfc_iocbq *cmd_iocb;
1644
1645 if (iotag != 0 && iotag <= phba->sli.last_iotag) {
1646 cmd_iocb = phba->sli.iocbq_lookup[iotag];
1647 list_del_init(&cmd_iocb->list);
1648 pring->txcmplq_cnt--;
1649 return cmd_iocb;
1650 }
1651
1652 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1653 "0372 iotag x%x is out off range: max iotag (x%x)\n",
1654 iotag, phba->sli.last_iotag);
1655 return NULL;
1656}
1657
1658/**
1555 * lpfc_sli_process_sol_iocb - process solicited iocb completion 1659 * lpfc_sli_process_sol_iocb - process solicited iocb completion
1556 * @phba: Pointer to HBA context object. 1660 * @phba: Pointer to HBA context object.
1557 * @pring: Pointer to driver SLI ring object. 1661 * @pring: Pointer to driver SLI ring object.
@@ -1954,7 +2058,7 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
1954 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 2058 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1955 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) { 2059 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1956 spin_unlock_irqrestore(&phba->hbalock, iflag); 2060 spin_unlock_irqrestore(&phba->hbalock, iflag);
1957 lpfc_rampdown_queue_depth(phba); 2061 phba->lpfc_rampdown_queue_depth(phba);
1958 spin_lock_irqsave(&phba->hbalock, iflag); 2062 spin_lock_irqsave(&phba->hbalock, iflag);
1959 } 2063 }
1960 2064
@@ -2068,39 +2172,215 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
2068} 2172}
2069 2173
2070/** 2174/**
2071 * lpfc_sli_handle_slow_ring_event - Handle ring events for non-FCP rings 2175 * lpfc_sli_sp_handle_rspiocb - Handle slow-path response iocb
2176 * @phba: Pointer to HBA context object.
2177 * @pring: Pointer to driver SLI ring object.
2178 * @rspiocbp: Pointer to driver response IOCB object.
2179 *
2180 * This function is called from the worker thread when there is a slow-path
2181 * response IOCB to process. This function chains all the response iocbs until
2182 * seeing the iocb with the LE bit set. The function will call
2183 * lpfc_sli_process_sol_iocb function if the response iocb indicates a
2184 * completion of a command iocb. The function will call the
2185 * lpfc_sli_process_unsol_iocb function if this is an unsolicited iocb.
2186 * The function frees the resources or calls the completion handler if this
2187 * iocb is an abort completion. The function returns NULL when the response
2188 * iocb has the LE bit set and all the chained iocbs are processed, otherwise
2189 * this function shall chain the iocb on to the iocb_continueq and return the
2190 * response iocb passed in.
2191 **/
2192static struct lpfc_iocbq *
2193lpfc_sli_sp_handle_rspiocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
2194 struct lpfc_iocbq *rspiocbp)
2195{
2196 struct lpfc_iocbq *saveq;
2197 struct lpfc_iocbq *cmdiocbp;
2198 struct lpfc_iocbq *next_iocb;
2199 IOCB_t *irsp = NULL;
2200 uint32_t free_saveq;
2201 uint8_t iocb_cmd_type;
2202 lpfc_iocb_type type;
2203 unsigned long iflag;
2204 int rc;
2205
2206 spin_lock_irqsave(&phba->hbalock, iflag);
2207 /* First add the response iocb to the countinueq list */
2208 list_add_tail(&rspiocbp->list, &(pring->iocb_continueq));
2209 pring->iocb_continueq_cnt++;
2210
2211 /* Now, determine whetehr the list is completed for processing */
2212 irsp = &rspiocbp->iocb;
2213 if (irsp->ulpLe) {
2214 /*
2215 * By default, the driver expects to free all resources
2216 * associated with this iocb completion.
2217 */
2218 free_saveq = 1;
2219 saveq = list_get_first(&pring->iocb_continueq,
2220 struct lpfc_iocbq, list);
2221 irsp = &(saveq->iocb);
2222 list_del_init(&pring->iocb_continueq);
2223 pring->iocb_continueq_cnt = 0;
2224
2225 pring->stats.iocb_rsp++;
2226
2227 /*
2228 * If resource errors reported from HBA, reduce
2229 * queuedepths of the SCSI device.
2230 */
2231 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2232 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2233 spin_unlock_irqrestore(&phba->hbalock, iflag);
2234 phba->lpfc_rampdown_queue_depth(phba);
2235 spin_lock_irqsave(&phba->hbalock, iflag);
2236 }
2237
2238 if (irsp->ulpStatus) {
2239 /* Rsp ring <ringno> error: IOCB */
2240 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2241 "0328 Rsp Ring %d error: "
2242 "IOCB Data: "
2243 "x%x x%x x%x x%x "
2244 "x%x x%x x%x x%x "
2245 "x%x x%x x%x x%x "
2246 "x%x x%x x%x x%x\n",
2247 pring->ringno,
2248 irsp->un.ulpWord[0],
2249 irsp->un.ulpWord[1],
2250 irsp->un.ulpWord[2],
2251 irsp->un.ulpWord[3],
2252 irsp->un.ulpWord[4],
2253 irsp->un.ulpWord[5],
2254 *(((uint32_t *) irsp) + 6),
2255 *(((uint32_t *) irsp) + 7),
2256 *(((uint32_t *) irsp) + 8),
2257 *(((uint32_t *) irsp) + 9),
2258 *(((uint32_t *) irsp) + 10),
2259 *(((uint32_t *) irsp) + 11),
2260 *(((uint32_t *) irsp) + 12),
2261 *(((uint32_t *) irsp) + 13),
2262 *(((uint32_t *) irsp) + 14),
2263 *(((uint32_t *) irsp) + 15));
2264 }
2265
2266 /*
2267 * Fetch the IOCB command type and call the correct completion
2268 * routine. Solicited and Unsolicited IOCBs on the ELS ring
2269 * get freed back to the lpfc_iocb_list by the discovery
2270 * kernel thread.
2271 */
2272 iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
2273 type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
2274 switch (type) {
2275 case LPFC_SOL_IOCB:
2276 spin_unlock_irqrestore(&phba->hbalock, iflag);
2277 rc = lpfc_sli_process_sol_iocb(phba, pring, saveq);
2278 spin_lock_irqsave(&phba->hbalock, iflag);
2279 break;
2280
2281 case LPFC_UNSOL_IOCB:
2282 spin_unlock_irqrestore(&phba->hbalock, iflag);
2283 rc = lpfc_sli_process_unsol_iocb(phba, pring, saveq);
2284 spin_lock_irqsave(&phba->hbalock, iflag);
2285 if (!rc)
2286 free_saveq = 0;
2287 break;
2288
2289 case LPFC_ABORT_IOCB:
2290 cmdiocbp = NULL;
2291 if (irsp->ulpCommand != CMD_XRI_ABORTED_CX)
2292 cmdiocbp = lpfc_sli_iocbq_lookup(phba, pring,
2293 saveq);
2294 if (cmdiocbp) {
2295 /* Call the specified completion routine */
2296 if (cmdiocbp->iocb_cmpl) {
2297 spin_unlock_irqrestore(&phba->hbalock,
2298 iflag);
2299 (cmdiocbp->iocb_cmpl)(phba, cmdiocbp,
2300 saveq);
2301 spin_lock_irqsave(&phba->hbalock,
2302 iflag);
2303 } else
2304 __lpfc_sli_release_iocbq(phba,
2305 cmdiocbp);
2306 }
2307 break;
2308
2309 case LPFC_UNKNOWN_IOCB:
2310 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2311 char adaptermsg[LPFC_MAX_ADPTMSG];
2312 memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
2313 memcpy(&adaptermsg[0], (uint8_t *)irsp,
2314 MAX_MSG_DATA);
2315 dev_warn(&((phba->pcidev)->dev),
2316 "lpfc%d: %s\n",
2317 phba->brd_no, adaptermsg);
2318 } else {
2319 /* Unknown IOCB command */
2320 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2321 "0335 Unknown IOCB "
2322 "command Data: x%x "
2323 "x%x x%x x%x\n",
2324 irsp->ulpCommand,
2325 irsp->ulpStatus,
2326 irsp->ulpIoTag,
2327 irsp->ulpContext);
2328 }
2329 break;
2330 }
2331
2332 if (free_saveq) {
2333 list_for_each_entry_safe(rspiocbp, next_iocb,
2334 &saveq->list, list) {
2335 list_del(&rspiocbp->list);
2336 __lpfc_sli_release_iocbq(phba, rspiocbp);
2337 }
2338 __lpfc_sli_release_iocbq(phba, saveq);
2339 }
2340 rspiocbp = NULL;
2341 }
2342 spin_unlock_irqrestore(&phba->hbalock, iflag);
2343 return rspiocbp;
2344}
2345
2346/**
2347 * lpfc_sli_handle_slow_ring_event - Wrapper func for handling slow-path iocbs
2072 * @phba: Pointer to HBA context object. 2348 * @phba: Pointer to HBA context object.
2073 * @pring: Pointer to driver SLI ring object. 2349 * @pring: Pointer to driver SLI ring object.
2074 * @mask: Host attention register mask for this ring. 2350 * @mask: Host attention register mask for this ring.
2075 * 2351 *
2076 * This function is called from the worker thread when there is a ring 2352 * This routine wraps the actual slow_ring event process routine from the
2077 * event for non-fcp rings. The caller does not hold any lock . 2353 * API jump table function pointer from the lpfc_hba struct.
2078 * The function processes each response iocb in the response ring until it
2079 * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
2080 * LE bit set. The function will call lpfc_sli_process_sol_iocb function if the
2081 * response iocb indicates a completion of a command iocb. The function
2082 * will call lpfc_sli_process_unsol_iocb function if this is an unsolicited
2083 * iocb. The function frees the resources or calls the completion handler if
2084 * this iocb is an abort completion. The function returns 0 when the allocated
2085 * iocbs are not freed, otherwise returns 1.
2086 **/ 2354 **/
2087int 2355void
2088lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba, 2356lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2089 struct lpfc_sli_ring *pring, uint32_t mask) 2357 struct lpfc_sli_ring *pring, uint32_t mask)
2090{ 2358{
2359 phba->lpfc_sli_handle_slow_ring_event(phba, pring, mask);
2360}
2361
2362/**
2363 * lpfc_sli_handle_slow_ring_event_s3 - Handle SLI3 ring event for non-FCP rings
2364 * @phba: Pointer to HBA context object.
2365 * @pring: Pointer to driver SLI ring object.
2366 * @mask: Host attention register mask for this ring.
2367 *
2368 * This function is called from the worker thread when there is a ring event
2369 * for non-fcp rings. The caller does not hold any lock. The function will
2370 * remove each response iocb in the response ring and calls the handle
2371 * response iocb routine (lpfc_sli_sp_handle_rspiocb) to process it.
2372 **/
2373static void
2374lpfc_sli_handle_slow_ring_event_s3(struct lpfc_hba *phba,
2375 struct lpfc_sli_ring *pring, uint32_t mask)
2376{
2091 struct lpfc_pgp *pgp; 2377 struct lpfc_pgp *pgp;
2092 IOCB_t *entry; 2378 IOCB_t *entry;
2093 IOCB_t *irsp = NULL; 2379 IOCB_t *irsp = NULL;
2094 struct lpfc_iocbq *rspiocbp = NULL; 2380 struct lpfc_iocbq *rspiocbp = NULL;
2095 struct lpfc_iocbq *next_iocb;
2096 struct lpfc_iocbq *cmdiocbp;
2097 struct lpfc_iocbq *saveq;
2098 uint8_t iocb_cmd_type;
2099 lpfc_iocb_type type;
2100 uint32_t status, free_saveq;
2101 uint32_t portRspPut, portRspMax; 2381 uint32_t portRspPut, portRspMax;
2102 int rc = 1;
2103 unsigned long iflag; 2382 unsigned long iflag;
2383 uint32_t status;
2104 2384
2105 pgp = &phba->port_gp[pring->ringno]; 2385 pgp = &phba->port_gp[pring->ringno];
2106 spin_lock_irqsave(&phba->hbalock, iflag); 2386 spin_lock_irqsave(&phba->hbalock, iflag);
@@ -2128,7 +2408,7 @@ lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2128 phba->work_hs = HS_FFER3; 2408 phba->work_hs = HS_FFER3;
2129 lpfc_handle_eratt(phba); 2409 lpfc_handle_eratt(phba);
2130 2410
2131 return 1; 2411 return;
2132 } 2412 }
2133 2413
2134 rmb(); 2414 rmb();
@@ -2173,138 +2453,10 @@ lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2173 2453
2174 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx); 2454 writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
2175 2455
2176 list_add_tail(&rspiocbp->list, &(pring->iocb_continueq)); 2456 spin_unlock_irqrestore(&phba->hbalock, iflag);
2177 2457 /* Handle the response IOCB */
2178 pring->iocb_continueq_cnt++; 2458 rspiocbp = lpfc_sli_sp_handle_rspiocb(phba, pring, rspiocbp);
2179 if (irsp->ulpLe) { 2459 spin_lock_irqsave(&phba->hbalock, iflag);
2180 /*
2181 * By default, the driver expects to free all resources
2182 * associated with this iocb completion.
2183 */
2184 free_saveq = 1;
2185 saveq = list_get_first(&pring->iocb_continueq,
2186 struct lpfc_iocbq, list);
2187 irsp = &(saveq->iocb);
2188 list_del_init(&pring->iocb_continueq);
2189 pring->iocb_continueq_cnt = 0;
2190
2191 pring->stats.iocb_rsp++;
2192
2193 /*
2194 * If resource errors reported from HBA, reduce
2195 * queuedepths of the SCSI device.
2196 */
2197 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
2198 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
2199 spin_unlock_irqrestore(&phba->hbalock, iflag);
2200 lpfc_rampdown_queue_depth(phba);
2201 spin_lock_irqsave(&phba->hbalock, iflag);
2202 }
2203
2204 if (irsp->ulpStatus) {
2205 /* Rsp ring <ringno> error: IOCB */
2206 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
2207 "0328 Rsp Ring %d error: "
2208 "IOCB Data: "
2209 "x%x x%x x%x x%x "
2210 "x%x x%x x%x x%x "
2211 "x%x x%x x%x x%x "
2212 "x%x x%x x%x x%x\n",
2213 pring->ringno,
2214 irsp->un.ulpWord[0],
2215 irsp->un.ulpWord[1],
2216 irsp->un.ulpWord[2],
2217 irsp->un.ulpWord[3],
2218 irsp->un.ulpWord[4],
2219 irsp->un.ulpWord[5],
2220 *(((uint32_t *) irsp) + 6),
2221 *(((uint32_t *) irsp) + 7),
2222 *(((uint32_t *) irsp) + 8),
2223 *(((uint32_t *) irsp) + 9),
2224 *(((uint32_t *) irsp) + 10),
2225 *(((uint32_t *) irsp) + 11),
2226 *(((uint32_t *) irsp) + 12),
2227 *(((uint32_t *) irsp) + 13),
2228 *(((uint32_t *) irsp) + 14),
2229 *(((uint32_t *) irsp) + 15));
2230 }
2231
2232 /*
2233 * Fetch the IOCB command type and call the correct
2234 * completion routine. Solicited and Unsolicited
2235 * IOCBs on the ELS ring get freed back to the
2236 * lpfc_iocb_list by the discovery kernel thread.
2237 */
2238 iocb_cmd_type = irsp->ulpCommand & CMD_IOCB_MASK;
2239 type = lpfc_sli_iocb_cmd_type(iocb_cmd_type);
2240 if (type == LPFC_SOL_IOCB) {
2241 spin_unlock_irqrestore(&phba->hbalock, iflag);
2242 rc = lpfc_sli_process_sol_iocb(phba, pring,
2243 saveq);
2244 spin_lock_irqsave(&phba->hbalock, iflag);
2245 } else if (type == LPFC_UNSOL_IOCB) {
2246 spin_unlock_irqrestore(&phba->hbalock, iflag);
2247 rc = lpfc_sli_process_unsol_iocb(phba, pring,
2248 saveq);
2249 spin_lock_irqsave(&phba->hbalock, iflag);
2250 if (!rc)
2251 free_saveq = 0;
2252 } else if (type == LPFC_ABORT_IOCB) {
2253 if ((irsp->ulpCommand != CMD_XRI_ABORTED_CX) &&
2254 ((cmdiocbp =
2255 lpfc_sli_iocbq_lookup(phba, pring,
2256 saveq)))) {
2257 /* Call the specified completion
2258 routine */
2259 if (cmdiocbp->iocb_cmpl) {
2260 spin_unlock_irqrestore(
2261 &phba->hbalock,
2262 iflag);
2263 (cmdiocbp->iocb_cmpl) (phba,
2264 cmdiocbp, saveq);
2265 spin_lock_irqsave(
2266 &phba->hbalock,
2267 iflag);
2268 } else
2269 __lpfc_sli_release_iocbq(phba,
2270 cmdiocbp);
2271 }
2272 } else if (type == LPFC_UNKNOWN_IOCB) {
2273 if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
2274
2275 char adaptermsg[LPFC_MAX_ADPTMSG];
2276
2277 memset(adaptermsg, 0,
2278 LPFC_MAX_ADPTMSG);
2279 memcpy(&adaptermsg[0], (uint8_t *) irsp,
2280 MAX_MSG_DATA);
2281 dev_warn(&((phba->pcidev)->dev),
2282 "lpfc%d: %s\n",
2283 phba->brd_no, adaptermsg);
2284 } else {
2285 /* Unknown IOCB command */
2286 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2287 "0335 Unknown IOCB "
2288 "command Data: x%x "
2289 "x%x x%x x%x\n",
2290 irsp->ulpCommand,
2291 irsp->ulpStatus,
2292 irsp->ulpIoTag,
2293 irsp->ulpContext);
2294 }
2295 }
2296
2297 if (free_saveq) {
2298 list_for_each_entry_safe(rspiocbp, next_iocb,
2299 &saveq->list, list) {
2300 list_del(&rspiocbp->list);
2301 __lpfc_sli_release_iocbq(phba,
2302 rspiocbp);
2303 }
2304 __lpfc_sli_release_iocbq(phba, saveq);
2305 }
2306 rspiocbp = NULL;
2307 }
2308 2460
2309 /* 2461 /*
2310 * If the port response put pointer has not been updated, sync 2462 * If the port response put pointer has not been updated, sync
@@ -2338,7 +2490,7 @@ lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
2338 } 2490 }
2339 2491
2340 spin_unlock_irqrestore(&phba->hbalock, iflag); 2492 spin_unlock_irqrestore(&phba->hbalock, iflag);
2341 return rc; 2493 return;
2342} 2494}
2343 2495
2344/** 2496/**
@@ -2420,7 +2572,7 @@ lpfc_sli_flush_fcp_rings(struct lpfc_hba *phba)
2420} 2572}
2421 2573
2422/** 2574/**
2423 * lpfc_sli_brdready - Check for host status bits 2575 * lpfc_sli_brdready_s3 - Check for sli3 host ready status
2424 * @phba: Pointer to HBA context object. 2576 * @phba: Pointer to HBA context object.
2425 * @mask: Bit mask to be checked. 2577 * @mask: Bit mask to be checked.
2426 * 2578 *
@@ -2432,8 +2584,8 @@ lpfc_sli_flush_fcp_rings(struct lpfc_hba *phba)
2432 * function returns 1 when HBA fail to restart otherwise returns 2584 * function returns 1 when HBA fail to restart otherwise returns
2433 * zero. 2585 * zero.
2434 **/ 2586 **/
2435int 2587static int
2436lpfc_sli_brdready(struct lpfc_hba *phba, uint32_t mask) 2588lpfc_sli_brdready_s3(struct lpfc_hba *phba, uint32_t mask)
2437{ 2589{
2438 uint32_t status; 2590 uint32_t status;
2439 int i = 0; 2591 int i = 0;
@@ -2647,7 +2799,7 @@ lpfc_sli_brdkill(struct lpfc_hba *phba)
2647} 2799}
2648 2800
2649/** 2801/**
2650 * lpfc_sli_brdreset - Reset the HBA 2802 * lpfc_sli_brdreset - Reset a sli-2 or sli-3 HBA
2651 * @phba: Pointer to HBA context object. 2803 * @phba: Pointer to HBA context object.
2652 * 2804 *
2653 * This function resets the HBA by writing HC_INITFF to the control 2805 * This function resets the HBA by writing HC_INITFF to the control
@@ -2683,7 +2835,8 @@ lpfc_sli_brdreset(struct lpfc_hba *phba)
2683 (cfg_value & 2835 (cfg_value &
2684 ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR))); 2836 ~(PCI_COMMAND_PARITY | PCI_COMMAND_SERR)));
2685 2837
2686 psli->sli_flag &= ~(LPFC_SLI2_ACTIVE | LPFC_PROCESS_LA); 2838 psli->sli_flag &= ~(LPFC_SLI_ACTIVE | LPFC_PROCESS_LA);
2839
2687 /* Now toggle INITFF bit in the Host Control Register */ 2840 /* Now toggle INITFF bit in the Host Control Register */
2688 writel(HC_INITFF, phba->HCregaddr); 2841 writel(HC_INITFF, phba->HCregaddr);
2689 mdelay(1); 2842 mdelay(1);
@@ -3289,32 +3442,20 @@ lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
3289 3442
3290 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI, 3443 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3291 "0345 Resetting board due to mailbox timeout\n"); 3444 "0345 Resetting board due to mailbox timeout\n");
3292 /* 3445
3293 * lpfc_offline calls lpfc_sli_hba_down which will clean up 3446 /* Reset the HBA device */
3294 * on oustanding mailbox commands. 3447 lpfc_reset_hba(phba);
3295 */
3296 /* If resets are disabled then set error state and return. */
3297 if (!phba->cfg_enable_hba_reset) {
3298 phba->link_state = LPFC_HBA_ERROR;
3299 return;
3300 }
3301 lpfc_offline_prep(phba);
3302 lpfc_offline(phba);
3303 lpfc_sli_brdrestart(phba);
3304 lpfc_online(phba);
3305 lpfc_unblock_mgmt_io(phba);
3306 return;
3307} 3448}
3308 3449
3309/** 3450/**
3310 * lpfc_sli_issue_mbox - Issue a mailbox command to firmware 3451 * lpfc_sli_issue_mbox_s3 - Issue an SLI3 mailbox command to firmware
3311 * @phba: Pointer to HBA context object. 3452 * @phba: Pointer to HBA context object.
3312 * @pmbox: Pointer to mailbox object. 3453 * @pmbox: Pointer to mailbox object.
3313 * @flag: Flag indicating how the mailbox need to be processed. 3454 * @flag: Flag indicating how the mailbox need to be processed.
3314 * 3455 *
3315 * This function is called by discovery code and HBA management code 3456 * This function is called by discovery code and HBA management code
3316 * to submit a mailbox command to firmware. This function gets the 3457 * to submit a mailbox command to firmware with SLI-3 interface spec. This
3317 * hbalock to protect the data structures. 3458 * function gets the hbalock to protect the data structures.
3318 * The mailbox command can be submitted in polling mode, in which case 3459 * The mailbox command can be submitted in polling mode, in which case
3319 * this function will wait in a polling loop for the completion of the 3460 * this function will wait in a polling loop for the completion of the
3320 * mailbox. 3461 * mailbox.
@@ -3332,8 +3473,9 @@ lpfc_mbox_timeout_handler(struct lpfc_hba *phba)
3332 * return codes the caller owns the mailbox command after the return of 3473 * return codes the caller owns the mailbox command after the return of
3333 * the function. 3474 * the function.
3334 **/ 3475 **/
3335int 3476static int
3336lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag) 3477lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
3478 uint32_t flag)
3337{ 3479{
3338 MAILBOX_t *mb; 3480 MAILBOX_t *mb;
3339 struct lpfc_sli *psli = &phba->sli; 3481 struct lpfc_sli *psli = &phba->sli;
@@ -3349,6 +3491,10 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3349 spin_lock_irqsave(&phba->hbalock, drvr_flag); 3491 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3350 if (!pmbox) { 3492 if (!pmbox) {
3351 /* processing mbox queue from intr_handler */ 3493 /* processing mbox queue from intr_handler */
3494 if (unlikely(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {
3495 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3496 return MBX_SUCCESS;
3497 }
3352 processing_queue = 1; 3498 processing_queue = 1;
3353 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE; 3499 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3354 pmbox = lpfc_mbox_get(phba); 3500 pmbox = lpfc_mbox_get(phba);
@@ -3365,7 +3511,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3365 lpfc_printf_log(phba, KERN_ERR, 3511 lpfc_printf_log(phba, KERN_ERR,
3366 LOG_MBOX | LOG_VPORT, 3512 LOG_MBOX | LOG_VPORT,
3367 "1806 Mbox x%x failed. No vport\n", 3513 "1806 Mbox x%x failed. No vport\n",
3368 pmbox->mb.mbxCommand); 3514 pmbox->u.mb.mbxCommand);
3369 dump_stack(); 3515 dump_stack();
3370 goto out_not_finished; 3516 goto out_not_finished;
3371 } 3517 }
@@ -3385,21 +3531,29 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3385 3531
3386 psli = &phba->sli; 3532 psli = &phba->sli;
3387 3533
3388 mb = &pmbox->mb; 3534 mb = &pmbox->u.mb;
3389 status = MBX_SUCCESS; 3535 status = MBX_SUCCESS;
3390 3536
3391 if (phba->link_state == LPFC_HBA_ERROR) { 3537 if (phba->link_state == LPFC_HBA_ERROR) {
3392 spin_unlock_irqrestore(&phba->hbalock, drvr_flag); 3538 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3393 3539
3394 /* Mbox command <mbxCommand> cannot issue */ 3540 /* Mbox command <mbxCommand> cannot issue */
3395 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag); 3541 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3542 "(%d):0311 Mailbox command x%x cannot "
3543 "issue Data: x%x x%x\n",
3544 pmbox->vport ? pmbox->vport->vpi : 0,
3545 pmbox->u.mb.mbxCommand, psli->sli_flag, flag);
3396 goto out_not_finished; 3546 goto out_not_finished;
3397 } 3547 }
3398 3548
3399 if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT && 3549 if (mb->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT &&
3400 !(readl(phba->HCregaddr) & HC_MBINT_ENA)) { 3550 !(readl(phba->HCregaddr) & HC_MBINT_ENA)) {
3401 spin_unlock_irqrestore(&phba->hbalock, drvr_flag); 3551 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3402 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag); 3552 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3553 "(%d):2528 Mailbox command x%x cannot "
3554 "issue Data: x%x x%x\n",
3555 pmbox->vport ? pmbox->vport->vpi : 0,
3556 pmbox->u.mb.mbxCommand, psli->sli_flag, flag);
3403 goto out_not_finished; 3557 goto out_not_finished;
3404 } 3558 }
3405 3559
@@ -3413,14 +3567,24 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3413 spin_unlock_irqrestore(&phba->hbalock, drvr_flag); 3567 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3414 3568
3415 /* Mbox command <mbxCommand> cannot issue */ 3569 /* Mbox command <mbxCommand> cannot issue */
3416 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag); 3570 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3571 "(%d):2529 Mailbox command x%x "
3572 "cannot issue Data: x%x x%x\n",
3573 pmbox->vport ? pmbox->vport->vpi : 0,
3574 pmbox->u.mb.mbxCommand,
3575 psli->sli_flag, flag);
3417 goto out_not_finished; 3576 goto out_not_finished;
3418 } 3577 }
3419 3578
3420 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE)) { 3579 if (!(psli->sli_flag & LPFC_SLI_ACTIVE)) {
3421 spin_unlock_irqrestore(&phba->hbalock, drvr_flag); 3580 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3422 /* Mbox command <mbxCommand> cannot issue */ 3581 /* Mbox command <mbxCommand> cannot issue */
3423 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag); 3582 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3583 "(%d):2530 Mailbox command x%x "
3584 "cannot issue Data: x%x x%x\n",
3585 pmbox->vport ? pmbox->vport->vpi : 0,
3586 pmbox->u.mb.mbxCommand,
3587 psli->sli_flag, flag);
3424 goto out_not_finished; 3588 goto out_not_finished;
3425 } 3589 }
3426 3590
@@ -3462,12 +3626,17 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3462 3626
3463 /* If we are not polling, we MUST be in SLI2 mode */ 3627 /* If we are not polling, we MUST be in SLI2 mode */
3464 if (flag != MBX_POLL) { 3628 if (flag != MBX_POLL) {
3465 if (!(psli->sli_flag & LPFC_SLI2_ACTIVE) && 3629 if (!(psli->sli_flag & LPFC_SLI_ACTIVE) &&
3466 (mb->mbxCommand != MBX_KILL_BOARD)) { 3630 (mb->mbxCommand != MBX_KILL_BOARD)) {
3467 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE; 3631 psli->sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
3468 spin_unlock_irqrestore(&phba->hbalock, drvr_flag); 3632 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
3469 /* Mbox command <mbxCommand> cannot issue */ 3633 /* Mbox command <mbxCommand> cannot issue */
3470 LOG_MBOX_CANNOT_ISSUE_DATA(phba, pmbox, psli, flag); 3634 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
3635 "(%d):2531 Mailbox command x%x "
3636 "cannot issue Data: x%x x%x\n",
3637 pmbox->vport ? pmbox->vport->vpi : 0,
3638 pmbox->u.mb.mbxCommand,
3639 psli->sli_flag, flag);
3471 goto out_not_finished; 3640 goto out_not_finished;
3472 } 3641 }
3473 /* timeout active mbox command */ 3642 /* timeout active mbox command */
@@ -3506,7 +3675,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3506 /* next set own bit for the adapter and copy over command word */ 3675 /* next set own bit for the adapter and copy over command word */
3507 mb->mbxOwner = OWN_CHIP; 3676 mb->mbxOwner = OWN_CHIP;
3508 3677
3509 if (psli->sli_flag & LPFC_SLI2_ACTIVE) { 3678 if (psli->sli_flag & LPFC_SLI_ACTIVE) {
3510 /* First copy command data to host SLIM area */ 3679 /* First copy command data to host SLIM area */
3511 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE); 3680 lpfc_sli_pcimem_bcopy(mb, phba->mbox, MAILBOX_CMD_SIZE);
3512 } else { 3681 } else {
@@ -3529,7 +3698,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3529 3698
3530 if (mb->mbxCommand == MBX_CONFIG_PORT) { 3699 if (mb->mbxCommand == MBX_CONFIG_PORT) {
3531 /* switch over to host mailbox */ 3700 /* switch over to host mailbox */
3532 psli->sli_flag |= LPFC_SLI2_ACTIVE; 3701 psli->sli_flag |= LPFC_SLI_ACTIVE;
3533 } 3702 }
3534 } 3703 }
3535 3704
@@ -3552,7 +3721,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3552 writel(CA_MBATT, phba->CAregaddr); 3721 writel(CA_MBATT, phba->CAregaddr);
3553 readl(phba->CAregaddr); /* flush */ 3722 readl(phba->CAregaddr); /* flush */
3554 3723
3555 if (psli->sli_flag & LPFC_SLI2_ACTIVE) { 3724 if (psli->sli_flag & LPFC_SLI_ACTIVE) {
3556 /* First read mbox status word */ 3725 /* First read mbox status word */
3557 word0 = *((uint32_t *)phba->mbox); 3726 word0 = *((uint32_t *)phba->mbox);
3558 word0 = le32_to_cpu(word0); 3727 word0 = le32_to_cpu(word0);
@@ -3591,7 +3760,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3591 spin_lock_irqsave(&phba->hbalock, drvr_flag); 3760 spin_lock_irqsave(&phba->hbalock, drvr_flag);
3592 } 3761 }
3593 3762
3594 if (psli->sli_flag & LPFC_SLI2_ACTIVE) { 3763 if (psli->sli_flag & LPFC_SLI_ACTIVE) {
3595 /* First copy command data */ 3764 /* First copy command data */
3596 word0 = *((uint32_t *)phba->mbox); 3765 word0 = *((uint32_t *)phba->mbox);
3597 word0 = le32_to_cpu(word0); 3766 word0 = le32_to_cpu(word0);
@@ -3604,7 +3773,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3604 if (((slimword0 & OWN_CHIP) != OWN_CHIP) 3773 if (((slimword0 & OWN_CHIP) != OWN_CHIP)
3605 && slimmb->mbxStatus) { 3774 && slimmb->mbxStatus) {
3606 psli->sli_flag &= 3775 psli->sli_flag &=
3607 ~LPFC_SLI2_ACTIVE; 3776 ~LPFC_SLI_ACTIVE;
3608 word0 = slimword0; 3777 word0 = slimword0;
3609 } 3778 }
3610 } 3779 }
@@ -3616,7 +3785,7 @@ lpfc_sli_issue_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)
3616 ha_copy = readl(phba->HAregaddr); 3785 ha_copy = readl(phba->HAregaddr);
3617 } 3786 }
3618 3787
3619 if (psli->sli_flag & LPFC_SLI2_ACTIVE) { 3788 if (psli->sli_flag & LPFC_SLI_ACTIVE) {
3620 /* copy results back to user */ 3789 /* copy results back to user */
3621 lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE); 3790 lpfc_sli_pcimem_bcopy(phba->mbox, mb, MAILBOX_CMD_SIZE);
3622 } else { 3791 } else {
@@ -3701,35 +3870,34 @@ lpfc_sli_next_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3701} 3870}
3702 3871
3703/** 3872/**
3704 * __lpfc_sli_issue_iocb - Lockless version of lpfc_sli_issue_iocb 3873 * __lpfc_sli_issue_iocb_s3 - SLI3 device lockless ver of lpfc_sli_issue_iocb
3705 * @phba: Pointer to HBA context object. 3874 * @phba: Pointer to HBA context object.
3706 * @pring: Pointer to driver SLI ring object. 3875 * @ring_number: SLI ring number to issue iocb on.
3707 * @piocb: Pointer to command iocb. 3876 * @piocb: Pointer to command iocb.
3708 * @flag: Flag indicating if this command can be put into txq. 3877 * @flag: Flag indicating if this command can be put into txq.
3709 * 3878 *
3710 * __lpfc_sli_issue_iocb is used by other functions in the driver 3879 * __lpfc_sli_issue_iocb_s3 is used by other functions in the driver to issue
3711 * to issue an iocb command to the HBA. If the PCI slot is recovering 3880 * an iocb command to an HBA with SLI-3 interface spec. If the PCI slot is
3712 * from error state or if HBA is resetting or if LPFC_STOP_IOCB_EVENT 3881 * recovering from error state, if HBA is resetting or if LPFC_STOP_IOCB_EVENT
3713 * flag is turned on, the function returns IOCB_ERROR. 3882 * flag is turned on, the function returns IOCB_ERROR. When the link is down,
3714 * When the link is down, this function allows only iocbs for 3883 * this function allows only iocbs for posting buffers. This function finds
3715 * posting buffers. 3884 * next available slot in the command ring and posts the command to the
3716 * This function finds next available slot in the command ring and 3885 * available slot and writes the port attention register to request HBA start
3717 * posts the command to the available slot and writes the port 3886 * processing new iocb. If there is no slot available in the ring and
3718 * attention register to request HBA start processing new iocb. 3887 * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the txq, otherwise
3719 * If there is no slot available in the ring and 3888 * the function returns IOCB_BUSY.
3720 * flag & SLI_IOCB_RET_IOCB is set, the new iocb is added to the
3721 * txq, otherwise the function returns IOCB_BUSY.
3722 * 3889 *
3723 * This function is called with hbalock held. 3890 * This function is called with hbalock held. The function will return success
3724 * The function will return success after it successfully submit the 3891 * after it successfully submit the iocb to firmware or after adding to the
3725 * iocb to firmware or after adding to the txq. 3892 * txq.
3726 **/ 3893 **/
3727static int 3894static int
3728__lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, 3895__lpfc_sli_issue_iocb_s3(struct lpfc_hba *phba, uint32_t ring_number,
3729 struct lpfc_iocbq *piocb, uint32_t flag) 3896 struct lpfc_iocbq *piocb, uint32_t flag)
3730{ 3897{
3731 struct lpfc_iocbq *nextiocb; 3898 struct lpfc_iocbq *nextiocb;
3732 IOCB_t *iocb; 3899 IOCB_t *iocb;
3900 struct lpfc_sli_ring *pring = &phba->sli.ring[ring_number];
3733 3901
3734 if (piocb->iocb_cmpl && (!piocb->vport) && 3902 if (piocb->iocb_cmpl && (!piocb->vport) &&
3735 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) && 3903 (piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
@@ -3833,6 +4001,52 @@ __lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3833 return IOCB_BUSY; 4001 return IOCB_BUSY;
3834} 4002}
3835 4003
4004/**
4005 * __lpfc_sli_issue_iocb - Wrapper func of lockless version for issuing iocb
4006 *
4007 * This routine wraps the actual lockless version for issusing IOCB function
4008 * pointer from the lpfc_hba struct.
4009 *
4010 * Return codes:
4011 * IOCB_ERROR - Error
4012 * IOCB_SUCCESS - Success
4013 * IOCB_BUSY - Busy
4014 **/
4015static inline int
4016__lpfc_sli_issue_iocb(struct lpfc_hba *phba, uint32_t ring_number,
4017 struct lpfc_iocbq *piocb, uint32_t flag)
4018{
4019 return phba->__lpfc_sli_issue_iocb(phba, ring_number, piocb, flag);
4020}
4021
4022/**
4023 * lpfc_sli_api_table_setup - Set up sli api fucntion jump table
4024 * @phba: The hba struct for which this call is being executed.
4025 * @dev_grp: The HBA PCI-Device group number.
4026 *
4027 * This routine sets up the SLI interface API function jump table in @phba
4028 * struct.
4029 * Returns: 0 - success, -ENODEV - failure.
4030 **/
4031int
4032lpfc_sli_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4033{
4034
4035 switch (dev_grp) {
4036 case LPFC_PCI_DEV_LP:
4037 phba->__lpfc_sli_issue_iocb = __lpfc_sli_issue_iocb_s3;
4038 phba->__lpfc_sli_release_iocbq = __lpfc_sli_release_iocbq_s3;
4039 break;
4040 default:
4041 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4042 "1419 Invalid HBA PCI-device group: 0x%x\n",
4043 dev_grp);
4044 return -ENODEV;
4045 break;
4046 }
4047 phba->lpfc_get_iocb_from_iocbq = lpfc_get_iocb_from_iocbq;
4048 return 0;
4049}
3836 4050
3837/** 4051/**
3838 * lpfc_sli_issue_iocb - Wrapper function for __lpfc_sli_issue_iocb 4052 * lpfc_sli_issue_iocb - Wrapper function for __lpfc_sli_issue_iocb
@@ -3848,14 +4062,14 @@ __lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3848 * functions which do not hold hbalock. 4062 * functions which do not hold hbalock.
3849 **/ 4063 **/
3850int 4064int
3851lpfc_sli_issue_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, 4065lpfc_sli_issue_iocb(struct lpfc_hba *phba, uint32_t ring_number,
3852 struct lpfc_iocbq *piocb, uint32_t flag) 4066 struct lpfc_iocbq *piocb, uint32_t flag)
3853{ 4067{
3854 unsigned long iflags; 4068 unsigned long iflags;
3855 int rc; 4069 int rc;
3856 4070
3857 spin_lock_irqsave(&phba->hbalock, iflags); 4071 spin_lock_irqsave(&phba->hbalock, iflags);
3858 rc = __lpfc_sli_issue_iocb(phba, pring, piocb, flag); 4072 rc = __lpfc_sli_issue_iocb(phba, ring_number, piocb, flag);
3859 spin_unlock_irqrestore(&phba->hbalock, iflags); 4073 spin_unlock_irqrestore(&phba->hbalock, iflags);
3860 4074
3861 return rc; 4075 return rc;
@@ -5077,53 +5291,104 @@ lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
5077} 5291}
5078 5292
5079/** 5293/**
5080 * lpfc_sli_flush_mbox_queue - mailbox queue cleanup function 5294 * lpfc_sli_mbox_sys_shutdown - shutdown mailbox command sub-system
5081 * @phba: Pointer to HBA context. 5295 * @phba: Pointer to HBA context.
5082 * 5296 *
5083 * This function is called to cleanup any pending mailbox 5297 * This function is called to shutdown the driver's mailbox sub-system.
5084 * objects in the driver queue before bringing the HBA offline. 5298 * It first marks the mailbox sub-system is in a block state to prevent
5085 * This function is called while resetting the HBA. 5299 * the asynchronous mailbox command from issued off the pending mailbox
5086 * The function is called without any lock held. The function 5300 * command queue. If the mailbox command sub-system shutdown is due to
5087 * takes hbalock to update SLI data structure. 5301 * HBA error conditions such as EEH or ERATT, this routine shall invoke
5088 * This function returns 1 when there is an active mailbox 5302 * the mailbox sub-system flush routine to forcefully bring down the
5089 * command pending else returns 0. 5303 * mailbox sub-system. Otherwise, if it is due to normal condition (such
5304 * as with offline or HBA function reset), this routine will wait for the
5305 * outstanding mailbox command to complete before invoking the mailbox
5306 * sub-system flush routine to gracefully bring down mailbox sub-system.
5090 **/ 5307 **/
5091int 5308void
5092lpfc_sli_flush_mbox_queue(struct lpfc_hba * phba) 5309lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *phba)
5093{ 5310{
5094 struct lpfc_vport *vport = phba->pport; 5311 struct lpfc_sli *psli = &phba->sli;
5095 int i = 0; 5312 uint8_t actcmd = MBX_HEARTBEAT;
5096 uint32_t ha_copy; 5313 unsigned long timeout;
5097 5314
5098 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE && !vport->stopped) { 5315 spin_lock_irq(&phba->hbalock);
5099 if (i++ > LPFC_MBOX_TMO * 1000) 5316 psli->sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
5100 return 1; 5317 spin_unlock_irq(&phba->hbalock);
5101 5318
5102 /* 5319 if (psli->sli_flag & LPFC_SLI_ACTIVE) {
5103 * Call lpfc_sli_handle_mb_event only if a mailbox cmd
5104 * did finish. This way we won't get the misleading
5105 * "Stray Mailbox Interrupt" message.
5106 */
5107 spin_lock_irq(&phba->hbalock); 5320 spin_lock_irq(&phba->hbalock);
5108 ha_copy = phba->work_ha; 5321 if (phba->sli.mbox_active)
5109 phba->work_ha &= ~HA_MBATT; 5322 actcmd = phba->sli.mbox_active->u.mb.mbxCommand;
5110 spin_unlock_irq(&phba->hbalock); 5323 spin_unlock_irq(&phba->hbalock);
5324 /* Determine how long we might wait for the active mailbox
5325 * command to be gracefully completed by firmware.
5326 */
5327 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, actcmd) *
5328 1000) + jiffies;
5329 while (phba->sli.mbox_active) {
5330 /* Check active mailbox complete status every 2ms */
5331 msleep(2);
5332 if (time_after(jiffies, timeout))
5333 /* Timeout, let the mailbox flush routine to
5334 * forcefully release active mailbox command
5335 */
5336 break;
5337 }
5338 }
5339 lpfc_sli_mbox_sys_flush(phba);
5340}
5111 5341
5112 if (ha_copy & HA_MBATT) 5342/**
5113 if (lpfc_sli_handle_mb_event(phba) == 0) 5343 * lpfc_sli_eratt_read - read sli-3 error attention events
5114 i = 0; 5344 * @phba: Pointer to HBA context.
5345 *
5346 * This function is called to read the SLI3 device error attention registers
5347 * for possible error attention events. The caller must hold the hostlock
5348 * with spin_lock_irq().
5349 *
5350 * This fucntion returns 1 when there is Error Attention in the Host Attention
5351 * Register and returns 0 otherwise.
5352 **/
5353static int
5354lpfc_sli_eratt_read(struct lpfc_hba *phba)
5355{
5356 uint32_t ha_copy;
5115 5357
5116 msleep(1); 5358 /* Read chip Host Attention (HA) register */
5117 } 5359 ha_copy = readl(phba->HAregaddr);
5360 if (ha_copy & HA_ERATT) {
5361 /* Read host status register to retrieve error event */
5362 lpfc_sli_read_hs(phba);
5118 5363
5119 return (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) ? 1 : 0; 5364 /* Check if there is a deferred error condition is active */
5365 if ((HS_FFER1 & phba->work_hs) &&
5366 ((HS_FFER2 | HS_FFER3 | HS_FFER4 | HS_FFER5 |
5367 HS_FFER6 | HS_FFER7) & phba->work_hs)) {
5368 spin_lock_irq(&phba->hbalock);
5369 phba->hba_flag |= DEFER_ERATT;
5370 spin_unlock_irq(&phba->hbalock);
5371 /* Clear all interrupt enable conditions */
5372 writel(0, phba->HCregaddr);
5373 readl(phba->HCregaddr);
5374 }
5375
5376 /* Set the driver HA work bitmap */
5377 spin_lock_irq(&phba->hbalock);
5378 phba->work_ha |= HA_ERATT;
5379 /* Indicate polling handles this ERATT */
5380 phba->hba_flag |= HBA_ERATT_HANDLED;
5381 spin_unlock_irq(&phba->hbalock);
5382 return 1;
5383 }
5384 return 0;
5120} 5385}
5121 5386
5122/** 5387/**
5123 * lpfc_sli_check_eratt - check error attention events 5388 * lpfc_sli_check_eratt - check error attention events
5124 * @phba: Pointer to HBA context. 5389 * @phba: Pointer to HBA context.
5125 * 5390 *
5126 * This function is called form timer soft interrupt context to check HBA's 5391 * This function is called from timer soft interrupt context to check HBA's
5127 * error attention register bit for error attention events. 5392 * error attention register bit for error attention events.
5128 * 5393 *
5129 * This fucntion returns 1 when there is Error Attention in the Host Attention 5394 * This fucntion returns 1 when there is Error Attention in the Host Attention
@@ -5134,10 +5399,6 @@ lpfc_sli_check_eratt(struct lpfc_hba *phba)
5134{ 5399{
5135 uint32_t ha_copy; 5400 uint32_t ha_copy;
5136 5401
5137 /* If PCI channel is offline, don't process it */
5138 if (unlikely(pci_channel_offline(phba->pcidev)))
5139 return 0;
5140
5141 /* If somebody is waiting to handle an eratt, don't process it 5402 /* If somebody is waiting to handle an eratt, don't process it
5142 * here. The brdkill function will do this. 5403 * here. The brdkill function will do this.
5143 */ 5404 */
@@ -5161,56 +5422,80 @@ lpfc_sli_check_eratt(struct lpfc_hba *phba)
5161 return 0; 5422 return 0;
5162 } 5423 }
5163 5424
5164 /* Read chip Host Attention (HA) register */ 5425 /* If PCI channel is offline, don't process it */
5165 ha_copy = readl(phba->HAregaddr); 5426 if (unlikely(pci_channel_offline(phba->pcidev))) {
5166 if (ha_copy & HA_ERATT) {
5167 /* Read host status register to retrieve error event */
5168 lpfc_sli_read_hs(phba);
5169
5170 /* Check if there is a deferred error condition is active */
5171 if ((HS_FFER1 & phba->work_hs) &&
5172 ((HS_FFER2 | HS_FFER3 | HS_FFER4 | HS_FFER5 |
5173 HS_FFER6 | HS_FFER7) & phba->work_hs)) {
5174 phba->hba_flag |= DEFER_ERATT;
5175 /* Clear all interrupt enable conditions */
5176 writel(0, phba->HCregaddr);
5177 readl(phba->HCregaddr);
5178 }
5179
5180 /* Set the driver HA work bitmap */
5181 phba->work_ha |= HA_ERATT;
5182 /* Indicate polling handles this ERATT */
5183 phba->hba_flag |= HBA_ERATT_HANDLED;
5184 spin_unlock_irq(&phba->hbalock); 5427 spin_unlock_irq(&phba->hbalock);
5185 return 1; 5428 return 0;
5429 }
5430
5431 switch (phba->sli_rev) {
5432 case LPFC_SLI_REV2:
5433 case LPFC_SLI_REV3:
5434 /* Read chip Host Attention (HA) register */
5435 ha_copy = lpfc_sli_eratt_read(phba);
5436 break;
5437 default:
5438 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5439 "0299 Invalid SLI revision (%d)\n",
5440 phba->sli_rev);
5441 ha_copy = 0;
5442 break;
5186 } 5443 }
5187 spin_unlock_irq(&phba->hbalock); 5444 spin_unlock_irq(&phba->hbalock);
5445
5446 return ha_copy;
5447}
5448
5449/**
5450 * lpfc_intr_state_check - Check device state for interrupt handling
5451 * @phba: Pointer to HBA context.
5452 *
5453 * This inline routine checks whether a device or its PCI slot is in a state
5454 * that the interrupt should be handled.
5455 *
5456 * This function returns 0 if the device or the PCI slot is in a state that
5457 * interrupt should be handled, otherwise -EIO.
5458 */
5459static inline int
5460lpfc_intr_state_check(struct lpfc_hba *phba)
5461{
5462 /* If the pci channel is offline, ignore all the interrupts */
5463 if (unlikely(pci_channel_offline(phba->pcidev)))
5464 return -EIO;
5465
5466 /* Update device level interrupt statistics */
5467 phba->sli.slistat.sli_intr++;
5468
5469 /* Ignore all interrupts during initialization. */
5470 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5471 return -EIO;
5472
5188 return 0; 5473 return 0;
5189} 5474}
5190 5475
5191/** 5476/**
5192 * lpfc_sp_intr_handler - The slow-path interrupt handler of lpfc driver 5477 * lpfc_sli_sp_intr_handler - Slow-path interrupt handler to SLI-3 device
5193 * @irq: Interrupt number. 5478 * @irq: Interrupt number.
5194 * @dev_id: The device context pointer. 5479 * @dev_id: The device context pointer.
5195 * 5480 *
5196 * This function is directly called from the PCI layer as an interrupt 5481 * This function is directly called from the PCI layer as an interrupt
5197 * service routine when the device is enabled with MSI-X multi-message 5482 * service routine when device with SLI-3 interface spec is enabled with
5198 * interrupt mode and there are slow-path events in the HBA. However, 5483 * MSI-X multi-message interrupt mode and there are slow-path events in
5199 * when the device is enabled with either MSI or Pin-IRQ interrupt mode, 5484 * the HBA. However, when the device is enabled with either MSI or Pin-IRQ
5200 * this function is called as part of the device-level interrupt handler. 5485 * interrupt mode, this function is called as part of the device-level
5201 * When the PCI slot is in error recovery or the HBA is undergoing 5486 * interrupt handler. When the PCI slot is in error recovery or the HBA
5202 * initialization, the interrupt handler will not process the interrupt. 5487 * is undergoing initialization, the interrupt handler will not process
5203 * The link attention and ELS ring attention events are handled by the 5488 * the interrupt. The link attention and ELS ring attention events are
5204 * worker thread. The interrupt handler signals the worker thread and 5489 * handled by the worker thread. The interrupt handler signals the worker
5205 * and returns for these events. This function is called without any 5490 * thread and returns for these events. This function is called without
5206 * lock held. It gets the hbalock to access and update SLI data 5491 * any lock held. It gets the hbalock to access and update SLI data
5207 * structures. 5492 * structures.
5208 * 5493 *
5209 * This function returns IRQ_HANDLED when interrupt is handled else it 5494 * This function returns IRQ_HANDLED when interrupt is handled else it
5210 * returns IRQ_NONE. 5495 * returns IRQ_NONE.
5211 **/ 5496 **/
5212irqreturn_t 5497irqreturn_t
5213lpfc_sp_intr_handler(int irq, void *dev_id) 5498lpfc_sli_sp_intr_handler(int irq, void *dev_id)
5214{ 5499{
5215 struct lpfc_hba *phba; 5500 struct lpfc_hba *phba;
5216 uint32_t ha_copy; 5501 uint32_t ha_copy;
@@ -5240,13 +5525,8 @@ lpfc_sp_intr_handler(int irq, void *dev_id)
5240 * individual interrupt handler in MSI-X multi-message interrupt mode 5525 * individual interrupt handler in MSI-X multi-message interrupt mode
5241 */ 5526 */
5242 if (phba->intr_type == MSIX) { 5527 if (phba->intr_type == MSIX) {
5243 /* If the pci channel is offline, ignore all the interrupts */ 5528 /* Check device state for handling interrupt */
5244 if (unlikely(pci_channel_offline(phba->pcidev))) 5529 if (lpfc_intr_state_check(phba))
5245 return IRQ_NONE;
5246 /* Update device-level interrupt statistics */
5247 phba->sli.slistat.sli_intr++;
5248 /* Ignore all interrupts during initialization. */
5249 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5250 return IRQ_NONE; 5530 return IRQ_NONE;
5251 /* Need to read HA REG for slow-path events */ 5531 /* Need to read HA REG for slow-path events */
5252 spin_lock_irqsave(&phba->hbalock, iflag); 5532 spin_lock_irqsave(&phba->hbalock, iflag);
@@ -5271,7 +5551,7 @@ lpfc_sp_intr_handler(int irq, void *dev_id)
5271 * interrupt. 5551 * interrupt.
5272 */ 5552 */
5273 if (unlikely(phba->hba_flag & DEFER_ERATT)) { 5553 if (unlikely(phba->hba_flag & DEFER_ERATT)) {
5274 spin_unlock_irq(&phba->hbalock); 5554 spin_unlock_irqrestore(&phba->hbalock, iflag);
5275 return IRQ_NONE; 5555 return IRQ_NONE;
5276 } 5556 }
5277 5557
@@ -5434,7 +5714,8 @@ lpfc_sp_intr_handler(int irq, void *dev_id)
5434 LOG_MBOX | LOG_SLI, 5714 LOG_MBOX | LOG_SLI,
5435 "0350 rc should have" 5715 "0350 rc should have"
5436 "been MBX_BUSY"); 5716 "been MBX_BUSY");
5437 goto send_current_mbox; 5717 if (rc != MBX_NOT_FINISHED)
5718 goto send_current_mbox;
5438 } 5719 }
5439 } 5720 }
5440 spin_lock_irqsave( 5721 spin_lock_irqsave(
@@ -5471,29 +5752,29 @@ send_current_mbox:
5471 } 5752 }
5472 return IRQ_HANDLED; 5753 return IRQ_HANDLED;
5473 5754
5474} /* lpfc_sp_intr_handler */ 5755} /* lpfc_sli_sp_intr_handler */
5475 5756
5476/** 5757/**
5477 * lpfc_fp_intr_handler - The fast-path interrupt handler of lpfc driver 5758 * lpfc_sli_fp_intr_handler - Fast-path interrupt handler to SLI-3 device.
5478 * @irq: Interrupt number. 5759 * @irq: Interrupt number.
5479 * @dev_id: The device context pointer. 5760 * @dev_id: The device context pointer.
5480 * 5761 *
5481 * This function is directly called from the PCI layer as an interrupt 5762 * This function is directly called from the PCI layer as an interrupt
5482 * service routine when the device is enabled with MSI-X multi-message 5763 * service routine when device with SLI-3 interface spec is enabled with
5483 * interrupt mode and there is a fast-path FCP IOCB ring event in the 5764 * MSI-X multi-message interrupt mode and there is a fast-path FCP IOCB
5484 * HBA. However, when the device is enabled with either MSI or Pin-IRQ 5765 * ring event in the HBA. However, when the device is enabled with either
5485 * interrupt mode, this function is called as part of the device-level 5766 * MSI or Pin-IRQ interrupt mode, this function is called as part of the
5486 * interrupt handler. When the PCI slot is in error recovery or the HBA 5767 * device-level interrupt handler. When the PCI slot is in error recovery
5487 * is undergoing initialization, the interrupt handler will not process 5768 * or the HBA is undergoing initialization, the interrupt handler will not
5488 * the interrupt. The SCSI FCP fast-path ring event are handled in the 5769 * process the interrupt. The SCSI FCP fast-path ring event are handled in
5489 * intrrupt context. This function is called without any lock held. It 5770 * the intrrupt context. This function is called without any lock held.
5490 * gets the hbalock to access and update SLI data structures. 5771 * It gets the hbalock to access and update SLI data structures.
5491 * 5772 *
5492 * This function returns IRQ_HANDLED when interrupt is handled else it 5773 * This function returns IRQ_HANDLED when interrupt is handled else it
5493 * returns IRQ_NONE. 5774 * returns IRQ_NONE.
5494 **/ 5775 **/
5495irqreturn_t 5776irqreturn_t
5496lpfc_fp_intr_handler(int irq, void *dev_id) 5777lpfc_sli_fp_intr_handler(int irq, void *dev_id)
5497{ 5778{
5498 struct lpfc_hba *phba; 5779 struct lpfc_hba *phba;
5499 uint32_t ha_copy; 5780 uint32_t ha_copy;
@@ -5513,13 +5794,8 @@ lpfc_fp_intr_handler(int irq, void *dev_id)
5513 * individual interrupt handler in MSI-X multi-message interrupt mode 5794 * individual interrupt handler in MSI-X multi-message interrupt mode
5514 */ 5795 */
5515 if (phba->intr_type == MSIX) { 5796 if (phba->intr_type == MSIX) {
5516 /* If pci channel is offline, ignore all the interrupts */ 5797 /* Check device state for handling interrupt */
5517 if (unlikely(pci_channel_offline(phba->pcidev))) 5798 if (lpfc_intr_state_check(phba))
5518 return IRQ_NONE;
5519 /* Update device-level interrupt statistics */
5520 phba->sli.slistat.sli_intr++;
5521 /* Ignore all interrupts during initialization. */
5522 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5523 return IRQ_NONE; 5799 return IRQ_NONE;
5524 /* Need to read HA REG for FCP ring and other ring events */ 5800 /* Need to read HA REG for FCP ring and other ring events */
5525 ha_copy = readl(phba->HAregaddr); 5801 ha_copy = readl(phba->HAregaddr);
@@ -5530,7 +5806,7 @@ lpfc_fp_intr_handler(int irq, void *dev_id)
5530 * any interrupt. 5806 * any interrupt.
5531 */ 5807 */
5532 if (unlikely(phba->hba_flag & DEFER_ERATT)) { 5808 if (unlikely(phba->hba_flag & DEFER_ERATT)) {
5533 spin_unlock_irq(&phba->hbalock); 5809 spin_unlock_irqrestore(&phba->hbalock, iflag);
5534 return IRQ_NONE; 5810 return IRQ_NONE;
5535 } 5811 }
5536 writel((ha_copy & (HA_R0_CLR_MSK | HA_R1_CLR_MSK)), 5812 writel((ha_copy & (HA_R0_CLR_MSK | HA_R1_CLR_MSK)),
@@ -5566,26 +5842,27 @@ lpfc_fp_intr_handler(int irq, void *dev_id)
5566 } 5842 }
5567 } 5843 }
5568 return IRQ_HANDLED; 5844 return IRQ_HANDLED;
5569} /* lpfc_fp_intr_handler */ 5845} /* lpfc_sli_fp_intr_handler */
5570 5846
5571/** 5847/**
5572 * lpfc_intr_handler - The device-level interrupt handler of lpfc driver 5848 * lpfc_sli_intr_handler - Device-level interrupt handler to SLI-3 device
5573 * @irq: Interrupt number. 5849 * @irq: Interrupt number.
5574 * @dev_id: The device context pointer. 5850 * @dev_id: The device context pointer.
5575 * 5851 *
5576 * This function is the device-level interrupt handler called from the PCI 5852 * This function is the HBA device-level interrupt handler to device with
5577 * layer when either MSI or Pin-IRQ interrupt mode is enabled and there is 5853 * SLI-3 interface spec, called from the PCI layer when either MSI or
5578 * an event in the HBA which requires driver attention. This function 5854 * Pin-IRQ interrupt mode is enabled and there is an event in the HBA which
5579 * invokes the slow-path interrupt attention handling function and fast-path 5855 * requires driver attention. This function invokes the slow-path interrupt
5580 * interrupt attention handling function in turn to process the relevant 5856 * attention handling function and fast-path interrupt attention handling
5581 * HBA attention events. This function is called without any lock held. It 5857 * function in turn to process the relevant HBA attention events. This
5582 * gets the hbalock to access and update SLI data structures. 5858 * function is called without any lock held. It gets the hbalock to access
5859 * and update SLI data structures.
5583 * 5860 *
5584 * This function returns IRQ_HANDLED when interrupt is handled, else it 5861 * This function returns IRQ_HANDLED when interrupt is handled, else it
5585 * returns IRQ_NONE. 5862 * returns IRQ_NONE.
5586 **/ 5863 **/
5587irqreturn_t 5864irqreturn_t
5588lpfc_intr_handler(int irq, void *dev_id) 5865lpfc_sli_intr_handler(int irq, void *dev_id)
5589{ 5866{
5590 struct lpfc_hba *phba; 5867 struct lpfc_hba *phba;
5591 irqreturn_t sp_irq_rc, fp_irq_rc; 5868 irqreturn_t sp_irq_rc, fp_irq_rc;
@@ -5600,15 +5877,8 @@ lpfc_intr_handler(int irq, void *dev_id)
5600 if (unlikely(!phba)) 5877 if (unlikely(!phba))
5601 return IRQ_NONE; 5878 return IRQ_NONE;
5602 5879
5603 /* If the pci channel is offline, ignore all the interrupts. */ 5880 /* Check device state for handling interrupt */
5604 if (unlikely(pci_channel_offline(phba->pcidev))) 5881 if (lpfc_intr_state_check(phba))
5605 return IRQ_NONE;
5606
5607 /* Update device level interrupt statistics */
5608 phba->sli.slistat.sli_intr++;
5609
5610 /* Ignore all interrupts during initialization. */
5611 if (unlikely(phba->link_state < LPFC_LINK_DOWN))
5612 return IRQ_NONE; 5882 return IRQ_NONE;
5613 5883
5614 spin_lock(&phba->hbalock); 5884 spin_lock(&phba->hbalock);
@@ -5650,7 +5920,7 @@ lpfc_intr_handler(int irq, void *dev_id)
5650 status2 >>= (4*LPFC_ELS_RING); 5920 status2 >>= (4*LPFC_ELS_RING);
5651 5921
5652 if (status1 || (status2 & HA_RXMASK)) 5922 if (status1 || (status2 & HA_RXMASK))
5653 sp_irq_rc = lpfc_sp_intr_handler(irq, dev_id); 5923 sp_irq_rc = lpfc_sli_sp_intr_handler(irq, dev_id);
5654 else 5924 else
5655 sp_irq_rc = IRQ_NONE; 5925 sp_irq_rc = IRQ_NONE;
5656 5926
@@ -5670,10 +5940,10 @@ lpfc_intr_handler(int irq, void *dev_id)
5670 status2 = 0; 5940 status2 = 0;
5671 5941
5672 if ((status1 & HA_RXMASK) || (status2 & HA_RXMASK)) 5942 if ((status1 & HA_RXMASK) || (status2 & HA_RXMASK))
5673 fp_irq_rc = lpfc_fp_intr_handler(irq, dev_id); 5943 fp_irq_rc = lpfc_sli_fp_intr_handler(irq, dev_id);
5674 else 5944 else
5675 fp_irq_rc = IRQ_NONE; 5945 fp_irq_rc = IRQ_NONE;
5676 5946
5677 /* Return device-level interrupt handling status */ 5947 /* Return device-level interrupt handling status */
5678 return (sp_irq_rc == IRQ_HANDLED) ? sp_irq_rc : fp_irq_rc; 5948 return (sp_irq_rc == IRQ_HANDLED) ? sp_irq_rc : fp_irq_rc;
5679} /* lpfc_intr_handler */ 5949} /* lpfc_sli_intr_handler */
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-18 07:28:17 -0500