Lines Matching defs:phba
44 lpfc_els_chk_latt(struct lpfc_hba * phba)
51 psli = &phba->sli;
53 if ((phba->hba_state >= LPFC_HBA_READY) ||
54 (phba->hba_state == LPFC_LINK_DOWN))
58 spin_lock_irq(phba->host->host_lock);
59 ha_copy = readl(phba->HAregaddr);
60 spin_unlock_irq(phba->host->host_lock);
66 lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY,
69 phba->brd_no, phba->hba_state);
77 spin_lock_irq(phba->host->host_lock);
78 phba->fc_flag |= FC_ABORT_DISCOVERY;
79 spin_unlock_irq(phba->host->host_lock);
81 if (phba->hba_state != LPFC_CLEAR_LA) {
82 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) {
83 phba->hba_state = LPFC_CLEAR_LA;
84 lpfc_clear_la(phba, mbox);
86 rc = lpfc_sli_issue_mbox (phba, mbox,
89 mempool_free(mbox, phba->mbox_mem_pool);
90 phba->hba_state = LPFC_HBA_ERROR;
100 lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
110 pring = &phba->sli.ring[LPFC_ELS_RING];
112 if (phba->hba_state < LPFC_LINK_UP)
116 spin_lock_irq(phba->host->host_lock);
117 elsiocb = lpfc_sli_get_iocbq(phba);
118 spin_unlock_irq(phba->host->host_lock);
127 ((pcmd->virt = lpfc_mbuf_alloc(phba,
131 spin_lock_irq(phba->host->host_lock);
132 lpfc_sli_release_iocbq(phba, elsiocb);
133 spin_unlock_irq(phba->host->host_lock);
143 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
147 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
149 spin_lock_irq(phba->host->host_lock);
150 lpfc_sli_release_iocbq(phba, elsiocb);
151 spin_unlock_irq(phba->host->host_lock);
162 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
165 spin_lock_irq(phba->host->host_lock);
166 lpfc_sli_release_iocbq(phba, elsiocb);
167 spin_unlock_irq(phba->host->host_lock);
168 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
169 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
185 icmd->ulpTimeout = phba->fc_ratov * 2;
216 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
224 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
227 phba->brd_no, elscmd,
228 did, elsiocb->iotag, phba->hba_state);
231 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
234 phba->brd_no, elscmd,
243 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
250 spin_lock_irq(phba->host->host_lock);
251 phba->fc_flag |= FC_FABRIC;
252 spin_unlock_irq(phba->host->host_lock);
254 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
256 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
258 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
260 if (phba->fc_topology == TOPOLOGY_LOOP) {
261 spin_lock_irq(phba->host->host_lock);
262 phba->fc_flag |= FC_PUBLIC_LOOP;
263 spin_unlock_irq(phba->host->host_lock);
269 phba->fc_sparam.cmn.altBbCredit = 1;
272 phba->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
286 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
288 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
292 phba->hba_state = LPFC_FABRIC_CFG_LINK;
293 lpfc_config_link(phba, mbox);
296 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
300 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
304 if (lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0))
310 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
319 lpfc_mbuf_free(phba, mp->virt, mp->phys);
322 mempool_free(mbox, phba->mbox_mem_pool);
331 lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
337 spin_lock_irq(phba->host->host_lock);
338 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
339 spin_unlock_irq(phba->host->host_lock);
341 phba->fc_edtov = FF_DEF_EDTOV;
342 phba->fc_ratov = FF_DEF_RATOV;
343 rc = memcmp(&phba->fc_portname, &sp->portName,
347 spin_lock_irq(phba->host->host_lock);
348 phba->fc_flag |= FC_PT2PT_PLOGI;
349 spin_unlock_irq(phba->host->host_lock);
358 phba->fc_myDID = PT2PT_LocalID;
360 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
364 lpfc_config_link(phba, mbox);
367 rc = lpfc_sli_issue_mbox(phba, mbox,
370 mempool_free(mbox, phba->mbox_mem_pool);
375 ndlp = lpfc_findnode_did(phba, PT2PT_RemoteID);
381 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
385 lpfc_nlp_init(phba, ndlp, PT2PT_RemoteID);
392 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
399 spin_lock_irq(phba->host->host_lock);
400 phba->fc_flag |= FC_PT2PT;
401 spin_unlock_irq(phba->host->host_lock);
404 lpfc_disc_start(phba);
411 lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
421 if (lpfc_els_chk_latt(phba)) {
428 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
433 spin_lock_irq(phba->host->host_lock);
434 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
435 spin_unlock_irq(phba->host->host_lock);
441 if (phba->alpa_map[0] == 0) {
442 phba->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
446 lpfc_printf_log(phba,
450 phba->brd_no,
465 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
468 phba->brd_no,
472 if (phba->hba_state == LPFC_FLOGI) {
478 rc = lpfc_cmpl_els_flogi_fabric(phba, ndlp, sp, irsp);
480 rc = lpfc_cmpl_els_flogi_nport(phba, ndlp, sp);
493 lpfc_disc_list_loopmap(phba);
496 lpfc_disc_start(phba);
500 lpfc_els_free_iocb(phba, cmdiocb);
504 lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
516 pring = &phba->sli.ring[LPFC_ELS_RING];
519 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
530 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
544 tmo = phba->fc_ratov;
545 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
546 lpfc_set_disctmo(phba);
547 phba->fc_ratov = tmo;
549 phba->fc_stat.elsXmitFLOGI++;
551 spin_lock_irq(phba->host->host_lock);
552 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
553 spin_unlock_irq(phba->host->host_lock);
555 lpfc_els_free_iocb(phba, elsiocb);
562 lpfc_els_abort_flogi(struct lpfc_hba * phba)
570 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
572 phba->brd_no, Fabric_DID);
574 pring = &phba->sli.ring[LPFC_ELS_RING];
580 spin_lock_irq(phba->host->host_lock);
586 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
589 spin_unlock_irq(phba->host->host_lock);
595 lpfc_initial_flogi(struct lpfc_hba *phba)
600 ndlp = lpfc_findnode_did(phba, Fabric_DID);
603 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
606 lpfc_nlp_init(phba, ndlp, Fabric_DID);
608 lpfc_dequeue_node(phba, ndlp);
610 if (lpfc_issue_els_flogi(phba, ndlp, 0)) {
617 lpfc_more_plogi(struct lpfc_hba * phba)
621 if (phba->num_disc_nodes)
622 phba->num_disc_nodes--;
625 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
628 phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt,
629 phba->fc_flag, phba->hba_state);
632 if (phba->fc_flag & FC_NLP_MORE) {
634 sentplogi = lpfc_els_disc_plogi(phba);
640 lpfc_plogi_confirm_nport(struct lpfc_hba *phba, struct lpfc_dmabuf *prsp,
662 new_ndlp = lpfc_findnode_wwpn(phba, &sp->portName);
672 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
676 lpfc_nlp_init(phba, new_ndlp, ndlp->nlp_DID);
679 lpfc_unreg_rpi(phba, new_ndlp);
682 lpfc_nlp_set_state(phba, new_ndlp, ndlp->nlp_state);
686 lpfc_drop_node(phba, ndlp);
688 lpfc_unreg_rpi(phba, ndlp);
690 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
696 lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
708 ndlp = lpfc_findnode_did(phba, irsp->un.elsreq64.remoteID);
716 spin_lock_irq(phba->host->host_lock);
718 spin_unlock_irq(phba->host->host_lock);
722 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
725 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
727 phba->num_disc_nodes);
730 if (lpfc_els_chk_latt(phba)) {
731 spin_lock_irq(phba->host->host_lock);
733 spin_unlock_irq(phba->host->host_lock);
743 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
746 spin_lock_irq(phba->host->host_lock);
748 spin_unlock_irq(phba->host->host_lock);
761 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
769 ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp);
770 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
774 if (disc && phba->num_disc_nodes) {
776 lpfc_more_plogi(phba);
778 if (phba->num_disc_nodes == 0) {
779 spin_lock_irq(phba->host->host_lock);
780 phba->fc_flag &= ~FC_NDISC_ACTIVE;
781 spin_unlock_irq(phba->host->host_lock);
783 lpfc_can_disctmo(phba);
784 if (phba->fc_flag & FC_RSCN_MODE) {
789 if ((phba->fc_rscn_id_cnt == 0) &&
790 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
791 spin_lock_irq(phba->host->host_lock);
792 phba->fc_flag &= ~FC_RSCN_MODE;
793 spin_unlock_irq(phba->host->host_lock);
795 lpfc_els_handle_rscn(phba);
802 lpfc_els_free_iocb(phba, cmdiocb);
807 lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
817 psli = &phba->sli;
821 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, NULL, did,
832 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
841 phba->fc_stat.elsXmitPLOGI++;
843 spin_lock_irq(phba->host->host_lock);
844 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
845 spin_unlock_irq(phba->host->host_lock);
846 lpfc_els_free_iocb(phba, elsiocb);
849 spin_unlock_irq(phba->host->host_lock);
854 lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
861 psli = &phba->sli;
867 spin_lock_irq(phba->host->host_lock);
869 spin_unlock_irq(phba->host->host_lock);
872 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
875 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
877 phba->num_disc_nodes);
879 phba->fc_prli_sent--;
881 if (lpfc_els_chk_latt(phba))
886 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
898 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
903 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI);
907 lpfc_els_free_iocb(phba, cmdiocb);
912 lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
923 psli = &phba->sli;
927 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
946 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
958 phba->fc_stat.elsXmitPRLI++;
960 spin_lock_irq(phba->host->host_lock);
962 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
964 spin_unlock_irq(phba->host->host_lock);
965 lpfc_els_free_iocb(phba, elsiocb);
968 spin_unlock_irq(phba->host->host_lock);
969 phba->fc_prli_sent++;
974 lpfc_more_adisc(struct lpfc_hba * phba)
978 if (phba->num_disc_nodes)
979 phba->num_disc_nodes--;
982 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
985 phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt,
986 phba->fc_flag, phba->hba_state);
989 if (phba->fc_flag & FC_NLP_MORE) {
990 lpfc_set_disctmo(phba);
993 sentadisc = lpfc_els_disc_adisc(phba);
999 lpfc_rscn_disc(struct lpfc_hba * phba)
1003 if (phba->fc_npr_cnt) {
1004 if (lpfc_els_disc_plogi(phba))
1007 if (phba->fc_flag & FC_RSCN_MODE) {
1011 if ((phba->fc_rscn_id_cnt == 0) &&
1012 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
1013 spin_lock_irq(phba->host->host_lock);
1014 phba->fc_flag &= ~FC_RSCN_MODE;
1015 spin_unlock_irq(phba->host->host_lock);
1017 lpfc_els_handle_rscn(phba);
1023 lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1032 psli = &phba->sli;
1044 spin_lock_irq(phba->host->host_lock);
1046 spin_unlock_irq(phba->host->host_lock);
1049 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1052 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1054 phba->num_disc_nodes);
1057 if (lpfc_els_chk_latt(phba)) {
1058 spin_lock_irq(phba->host->host_lock);
1060 spin_unlock_irq(phba->host->host_lock);
1066 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1069 spin_lock_irq(phba->host->host_lock);
1071 spin_unlock_irq(phba->host->host_lock);
1072 lpfc_set_disctmo(phba);
1082 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1087 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1091 if (disc && phba->num_disc_nodes) {
1093 lpfc_more_adisc(phba);
1096 if (phba->num_disc_nodes == 0) {
1097 lpfc_can_disctmo(phba);
1099 if ((phba->hba_state < LPFC_HBA_READY) &&
1100 (phba->hba_state != LPFC_CLEAR_LA)) {
1102 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
1104 phba->hba_state = LPFC_CLEAR_LA;
1105 lpfc_clear_la(phba, mbox);
1109 (phba, mbox,
1113 phba->mbox_mem_pool);
1114 lpfc_disc_flush_list(phba);
1124 phba->hba_state =
1129 lpfc_rscn_disc(phba);
1134 lpfc_els_free_iocb(phba, cmdiocb);
1139 lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1150 psli = &phba->sli;
1154 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1168 ap->hardAL_PA = phba->fc_pref_ALPA;
1169 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
1170 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1171 ap->DID = be32_to_cpu(phba->fc_myDID);
1173 phba->fc_stat.elsXmitADISC++;
1175 spin_lock_irq(phba->host->host_lock);
1177 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1179 spin_unlock_irq(phba->host->host_lock);
1180 lpfc_els_free_iocb(phba, elsiocb);
1183 spin_unlock_irq(phba->host->host_lock);
1188 lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1195 psli = &phba->sli;
1201 spin_lock_irq(phba->host->host_lock);
1203 spin_unlock_irq(phba->host->host_lock);
1206 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1209 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1211 phba->num_disc_nodes);
1214 if (lpfc_els_chk_latt(phba))
1219 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1231 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1238 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO);
1242 lpfc_els_free_iocb(phba, cmdiocb);
1247 lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1257 psli = &phba->sli;
1261 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1272 *((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID);
1274 memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name));
1276 phba->fc_stat.elsXmitLOGO++;
1278 spin_lock_irq(phba->host->host_lock);
1280 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1282 spin_unlock_irq(phba->host->host_lock);
1283 lpfc_els_free_iocb(phba, elsiocb);
1286 spin_unlock_irq(phba->host->host_lock);
1291 lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1299 lpfc_printf_log(phba,
1303 phba->brd_no,
1308 lpfc_els_chk_latt(phba);
1309 lpfc_els_free_iocb(phba, cmdiocb);
1314 lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1324 psli = &phba->sli;
1327 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1331 lpfc_nlp_init(phba, ndlp, nportid);
1333 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1350 phba->fc_stat.elsXmitSCR++;
1352 spin_lock_irq(phba->host->host_lock);
1353 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1354 spin_unlock_irq(phba->host->host_lock);
1356 lpfc_els_free_iocb(phba, elsiocb);
1359 spin_unlock_irq(phba->host->host_lock);
1365 lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1378 psli = &phba->sli;
1381 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1384 lpfc_nlp_init(phba, ndlp, nportid);
1386 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1404 *lp++ = be32_to_cpu(phba->fc_myDID);
1408 memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name));
1409 memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1410 if ((ondlp = lpfc_findnode_did(phba, nportid))) {
1417 phba->fc_stat.elsXmitFARPR++;
1419 spin_lock_irq(phba->host->host_lock);
1420 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1421 spin_unlock_irq(phba->host->host_lock);
1423 lpfc_els_free_iocb(phba, elsiocb);
1426 spin_unlock_irq(phba->host->host_lock);
1432 lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp)
1443 if (phba->num_disc_nodes) {
1447 lpfc_more_plogi(phba);
1449 if (phba->num_disc_nodes == 0) {
1450 phba->fc_flag &= ~FC_NDISC_ACTIVE;
1451 lpfc_can_disctmo(phba);
1452 if (phba->fc_flag & FC_RSCN_MODE) {
1458 if((phba->fc_rscn_id_cnt==0) &&
1459 !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
1460 phba->fc_flag &= ~FC_RSCN_MODE;
1463 lpfc_els_handle_rscn(phba);
1476 struct lpfc_hba *phba;
1481 phba = ndlp->nlp_phba;
1484 spin_lock_irqsave(phba->host->host_lock, iflag);
1486 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1492 list_add_tail(&evtp->evt_listp, &phba->work_list);
1493 if (phba->work_wait)
1494 wake_up(phba->work_wait);
1496 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1503 struct lpfc_hba *phba;
1508 phba = ndlp->nlp_phba;
1509 spin_lock_irq(phba->host->host_lock);
1515 spin_unlock_irq(phba->host->host_lock);
1520 spin_unlock_irq(phba->host->host_lock);
1531 lpfc_issue_els_flogi(phba, ndlp, retry);
1534 if(!lpfc_issue_els_plogi(phba, ndlp->nlp_DID, retry)) {
1536 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
1540 if (!lpfc_issue_els_adisc(phba, ndlp, retry)) {
1542 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
1546 if (!lpfc_issue_els_prli(phba, ndlp, retry)) {
1548 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
1552 if (!lpfc_issue_els_logo(phba, ndlp, retry)) {
1554 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
1562 lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1597 ndlp = lpfc_findnode_did(phba, did);
1694 phba->fc_stat.elsRetryExceeded++;
1701 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1704 phba->brd_no,
1709 if (timer_pending(&phba->fc_disctmo) ||
1710 (phba->fc_flag & FC_RSCN_MODE)) {
1711 lpfc_set_disctmo(phba);
1715 phba->fc_stat.elsXmitRetry++;
1717 phba->fc_stat.elsDelayRetry++;
1724 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
1731 lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry);
1736 lpfc_nlp_set_state(phba, ndlp,
1739 lpfc_issue_els_plogi(phba, did, cmdiocb->retry);
1743 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
1744 lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry);
1748 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
1749 lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry);
1753 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
1754 lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry);
1760 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1763 phba->brd_no,
1770 lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
1786 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1789 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
1795 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1798 spin_lock_irq(phba->host->host_lock);
1799 lpfc_sli_release_iocbq(phba, elsiocb);
1800 spin_unlock_irq(phba->host->host_lock);
1805 lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1813 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1816 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
1821 lpfc_drop_node(phba, ndlp);
1824 lpfc_unreg_rpi(phba, ndlp);
1829 lpfc_els_free_iocb(phba, cmdiocb);
1834 lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1850 if (lpfc_els_chk_latt(phba) || !ndlp) {
1854 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1857 mempool_free(mbox, phba->mbox_mem_pool);
1863 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1866 phba->brd_no,
1875 lpfc_unreg_rpi(phba, ndlp);
1879 lpfc_nlp_set_state(phba, ndlp, NLP_STE_REG_LOGIN_ISSUE);
1880 if (lpfc_sli_issue_mbox(phba, mbox,
1895 lpfc_drop_node(phba, ndlp);
1902 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1905 mempool_free(mbox, phba->mbox_mem_pool);
1909 spin_lock_irq(phba->host->host_lock);
1911 spin_unlock_irq(phba->host->host_lock);
1913 lpfc_els_free_iocb(phba, cmdiocb);
1918 lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1932 psli = &phba->sli;
1939 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1953 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1967 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
1971 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1996 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1999 phba->brd_no, elsiocb->iotag,
2004 spin_lock_irq(phba->host->host_lock);
2006 spin_unlock_irq(phba->host->host_lock);
2012 phba->fc_stat.elsXmitACC++;
2013 spin_lock_irq(phba->host->host_lock);
2014 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2015 spin_unlock_irq(phba->host->host_lock);
2017 lpfc_els_free_iocb(phba, elsiocb);
2024 lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
2036 psli = &phba->sli;
2040 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2055 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2058 phba->brd_no, rejectError, elsiocb->iotag,
2062 phba->fc_stat.elsXmitLSRJT++;
2064 spin_lock_irq(phba->host->host_lock);
2065 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2066 spin_unlock_irq(phba->host->host_lock);
2068 lpfc_els_free_iocb(phba, elsiocb);
2075 lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
2088 psli = &phba->sli;
2092 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2102 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2105 phba->brd_no, elsiocb->iotag,
2115 ap->hardAL_PA = phba->fc_pref_ALPA;
2116 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2117 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2118 ap->DID = be32_to_cpu(phba->fc_myDID);
2120 phba->fc_stat.elsXmitACC++;
2122 spin_lock_irq(phba->host->host_lock);
2123 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2124 spin_unlock_irq(phba->host->host_lock);
2126 lpfc_els_free_iocb(phba, elsiocb);
2133 lpfc_els_rsp_prli_acc(struct lpfc_hba *phba, struct lpfc_iocbq *oldiocb,
2147 psli = &phba->sli;
2151 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, ndlp,
2161 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2164 phba->brd_no, elsiocb->iotag,
2177 vpd = &phba->vpd;
2196 phba->fc_stat.elsXmitACC++;
2199 spin_lock_irq(phba->host->host_lock);
2200 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2201 spin_unlock_irq(phba->host->host_lock);
2203 lpfc_els_free_iocb(phba, elsiocb);
2210 lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
2223 psli = &phba->sli;
2231 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2241 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2244 phba->brd_no, elsiocb->iotag,
2256 memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2257 memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2265 &phba->fc_portname, sizeof (struct lpfc_name));
2276 phba->fc_stat.elsXmitACC++;
2282 spin_lock_irq(phba->host->host_lock);
2283 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2284 spin_unlock_irq(phba->host->host_lock);
2286 lpfc_els_free_iocb(phba, elsiocb);
2293 lpfc_els_disc_adisc(struct lpfc_hba *phba)
2300 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
2304 spin_lock_irq(phba->host->host_lock);
2306 spin_unlock_irq(phba->host->host_lock);
2308 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
2309 lpfc_issue_els_adisc(phba, ndlp, 0);
2311 phba->num_disc_nodes++;
2312 if (phba->num_disc_nodes >=
2313 phba->cfg_discovery_threads) {
2314 spin_lock_irq(phba->host->host_lock);
2315 phba->fc_flag |= FC_NLP_MORE;
2316 spin_unlock_irq(phba->host->host_lock);
2322 spin_lock_irq(phba->host->host_lock);
2323 phba->fc_flag &= ~FC_NLP_MORE;
2324 spin_unlock_irq(phba->host->host_lock);
2330 lpfc_els_disc_plogi(struct lpfc_hba * phba)
2337 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
2343 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
2344 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
2346 phba->num_disc_nodes++;
2347 if (phba->num_disc_nodes >=
2348 phba->cfg_discovery_threads) {
2349 spin_lock_irq(phba->host->host_lock);
2350 phba->fc_flag |= FC_NLP_MORE;
2351 spin_unlock_irq(phba->host->host_lock);
2357 spin_lock_irq(phba->host->host_lock);
2358 phba->fc_flag &= ~FC_NLP_MORE;
2359 spin_unlock_irq(phba->host->host_lock);
2365 lpfc_els_flush_rscn(struct lpfc_hba * phba)
2370 for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2371 mp = phba->fc_rscn_id_list[i];
2372 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2374 phba->fc_rscn_id_list[i] = NULL;
2376 phba->fc_rscn_id_cnt = 0;
2377 spin_lock_irq(phba->host->host_lock);
2378 phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2379 spin_unlock_irq(phba->host->host_lock);
2380 lpfc_can_disctmo(phba);
2385 lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
2401 if (phba->fc_flag & FC_RSCN_DISCOVERY) {
2405 for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2406 mp = phba->fc_rscn_id_list[i];
2439 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
2442 phba->brd_no, rscn_did.un.word);
2454 lpfc_rscn_recovery_check(struct lpfc_hba *phba)
2462 list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) {
2464 lpfc_rscn_payload_check(phba, ndlp->nlp_DID) == 0)
2467 lpfc_disc_state_machine(phba, ndlp, NULL,
2475 lpfc_cancel_retry_delay_tmo(phba, ndlp);
2482 lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2502 lpfc_printf_log(phba,
2506 phba->brd_no,
2507 phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt);
2510 fc_host_post_event(phba->host, fc_get_event_number(),
2516 if (phba->hba_state <= LPFC_NS_QRY) {
2517 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2525 if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2526 if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
2527 !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
2528 spin_lock_irq(phba->host->host_lock);
2529 phba->fc_flag |= FC_RSCN_MODE;
2530 spin_unlock_irq(phba->host->host_lock);
2531 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2539 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2542 phba->brd_no, phba->fc_rscn_id_cnt,
2543 phba->fc_flag, phba->hba_state);
2545 spin_lock_irq(phba->host->host_lock);
2546 phba->fc_flag |= FC_RSCN_DISCOVERY;
2547 spin_unlock_irq(phba->host->host_lock);
2549 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2552 phba->brd_no, phba->fc_rscn_id_cnt,
2553 phba->fc_flag, phba->hba_state);
2556 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2560 lpfc_rscn_recovery_check(phba);
2564 phba->fc_flag |= FC_RSCN_MODE;
2565 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2572 lpfc_set_disctmo(phba);
2575 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
2578 lpfc_rscn_recovery_check(phba);
2580 return lpfc_els_handle_rscn(phba);
2584 lpfc_els_handle_rscn(struct lpfc_hba * phba)
2589 lpfc_set_disctmo(phba);
2592 lpfc_printf_log(phba,
2596 phba->brd_no,
2597 phba->fc_flag, 0, phba->fc_rscn_id_cnt,
2598 phba->hba_state);
2601 phba->fc_ns_retry = 0;
2602 ndlp = lpfc_findnode_did(phba, NameServer_DID);
2605 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) {
2613 ndlp = lpfc_findnode_did(phba, NameServer_DID);
2619 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2621 lpfc_els_flush_rscn(phba);
2624 lpfc_nlp_init(phba, ndlp, NameServer_DID);
2627 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
2628 lpfc_issue_els_plogi(phba, NameServer_DID, 0);
2635 lpfc_els_flush_rscn(phba);
2640 lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2658 lpfc_set_disctmo(phba);
2660 if (phba->fc_topology == TOPOLOGY_LOOP) {
2666 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
2669 phba->brd_no, cmd, did);
2675 if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) {
2680 rc = memcmp(&phba->fc_portname, &sp->portName,
2684 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
2688 lpfc_linkdown(phba);
2689 lpfc_init_link(phba, mbox,
2690 phba->cfg_topology,
2691 phba->cfg_link_speed);
2695 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
2696 lpfc_set_loopback_flag(phba);
2698 mempool_free(mbox, phba->mbox_mem_pool);
2702 spin_lock_irq(phba->host->host_lock);
2703 phba->fc_flag |= FC_PT2PT_PLOGI;
2704 spin_unlock_irq(phba->host->host_lock);
2706 phba->fc_flag |= FC_PT2PT;
2707 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2714 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2719 lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
2725 lpfc_els_rcv_rnid(struct lpfc_hba * phba,
2749 lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp);
2757 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2763 lpfc_els_rcv_lirr(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2773 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2778 lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2791 psli = &phba->sli;
2801 mempool_free(pmb, phba->mbox_mem_pool);
2806 mempool_free(pmb, phba->mbox_mem_pool);
2807 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, lpfc_max_els_tries, ndlp,
2821 if (phba->fc_topology != TOPOLOGY_LOOP)
2825 if (phba->fc_flag & FC_FABRIC)
2838 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2841 phba->brd_no, elsiocb->iotag,
2846 phba->fc_stat.elsXmitACC++;
2848 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2849 lpfc_els_free_iocb(phba, elsiocb);
2855 lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2871 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2881 ((flag == 2) && (memcmp(&rps->un.portName, &phba->fc_portname,
2883 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC))) {
2884 lpfc_read_lnk_stat(phba, mbox);
2889 if (lpfc_sli_issue_mbox (phba, mbox,
2895 mempool_free(mbox, phba->mbox_mem_pool);
2902 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2907 lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
2918 psli = &phba->sli;
2921 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2940 rpl_rsp.port_num_blk.portID = be32_to_cpu(phba->fc_myDID);
2941 memcpy(&rpl_rsp.port_num_blk.portName, &phba->fc_portname,
2948 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2951 phba->brd_no, elsiocb->iotag,
2957 phba->fc_stat.elsXmitACC++;
2958 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2959 lpfc_els_free_iocb(phba, elsiocb);
2966 lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2982 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2999 lpfc_els_rsp_rpl_acc(phba, cmdsize, cmdiocb, ndlp);
3005 lpfc_els_rcv_farp(struct lpfc_hba * phba,
3023 lpfc_printf_log(phba,
3027 phba->brd_no, did);
3037 if (memcmp(&fp->RportName, &phba->fc_portname,
3044 if (memcmp(&fp->RnodeName, &phba->fc_nodename,
3055 lpfc_nlp_set_state(phba, ndlp,
3057 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
3062 lpfc_issue_els_farpr(phba, did, 0);
3070 lpfc_els_rcv_farpr(struct lpfc_hba * phba,
3085 lpfc_printf_log(phba,
3089 phba->brd_no, did);
3092 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
3098 lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3109 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n",
3110 phba->brd_no);
3122 if (phba->hba_state == LPFC_LOCAL_CFG_LINK) {
3123 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3125 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3133 &phba->fc_nodes, nlp_listp) {
3141 lpfc_drop_node(phba, ndlp);
3146 lpfc_unreg_rpi(phba, ndlp);
3150 phba->hba_state = LPFC_FLOGI;
3151 lpfc_set_disctmo(phba);
3152 lpfc_initial_flogi(phba);
3158 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes,
3166 lpfc_nlp_set_state(phba, ndlp,
3172 lpfc_nlp_set_state(phba, ndlp,
3182 lpfc_disc_start(phba);
3190 struct lpfc_hba *phba;
3193 phba = (struct lpfc_hba *)ptr;
3194 if (phba == 0)
3196 spin_lock_irqsave(phba->host->host_lock, iflag);
3197 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3198 phba->work_hba_events |= WORKER_ELS_TMO;
3199 if (phba->work_wait)
3200 wake_up(phba->work_wait);
3202 spin_unlock_irqrestore(phba->host->host_lock, iflag);
3207 lpfc_els_timeout_handler(struct lpfc_hba *phba)
3218 if (phba == 0)
3220 spin_lock_irq(phba->host->host_lock);
3222 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3223 spin_unlock_irq(phba->host->host_lock);
3226 timeout = (uint32_t)(phba->fc_ratov << 1);
3228 pring = &phba->sli.ring[LPFC_ELS_RING];
3260 ndlp = __lpfc_findnode_rpi(phba, cmd->ulpContext);
3266 lpfc_printf_log(phba,
3270 phba->brd_no, els_command,
3273 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3275 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3276 mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
3278 spin_unlock_irq(phba->host->host_lock);
3282 lpfc_els_flush_cmd(struct lpfc_hba *phba)
3285 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3289 spin_lock_irq(phba->host->host_lock);
3316 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3318 spin_unlock_irq(phba->host->host_lock);
3328 (piocb->iocb_cmpl) (phba, piocb, piocb);
3330 lpfc_sli_release_iocbq(phba, piocb);
3337 lpfc_els_unsol_event(struct lpfc_hba * phba,
3352 psli = &phba->sli;
3358 phba->fc_stat.NoRcvBuf++;
3359 lpfc_post_buffer(phba, pring, 0, 1);
3370 mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un.
3383 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1);
3386 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3393 if (lpfc_els_chk_latt(phba)) {
3394 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3401 ndlp = lpfc_findnode_did(phba, did);
3404 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3406 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3412 lpfc_nlp_init(phba, ndlp, did);
3417 lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
3420 phba->fc_stat.elsRcvFrame++;
3430 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3432 "Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state);
3436 phba->fc_stat.elsRcvPLOGI++;
3437 if (phba->hba_state < LPFC_DISC_AUTH) {
3441 ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp);
3442 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI);
3445 phba->fc_stat.elsRcvFLOGI++;
3446 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode);
3448 lpfc_drop_node(phba, ndlp);
3451 phba->fc_stat.elsRcvLOGO++;
3452 if (phba->hba_state < LPFC_DISC_AUTH) {
3456 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
3459 phba->fc_stat.elsRcvPRLO++;
3460 if (phba->hba_state < LPFC_DISC_AUTH) {
3464 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
3467 phba->fc_stat.elsRcvRSCN++;
3468 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode);
3470 lpfc_drop_node(phba, ndlp);
3473 phba->fc_stat.elsRcvADISC++;
3474 if (phba->hba_state < LPFC_DISC_AUTH) {
3478 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC);
3481 phba->fc_stat.elsRcvPDISC++;
3482 if (phba->hba_state < LPFC_DISC_AUTH) {
3486 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC);
3489 phba->fc_stat.elsRcvFARPR++;
3490 lpfc_els_rcv_farpr(phba, elsiocb, ndlp);
3493 phba->fc_stat.elsRcvFARP++;
3494 lpfc_els_rcv_farp(phba, elsiocb, ndlp);
3497 phba->fc_stat.elsRcvFAN++;
3498 lpfc_els_rcv_fan(phba, elsiocb, ndlp);
3501 phba->fc_stat.elsRcvPRLI++;
3502 if (phba->hba_state < LPFC_DISC_AUTH) {
3506 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
3509 phba->fc_stat.elsRcvLIRR++;
3510 lpfc_els_rcv_lirr(phba, elsiocb, ndlp);
3512 lpfc_drop_node(phba, ndlp);
3515 phba->fc_stat.elsRcvRPS++;
3516 lpfc_els_rcv_rps(phba, elsiocb, ndlp);
3518 lpfc_drop_node(phba, ndlp);
3521 phba->fc_stat.elsRcvRPL++;
3522 lpfc_els_rcv_rpl(phba, elsiocb, ndlp);
3524 lpfc_drop_node(phba, ndlp);
3527 phba->fc_stat.elsRcvRNID++;
3528 lpfc_els_rcv_rnid(phba, elsiocb, ndlp);
3530 lpfc_drop_node(phba, ndlp);
3537 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3539 "NPORT x%x\n", phba->brd_no, cmd, did);
3541 lpfc_drop_node(phba, ndlp);
3551 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp);
3557 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3563 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3565 "Data: x%x x%x x%x\n", phba->brd_no,
3568 phba->fc_stat.elsRcvDrop++;