Lines Matching defs:phba
57 static int lpfc_issue_fabric_iocb(struct lpfc_hba *phba,
59 static void lpfc_cmpl_els_edc(struct lpfc_hba *phba,
96 struct lpfc_hba *phba = vport->phba;
100 phba->link_state == LPFC_LINK_DOWN ||
101 phba->sli_rev > LPFC_SLI_REV3)
105 if (lpfc_readl(phba->HAregaddr, &ha_copy))
115 phba->pport->port_state);
125 if (phba->link_state != LPFC_CLEAR_LA)
126 lpfc_issue_clear_la(phba, vport);
174 struct lpfc_hba *phba = vport->phba;
180 if (!lpfc_is_link_up(phba))
184 elsiocb = lpfc_sli_get_iocbq(phba);
193 test_bit(HBA_FIP_SUPPORT, &phba->hba_flag) &&
221 pcmd->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &pcmd->phys);
231 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
243 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
256 timeout = phba->fc_ratov;
259 timeout = phba->fc_ratov * 2;
266 if (phba->sli_rev == LPFC_SLI_REV4)
271 lpfc_sli_prep_els_req_rsp(phba, elsiocb, vport, bmp, cmd_size, did,
292 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
320 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
324 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
329 lpfc_sli_release_iocbq(phba, elsiocb);
352 struct lpfc_hba *phba = vport->phba;
359 sp = &phba->fc_fabparam;
366 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
373 lpfc_config_link(phba, mbox);
377 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
383 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
388 rc = lpfc_reg_rpi(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox,
406 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
420 lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
443 struct lpfc_hba *phba = vport->phba;
450 if ((phba->sli_rev == LPFC_SLI_REV4) &&
451 !(phba->link_flag & LS_LOOPBACK_MODE) &&
460 mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
469 rc = lpfc_mbox_rsrc_prep(phba, mboxq);
475 memcpy(dmabuf->virt, &phba->fc_fabparam,
490 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
498 lpfc_mbox_rsrc_cleanup(phba, mboxq, MBOX_THD_UNLOCKED);
520 struct lpfc_hba *phba = vport->phba;
524 mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
526 lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
528 "HBA state x%x\n", phba->pport->port_state);
536 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
538 lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
541 rc, phba->pport->port_state);
542 mempool_free(mboxq, phba->mbox_mem_pool);
572 struct lpfc_hba *phba = vport->phba;
595 (vport->fc_prevDID || phba->cfg_delay_discovery))
626 struct lpfc_hba *phba = vport->phba;
633 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
635 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
637 phba->fc_edtovResol = sp->cmn.edtovResolution;
638 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
640 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP)
661 if (phba->cfg_enable_SmartSAN ||
662 (phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT)) {
665 if (phba->cfg_enable_SmartSAN)
679 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
681 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
688 spin_lock_irq(&phba->hbalock);
689 phba->link_flag |= LS_NPIV_FAB_SUPPORTED;
690 spin_unlock_irq(&phba->hbalock);
698 spin_lock_irq(&phba->hbalock);
699 phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
700 spin_unlock_irq(&phba->hbalock);
708 if ((phba->sli_rev == LPFC_SLI_REV4) &&
709 (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)) {
712 lpfc_unregister_fcf_prep(phba);
737 if (phba->sli_rev == LPFC_SLI_REV4) {
748 } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
755 lpfc_register_new_vport(phba, vport, ndlp);
759 if (phba->sli_rev < LPFC_SLI_REV4) {
761 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED &&
763 lpfc_register_new_vport(phba, vport, ndlp);
771 lpfc_start_fdiscs(phba);
772 lpfc_do_scr_ns_plogi(phba, vport);
809 struct lpfc_hba *phba = vport->phba;
818 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED;
821 if ((phba->sli_rev == LPFC_SLI_REV4) && phba->fc_topology_changed) {
822 lpfc_unregister_fcf_prep(phba);
824 phba->fc_topology_changed = 0;
871 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
875 lpfc_config_link(phba, mbox);
879 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
881 mempool_free(mbox, phba->mbox_mem_pool);
903 * @phba: pointer to lpfc hba data structure.
925 lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
948 ulp_status = get_job_ulpstatus(phba, rspiocb);
949 ulp_word4 = get_job_word4(phba, rspiocb);
951 if (phba->sli_rev == LPFC_SLI_REV4) {
968 if (test_bit(HBA_FIP_SUPPORT, &phba->hba_flag) &&
969 (phba->fcf.fcf_flag & FCF_DISCOVERY)) {
970 if (phba->link_state < LPFC_LINK_UP)
972 if ((phba->fcoe_cvl_eventtag_attn ==
973 phba->fcoe_cvl_eventtag) &&
979 phba->fcoe_cvl_eventtag_attn =
980 phba->fcoe_cvl_eventtag;
981 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | LOG_ELS,
985 phba->fcf.current_rec.fcf_indx,
987 lpfc_sli4_set_fcf_flogi_fail(phba,
988 phba->fcf.current_rec.fcf_indx);
989 fcf_index = lpfc_sli4_fcf_rr_next_index_get(phba);
1004 phba->hba_flag, phba->fcf.fcf_flag);
1007 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1052 if (phba->alpa_map[0] == 0)
1054 if ((phba->sli_rev == LPFC_SLI_REV4) &&
1057 phba->fc_topology_changed)) {
1059 if (phba->fc_topology_changed) {
1060 lpfc_unregister_fcf_prep(phba);
1063 phba->fc_topology_changed = 0;
1102 if (lpfc_is_vmid_enabled(phba))
1105 vport->phba->pport->vmid_flag |= (LPFC_VMID_ISSUE_QFPA |
1122 else if (!test_bit(HBA_FCOE_MODE, &phba->hba_flag))
1131 phba->fcf.current_rec.fcf_indx,
1132 phba->fcf.current_rec.switch_name[0],
1133 phba->fcf.current_rec.switch_name[1],
1134 phba->fcf.current_rec.switch_name[2],
1135 phba->fcf.current_rec.switch_name[3],
1136 phba->fcf.current_rec.switch_name[4],
1137 phba->fcf.current_rec.switch_name[5],
1138 phba->fcf.current_rec.switch_name[6],
1139 phba->fcf.current_rec.switch_name[7],
1140 phba->fcf.current_rec.fabric_name[0],
1141 phba->fcf.current_rec.fabric_name[1],
1142 phba->fcf.current_rec.fabric_name[2],
1143 phba->fcf.current_rec.fabric_name[3],
1144 phba->fcf.current_rec.fabric_name[4],
1145 phba->fcf.current_rec.fabric_name[5],
1146 phba->fcf.current_rec.fabric_name[6],
1147 phba->fcf.current_rec.fabric_name[7]);
1150 spin_lock_irq(&phba->hbalock);
1151 phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
1152 spin_unlock_irq(&phba->hbalock);
1153 clear_bit(FCF_RR_INPROG, &phba->hba_flag);
1154 clear_bit(HBA_DEVLOSS_TMO, &phba->hba_flag);
1155 phba->fcf.fcf_redisc_attempted = 0; /* reset */
1160 if (test_bit(HBA_FIP_SUPPORT, &phba->hba_flag))
1165 phba->fcf.current_rec.fcf_indx);
1166 spin_lock_irq(&phba->hbalock);
1167 phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
1168 spin_unlock_irq(&phba->hbalock);
1169 clear_bit(FCF_RR_INPROG, &phba->hba_flag);
1170 clear_bit(HBA_DEVLOSS_TMO, &phba->hba_flag);
1171 phba->fcf.fcf_redisc_attempted = 0; /* reset */
1186 spin_lock_irq(&phba->hbalock);
1187 phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
1188 spin_unlock_irq(&phba->hbalock);
1201 (phba->link_state != LPFC_CLEAR_LA)) {
1203 lpfc_issue_clear_la(phba, vport);
1207 clear_bit(HBA_FLOGI_OUTSTANDING, &phba->hba_flag);
1209 lpfc_els_free_iocb(phba, cmdiocb);
1216 * @phba: pointer to lpfc hba data structure.
1222 lpfc_cmpl_els_link_down(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1232 ulp_status = get_job_ulpstatus(phba, rspiocb);
1233 ulp_word4 = get_job_word4(phba, rspiocb);
1235 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1243 atomic_dec(&phba->fabric_iocb_count);
1245 lpfc_els_free_iocb(phba, cmdiocb);
1273 struct lpfc_hba *phba = vport->phba;
1312 if (phba->cfg_vmid_priority_tagging) {
1317 memcpy(vport->lpfc_vmid_host_uuid, phba->wwpn,
1318 sizeof(phba->wwpn));
1319 memcpy(&vport->lpfc_vmid_host_uuid[8], phba->wwnn,
1320 sizeof(phba->wwnn));
1324 if (phba->sli_rev == LPFC_SLI_REV4) {
1325 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
1333 phba->fcf.fcfi);
1343 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
1352 if (phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
1358 tmo = phba->fc_ratov;
1359 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
1361 phba->fc_ratov = tmo;
1363 phba->fc_stat.elsXmitFLOGI++;
1368 phba->sli3_options, 0, 0);
1372 lpfc_els_free_iocb(phba, elsiocb);
1377 set_bit(HBA_FLOGI_ISSUED, &phba->hba_flag);
1378 set_bit(HBA_FLOGI_OUTSTANDING, &phba->hba_flag);
1380 rc = lpfc_issue_fabric_iocb(phba, elsiocb);
1382 clear_bit(HBA_FLOGI_ISSUED, &phba->hba_flag);
1383 clear_bit(HBA_FLOGI_OUTSTANDING, &phba->hba_flag);
1384 lpfc_els_free_iocb(phba, elsiocb);
1390 phba->link_flag &= ~LS_EXTERNAL_LOOPBACK;
1393 if (phba->defer_flogi_acc_flag) {
1404 if (phba->sli_rev == LPFC_SLI_REV4) {
1407 phba->defer_flogi_acc_rx_id);
1410 phba->defer_flogi_acc_ox_id);
1413 icmd->ulpContext = phba->defer_flogi_acc_rx_id;
1415 phba->defer_flogi_acc_ox_id;
1421 phba->defer_flogi_acc_rx_id,
1422 phba->defer_flogi_acc_ox_id, phba->hba_flag);
1428 phba->defer_flogi_acc_flag = false;
1442 * @phba: pointer to lpfc hba data structure.
1445 * with a @phba. This routine walks all the outstanding IOCBs on the txcmplq
1455 lpfc_els_abort_flogi(struct lpfc_hba *phba)
1463 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
1467 pring = lpfc_phba_elsring(phba);
1475 spin_lock_irq(&phba->hbalock);
1477 ulp_command = get_job_cmnd(phba, iocb);
1481 if (test_bit(FC_PT2PT, &phba->pport->fc_flag) &&
1483 &phba->pport->fc_flag))
1486 lpfc_sli_issue_abort_iotag(phba, pring, iocb,
1492 lpfc_issue_hb_tmo(phba);
1494 spin_unlock_irq(&phba->hbalock);
1635 * @phba: pointer to lpfc hba data structure.
1665 lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
1692 if (phba->sli_rev == LPFC_SLI_REV4) {
1693 active_rrqs_xri_bitmap = mempool_alloc(phba->active_rrq_pool,
1697 phba->cfg_rrq_xri_bitmap_sz);
1714 phba->active_rrq_pool);
1721 phba->active_rrq_pool);
1725 if (phba->sli_rev == LPFC_SLI_REV4 &&
1729 phba->cfg_rrq_xri_bitmap_sz);
1753 if (phba->sli_rev == LPFC_SLI_REV4)
1756 phba->cfg_rrq_xri_bitmap_sz);
1837 if (phba->sli_rev == LPFC_SLI_REV4 &&
1841 phba->cfg_rrq_xri_bitmap_sz);
1856 if (phba->sli_rev == LPFC_SLI_REV4 &&
1860 phba->cfg_rrq_xri_bitmap_sz);
1879 if (phba->sli_rev == LPFC_SLI_REV4 &&
1882 phba->active_rrq_pool);
1922 * @phba: pointer to lpfc hba data structure.
1933 lpfc_cmpl_els_rrq(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1939 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1940 u32 ulp_word4 = get_job_word4(phba, rspiocb);
1949 get_job_els_rsp64_did(phba, cmdiocb));
1965 (phba)->pport->cfg_log_verbose & LOG_ELS)
1973 lpfc_clr_rrq_active(phba, rrq->xritag, rrq);
1974 lpfc_els_free_iocb(phba, cmdiocb);
1980 * @phba: pointer to lpfc hba data structure.
1999 lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2014 ulp_status = get_job_ulpstatus(phba, rspiocb);
2015 ulp_word4 = get_job_word4(phba, rspiocb);
2016 did = get_job_els_rsp64_did(phba, cmdiocb);
2018 if (phba->sli_rev == LPFC_SLI_REV4) {
2065 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
2078 (phba)->pport->cfg_log_verbose & LOG_ELS)
2122 ndlp = lpfc_plogi_confirm_nport(phba, prsp->virt, ndlp);
2128 if ((phba->cfg_vmid_app_header && sp->cmn.app_hdr_support) ||
2129 (phba->cfg_vmid_priority_tagging &&
2131 lpfc_printf_log(phba, KERN_DEBUG, LOG_ELS,
2165 lpfc_els_free_iocb(phba, cmdiocb);
2193 struct lpfc_hba *phba = vport->phba;
2261 else if (phba->cfg_vmid_app_header &&
2262 bf_get(lpfc_ftr_ashdr, &phba->sli4_hba.sli4_flags))
2272 if (phba->sli.sli_flag & LPFC_SLI_SUPPRESS_RSP) {
2278 phba->fc_stat.elsXmitPLOGI++;
2286 lpfc_els_free_iocb(phba, elsiocb);
2290 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
2292 lpfc_els_free_iocb(phba, elsiocb);
2302 * @phba: pointer to lpfc hba data structure.
2314 lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2330 ulp_status = get_job_ulpstatus(phba, rspiocb);
2331 ulp_word4 = get_job_word4(phba, rspiocb);
2360 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
2441 lpfc_els_free_iocb(phba, cmdiocb);
2471 struct lpfc_hba *phba = vport->phba;
2485 if (phba->sli_rev == LPFC_SLI_REV4 &&
2519 if (phba->sli_rev == LPFC_SLI_REV3 &&
2552 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
2579 if (phba->nsler) {
2585 if ((phba->cfg_nvme_enable_fb) &&
2586 !phba->nvmet_support)
2589 if (phba->nvmet_support) {
2605 phba->fc_stat.elsXmitPRLI++;
2613 lpfc_els_free_iocb(phba, elsiocb);
2617 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
2619 lpfc_els_free_iocb(phba, elsiocb);
2637 if (phba->sli_rev == LPFC_SLI_REV4 &&
2683 struct lpfc_hba *phba = vport->phba;
2689 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
2691 (phba->sli_rev < LPFC_SLI_REV4)) {
2697 if (!lpfc_is_link_up(phba))
2708 lpfc_issue_clear_la(phba, vport);
2709 lpfc_issue_reg_vpi(phba, vport);
2718 lpfc_issue_clear_la(phba, vport);
2769 * @phba: pointer to lpfc hba data structure.
2784 lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2799 ulp_status = get_job_ulpstatus(phba, rspiocb);
2800 ulp_word4 = get_job_word4(phba, rspiocb);
2802 if (phba->sli_rev == LPFC_SLI_REV4) {
2841 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
2883 lpfc_els_free_iocb(phba, cmdiocb);
2912 struct lpfc_hba *phba = vport->phba;
2932 ap->hardAL_PA = phba->fc_pref_ALPA;
2937 phba->fc_stat.elsXmitADISC++;
2944 lpfc_els_free_iocb(phba, elsiocb);
2952 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
2954 lpfc_els_free_iocb(phba, elsiocb);
2970 * @phba: pointer to lpfc hba data structure.
2980 lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2996 ulp_status = get_job_ulpstatus(phba, rspiocb);
2997 ulp_word4 = get_job_word4(phba, rspiocb);
2999 if (phba->sli_rev == LPFC_SLI_REV4) {
3064 if (phba->sli_rev == LPFC_SLI_REV4)
3101 lpfc_els_free_iocb(phba, cmdiocb);
3122 lpfc_els_free_iocb(phba, cmdiocb);
3151 struct lpfc_hba *phba = vport->phba;
3179 phba->fc_stat.elsXmitLOGO++;
3187 lpfc_els_free_iocb(phba, elsiocb);
3195 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3197 lpfc_els_free_iocb(phba, elsiocb);
3217 * @phba: pointer to lpfc hba data structure.
3231 lpfc_cmpl_els_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3239 ulp_status = get_job_ulpstatus(phba, rspiocb);
3240 ulp_word4 = get_job_word4(phba, rspiocb);
3241 did = get_job_els_rsp64_did(phba, cmdiocb);
3243 if (phba->sli_rev == LPFC_SLI_REV4) {
3266 lpfc_els_free_iocb(phba, cmdiocb);
3288 struct lpfc_hba *phba = vport->phba;
3306 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3315 rc = lpfc_reg_rpi(phba, vport->vpi, fc_ndlp->nlp_DID,
3331 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
3343 lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
3354 * @phba: pointer to lpfc hba data structure.
3364 lpfc_cmpl_els_disc_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3376 ulp_status = get_job_ulpstatus(phba, rspiocb);
3377 ulp_word4 = get_job_word4(phba, rspiocb);
3378 did = get_job_els_rsp64_did(phba, cmdiocb);
3380 if (phba->sli_rev == LPFC_SLI_REV4) {
3426 phba->fc_stat.elsRetryExceeded++;
3430 lpfc_cmpl_els_edc(phba, cmdiocb, rspiocb);
3465 phba->cgn_reg_signal,
3466 phba->cgn_reg_fpin);
3472 lpfc_els_free_iocb(phba, cmdiocb);
3501 struct lpfc_hba *phba = vport->phba;
3522 if (phba->sli_rev == LPFC_SLI_REV4) {
3525 lpfc_els_free_iocb(phba, elsiocb);
3545 phba->fc_stat.elsXmitSCR++;
3549 lpfc_els_free_iocb(phba, elsiocb);
3557 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3559 lpfc_els_free_iocb(phba, elsiocb);
3590 struct lpfc_hba *phba = vport->phba;
3601 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP &&
3642 phba->fc_stat.elsXmitRSCN++;
3646 lpfc_els_free_iocb(phba, elsiocb);
3654 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3656 lpfc_els_free_iocb(phba, elsiocb);
3689 struct lpfc_hba *phba = vport->phba;
3741 phba->fc_stat.elsXmitFARPR++;
3745 lpfc_els_free_iocb(phba, elsiocb);
3749 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3755 lpfc_els_free_iocb(phba, elsiocb);
3785 struct lpfc_hba *phba = vport->phba;
3828 ndlp->nlp_DID, phba->cgn_reg_signal,
3829 phba->cgn_reg_fpin);
3831 phba->cgn_fpin_frequency = LPFC_FPIN_INIT_FREQ;
3835 lpfc_els_free_iocb(phba, elsiocb);
3843 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
3845 lpfc_els_free_iocb(phba, elsiocb);
3891 * @phba: pointer to lpfc hba data structure.
3897 * sets @phba values in preparation for a set_featues mailbox.
3900 lpfc_least_capable_settings(struct lpfc_hba *phba,
3931 drv_sig_cap = phba->cgn_reg_signal;
3934 if (rsp_sig_freq_cyc > phba->cgn_sig_freq)
3935 phba->cgn_sig_freq = rsp_sig_freq_cyc;
3941 phba->cgn_reg_fpin = LPFC_CGN_FPIN_WARN | LPFC_CGN_FPIN_ALARM;
3942 phba->cgn_reg_signal = EDC_CG_SIG_NOTSUPPORTED;
3946 phba->cgn_reg_signal = EDC_CG_SIG_WARN_ONLY;
3947 phba->cgn_reg_fpin &= ~LPFC_CGN_FPIN_WARN;
3951 phba->cgn_reg_signal = EDC_CG_SIG_WARN_ALARM;
3952 phba->cgn_reg_fpin = LPFC_CGN_FPIN_NONE;
3955 phba->cgn_reg_signal = EDC_CG_SIG_WARN_ONLY;
3956 phba->cgn_reg_fpin &= ~LPFC_CGN_FPIN_WARN;
3964 phba->cgn_reg_signal = EDC_CG_SIG_NOTSUPPORTED;
3965 phba->cgn_sig_freq = 0;
3966 phba->cgn_reg_fpin = LPFC_CGN_FPIN_ALARM | LPFC_CGN_FPIN_WARN;
3974 * @phba: pointer to lpfc hba data structure.
3986 lpfc_cmpl_els_edc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4004 ulp_status = get_job_ulpstatus(phba, rspiocb);
4005 ulp_word4 = get_job_word4(phba, rspiocb);
4006 did = get_job_els_rsp64_did(phba, rspiocb);
4008 if (phba->sli_rev == LPFC_SLI_REV4) {
4017 lpfc_debugfs_disc_trc(phba->pport, LPFC_DISC_TRC_ELS_CMD,
4022 lpfc_printf_log(phba, KERN_INFO, LOG_ELS | LOG_CGN_MGMT,
4047 lpfc_printf_log(phba, KERN_INFO,
4075 lpfc_printf_log(phba, KERN_WARNING, LOG_CGN_MGMT,
4088 lpfc_printf_log(phba, KERN_WARNING,
4098 lpfc_printf_log(phba, KERN_INFO,
4115 phba, KERN_WARNING, LOG_CGN_MGMT,
4126 phba, KERN_INFO, LOG_ELS | LOG_CGN_MGMT,
4141 lpfc_least_capable_settings(phba, pcgd);
4146 lpfc_printf_log(phba, KERN_WARNING, LOG_CGN_MGMT,
4159 phba->cgn_reg_fpin = LPFC_CGN_FPIN_ALARM | LPFC_CGN_FPIN_WARN;
4160 phba->cgn_reg_signal = EDC_CG_SIG_NOTSUPPORTED;
4161 phba->cgn_sig_freq = 0;
4162 lpfc_printf_log(phba, KERN_WARNING, LOG_ELS | LOG_CGN_MGMT,
4167 lpfc_config_cgn_signal(phba);
4170 lpfc_els_chk_latt(phba->pport);
4171 lpfc_debugfs_disc_trc(phba->pport, LPFC_DISC_TRC_ELS_CMD,
4174 lpfc_els_free_iocb(phba, cmdiocb);
4179 lpfc_format_edc_lft_desc(struct lpfc_hba *phba, struct fc_tlv_desc *tlv)
4188 cpu_to_be32(phba->degrade_activate_threshold);
4190 cpu_to_be32(phba->degrade_deactivate_threshold);
4191 lft->fec_degrade_interval = cpu_to_be32(phba->fec_degrade_interval);
4195 lpfc_format_edc_cgn_desc(struct lpfc_hba *phba, struct fc_tlv_desc *tlv)
4213 if (phba->cmf_active_mode == LPFC_CFG_OFF) {
4218 phba->cgn_sig_freq = 0;
4221 switch (phba->cgn_reg_signal) {
4243 lpfc_link_is_lds_capable(struct lpfc_hba *phba)
4245 if (!(phba->lmt & LMT_64Gb))
4247 if (phba->sli_rev != LPFC_SLI_REV4)
4250 if (phba->sli4_hba.conf_trunk) {
4251 if (phba->trunk_link.phy_lnk_speed == LPFC_USER_LINK_SPEED_64G)
4253 } else if (phba->fc_linkspeed == LPFC_LINK_SPEED_64GHZ) {
4284 struct lpfc_hba *phba = vport->phba;
4301 cgn_desc_size = (phba->cgn_init_reg_signal) ?
4303 lft_desc_size = (lpfc_link_is_lds_capable(phba)) ?
4326 lpfc_format_edc_cgn_desc(phba, tlv);
4327 phba->cgn_sig_freq = lpfc_fabric_cgn_frequency;
4332 lpfc_format_edc_lft_desc(phba, tlv);
4337 ndlp->nlp_DID, phba->cgn_reg_signal,
4338 phba->cgn_reg_fpin);
4343 lpfc_els_free_iocb(phba, elsiocb);
4350 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
4356 lpfc_els_free_iocb(phba, elsiocb);
4362 phba->cgn_reg_fpin = LPFC_CGN_FPIN_WARN | LPFC_CGN_FPIN_ALARM;
4363 phba->cgn_reg_signal = EDC_CG_SIG_NOTSUPPORTED;
4440 struct lpfc_hba *phba = vport->phba;
4448 spin_lock_irqsave(&phba->hbalock, flags);
4450 spin_unlock_irqrestore(&phba->hbalock, flags);
4457 list_add_tail(&evtp->evt_listp, &phba->work_list);
4458 spin_unlock_irqrestore(&phba->hbalock, flags);
4460 lpfc_worker_wake_up(phba);
4550 struct lpfc_hba *phba = vport->phba;
4557 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4559 lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4565 if (phba->sli_rev <= LPFC_SLI_REV3) {
4566 spin_lock_irq(&phba->hbalock);
4567 phba->sli.sli_flag |= LPFC_PROCESS_LA;
4568 control = readl(phba->HCregaddr);
4570 writel(control, phba->HCregaddr);
4571 readl(phba->HCregaddr); /* flush */
4572 spin_unlock_irq(&phba->hbalock);
4575 lpfc_init_link(phba, mbox, phba->cfg_topology,
4576 phba->cfg_link_speed);
4579 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
4581 lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
4584 mempool_free(mbox, phba->mbox_mem_pool);
4593 * @phba: pointer to lpfc hba data structure.
4613 lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4627 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
4628 u32 ulp_word4 = get_job_word4(phba, rspiocb);
4644 did = get_job_els_rsp64_did(phba, rspiocb);
4658 if (phba->sli_rev == LPFC_SLI_REV4) {
4663 lpfc_set_rrq_active(phba, ndlp,
4831 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
4883 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
4943 (phba->fc_topology != LPFC_TOPOLOGY_LOOP) &&
4948 if (phba->link_flag != LS_LOOPBACK_MODE)
4967 phba->fc_stat.elsRetryExceeded++;
4978 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
5006 phba->fc_stat.elsXmitRetry++;
5008 phba->fc_stat.elsDelayRetry++;
5086 * @phba: pointer to lpfc hba data structure.
5099 lpfc_els_free_data(struct lpfc_hba *phba, struct lpfc_dmabuf *buf_ptr1)
5108 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
5111 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
5118 * @phba: pointer to lpfc hba data structure.
5129 lpfc_els_free_bpl(struct lpfc_hba *phba, struct lpfc_dmabuf *buf_ptr)
5131 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
5138 * @phba: pointer to lpfc hba data structure.
5154 * adds the DMA buffer the @phba data structure for the delayed release.
5158 * invoked to release the IOCB data structure back to @phba IOCBQ list.
5164 lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
5183 spin_lock_irq(&phba->hbalock);
5190 &phba->elsbuf);
5191 phba->elsbuf_cnt++;
5194 list_add_tail(&buf_ptr->list, &phba->elsbuf);
5195 phba->elsbuf_cnt++;
5196 spin_unlock_irq(&phba->hbalock);
5200 lpfc_els_free_data(phba, buf_ptr1);
5207 lpfc_els_free_bpl(phba, buf_ptr);
5210 lpfc_sli_release_iocbq(phba, elsiocb);
5216 * @phba: pointer to lpfc hba data structure.
5227 lpfc_cmpl_els_logo_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
5234 ulp_status = get_job_ulpstatus(phba, rspiocb);
5235 ulp_word4 = get_job_word4(phba, rspiocb);
5274 lpfc_els_free_iocb(phba, cmdiocb);
5280 * @phba: pointer to lpfc hba data structure.
5284 * RPI (Remote Port Index) mailbox command to the @phba. It simply releases
5291 lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
5319 lpfc_mbox_rsrc_cleanup(phba, pmb, MBOX_THD_UNLOCKED);
5324 * @phba: pointer to lpfc hba data structure.
5336 lpfc_cmpl_els_rsp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
5347 lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
5354 ulp_status = get_job_ulpstatus(phba, rspiocb);
5355 ulp_word4 = get_job_word4(phba, rspiocb);
5356 did = get_job_els_rsp64_did(phba, cmdiocb);
5358 if (phba->sli_rev == LPFC_SLI_REV4) {
5370 lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
5425 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
5443 lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
5457 if (phba->sli_rev == LPFC_SLI_REV4 &&
5463 lpfc_sli4_free_rpi(phba, ndlp->nlp_rpi);
5485 lpfc_els_free_iocb(phba, cmdiocb);
5520 struct lpfc_hba *phba = vport->phba;
5545 if (phba->sli_rev == LPFC_SLI_REV4) {
5580 if (phba->sli_rev == LPFC_SLI_REV4) {
5610 memcpy(sp, &phba->fc_fabparam,
5639 if (phba->sli.sli_flag & LPFC_SLI_SUPPRESS_RSP) {
5658 if (phba->sli_rev == LPFC_SLI_REV4) {
5696 if (phba->sli_rev == LPFC_SLI_REV4) {
5742 phba->fc_stat.elsXmitACC++;
5745 lpfc_els_free_iocb(phba, elsiocb);
5749 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
5751 lpfc_els_free_iocb(phba, elsiocb);
5795 struct lpfc_hba *phba = vport->phba;
5809 if (phba->sli_rev == LPFC_SLI_REV4) {
5812 get_job_ulpcontext(phba, oldiocb)); /* Xri / rx_id */
5814 get_job_rcvoxid(phba, oldiocb));
5837 get_job_ulpcontext(phba, elsiocb), ndlp->nlp_DID,
5843 phba->fc_stat.elsXmitLSRJT++;
5847 lpfc_els_free_iocb(phba, elsiocb);
5855 if (phba->sli_rev == LPFC_SLI_REV4 &&
5863 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
5865 lpfc_els_free_iocb(phba, elsiocb);
5891 struct lpfc_hba *phba = vport->phba;
5904 lft_desc_size = (lpfc_link_is_lds_capable(phba)) ?
5912 if (phba->sli_rev == LPFC_SLI_REV4) {
5915 get_job_ulpcontext(phba, cmdiocb)); /* Xri / rx_id */
5917 get_job_rcvoxid(phba, cmdiocb));
5937 lpfc_format_edc_cgn_desc(phba, tlv);
5940 lpfc_format_edc_lft_desc(phba, tlv);
5948 phba->fc_stat.elsXmitACC++;
5951 lpfc_els_free_iocb(phba, elsiocb);
5955 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
5957 lpfc_els_free_iocb(phba, elsiocb);
5997 struct lpfc_hba *phba = vport->phba;
6013 if (phba->sli_rev == LPFC_SLI_REV4) {
6017 get_job_ulpcontext(phba, oldiocb));
6018 ulp_context = get_job_ulpcontext(phba, elsiocb);
6021 get_job_rcvoxid(phba, oldiocb));
6044 ap->hardAL_PA = phba->fc_pref_ALPA;
6053 phba->fc_stat.elsXmitACC++;
6057 lpfc_els_free_iocb(phba, elsiocb);
6061 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
6063 lpfc_els_free_iocb(phba, elsiocb);
6094 struct lpfc_hba *phba = vport->phba;
6137 if (phba->sli_rev == LPFC_SLI_REV4) {
6140 get_job_ulpcontext(phba, oldiocb)); /* Xri / rx_id */
6141 ulp_context = get_job_ulpcontext(phba, elsiocb);
6143 get_job_rcvoxid(phba, oldiocb));
6167 vpd = &phba->vpd;
6208 if (phba->nvmet_support) {
6211 if (phba->cfg_nvme_enable_fb) {
6219 phba->cfg_nvmet_fb_size);
6245 phba->fc_stat.elsXmitACC++;
6249 lpfc_els_free_iocb(phba, elsiocb);
6253 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
6255 lpfc_els_free_iocb(phba, elsiocb);
6287 struct lpfc_hba *phba = vport->phba;
6307 if (phba->sli_rev == LPFC_SLI_REV4) {
6310 get_job_ulpcontext(phba, oldiocb)); /* Xri / rx_id */
6311 ulp_context = get_job_ulpcontext(phba, elsiocb);
6313 get_job_rcvoxid(phba, oldiocb));
6359 phba->fc_stat.elsXmitACC++;
6363 lpfc_els_free_iocb(phba, elsiocb);
6367 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
6369 lpfc_els_free_iocb(phba, elsiocb);
6389 struct lpfc_hba *phba = vport->phba;
6410 get_job_ulpcontext(phba, iocb));
6421 lpfc_clr_rrq_active(phba, xri, prrq);
6440 struct lpfc_hba *phba = vport->phba;
6449 if (phba->sli_rev == LPFC_SLI_REV4)
6464 if (phba->sli_rev == LPFC_SLI_REV4) {
6467 get_job_ulpcontext(phba, oldiocb)); /* Xri / rx_id */
6468 ulp_context = get_job_ulpcontext(phba, elsiocb);
6470 get_job_rcvoxid(phba, oldiocb));
6493 phba->fc_stat.elsXmitACC++;
6497 lpfc_els_free_iocb(phba, elsiocb);
6501 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
6503 lpfc_els_free_iocb(phba, elsiocb);
6749 if (vport->phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
6750 bbCredit = vport->phba->fc_fabparam.cmn.bbCreditLsb |
6751 (vport->phba->fc_fabparam.cmn.bbCreditMsb << 8);
6764 lpfc_rdp_res_oed_temp_desc(struct lpfc_hba *phba,
6776 if (phba->sfp_alarm & LPFC_TRANSGRESSION_HIGH_TEMPERATURE)
6778 if (phba->sfp_alarm & LPFC_TRANSGRESSION_LOW_TEMPERATURE)
6780 if (phba->sfp_warning & LPFC_TRANSGRESSION_HIGH_TEMPERATURE)
6782 if (phba->sfp_warning & LPFC_TRANSGRESSION_LOW_TEMPERATURE)
6792 lpfc_rdp_res_oed_voltage_desc(struct lpfc_hba *phba,
6805 if (phba->sfp_alarm & LPFC_TRANSGRESSION_HIGH_VOLTAGE)
6807 if (phba->sfp_alarm & LPFC_TRANSGRESSION_LOW_VOLTAGE)
6809 if (phba->sfp_warning & LPFC_TRANSGRESSION_HIGH_VOLTAGE)
6811 if (phba->sfp_warning & LPFC_TRANSGRESSION_LOW_VOLTAGE)
6821 lpfc_rdp_res_oed_txbias_desc(struct lpfc_hba *phba,
6834 if (phba->sfp_alarm & LPFC_TRANSGRESSION_HIGH_TXBIAS)
6836 if (phba->sfp_alarm & LPFC_TRANSGRESSION_LOW_TXBIAS)
6838 if (phba->sfp_warning & LPFC_TRANSGRESSION_HIGH_TXBIAS)
6840 if (phba->sfp_warning & LPFC_TRANSGRESSION_LOW_TXBIAS)
6850 lpfc_rdp_res_oed_txpower_desc(struct lpfc_hba *phba,
6863 if (phba->sfp_alarm & LPFC_TRANSGRESSION_HIGH_TXPOWER)
6865 if (phba->sfp_alarm & LPFC_TRANSGRESSION_LOW_TXPOWER)
6867 if (phba->sfp_warning & LPFC_TRANSGRESSION_HIGH_TXPOWER)
6869 if (phba->sfp_warning & LPFC_TRANSGRESSION_LOW_TXPOWER)
6880 lpfc_rdp_res_oed_rxpower_desc(struct lpfc_hba *phba,
6893 if (phba->sfp_alarm & LPFC_TRANSGRESSION_HIGH_RXPOWER)
6895 if (phba->sfp_alarm & LPFC_TRANSGRESSION_LOW_RXPOWER)
6897 if (phba->sfp_warning & LPFC_TRANSGRESSION_HIGH_RXPOWER)
6899 if (phba->sfp_warning & LPFC_TRANSGRESSION_LOW_RXPOWER)
6940 lpfc_rdp_res_speed(struct fc_rdp_port_speed_desc *desc, struct lpfc_hba *phba)
6947 switch (phba->fc_linkspeed) {
6985 if (phba->lmt & LMT_256Gb)
6987 if (phba->lmt & LMT_128Gb)
6989 if (phba->lmt & LMT_64Gb)
6991 if (phba->lmt & LMT_32Gb)
6993 if (phba->lmt & LMT_16Gb)
6995 if (phba->lmt & LMT_10Gb)
6997 if (phba->lmt & LMT_8Gb)
6999 if (phba->lmt & LMT_4Gb)
7001 if (phba->lmt & LMT_2Gb)
7003 if (phba->lmt & LMT_1Gb)
7008 if (phba->cfg_link_speed != LPFC_USER_LINK_SPEED_AUTO)
7058 lpfc_els_rdp_cmpl(struct lpfc_hba *phba, struct lpfc_rdp_context *rdp_context,
7087 ulp_context = get_job_ulpcontext(phba, elsiocb);
7088 if (phba->sli_rev == LPFC_SLI_REV4) {
7114 phba->sfp_alarm |= *flag_ptr;
7116 phba->sfp_warning |= *flag_ptr;
7126 phba);
7137 len += lpfc_rdp_res_oed_temp_desc(phba,
7140 len += lpfc_rdp_res_oed_voltage_desc(phba,
7143 len += lpfc_rdp_res_oed_txbias_desc(phba,
7146 len += lpfc_rdp_res_oed_txpower_desc(phba,
7149 len += lpfc_rdp_res_oed_rxpower_desc(phba,
7164 phba->fc_stat.elsXmitACC++;
7167 lpfc_els_free_iocb(phba, elsiocb);
7171 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
7173 lpfc_els_free_iocb(phba, elsiocb);
7186 if (phba->sli_rev == LPFC_SLI_REV4) {
7206 phba->fc_stat.elsXmitLSRJT++;
7210 lpfc_els_free_iocb(phba, elsiocb);
7214 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
7216 lpfc_els_free_iocb(phba, elsiocb);
7229 lpfc_get_rdp_info(struct lpfc_hba *phba, struct lpfc_rdp_context *rdp_context)
7234 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
7236 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_ELS,
7241 if (lpfc_sli4_dump_page_a0(phba, mbox))
7246 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
7248 lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
7255 mempool_free(mbox, phba->mbox_mem_pool);
7259 int lpfc_get_sfp_info_wait(struct lpfc_hba *phba,
7269 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
7271 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_ELS,
7276 if (lpfc_sli4_dump_page_a0(phba, mbox))
7281 if (phba->sli_rev < LPFC_SLI_REV4) {
7304 mbox->vport = phba->pport;
7306 rc = lpfc_sli_issue_mbox_wait(phba, mbox, 30);
7312 if (phba->sli_rev == LPFC_SLI_REV4)
7331 mbox->vport = phba->pport;
7337 &mbox->u.mqe.un.mem_dump_type3, phba->sli4_hba.physical_port);
7340 if (phba->sli_rev < LPFC_SLI_REV4) {
7364 rc = lpfc_sli_issue_mbox_wait(phba, mbox, 30);
7376 lpfc_mbox_rsrc_cleanup(phba, mbox, MBOX_THD_UNLOCKED);
7381 mempool_free(mbox, phba->mbox_mem_pool);
7406 struct lpfc_hba *phba = vport->phba;
7414 if (phba->sli_rev < LPFC_SLI_REV4 ||
7415 bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
7422 if (phba->sli_rev < LPFC_SLI_REV4 ||
7423 test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
7466 if (lpfc_get_rdp_info(phba, rdp_context)) {
7490 lpfc_els_lcb_rsp(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
7516 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX,
7525 mempool_free(pmb, phba->mbox_mem_pool);
7529 mempool_free(pmb, phba->mbox_mem_pool);
7531 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
7545 if (phba->sli_rev == LPFC_SLI_REV4) {
7564 phba->fc_stat.elsXmitACC++;
7568 lpfc_els_free_iocb(phba, elsiocb);
7572 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
7574 lpfc_els_free_iocb(phba, elsiocb);
7583 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
7590 if (phba->sli_rev == LPFC_SLI_REV4) {
7611 phba->fc_stat.elsXmitLSRJT++;
7614 lpfc_els_free_iocb(phba, elsiocb);
7618 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
7620 lpfc_els_free_iocb(phba, elsiocb);
7632 struct lpfc_hba *phba = vport->phba;
7638 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
7645 lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
7649 mbox->vport = phba->pport;
7652 phba->sli4_hba.physical_port);
7663 if (phba->sli4_hba.pc_sli4_params.bv1s) {
7675 mempool_free(mbox, phba->mbox_mem_pool);
7689 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
7691 mempool_free(mbox, phba->mbox_mem_pool);
7717 struct lpfc_hba *phba = vport->phba;
7745 if (phba->sli_rev < LPFC_SLI_REV4 ||
7746 test_bit(HBA_FCOE_MODE, &phba->hba_flag) ||
7747 (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
7765 lcb_context->ox_id = get_job_rcvoxid(phba, cmdiocb);
7766 lcb_context->rx_id = get_job_ulpcontext(phba, cmdiocb);
7805 struct lpfc_hba *phba = vport->phba;
7819 lpfc_in_buf_free(phba, vport->fc_rscn_id_list[i]);
7932 if (vport->phba->nvmet_support)
8024 struct lpfc_hba *phba = vport->phba;
8082 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
8091 if (lpfc_find_vport_by_did(phba, nportid))
8110 tmo = ((phba->fc_ratov * 3) + 3);
8146 tmo = ((phba->fc_ratov * 3) + 3);
8235 struct lpfc_hba *phba = vport->phba;
8264 if (phba->cfg_ns_query == LPFC_NS_QUERY_GID_FT) {
8267 } else if (phba->cfg_ns_query == LPFC_NS_QUERY_GID_PT) {
8329 struct lpfc_hba *phba = vport->phba;
8341 phba->link_flag &= ~LS_EXTERNAL_LOOPBACK;
8350 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
8374 if (phba->sli_rev < LPFC_SLI_REV4) {
8375 mbox = mempool_alloc(phba->mbox_mem_pool,
8379 lpfc_linkdown(phba);
8380 lpfc_init_link(phba, mbox,
8381 phba->cfg_topology,
8382 phba->cfg_link_speed);
8386 rc = lpfc_sli_issue_mbox(phba, mbox,
8388 lpfc_set_loopback_flag(phba);
8390 mempool_free(mbox, phba->mbox_mem_pool);
8395 phba->link_flag |= LS_EXTERNAL_LOOPBACK;
8403 lpfc_els_abort_flogi(phba);
8448 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
8451 if (!test_bit(HBA_FLOGI_ISSUED, &phba->hba_flag)) {
8452 phba->defer_flogi_acc_rx_id = bf_get(wqe_ctxt_tag,
8454 phba->defer_flogi_acc_ox_id = bf_get(wqe_rcvoxid,
8462 phba->defer_flogi_acc_rx_id,
8463 phba->defer_flogi_acc_ox_id, phba->hba_flag);
8465 phba->defer_flogi_acc_flag = true;
8603 if (vport->phba->sli_rev == LPFC_SLI_REV4)
8609 * @phba: pointer to lpfc hba data structure.
8627 lpfc_els_rsp_rls_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
8651 mempool_free(pmb, phba->mbox_mem_pool);
8656 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
8664 mempool_free(pmb, phba->mbox_mem_pool);
8668 ulp_context = get_job_ulpcontext(phba, elsiocb);
8669 if (phba->sli_rev == LPFC_SLI_REV4) {
8691 mempool_free(pmb, phba->mbox_mem_pool);
8700 phba->fc_stat.elsXmitACC++;
8703 lpfc_els_free_iocb(phba, elsiocb);
8707 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
8709 lpfc_els_free_iocb(phba, elsiocb);
8737 struct lpfc_hba *phba = vport->phba;
8740 u32 ctx = get_job_ulpcontext(phba, cmdiocb);
8741 u32 ox_id = get_job_rcvoxid(phba, cmdiocb);
8748 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
8750 lpfc_read_lnk_stat(phba, mbox);
8757 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
8766 mempool_free(mbox, phba->mbox_mem_pool);
8806 struct lpfc_hba *phba = vport->phba;
8820 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
8831 ulp_context = get_job_ulpcontext(phba, elsiocb);
8833 if (phba->sli_rev == LPFC_SLI_REV4) {
8836 get_job_ulpcontext(phba, cmdiocb));
8838 get_job_rcvoxid(phba, cmdiocb));
8841 icmd->ulpContext = get_job_ulpcontext(phba, cmdiocb);
8842 icmd->unsli3.rcvsli3.ox_id = get_job_rcvoxid(phba, cmdiocb);
8848 rtv_rsp->ratov = cpu_to_be32(phba->fc_ratov * 1000); /* report msecs */
8849 rtv_rsp->edtov = cpu_to_be32(phba->fc_edtov);
8850 bf_set(qtov_edtovres, rtv_rsp, phba->fc_edtovResol ? 1 : 0);
8864 phba->fc_stat.elsXmitACC++;
8867 lpfc_els_free_iocb(phba, elsiocb);
8871 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
8873 lpfc_els_free_iocb(phba, elsiocb);
8905 struct lpfc_hba *phba = vport->phba;
8929 bf_set(rrq_oxid, els_rrq, phba->sli4_hba.xri_ids[rrq->xritag]);
8946 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
8954 lpfc_els_free_iocb(phba, elsiocb);
8960 * @phba: pointer to lpfc hba data structure.
8971 lpfc_send_rrq(struct lpfc_hba *phba, struct lpfc_node_rrq *rrq)
8978 if (lpfc_test_rrq_active(phba, ndlp, rrq->xritag))
9009 struct lpfc_hba *phba = vport->phba;
9023 ulp_context = get_job_ulpcontext(phba, elsiocb);
9024 if (phba->sli_rev == LPFC_SLI_REV4) {
9028 get_job_ulpcontext(phba, oldiocb));
9030 get_job_rcvoxid(phba, oldiocb));
9033 icmd->ulpContext = get_job_ulpcontext(phba, oldiocb);
9034 icmd->unsli3.rcvsli3.ox_id = get_job_rcvoxid(phba, oldiocb);
9060 phba->fc_stat.elsXmitACC++;
9063 lpfc_els_free_iocb(phba, elsiocb);
9067 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
9069 lpfc_els_free_iocb(phba, elsiocb);
9168 did = get_job_els_rsp64_did(vport->phba, cmdiocb);
9236 did = get_job_els_rsp64_did(vport->phba, cmdiocb);
9257 * compared against those in the phba data structure. If any of those is
9270 struct lpfc_hba *phba = vport->phba;
9278 if ((vport == phba->pport) &&
9280 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
9282 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
9289 if (phba->sli_rev < LPFC_SLI_REV4)
9315 struct lpfc_hba *phba = vport->phba;
9337 phba->cgn_reg_signal = EDC_CG_SIG_NOTSUPPORTED;
9338 phba->cgn_sig_freq = 0;
9339 phba->cgn_reg_fpin = LPFC_CGN_FPIN_ALARM | LPFC_CGN_FPIN_WARN;
9352 lpfc_printf_log(phba, KERN_WARNING,
9366 lpfc_printf_log(phba, KERN_WARNING,
9376 lpfc_printf_log(phba, KERN_INFO,
9393 phba, KERN_WARNING, LOG_CGN_MGMT,
9402 phba->cgn_reg_fpin = phba->cgn_init_reg_fpin;
9403 phba->cgn_reg_signal = phba->cgn_init_reg_signal;
9409 phba->cgn_sig_freq = lpfc_fabric_cgn_frequency;
9412 phba, (struct fc_diag_cg_sig_desc *)tlv);
9416 lpfc_printf_log(phba, KERN_WARNING,
9430 lpfc_config_cgn_signal(phba);
9448 struct lpfc_hba *phba = vport->phba;
9459 lpfc_worker_wake_up(phba);
9476 struct lpfc_hba *phba = vport->phba;
9488 timeout = (uint32_t)(phba->fc_ratov << 1);
9490 pring = lpfc_phba_elsring(phba);
9494 if (test_bit(FC_UNLOADING, &phba->pport->load_flag))
9497 spin_lock_irq(&phba->hbalock);
9498 if (phba->sli_rev == LPFC_SLI_REV4)
9502 ulp_command = get_job_cmnd(phba, piocb);
9503 ulp_context = get_job_ulpcontext(phba, piocb);
9504 did = get_job_els_rsp64_did(phba, piocb);
9506 if (phba->sli_rev == LPFC_SLI_REV4) {
9550 if (phba->sli_rev == LPFC_SLI_REV4)
9552 spin_unlock_irq(&phba->hbalock);
9560 spin_lock_irq(&phba->hbalock);
9562 lpfc_sli_issue_abort_iotag(phba, pring, piocb, NULL);
9563 spin_unlock_irq(&phba->hbalock);
9567 lpfc_issue_hb_tmo(phba);
9570 if (!test_bit(FC_UNLOADING, &phba->pport->load_flag))
9600 struct lpfc_hba *phba = vport->phba;
9615 spin_lock_irqsave(&phba->hbalock, iflags);
9616 pring = lpfc_phba_elsring(phba);
9620 spin_unlock_irqrestore(&phba->hbalock, iflags);
9624 if (phba->sli_rev == LPFC_SLI_REV4)
9627 mbx_tmo_err = test_bit(MBX_TMO_ERR, &phba->bit_flags);
9642 ulp_command = get_job_cmnd(phba, piocb);
9653 if (phba->link_state == LPFC_LINK_DOWN)
9660 if (phba->sli_rev == LPFC_SLI_REV4)
9662 spin_unlock_irqrestore(&phba->hbalock, iflags);
9666 spin_lock_irqsave(&phba->hbalock, iflags);
9671 lpfc_sli_issue_abort_iotag(phba, pring, piocb, NULL);
9673 spin_unlock_irqrestore(&phba->hbalock, iflags);
9676 lpfc_sli_cancel_iocbs(phba, &cancel_list, IOSTAT_LOCAL_REJECT,
9680 lpfc_issue_hb_tmo(phba);
9687 spin_lock_irqsave(&phba->hbalock, iflags);
9688 if (phba->sli_rev == LPFC_SLI_REV4)
9695 ulp_command = get_job_cmnd(phba, piocb);
9716 if (vport == phba->pport) {
9718 &phba->fabric_iocb_list, list) {
9724 if (phba->sli_rev == LPFC_SLI_REV4)
9726 spin_unlock_irqrestore(&phba->hbalock, iflags);
9729 lpfc_sli_cancel_iocbs(phba, &abort_list,
9737 * @phba: pointer to lpfc hba data structure.
9740 * @phba. It first aborts the @phba by invoking the lpfc_fabric_abort_hba()
9742 * IOCBs to the @phba other than the QUE_RING and ABORT/CLOSE IOCBs. For
9753 lpfc_els_flush_all_cmd(struct lpfc_hba *phba)
9757 spin_lock_irq(&phba->port_list_lock);
9758 list_for_each_entry(vport, &phba->port_list, listentry)
9760 spin_unlock_irq(&phba->port_list_lock);
9767 * @phba: Pointer to hba context object.
9775 lpfc_send_els_failure_event(struct lpfc_hba *phba,
9792 ulp_status = get_job_ulpstatus(phba, rspiocbp);
9793 ulp_word4 = get_job_word4(phba, rspiocbp);
9931 * @phba: Pointer to phba object.
9939 lpfc_display_fpin_wwpn(struct lpfc_hba *phba, __be64 *wwnlist, u32 cnt)
9967 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
9977 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
9993 * @phba: Pointer to phba object.
9999 lpfc_els_rcv_fpin_li(struct lpfc_hba *phba, struct fc_tlv_desc *tlv)
10009 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
10019 lpfc_display_fpin_wwpn(phba, (__be64 *)&li->pname_list, cnt);
10024 * @phba: Pointer to hba object.
10030 lpfc_els_rcv_fpin_del(struct lpfc_hba *phba, struct fc_tlv_desc *tlv)
10043 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
10062 * @phba: Pointer to hba object.
10068 lpfc_els_rcv_fpin_peer_cgn(struct lpfc_hba *phba, struct fc_tlv_desc *tlv)
10079 phba->cgn_fpin_frequency = be32_to_cpu(pc->event_period);
10081 lpfc_printf_log(phba, KERN_INFO, LOG_CGN_MGMT | LOG_ELS,
10092 lpfc_display_fpin_wwpn(phba, (__be64 *)&pc->pname_list, cnt);
10097 * @phba: Pointer to hba object.
10107 lpfc_els_rcv_fpin_cgn(struct lpfc_hba *phba, struct fc_tlv_desc *tlv)
10144 if (phba->cmf_active_mode != LPFC_CFG_OFF) {
10145 if (phba->cgn_reg_fpin & LPFC_CGN_FPIN_ALARM) {
10147 atomic_inc(&phba->cgn_sync_alarm_cnt);
10153 atomic_inc(&phba->cgn_fabric_alarm_cnt);
10159 if (phba->cmf_active_mode != LPFC_CFG_OFF) {
10160 if (phba->cgn_reg_fpin & LPFC_CGN_FPIN_WARN) {
10162 atomic_inc(&phba->cgn_sync_warn_cnt);
10168 atomic_inc(&phba->cgn_fabric_warn_cnt);
10171 phba->cgn_fpin_frequency =
10173 value = phba->cgn_fpin_frequency;
10174 if (phba->cgn_i) {
10176 phba->cgn_i->virt;
10199 lpfc_printf_log(phba, (nm_log ? KERN_WARNING : KERN_INFO),
10211 struct lpfc_hba *phba = vport->phba;
10232 lpfc_printf_log(phba, KERN_WARNING, LOG_CGN_MGMT,
10249 lpfc_els_rcv_fpin_li(phba, tlv);
10253 lpfc_els_rcv_fpin_del(phba, tlv);
10257 lpfc_els_rcv_fpin_peer_cgn(phba, tlv);
10261 deliver = lpfc_els_rcv_fpin_cgn(phba, tlv);
10265 lpfc_printf_log(phba, KERN_WARNING, LOG_CGN_MGMT,
10273 lpfc_cgn_update_stat(phba, dtag);
10282 lpfc_printf_log(phba, KERN_WARNING, LOG_CGN_MGMT,
10317 * @phba: pointer to lpfc hba data structure.
10330 lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
10347 if (phba->sli_rev == LPFC_SLI_REV4)
10351 status = get_job_ulpstatus(phba, elsiocb);
10353 if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) == 0)
10354 lpfc_sli3_post_buffer(phba, pring, 1);
10356 did = get_job_els_rsp64_did(phba, elsiocb);
10360 status, get_job_word4(phba, elsiocb), did);
10392 phba->fc_stat.elsRcvFrame++;
10437 phba->fc_stat.elsRcvPLOGI++;
10438 ndlp = lpfc_plogi_confirm_nport(phba, payload, ndlp);
10439 if (phba->sli_rev == LPFC_SLI_REV4 &&
10440 test_bit(FC_PT2PT, &phba->pport->fc_flag)) {
10465 if (!test_bit(FC_PT2PT, &phba->pport->fc_flag) ||
10466 test_bit(FC_PT2PT_PLOGI, &phba->pport->fc_flag)) {
10486 phba->fc_stat.elsRcvFLOGI++;
10502 if (phba->defer_flogi_acc_flag)
10513 phba->fc_stat.elsRcvLOGO++;
10530 phba->fc_stat.elsRcvPRLO++;
10540 phba->fc_stat.elsRcvLCB++;
10544 phba->fc_stat.elsRcvRDP++;
10548 phba->fc_stat.elsRcvRSCN++;
10560 phba->fc_stat.elsRcvADISC++;
10574 phba->fc_stat.elsRcvPDISC++;
10588 phba->fc_stat.elsRcvFARPR++;
10596 phba->fc_stat.elsRcvFARP++;
10604 phba->fc_stat.elsRcvFAN++;
10613 phba->fc_stat.elsRcvPRLI++;
10627 phba->fc_stat.elsRcvLIRR++;
10638 phba->fc_stat.elsRcvRLS++;
10649 phba->fc_stat.elsRcvRPL++;
10660 phba->fc_stat.elsRcvRNID++;
10670 phba->fc_stat.elsRcvRTV++;
10681 phba->fc_stat.elsRcvRRQ++;
10692 phba->fc_stat.elsRcvECHO++;
10717 phba->fc_stat.elsRcvRDF++;
10772 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
10775 lpfc_linkdown(phba);
10776 lpfc_init_link(phba, mbox,
10777 phba->cfg_topology,
10778 phba->cfg_link_speed);
10782 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT) ==
10784 mempool_free(mbox, phba->mbox_mem_pool);
10794 cmd, status, get_job_word4(phba, elsiocb), did);
10796 phba->fc_stat.elsRcvDrop++;
10801 * @phba: pointer to lpfc hba data structure.
10812 lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
10828 ulp_command = get_job_cmnd(phba, elsiocb);
10829 status = get_job_ulpstatus(phba, elsiocb);
10830 parameter = get_job_word4(phba, elsiocb);
10831 if (phba->sli_rev == LPFC_SLI_REV4)
10837 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
10841 phba->fc_stat.NoRcvBuf++;
10843 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
10844 lpfc_sli3_post_buffer(phba, pring, 0);
10848 if (phba->sli_rev == LPFC_SLI_REV3) {
10850 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
10854 vport = phba->pport;
10856 vport = lpfc_find_vport_by_vpid(phba,
10868 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
10876 elsiocb->cmd_dmabuf = lpfc_sli_ringpostbuf_get(phba, pring,
10881 elsiocb->bpl_dmabuf = lpfc_sli_ringpostbuf_get(phba,
10887 lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
10893 lpfc_in_buf_free(phba, elsiocb->cmd_dmabuf);
10898 lpfc_in_buf_free(phba, elsiocb->bpl_dmabuf);
10929 * @phba: pointer to lpfc hba data structure.
10941 lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
10953 phba->fc_ratov);
10955 jiffies + msecs_to_jiffies(1000 * phba->fc_ratov));
10963 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
10985 if ((phba->cfg_enable_SmartSAN ||
10986 phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT) &&
10993 * @phba: pointer to lpfc hba data structure.
11004 lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
11019 if (phba->sli_rev == LPFC_SLI_REV4 &&
11036 lpfc_init_vpi(phba, pmb, vport->vpi);
11039 rc = lpfc_sli_issue_mbox(phba, pmb,
11053 if (phba->sli_rev == LPFC_SLI_REV4)
11061 if (phba->sli_rev == LPFC_SLI_REV4)
11074 if (vport == phba->pport) {
11075 if (phba->sli_rev < LPFC_SLI_REV4)
11083 lpfc_start_fdiscs(phba);
11084 lpfc_do_scr_ns_plogi(phba, vport);
11087 lpfc_do_scr_ns_plogi(phba, vport);
11096 mempool_free(pmb, phba->mbox_mem_pool);
11101 if (lpfc_is_vmid_enabled(phba))
11103 vport->vmid_flag = vport->phba->pport->vmid_flag;
11110 * @phba: pointer to lpfc hba data structure.
11118 lpfc_register_new_vport(struct lpfc_hba *phba, struct lpfc_vport *vport,
11123 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
11129 mempool_free(mbox, phba->mbox_mem_pool);
11134 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
11140 mempool_free(mbox, phba->mbox_mem_pool);
11161 * @phba: pointer to lpfc hba data structure.
11166 lpfc_cancel_all_vport_retry_delay_timer(struct lpfc_hba *phba)
11174 link_state = phba->link_state;
11175 lpfc_linkdown(phba);
11176 phba->link_state = link_state;
11178 vports = lpfc_create_vport_work_array(phba);
11181 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
11187 lpfc_destroy_vport_work_array(phba, vports);
11193 * @phba: pointer to lpfc hba data structure.
11200 lpfc_retry_pport_discovery(struct lpfc_hba *phba)
11205 lpfc_cancel_all_vport_retry_delay_timer(phba);
11208 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
11217 phba->pport->port_state = LPFC_FLOGI;
11223 * @phba: pointer to lpfc hba data structure.
11231 lpfc_fabric_login_reqd(struct lpfc_hba *phba,
11235 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
11236 u32 ulp_word4 = get_job_word4(phba, rspiocb);
11247 * @phba: pointer to lpfc hba data structure.
11266 lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
11279 ulp_status = get_job_ulpstatus(phba, rspiocb);
11280 ulp_word4 = get_job_word4(phba, rspiocb);
11290 list_for_each_entry(piocb, &phba->fabric_iocb_list, list) {
11300 if (lpfc_fabric_login_reqd(phba, cmdiocb, rspiocb)) {
11301 lpfc_retry_pport_discovery(phba);
11306 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
11320 if (vport->phba->fc_topology == LPFC_TOPOLOGY_LOOP)
11355 if (phba->sli_rev == LPFC_SLI_REV4)
11360 if (phba->sli_rev == LPFC_SLI_REV4)
11364 } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
11370 lpfc_register_new_vport(phba, vport, ndlp);
11378 lpfc_register_new_vport(phba, vport, ndlp);
11380 lpfc_do_scr_ns_plogi(phba, vport);
11395 lpfc_els_free_iocb(phba, cmdiocb);
11422 struct lpfc_hba *phba = vport->phba;
11444 if (phba->sli_rev == LPFC_SLI_REV4) {
11459 memcpy(pcmd, &vport->phba->pport->fc_sparam, sizeof(struct serv_parm));
11481 phba->fc_stat.elsXmitFDISC++;
11492 rc = lpfc_issue_fabric_iocb(phba, elsiocb);
11502 lpfc_els_free_iocb(phba, elsiocb);
11511 * @phba: pointer to lpfc hba data structure.
11524 lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
11534 ulp_status = get_job_ulpstatus(phba, rspiocb);
11535 ulp_word4 = get_job_word4(phba, rspiocb);
11537 if (phba->sli_rev == LPFC_SLI_REV4) {
11538 did = get_job_els_rsp64_did(phba, cmdiocb);
11542 did = get_job_els_rsp64_did(phba, rspiocb);
11576 lpfc_els_free_iocb(phba, cmdiocb);
11599 struct lpfc_hba *phba = vport->phba;
11629 lpfc_els_free_iocb(phba, elsiocb);
11633 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 0);
11635 lpfc_els_free_iocb(phba, elsiocb);
11662 struct lpfc_hba *phba = from_timer(phba, t, fabric_block_timer);
11666 spin_lock_irqsave(&phba->pport->work_port_lock, iflags);
11667 tmo_posted = phba->pport->work_port_events & WORKER_FABRIC_BLOCK_TMO;
11669 phba->pport->work_port_events |= WORKER_FABRIC_BLOCK_TMO;
11670 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflags);
11673 lpfc_worker_wake_up(phba);
11679 * @phba: pointer to lpfc hba data structure.
11688 lpfc_resume_fabric_iocbs(struct lpfc_hba *phba)
11696 spin_lock_irqsave(&phba->hbalock, iflags);
11698 if (atomic_read(&phba->fabric_iocb_count) == 0) {
11699 list_remove_head(&phba->fabric_iocb_list, iocb, typeof(*iocb),
11703 atomic_inc(&phba->fabric_iocb_count);
11705 spin_unlock_irqrestore(&phba->hbalock, iflags);
11715 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, iocb, 0);
11723 iocb->cmd_cmpl(phba, iocb, iocb);
11725 atomic_dec(&phba->fabric_iocb_count);
11733 * @phba: pointer to lpfc hba data structure.
11741 lpfc_unblock_fabric_iocbs(struct lpfc_hba *phba)
11743 clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
11745 lpfc_resume_fabric_iocbs(phba);
11751 * @phba: pointer to lpfc hba data structure.
11759 lpfc_block_fabric_iocbs(struct lpfc_hba *phba)
11763 blocked = test_and_set_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
11766 mod_timer(&phba->fabric_block_timer,
11774 * @phba: pointer to lpfc hba data structure.
11786 lpfc_cmpl_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
11790 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
11791 u32 ulp_word4 = get_job_word4(phba, rspiocb);
11799 lpfc_block_fabric_iocbs(phba);
11804 lpfc_block_fabric_iocbs(phba);
11812 lpfc_block_fabric_iocbs(phba);
11816 BUG_ON(atomic_read(&phba->fabric_iocb_count) == 0);
11821 cmdiocb->cmd_cmpl(phba, cmdiocb, rspiocb);
11823 atomic_dec(&phba->fabric_iocb_count);
11824 if (!test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags)) {
11826 lpfc_resume_fabric_iocbs(phba);
11832 * @phba: pointer to lpfc hba data structure.
11855 lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb)
11861 BUG_ON(atomic_read(&phba->fabric_iocb_count) > 1);
11863 spin_lock_irqsave(&phba->hbalock, iflags);
11864 ready = atomic_read(&phba->fabric_iocb_count) == 0 &&
11865 !test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
11869 atomic_inc(&phba->fabric_iocb_count);
11870 spin_unlock_irqrestore(&phba->hbalock, iflags);
11880 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, iocb, 0);
11886 atomic_dec(&phba->fabric_iocb_count);
11889 spin_lock_irqsave(&phba->hbalock, iflags);
11890 list_add_tail(&iocb->list, &phba->fabric_iocb_list);
11891 spin_unlock_irqrestore(&phba->hbalock, iflags);
11911 struct lpfc_hba *phba = vport->phba;
11914 spin_lock_irq(&phba->hbalock);
11915 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
11923 spin_unlock_irq(&phba->hbalock);
11926 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
11944 struct lpfc_hba *phba = ndlp->phba;
11948 pring = lpfc_phba_elsring(phba);
11953 spin_lock_irq(&phba->hbalock);
11954 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
11956 if ((lpfc_check_sli_ndlp(phba, pring, piocb, ndlp))) {
11961 spin_unlock_irq(&phba->hbalock);
11964 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
11970 * @phba: pointer to lpfc hba data structure.
11979 void lpfc_fabric_abort_hba(struct lpfc_hba *phba)
11983 spin_lock_irq(&phba->hbalock);
11984 list_splice_init(&phba->fabric_iocb_list, &completions);
11985 spin_unlock_irq(&phba->hbalock);
11988 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
12002 struct lpfc_hba *phba = vport->phba;
12007 spin_lock_irqsave(&phba->sli4_hba.sgl_list_lock, iflag);
12009 &phba->sli4_hba.lpfc_abts_els_sgl_list, list) {
12024 &phba->sli4_hba.lpfc_els_sgl_list);
12028 spin_unlock_irqrestore(&phba->sli4_hba.sgl_list_lock, iflag);
12034 * @phba: pointer to lpfc hba data structure.
12041 lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
12053 pring = lpfc_phba_elsring(phba);
12055 spin_lock_irqsave(&phba->sli4_hba.sgl_list_lock, iflag);
12057 &phba->sli4_hba.lpfc_abts_els_sgl_list, list) {
12063 &phba->sli4_hba.lpfc_els_sgl_list);
12065 spin_unlock_irqrestore(&phba->sli4_hba.sgl_list_lock,
12069 lpfc_set_rrq_active(phba, ndlp,
12077 lpfc_worker_wake_up(phba);
12081 spin_unlock_irqrestore(&phba->sli4_hba.sgl_list_lock, iflag);
12082 lxri = lpfc_sli4_xri_inrange(phba, xri);
12086 spin_lock_irqsave(&phba->hbalock, iflag);
12087 sglq_entry = __lpfc_get_active_sglq(phba, lxri);
12089 spin_unlock_irqrestore(&phba->hbalock, iflag);
12093 spin_unlock_irqrestore(&phba->hbalock, iflag);
12111 struct lpfc_hba *phba;
12115 phba = vport->phba;
12117 lpfc_printf_log(phba, KERN_INFO,
12122 lpfc_printf_log(phba, KERN_ERR, LOG_TRACE_EVENT,
12179 lpfc_cmpl_els_qfpa(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
12188 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
12189 u32 ulp_word4 = get_job_word4(phba, rspiocb);
12267 lpfc_els_free_iocb(phba, cmdiocb);
12273 struct lpfc_hba *phba = vport->phba;
12279 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
12297 lpfc_els_free_iocb(vport->phba, elsiocb);
12301 ret = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, elsiocb, 2);
12303 lpfc_els_free_iocb(phba, elsiocb);
12381 lpfc_els_free_iocb(vport->phba, elsiocb);
12385 ret = lpfc_sli_issue_iocb(vport->phba, LPFC_ELS_RING, elsiocb, 0);
12387 lpfc_els_free_iocb(vport->phba, elsiocb);
12399 lpfc_cmpl_els_uvem(struct lpfc_hba *phba, struct lpfc_iocbq *icmdiocb,
12409 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
12410 u32 ulp_word4 = get_job_word4(phba, rspiocb);
12434 spin_lock(&phba->hbalock);
12437 phba->pport->vmid_flag |= LPFC_VMID_IN_USE;
12438 spin_unlock(&phba->hbalock);
12449 lpfc_els_free_iocb(phba, icmdiocb);