1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 4 * Copyright (c) 2014- QLogic Corporation. 5 * All rights reserved 6 * www.qlogic.com 7 * 8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter. 9 */ 10 11 #include "bfad_drv.h" 12 #include "bfad_im.h" 13 #include "bfa_plog.h" 14 #include "bfa_cs.h" 15 #include "bfa_modules.h" 16 17 BFA_TRC_FILE(HAL, FCXP); 18 19 /* 20 * LPS related definitions 21 */ 22 #define BFA_LPS_MIN_LPORTS (1) 23 #define BFA_LPS_MAX_LPORTS (256) 24 25 /* 26 * Maximum Vports supported per physical port or vf. 27 */ 28 #define BFA_LPS_MAX_VPORTS_SUPP_CB 255 29 #define BFA_LPS_MAX_VPORTS_SUPP_CT 190 30 31 32 /* 33 * FC PORT related definitions 34 */ 35 /* 36 * The port is considered disabled if corresponding physical port or IOC are 37 * disabled explicitly 38 */ 39 #define BFA_PORT_IS_DISABLED(bfa) \ 40 ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \ 41 (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE)) 42 43 /* 44 * BFA port state machine events 45 */ 46 enum bfa_fcport_sm_event { 47 BFA_FCPORT_SM_START = 1, /* start port state machine */ 48 BFA_FCPORT_SM_STOP = 2, /* stop port state machine */ 49 BFA_FCPORT_SM_ENABLE = 3, /* enable port */ 50 BFA_FCPORT_SM_DISABLE = 4, /* disable port state machine */ 51 BFA_FCPORT_SM_FWRSP = 5, /* firmware enable/disable rsp */ 52 BFA_FCPORT_SM_LINKUP = 6, /* firmware linkup event */ 53 BFA_FCPORT_SM_LINKDOWN = 7, /* firmware linkup down */ 54 BFA_FCPORT_SM_QRESUME = 8, /* CQ space available */ 55 BFA_FCPORT_SM_HWFAIL = 9, /* IOC h/w failure */ 56 BFA_FCPORT_SM_DPORTENABLE = 10, /* enable dport */ 57 BFA_FCPORT_SM_DPORTDISABLE = 11,/* disable dport */ 58 BFA_FCPORT_SM_FAA_MISCONFIG = 12, /* FAA misconfiguratin */ 59 BFA_FCPORT_SM_DDPORTENABLE = 13, /* enable ddport */ 60 BFA_FCPORT_SM_DDPORTDISABLE = 14, /* disable ddport */ 61 }; 62 63 /* 64 * BFA port link notification state machine events 65 */ 66 67 enum bfa_fcport_ln_sm_event { 68 BFA_FCPORT_LN_SM_LINKUP = 1, /* linkup event */ 69 BFA_FCPORT_LN_SM_LINKDOWN = 2, /* linkdown event */ 70 BFA_FCPORT_LN_SM_NOTIFICATION = 3 /* done notification */ 71 }; 72 73 /* 74 * RPORT related definitions 75 */ 76 #define bfa_rport_offline_cb(__rp) do { \ 77 if ((__rp)->bfa->fcs) \ 78 bfa_cb_rport_offline((__rp)->rport_drv); \ 79 else { \ 80 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \ 81 __bfa_cb_rport_offline, (__rp)); \ 82 } \ 83 } while (0) 84 85 #define bfa_rport_online_cb(__rp) do { \ 86 if ((__rp)->bfa->fcs) \ 87 bfa_cb_rport_online((__rp)->rport_drv); \ 88 else { \ 89 bfa_cb_queue((__rp)->bfa, &(__rp)->hcb_qe, \ 90 __bfa_cb_rport_online, (__rp)); \ 91 } \ 92 } while (0) 93 94 /* 95 * forward declarations FCXP related functions 96 */ 97 static void __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete); 98 static void hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp, 99 struct bfi_fcxp_send_rsp_s *fcxp_rsp); 100 static void hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, 101 struct bfa_fcxp_s *fcxp, struct fchs_s *fchs); 102 static void bfa_fcxp_qresume(void *cbarg); 103 static void bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, 104 struct bfi_fcxp_send_req_s *send_req); 105 106 /* 107 * forward declarations for LPS functions 108 */ 109 static void bfa_lps_login_rsp(struct bfa_s *bfa, 110 struct bfi_lps_login_rsp_s *rsp); 111 static void bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count); 112 static void bfa_lps_logout_rsp(struct bfa_s *bfa, 113 struct bfi_lps_logout_rsp_s *rsp); 114 static void bfa_lps_reqq_resume(void *lps_arg); 115 static void bfa_lps_free(struct bfa_lps_s *lps); 116 static void bfa_lps_send_login(struct bfa_lps_s *lps); 117 static void bfa_lps_send_logout(struct bfa_lps_s *lps); 118 static void bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps); 119 static void bfa_lps_login_comp(struct bfa_lps_s *lps); 120 static void bfa_lps_logout_comp(struct bfa_lps_s *lps); 121 static void bfa_lps_cvl_event(struct bfa_lps_s *lps); 122 123 /* 124 * forward declaration for LPS state machine 125 */ 126 static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event); 127 static void bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event); 128 static void bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event 129 event); 130 static void bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event); 131 static void bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, 132 enum bfa_lps_event event); 133 static void bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event); 134 static void bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event 135 event); 136 137 /* 138 * forward declaration for FC Port functions 139 */ 140 static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport); 141 static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport); 142 static void bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport); 143 static void bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport); 144 static void bfa_fcport_set_wwns(struct bfa_fcport_s *fcport); 145 static void __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete); 146 static void bfa_fcport_scn(struct bfa_fcport_s *fcport, 147 enum bfa_port_linkstate event, bfa_boolean_t trunk); 148 static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, 149 enum bfa_port_linkstate event); 150 static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete); 151 static void bfa_fcport_stats_get_timeout(void *cbarg); 152 static void bfa_fcport_stats_clr_timeout(void *cbarg); 153 static void bfa_trunk_iocdisable(struct bfa_s *bfa); 154 155 /* 156 * forward declaration for FC PORT state machine 157 */ 158 static void bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport, 159 enum bfa_fcport_sm_event event); 160 static void bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport, 161 enum bfa_fcport_sm_event event); 162 static void bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport, 163 enum bfa_fcport_sm_event event); 164 static void bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport, 165 enum bfa_fcport_sm_event event); 166 static void bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport, 167 enum bfa_fcport_sm_event event); 168 static void bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport, 169 enum bfa_fcport_sm_event event); 170 static void bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport, 171 enum bfa_fcport_sm_event event); 172 static void bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport, 173 enum bfa_fcport_sm_event event); 174 static void bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport, 175 enum bfa_fcport_sm_event event); 176 static void bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport, 177 enum bfa_fcport_sm_event event); 178 static void bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport, 179 enum bfa_fcport_sm_event event); 180 static void bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport, 181 enum bfa_fcport_sm_event event); 182 static void bfa_fcport_sm_dport(struct bfa_fcport_s *fcport, 183 enum bfa_fcport_sm_event event); 184 static void bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport, 185 enum bfa_fcport_sm_event event); 186 static void bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport, 187 enum bfa_fcport_sm_event event); 188 189 static void bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln, 190 enum bfa_fcport_ln_sm_event event); 191 static void bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln, 192 enum bfa_fcport_ln_sm_event event); 193 static void bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln, 194 enum bfa_fcport_ln_sm_event event); 195 static void bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln, 196 enum bfa_fcport_ln_sm_event event); 197 static void bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln, 198 enum bfa_fcport_ln_sm_event event); 199 static void bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln, 200 enum bfa_fcport_ln_sm_event event); 201 static void bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln, 202 enum bfa_fcport_ln_sm_event event); 203 204 static struct bfa_sm_table_s hal_port_sm_table[] = { 205 {BFA_SM(bfa_fcport_sm_uninit), BFA_PORT_ST_UNINIT}, 206 {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PORT_ST_ENABLING_QWAIT}, 207 {BFA_SM(bfa_fcport_sm_enabling), BFA_PORT_ST_ENABLING}, 208 {BFA_SM(bfa_fcport_sm_linkdown), BFA_PORT_ST_LINKDOWN}, 209 {BFA_SM(bfa_fcport_sm_linkup), BFA_PORT_ST_LINKUP}, 210 {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PORT_ST_DISABLING_QWAIT}, 211 {BFA_SM(bfa_fcport_sm_toggling_qwait), BFA_PORT_ST_TOGGLING_QWAIT}, 212 {BFA_SM(bfa_fcport_sm_disabling), BFA_PORT_ST_DISABLING}, 213 {BFA_SM(bfa_fcport_sm_disabled), BFA_PORT_ST_DISABLED}, 214 {BFA_SM(bfa_fcport_sm_stopped), BFA_PORT_ST_STOPPED}, 215 {BFA_SM(bfa_fcport_sm_iocdown), BFA_PORT_ST_IOCDOWN}, 216 {BFA_SM(bfa_fcport_sm_iocfail), BFA_PORT_ST_IOCDOWN}, 217 {BFA_SM(bfa_fcport_sm_dport), BFA_PORT_ST_DPORT}, 218 {BFA_SM(bfa_fcport_sm_ddport), BFA_PORT_ST_DDPORT}, 219 {BFA_SM(bfa_fcport_sm_faa_misconfig), BFA_PORT_ST_FAA_MISCONFIG}, 220 }; 221 222 223 /* 224 * forward declaration for RPORT related functions 225 */ 226 static struct bfa_rport_s *bfa_rport_alloc(struct bfa_rport_mod_s *rp_mod); 227 static void bfa_rport_free(struct bfa_rport_s *rport); 228 static bfa_boolean_t bfa_rport_send_fwcreate(struct bfa_rport_s *rp); 229 static bfa_boolean_t bfa_rport_send_fwdelete(struct bfa_rport_s *rp); 230 static bfa_boolean_t bfa_rport_send_fwspeed(struct bfa_rport_s *rp); 231 static void __bfa_cb_rport_online(void *cbarg, 232 bfa_boolean_t complete); 233 static void __bfa_cb_rport_offline(void *cbarg, 234 bfa_boolean_t complete); 235 236 /* 237 * forward declaration for RPORT state machine 238 */ 239 static void bfa_rport_sm_uninit(struct bfa_rport_s *rp, 240 enum bfa_rport_event event); 241 static void bfa_rport_sm_created(struct bfa_rport_s *rp, 242 enum bfa_rport_event event); 243 static void bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, 244 enum bfa_rport_event event); 245 static void bfa_rport_sm_online(struct bfa_rport_s *rp, 246 enum bfa_rport_event event); 247 static void bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, 248 enum bfa_rport_event event); 249 static void bfa_rport_sm_offline(struct bfa_rport_s *rp, 250 enum bfa_rport_event event); 251 static void bfa_rport_sm_deleting(struct bfa_rport_s *rp, 252 enum bfa_rport_event event); 253 static void bfa_rport_sm_offline_pending(struct bfa_rport_s *rp, 254 enum bfa_rport_event event); 255 static void bfa_rport_sm_delete_pending(struct bfa_rport_s *rp, 256 enum bfa_rport_event event); 257 static void bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, 258 enum bfa_rport_event event); 259 static void bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, 260 enum bfa_rport_event event); 261 static void bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, 262 enum bfa_rport_event event); 263 static void bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, 264 enum bfa_rport_event event); 265 266 /* 267 * PLOG related definitions 268 */ 269 static int 270 plkd_validate_logrec(struct bfa_plog_rec_s *pl_rec) 271 { 272 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) && 273 (pl_rec->log_type != BFA_PL_LOG_TYPE_STRING)) 274 return 1; 275 276 if ((pl_rec->log_type != BFA_PL_LOG_TYPE_INT) && 277 (pl_rec->log_num_ints > BFA_PL_INT_LOG_SZ)) 278 return 1; 279 280 return 0; 281 } 282 283 static void 284 bfa_plog_add(struct bfa_plog_s *plog, struct bfa_plog_rec_s *pl_rec) 285 { 286 u16 tail; 287 struct bfa_plog_rec_s *pl_recp; 288 289 if (plog->plog_enabled == 0) 290 return; 291 292 if (plkd_validate_logrec(pl_rec)) { 293 WARN_ON(1); 294 return; 295 } 296 297 tail = plog->tail; 298 299 pl_recp = &(plog->plog_recs[tail]); 300 301 memcpy(pl_recp, pl_rec, sizeof(struct bfa_plog_rec_s)); 302 303 pl_recp->tv = ktime_get_real_seconds(); 304 BFA_PL_LOG_REC_INCR(plog->tail); 305 306 if (plog->head == plog->tail) 307 BFA_PL_LOG_REC_INCR(plog->head); 308 } 309 310 void 311 bfa_plog_init(struct bfa_plog_s *plog) 312 { 313 memset((char *)plog, 0, sizeof(struct bfa_plog_s)); 314 315 memcpy(plog->plog_sig, BFA_PL_SIG_STR, BFA_PL_SIG_LEN); 316 plog->head = plog->tail = 0; 317 plog->plog_enabled = 1; 318 } 319 320 void 321 bfa_plog_str(struct bfa_plog_s *plog, enum bfa_plog_mid mid, 322 enum bfa_plog_eid event, 323 u16 misc, char *log_str) 324 { 325 struct bfa_plog_rec_s lp; 326 327 if (plog->plog_enabled) { 328 memset(&lp, 0, sizeof(struct bfa_plog_rec_s)); 329 lp.mid = mid; 330 lp.eid = event; 331 lp.log_type = BFA_PL_LOG_TYPE_STRING; 332 lp.misc = misc; 333 strlcpy(lp.log_entry.string_log, log_str, 334 BFA_PL_STRING_LOG_SZ); 335 lp.log_entry.string_log[BFA_PL_STRING_LOG_SZ - 1] = '\0'; 336 bfa_plog_add(plog, &lp); 337 } 338 } 339 340 void 341 bfa_plog_intarr(struct bfa_plog_s *plog, enum bfa_plog_mid mid, 342 enum bfa_plog_eid event, 343 u16 misc, u32 *intarr, u32 num_ints) 344 { 345 struct bfa_plog_rec_s lp; 346 u32 i; 347 348 if (num_ints > BFA_PL_INT_LOG_SZ) 349 num_ints = BFA_PL_INT_LOG_SZ; 350 351 if (plog->plog_enabled) { 352 memset(&lp, 0, sizeof(struct bfa_plog_rec_s)); 353 lp.mid = mid; 354 lp.eid = event; 355 lp.log_type = BFA_PL_LOG_TYPE_INT; 356 lp.misc = misc; 357 358 for (i = 0; i < num_ints; i++) 359 lp.log_entry.int_log[i] = intarr[i]; 360 361 lp.log_num_ints = (u8) num_ints; 362 363 bfa_plog_add(plog, &lp); 364 } 365 } 366 367 void 368 bfa_plog_fchdr(struct bfa_plog_s *plog, enum bfa_plog_mid mid, 369 enum bfa_plog_eid event, 370 u16 misc, struct fchs_s *fchdr) 371 { 372 u32 *tmp_int = (u32 *) fchdr; 373 u32 ints[BFA_PL_INT_LOG_SZ]; 374 375 if (plog->plog_enabled) { 376 ints[0] = tmp_int[0]; 377 ints[1] = tmp_int[1]; 378 ints[2] = tmp_int[4]; 379 380 bfa_plog_intarr(plog, mid, event, misc, ints, 3); 381 } 382 } 383 384 void 385 bfa_plog_fchdr_and_pl(struct bfa_plog_s *plog, enum bfa_plog_mid mid, 386 enum bfa_plog_eid event, u16 misc, struct fchs_s *fchdr, 387 u32 pld_w0) 388 { 389 u32 *tmp_int = (u32 *) fchdr; 390 u32 ints[BFA_PL_INT_LOG_SZ]; 391 392 if (plog->plog_enabled) { 393 ints[0] = tmp_int[0]; 394 ints[1] = tmp_int[1]; 395 ints[2] = tmp_int[4]; 396 ints[3] = pld_w0; 397 398 bfa_plog_intarr(plog, mid, event, misc, ints, 4); 399 } 400 } 401 402 403 /* 404 * fcxp_pvt BFA FCXP private functions 405 */ 406 407 static void 408 claim_fcxps_mem(struct bfa_fcxp_mod_s *mod) 409 { 410 u16 i; 411 struct bfa_fcxp_s *fcxp; 412 413 fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod); 414 memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps); 415 416 INIT_LIST_HEAD(&mod->fcxp_req_free_q); 417 INIT_LIST_HEAD(&mod->fcxp_rsp_free_q); 418 INIT_LIST_HEAD(&mod->fcxp_active_q); 419 INIT_LIST_HEAD(&mod->fcxp_req_unused_q); 420 INIT_LIST_HEAD(&mod->fcxp_rsp_unused_q); 421 422 mod->fcxp_list = fcxp; 423 424 for (i = 0; i < mod->num_fcxps; i++) { 425 fcxp->fcxp_mod = mod; 426 fcxp->fcxp_tag = i; 427 428 if (i < (mod->num_fcxps / 2)) { 429 list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q); 430 fcxp->req_rsp = BFA_TRUE; 431 } else { 432 list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q); 433 fcxp->req_rsp = BFA_FALSE; 434 } 435 436 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp); 437 fcxp->reqq_waiting = BFA_FALSE; 438 439 fcxp = fcxp + 1; 440 } 441 442 bfa_mem_kva_curp(mod) = (void *)fcxp; 443 } 444 445 void 446 bfa_fcxp_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo, 447 struct bfa_s *bfa) 448 { 449 struct bfa_fcxp_mod_s *fcxp_mod = BFA_FCXP_MOD(bfa); 450 struct bfa_mem_kva_s *fcxp_kva = BFA_MEM_FCXP_KVA(bfa); 451 struct bfa_mem_dma_s *seg_ptr; 452 u16 nsegs, idx, per_seg_fcxp; 453 u16 num_fcxps = cfg->fwcfg.num_fcxp_reqs; 454 u32 per_fcxp_sz; 455 456 if (num_fcxps == 0) 457 return; 458 459 if (cfg->drvcfg.min_cfg) 460 per_fcxp_sz = 2 * BFA_FCXP_MAX_IBUF_SZ; 461 else 462 per_fcxp_sz = BFA_FCXP_MAX_IBUF_SZ + BFA_FCXP_MAX_LBUF_SZ; 463 464 /* dma memory */ 465 nsegs = BFI_MEM_DMA_NSEGS(num_fcxps, per_fcxp_sz); 466 per_seg_fcxp = BFI_MEM_NREQS_SEG(per_fcxp_sz); 467 468 bfa_mem_dma_seg_iter(fcxp_mod, seg_ptr, nsegs, idx) { 469 if (num_fcxps >= per_seg_fcxp) { 470 num_fcxps -= per_seg_fcxp; 471 bfa_mem_dma_setup(minfo, seg_ptr, 472 per_seg_fcxp * per_fcxp_sz); 473 } else 474 bfa_mem_dma_setup(minfo, seg_ptr, 475 num_fcxps * per_fcxp_sz); 476 } 477 478 /* kva memory */ 479 bfa_mem_kva_setup(minfo, fcxp_kva, 480 cfg->fwcfg.num_fcxp_reqs * sizeof(struct bfa_fcxp_s)); 481 } 482 483 void 484 bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 485 struct bfa_pcidev_s *pcidev) 486 { 487 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 488 489 mod->bfa = bfa; 490 mod->num_fcxps = cfg->fwcfg.num_fcxp_reqs; 491 492 /* 493 * Initialize FCXP request and response payload sizes. 494 */ 495 mod->req_pld_sz = mod->rsp_pld_sz = BFA_FCXP_MAX_IBUF_SZ; 496 if (!cfg->drvcfg.min_cfg) 497 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ; 498 499 INIT_LIST_HEAD(&mod->req_wait_q); 500 INIT_LIST_HEAD(&mod->rsp_wait_q); 501 502 claim_fcxps_mem(mod); 503 } 504 505 void 506 bfa_fcxp_iocdisable(struct bfa_s *bfa) 507 { 508 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 509 struct bfa_fcxp_s *fcxp; 510 struct list_head *qe, *qen; 511 512 /* Enqueue unused fcxp resources to free_q */ 513 list_splice_tail_init(&mod->fcxp_req_unused_q, &mod->fcxp_req_free_q); 514 list_splice_tail_init(&mod->fcxp_rsp_unused_q, &mod->fcxp_rsp_free_q); 515 516 list_for_each_safe(qe, qen, &mod->fcxp_active_q) { 517 fcxp = (struct bfa_fcxp_s *) qe; 518 if (fcxp->caller == NULL) { 519 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg, 520 BFA_STATUS_IOC_FAILURE, 0, 0, NULL); 521 bfa_fcxp_free(fcxp); 522 } else { 523 fcxp->rsp_status = BFA_STATUS_IOC_FAILURE; 524 bfa_cb_queue(bfa, &fcxp->hcb_qe, 525 __bfa_fcxp_send_cbfn, fcxp); 526 } 527 } 528 } 529 530 static struct bfa_fcxp_s * 531 bfa_fcxp_get(struct bfa_fcxp_mod_s *fm, bfa_boolean_t req) 532 { 533 struct bfa_fcxp_s *fcxp; 534 535 if (req) 536 bfa_q_deq(&fm->fcxp_req_free_q, &fcxp); 537 else 538 bfa_q_deq(&fm->fcxp_rsp_free_q, &fcxp); 539 540 if (fcxp) 541 list_add_tail(&fcxp->qe, &fm->fcxp_active_q); 542 543 return fcxp; 544 } 545 546 static void 547 bfa_fcxp_init_reqrsp(struct bfa_fcxp_s *fcxp, 548 struct bfa_s *bfa, 549 u8 *use_ibuf, 550 u32 *nr_sgles, 551 bfa_fcxp_get_sgaddr_t *r_sga_cbfn, 552 bfa_fcxp_get_sglen_t *r_sglen_cbfn, 553 struct list_head *r_sgpg_q, 554 int n_sgles, 555 bfa_fcxp_get_sgaddr_t sga_cbfn, 556 bfa_fcxp_get_sglen_t sglen_cbfn) 557 { 558 559 WARN_ON(bfa == NULL); 560 561 bfa_trc(bfa, fcxp->fcxp_tag); 562 563 if (n_sgles == 0) { 564 *use_ibuf = 1; 565 } else { 566 WARN_ON(*sga_cbfn == NULL); 567 WARN_ON(*sglen_cbfn == NULL); 568 569 *use_ibuf = 0; 570 *r_sga_cbfn = sga_cbfn; 571 *r_sglen_cbfn = sglen_cbfn; 572 573 *nr_sgles = n_sgles; 574 575 /* 576 * alloc required sgpgs 577 */ 578 if (n_sgles > BFI_SGE_INLINE) 579 WARN_ON(1); 580 } 581 582 } 583 584 static void 585 bfa_fcxp_init(struct bfa_fcxp_s *fcxp, 586 void *caller, struct bfa_s *bfa, int nreq_sgles, 587 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn, 588 bfa_fcxp_get_sglen_t req_sglen_cbfn, 589 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn, 590 bfa_fcxp_get_sglen_t rsp_sglen_cbfn) 591 { 592 593 WARN_ON(bfa == NULL); 594 595 bfa_trc(bfa, fcxp->fcxp_tag); 596 597 fcxp->caller = caller; 598 599 bfa_fcxp_init_reqrsp(fcxp, bfa, 600 &fcxp->use_ireqbuf, &fcxp->nreq_sgles, &fcxp->req_sga_cbfn, 601 &fcxp->req_sglen_cbfn, &fcxp->req_sgpg_q, 602 nreq_sgles, req_sga_cbfn, req_sglen_cbfn); 603 604 bfa_fcxp_init_reqrsp(fcxp, bfa, 605 &fcxp->use_irspbuf, &fcxp->nrsp_sgles, &fcxp->rsp_sga_cbfn, 606 &fcxp->rsp_sglen_cbfn, &fcxp->rsp_sgpg_q, 607 nrsp_sgles, rsp_sga_cbfn, rsp_sglen_cbfn); 608 609 } 610 611 static void 612 bfa_fcxp_put(struct bfa_fcxp_s *fcxp) 613 { 614 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod; 615 struct bfa_fcxp_wqe_s *wqe; 616 617 if (fcxp->req_rsp) 618 bfa_q_deq(&mod->req_wait_q, &wqe); 619 else 620 bfa_q_deq(&mod->rsp_wait_q, &wqe); 621 622 if (wqe) { 623 bfa_trc(mod->bfa, fcxp->fcxp_tag); 624 625 bfa_fcxp_init(fcxp, wqe->caller, wqe->bfa, wqe->nreq_sgles, 626 wqe->nrsp_sgles, wqe->req_sga_cbfn, 627 wqe->req_sglen_cbfn, wqe->rsp_sga_cbfn, 628 wqe->rsp_sglen_cbfn); 629 630 wqe->alloc_cbfn(wqe->alloc_cbarg, fcxp); 631 return; 632 } 633 634 WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp)); 635 list_del(&fcxp->qe); 636 637 if (fcxp->req_rsp) 638 list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q); 639 else 640 list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q); 641 } 642 643 static void 644 bfa_fcxp_null_comp(void *bfad_fcxp, struct bfa_fcxp_s *fcxp, void *cbarg, 645 bfa_status_t req_status, u32 rsp_len, 646 u32 resid_len, struct fchs_s *rsp_fchs) 647 { 648 /* discarded fcxp completion */ 649 } 650 651 static void 652 __bfa_fcxp_send_cbfn(void *cbarg, bfa_boolean_t complete) 653 { 654 struct bfa_fcxp_s *fcxp = cbarg; 655 656 if (complete) { 657 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg, 658 fcxp->rsp_status, fcxp->rsp_len, 659 fcxp->residue_len, &fcxp->rsp_fchs); 660 } else { 661 bfa_fcxp_free(fcxp); 662 } 663 } 664 665 static void 666 hal_fcxp_send_comp(struct bfa_s *bfa, struct bfi_fcxp_send_rsp_s *fcxp_rsp) 667 { 668 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 669 struct bfa_fcxp_s *fcxp; 670 u16 fcxp_tag = be16_to_cpu(fcxp_rsp->fcxp_tag); 671 672 bfa_trc(bfa, fcxp_tag); 673 674 fcxp_rsp->rsp_len = be32_to_cpu(fcxp_rsp->rsp_len); 675 676 /* 677 * @todo f/w should not set residue to non-0 when everything 678 * is received. 679 */ 680 if (fcxp_rsp->req_status == BFA_STATUS_OK) 681 fcxp_rsp->residue_len = 0; 682 else 683 fcxp_rsp->residue_len = be32_to_cpu(fcxp_rsp->residue_len); 684 685 fcxp = BFA_FCXP_FROM_TAG(mod, fcxp_tag); 686 687 WARN_ON(fcxp->send_cbfn == NULL); 688 689 hal_fcxp_rx_plog(mod->bfa, fcxp, fcxp_rsp); 690 691 if (fcxp->send_cbfn != NULL) { 692 bfa_trc(mod->bfa, (NULL == fcxp->caller)); 693 if (fcxp->caller == NULL) { 694 fcxp->send_cbfn(fcxp->caller, fcxp, fcxp->send_cbarg, 695 fcxp_rsp->req_status, fcxp_rsp->rsp_len, 696 fcxp_rsp->residue_len, &fcxp_rsp->fchs); 697 /* 698 * fcxp automatically freed on return from the callback 699 */ 700 bfa_fcxp_free(fcxp); 701 } else { 702 fcxp->rsp_status = fcxp_rsp->req_status; 703 fcxp->rsp_len = fcxp_rsp->rsp_len; 704 fcxp->residue_len = fcxp_rsp->residue_len; 705 fcxp->rsp_fchs = fcxp_rsp->fchs; 706 707 bfa_cb_queue(bfa, &fcxp->hcb_qe, 708 __bfa_fcxp_send_cbfn, fcxp); 709 } 710 } else { 711 bfa_trc(bfa, (NULL == fcxp->send_cbfn)); 712 } 713 } 714 715 static void 716 hal_fcxp_tx_plog(struct bfa_s *bfa, u32 reqlen, struct bfa_fcxp_s *fcxp, 717 struct fchs_s *fchs) 718 { 719 /* 720 * TODO: TX ox_id 721 */ 722 if (reqlen > 0) { 723 if (fcxp->use_ireqbuf) { 724 u32 pld_w0 = 725 *((u32 *) BFA_FCXP_REQ_PLD(fcxp)); 726 727 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP, 728 BFA_PL_EID_TX, 729 reqlen + sizeof(struct fchs_s), fchs, 730 pld_w0); 731 } else { 732 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, 733 BFA_PL_EID_TX, 734 reqlen + sizeof(struct fchs_s), 735 fchs); 736 } 737 } else { 738 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_TX, 739 reqlen + sizeof(struct fchs_s), fchs); 740 } 741 } 742 743 static void 744 hal_fcxp_rx_plog(struct bfa_s *bfa, struct bfa_fcxp_s *fcxp, 745 struct bfi_fcxp_send_rsp_s *fcxp_rsp) 746 { 747 if (fcxp_rsp->rsp_len > 0) { 748 if (fcxp->use_irspbuf) { 749 u32 pld_w0 = 750 *((u32 *) BFA_FCXP_RSP_PLD(fcxp)); 751 752 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_FCXP, 753 BFA_PL_EID_RX, 754 (u16) fcxp_rsp->rsp_len, 755 &fcxp_rsp->fchs, pld_w0); 756 } else { 757 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, 758 BFA_PL_EID_RX, 759 (u16) fcxp_rsp->rsp_len, 760 &fcxp_rsp->fchs); 761 } 762 } else { 763 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_FCXP, BFA_PL_EID_RX, 764 (u16) fcxp_rsp->rsp_len, &fcxp_rsp->fchs); 765 } 766 } 767 768 /* 769 * Handler to resume sending fcxp when space in available in cpe queue. 770 */ 771 static void 772 bfa_fcxp_qresume(void *cbarg) 773 { 774 struct bfa_fcxp_s *fcxp = cbarg; 775 struct bfa_s *bfa = fcxp->fcxp_mod->bfa; 776 struct bfi_fcxp_send_req_s *send_req; 777 778 fcxp->reqq_waiting = BFA_FALSE; 779 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP); 780 bfa_fcxp_queue(fcxp, send_req); 781 } 782 783 /* 784 * Queue fcxp send request to foimrware. 785 */ 786 static void 787 bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req) 788 { 789 struct bfa_s *bfa = fcxp->fcxp_mod->bfa; 790 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info; 791 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info; 792 struct bfa_rport_s *rport = reqi->bfa_rport; 793 794 bfi_h2i_set(send_req->mh, BFI_MC_FCXP, BFI_FCXP_H2I_SEND_REQ, 795 bfa_fn_lpu(bfa)); 796 797 send_req->fcxp_tag = cpu_to_be16(fcxp->fcxp_tag); 798 if (rport) { 799 send_req->rport_fw_hndl = rport->fw_handle; 800 send_req->max_frmsz = cpu_to_be16(rport->rport_info.max_frmsz); 801 if (send_req->max_frmsz == 0) 802 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ); 803 } else { 804 send_req->rport_fw_hndl = 0; 805 send_req->max_frmsz = cpu_to_be16(FC_MAX_PDUSZ); 806 } 807 808 send_req->vf_id = cpu_to_be16(reqi->vf_id); 809 send_req->lp_fwtag = bfa_lps_get_fwtag(bfa, reqi->lp_tag); 810 send_req->class = reqi->class; 811 send_req->rsp_timeout = rspi->rsp_timeout; 812 send_req->cts = reqi->cts; 813 send_req->fchs = reqi->fchs; 814 815 send_req->req_len = cpu_to_be32(reqi->req_tot_len); 816 send_req->rsp_maxlen = cpu_to_be32(rspi->rsp_maxlen); 817 818 /* 819 * setup req sgles 820 */ 821 if (fcxp->use_ireqbuf == 1) { 822 bfa_alen_set(&send_req->req_alen, reqi->req_tot_len, 823 BFA_FCXP_REQ_PLD_PA(fcxp)); 824 } else { 825 if (fcxp->nreq_sgles > 0) { 826 WARN_ON(fcxp->nreq_sgles != 1); 827 bfa_alen_set(&send_req->req_alen, reqi->req_tot_len, 828 fcxp->req_sga_cbfn(fcxp->caller, 0)); 829 } else { 830 WARN_ON(reqi->req_tot_len != 0); 831 bfa_alen_set(&send_req->rsp_alen, 0, 0); 832 } 833 } 834 835 /* 836 * setup rsp sgles 837 */ 838 if (fcxp->use_irspbuf == 1) { 839 WARN_ON(rspi->rsp_maxlen > BFA_FCXP_MAX_LBUF_SZ); 840 841 bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen, 842 BFA_FCXP_RSP_PLD_PA(fcxp)); 843 } else { 844 if (fcxp->nrsp_sgles > 0) { 845 WARN_ON(fcxp->nrsp_sgles != 1); 846 bfa_alen_set(&send_req->rsp_alen, rspi->rsp_maxlen, 847 fcxp->rsp_sga_cbfn(fcxp->caller, 0)); 848 849 } else { 850 WARN_ON(rspi->rsp_maxlen != 0); 851 bfa_alen_set(&send_req->rsp_alen, 0, 0); 852 } 853 } 854 855 hal_fcxp_tx_plog(bfa, reqi->req_tot_len, fcxp, &reqi->fchs); 856 857 bfa_reqq_produce(bfa, BFA_REQQ_FCXP, send_req->mh); 858 859 bfa_trc(bfa, bfa_reqq_pi(bfa, BFA_REQQ_FCXP)); 860 bfa_trc(bfa, bfa_reqq_ci(bfa, BFA_REQQ_FCXP)); 861 } 862 863 /* 864 * Allocate an FCXP instance to send a response or to send a request 865 * that has a response. Request/response buffers are allocated by caller. 866 * 867 * @param[in] bfa BFA bfa instance 868 * @param[in] nreq_sgles Number of SG elements required for request 869 * buffer. 0, if fcxp internal buffers are used. 870 * Use bfa_fcxp_get_reqbuf() to get the 871 * internal req buffer. 872 * @param[in] req_sgles SG elements describing request buffer. Will be 873 * copied in by BFA and hence can be freed on 874 * return from this function. 875 * @param[in] get_req_sga function ptr to be called to get a request SG 876 * Address (given the sge index). 877 * @param[in] get_req_sglen function ptr to be called to get a request SG 878 * len (given the sge index). 879 * @param[in] get_rsp_sga function ptr to be called to get a response SG 880 * Address (given the sge index). 881 * @param[in] get_rsp_sglen function ptr to be called to get a response SG 882 * len (given the sge index). 883 * @param[in] req Allocated FCXP is used to send req or rsp? 884 * request - BFA_TRUE, response - BFA_FALSE 885 * 886 * @return FCXP instance. NULL on failure. 887 */ 888 struct bfa_fcxp_s * 889 bfa_fcxp_req_rsp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles, 890 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn, 891 bfa_fcxp_get_sglen_t req_sglen_cbfn, 892 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn, 893 bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req) 894 { 895 struct bfa_fcxp_s *fcxp = NULL; 896 897 WARN_ON(bfa == NULL); 898 899 fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa), req); 900 if (fcxp == NULL) 901 return NULL; 902 903 bfa_trc(bfa, fcxp->fcxp_tag); 904 905 bfa_fcxp_init(fcxp, caller, bfa, nreq_sgles, nrsp_sgles, req_sga_cbfn, 906 req_sglen_cbfn, rsp_sga_cbfn, rsp_sglen_cbfn); 907 908 return fcxp; 909 } 910 911 /* 912 * Get the internal request buffer pointer 913 * 914 * @param[in] fcxp BFA fcxp pointer 915 * 916 * @return pointer to the internal request buffer 917 */ 918 void * 919 bfa_fcxp_get_reqbuf(struct bfa_fcxp_s *fcxp) 920 { 921 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod; 922 void *reqbuf; 923 924 WARN_ON(fcxp->use_ireqbuf != 1); 925 reqbuf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag, 926 mod->req_pld_sz + mod->rsp_pld_sz); 927 return reqbuf; 928 } 929 930 u32 931 bfa_fcxp_get_reqbufsz(struct bfa_fcxp_s *fcxp) 932 { 933 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod; 934 935 return mod->req_pld_sz; 936 } 937 938 /* 939 * Get the internal response buffer pointer 940 * 941 * @param[in] fcxp BFA fcxp pointer 942 * 943 * @return pointer to the internal request buffer 944 */ 945 void * 946 bfa_fcxp_get_rspbuf(struct bfa_fcxp_s *fcxp) 947 { 948 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod; 949 void *fcxp_buf; 950 951 WARN_ON(fcxp->use_irspbuf != 1); 952 953 fcxp_buf = bfa_mem_get_dmabuf_kva(mod, fcxp->fcxp_tag, 954 mod->req_pld_sz + mod->rsp_pld_sz); 955 956 /* fcxp_buf = req_buf + rsp_buf :- add req_buf_sz to get to rsp_buf */ 957 return ((u8 *) fcxp_buf) + mod->req_pld_sz; 958 } 959 960 /* 961 * Free the BFA FCXP 962 * 963 * @param[in] fcxp BFA fcxp pointer 964 * 965 * @return void 966 */ 967 void 968 bfa_fcxp_free(struct bfa_fcxp_s *fcxp) 969 { 970 struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod; 971 972 WARN_ON(fcxp == NULL); 973 bfa_trc(mod->bfa, fcxp->fcxp_tag); 974 bfa_fcxp_put(fcxp); 975 } 976 977 /* 978 * Send a FCXP request 979 * 980 * @param[in] fcxp BFA fcxp pointer 981 * @param[in] rport BFA rport pointer. Could be left NULL for WKA rports 982 * @param[in] vf_id virtual Fabric ID 983 * @param[in] lp_tag lport tag 984 * @param[in] cts use Continuous sequence 985 * @param[in] cos fc Class of Service 986 * @param[in] reqlen request length, does not include FCHS length 987 * @param[in] fchs fc Header Pointer. The header content will be copied 988 * in by BFA. 989 * 990 * @param[in] cbfn call back function to be called on receiving 991 * the response 992 * @param[in] cbarg arg for cbfn 993 * @param[in] rsp_timeout 994 * response timeout 995 * 996 * @return bfa_status_t 997 */ 998 void 999 bfa_fcxp_send(struct bfa_fcxp_s *fcxp, struct bfa_rport_s *rport, 1000 u16 vf_id, u8 lp_tag, bfa_boolean_t cts, enum fc_cos cos, 1001 u32 reqlen, struct fchs_s *fchs, bfa_cb_fcxp_send_t cbfn, 1002 void *cbarg, u32 rsp_maxlen, u8 rsp_timeout) 1003 { 1004 struct bfa_s *bfa = fcxp->fcxp_mod->bfa; 1005 struct bfa_fcxp_req_info_s *reqi = &fcxp->req_info; 1006 struct bfa_fcxp_rsp_info_s *rspi = &fcxp->rsp_info; 1007 struct bfi_fcxp_send_req_s *send_req; 1008 1009 bfa_trc(bfa, fcxp->fcxp_tag); 1010 1011 /* 1012 * setup request/response info 1013 */ 1014 reqi->bfa_rport = rport; 1015 reqi->vf_id = vf_id; 1016 reqi->lp_tag = lp_tag; 1017 reqi->class = cos; 1018 rspi->rsp_timeout = rsp_timeout; 1019 reqi->cts = cts; 1020 reqi->fchs = *fchs; 1021 reqi->req_tot_len = reqlen; 1022 rspi->rsp_maxlen = rsp_maxlen; 1023 fcxp->send_cbfn = cbfn ? cbfn : bfa_fcxp_null_comp; 1024 fcxp->send_cbarg = cbarg; 1025 1026 /* 1027 * If no room in CPE queue, wait for space in request queue 1028 */ 1029 send_req = bfa_reqq_next(bfa, BFA_REQQ_FCXP); 1030 if (!send_req) { 1031 bfa_trc(bfa, fcxp->fcxp_tag); 1032 fcxp->reqq_waiting = BFA_TRUE; 1033 bfa_reqq_wait(bfa, BFA_REQQ_FCXP, &fcxp->reqq_wqe); 1034 return; 1035 } 1036 1037 bfa_fcxp_queue(fcxp, send_req); 1038 } 1039 1040 /* 1041 * Abort a BFA FCXP 1042 * 1043 * @param[in] fcxp BFA fcxp pointer 1044 * 1045 * @return void 1046 */ 1047 bfa_status_t 1048 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp) 1049 { 1050 bfa_trc(fcxp->fcxp_mod->bfa, fcxp->fcxp_tag); 1051 WARN_ON(1); 1052 return BFA_STATUS_OK; 1053 } 1054 1055 void 1056 bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe, 1057 bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg, 1058 void *caller, int nreq_sgles, 1059 int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn, 1060 bfa_fcxp_get_sglen_t req_sglen_cbfn, 1061 bfa_fcxp_get_sgaddr_t rsp_sga_cbfn, 1062 bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req) 1063 { 1064 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 1065 1066 if (req) 1067 WARN_ON(!list_empty(&mod->fcxp_req_free_q)); 1068 else 1069 WARN_ON(!list_empty(&mod->fcxp_rsp_free_q)); 1070 1071 wqe->alloc_cbfn = alloc_cbfn; 1072 wqe->alloc_cbarg = alloc_cbarg; 1073 wqe->caller = caller; 1074 wqe->bfa = bfa; 1075 wqe->nreq_sgles = nreq_sgles; 1076 wqe->nrsp_sgles = nrsp_sgles; 1077 wqe->req_sga_cbfn = req_sga_cbfn; 1078 wqe->req_sglen_cbfn = req_sglen_cbfn; 1079 wqe->rsp_sga_cbfn = rsp_sga_cbfn; 1080 wqe->rsp_sglen_cbfn = rsp_sglen_cbfn; 1081 1082 if (req) 1083 list_add_tail(&wqe->qe, &mod->req_wait_q); 1084 else 1085 list_add_tail(&wqe->qe, &mod->rsp_wait_q); 1086 } 1087 1088 void 1089 bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe) 1090 { 1091 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 1092 1093 WARN_ON(!bfa_q_is_on_q(&mod->req_wait_q, wqe) || 1094 !bfa_q_is_on_q(&mod->rsp_wait_q, wqe)); 1095 list_del(&wqe->qe); 1096 } 1097 1098 void 1099 bfa_fcxp_discard(struct bfa_fcxp_s *fcxp) 1100 { 1101 /* 1102 * If waiting for room in request queue, cancel reqq wait 1103 * and free fcxp. 1104 */ 1105 if (fcxp->reqq_waiting) { 1106 fcxp->reqq_waiting = BFA_FALSE; 1107 bfa_reqq_wcancel(&fcxp->reqq_wqe); 1108 bfa_fcxp_free(fcxp); 1109 return; 1110 } 1111 1112 fcxp->send_cbfn = bfa_fcxp_null_comp; 1113 } 1114 1115 void 1116 bfa_fcxp_isr(struct bfa_s *bfa, struct bfi_msg_s *msg) 1117 { 1118 switch (msg->mhdr.msg_id) { 1119 case BFI_FCXP_I2H_SEND_RSP: 1120 hal_fcxp_send_comp(bfa, (struct bfi_fcxp_send_rsp_s *) msg); 1121 break; 1122 1123 default: 1124 bfa_trc(bfa, msg->mhdr.msg_id); 1125 WARN_ON(1); 1126 } 1127 } 1128 1129 u32 1130 bfa_fcxp_get_maxrsp(struct bfa_s *bfa) 1131 { 1132 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 1133 1134 return mod->rsp_pld_sz; 1135 } 1136 1137 void 1138 bfa_fcxp_res_recfg(struct bfa_s *bfa, u16 num_fcxp_fw) 1139 { 1140 struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa); 1141 struct list_head *qe; 1142 int i; 1143 1144 for (i = 0; i < (mod->num_fcxps - num_fcxp_fw); i++) { 1145 if (i < ((mod->num_fcxps - num_fcxp_fw) / 2)) { 1146 bfa_q_deq_tail(&mod->fcxp_req_free_q, &qe); 1147 list_add_tail(qe, &mod->fcxp_req_unused_q); 1148 } else { 1149 bfa_q_deq_tail(&mod->fcxp_rsp_free_q, &qe); 1150 list_add_tail(qe, &mod->fcxp_rsp_unused_q); 1151 } 1152 } 1153 } 1154 1155 /* 1156 * BFA LPS state machine functions 1157 */ 1158 1159 /* 1160 * Init state -- no login 1161 */ 1162 static void 1163 bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event) 1164 { 1165 bfa_trc(lps->bfa, lps->bfa_tag); 1166 bfa_trc(lps->bfa, event); 1167 1168 switch (event) { 1169 case BFA_LPS_SM_LOGIN: 1170 if (bfa_reqq_full(lps->bfa, lps->reqq)) { 1171 bfa_sm_set_state(lps, bfa_lps_sm_loginwait); 1172 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe); 1173 } else { 1174 bfa_sm_set_state(lps, bfa_lps_sm_login); 1175 bfa_lps_send_login(lps); 1176 } 1177 1178 if (lps->fdisc) 1179 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1180 BFA_PL_EID_LOGIN, 0, "FDISC Request"); 1181 else 1182 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1183 BFA_PL_EID_LOGIN, 0, "FLOGI Request"); 1184 break; 1185 1186 case BFA_LPS_SM_LOGOUT: 1187 bfa_lps_logout_comp(lps); 1188 break; 1189 1190 case BFA_LPS_SM_DELETE: 1191 bfa_lps_free(lps); 1192 break; 1193 1194 case BFA_LPS_SM_RX_CVL: 1195 case BFA_LPS_SM_OFFLINE: 1196 break; 1197 1198 case BFA_LPS_SM_FWRSP: 1199 /* 1200 * Could happen when fabric detects loopback and discards 1201 * the lps request. Fw will eventually sent out the timeout 1202 * Just ignore 1203 */ 1204 break; 1205 case BFA_LPS_SM_SET_N2N_PID: 1206 /* 1207 * When topology is set to loop, bfa_lps_set_n2n_pid() sends 1208 * this event. Ignore this event. 1209 */ 1210 break; 1211 1212 default: 1213 bfa_sm_fault(lps->bfa, event); 1214 } 1215 } 1216 1217 /* 1218 * login is in progress -- awaiting response from firmware 1219 */ 1220 static void 1221 bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event) 1222 { 1223 bfa_trc(lps->bfa, lps->bfa_tag); 1224 bfa_trc(lps->bfa, event); 1225 1226 switch (event) { 1227 case BFA_LPS_SM_FWRSP: 1228 if (lps->status == BFA_STATUS_OK) { 1229 bfa_sm_set_state(lps, bfa_lps_sm_online); 1230 if (lps->fdisc) 1231 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1232 BFA_PL_EID_LOGIN, 0, "FDISC Accept"); 1233 else 1234 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1235 BFA_PL_EID_LOGIN, 0, "FLOGI Accept"); 1236 /* If N2N, send the assigned PID to FW */ 1237 bfa_trc(lps->bfa, lps->fport); 1238 bfa_trc(lps->bfa, lps->lp_pid); 1239 1240 if (!lps->fport && lps->lp_pid) 1241 bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID); 1242 } else { 1243 bfa_sm_set_state(lps, bfa_lps_sm_init); 1244 if (lps->fdisc) 1245 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1246 BFA_PL_EID_LOGIN, 0, 1247 "FDISC Fail (RJT or timeout)"); 1248 else 1249 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1250 BFA_PL_EID_LOGIN, 0, 1251 "FLOGI Fail (RJT or timeout)"); 1252 } 1253 bfa_lps_login_comp(lps); 1254 break; 1255 1256 case BFA_LPS_SM_OFFLINE: 1257 case BFA_LPS_SM_DELETE: 1258 bfa_sm_set_state(lps, bfa_lps_sm_init); 1259 break; 1260 1261 case BFA_LPS_SM_SET_N2N_PID: 1262 bfa_trc(lps->bfa, lps->fport); 1263 bfa_trc(lps->bfa, lps->lp_pid); 1264 break; 1265 1266 default: 1267 bfa_sm_fault(lps->bfa, event); 1268 } 1269 } 1270 1271 /* 1272 * login pending - awaiting space in request queue 1273 */ 1274 static void 1275 bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event) 1276 { 1277 bfa_trc(lps->bfa, lps->bfa_tag); 1278 bfa_trc(lps->bfa, event); 1279 1280 switch (event) { 1281 case BFA_LPS_SM_RESUME: 1282 bfa_sm_set_state(lps, bfa_lps_sm_login); 1283 bfa_lps_send_login(lps); 1284 break; 1285 1286 case BFA_LPS_SM_OFFLINE: 1287 case BFA_LPS_SM_DELETE: 1288 bfa_sm_set_state(lps, bfa_lps_sm_init); 1289 bfa_reqq_wcancel(&lps->wqe); 1290 break; 1291 1292 case BFA_LPS_SM_RX_CVL: 1293 /* 1294 * Login was not even sent out; so when getting out 1295 * of this state, it will appear like a login retry 1296 * after Clear virtual link 1297 */ 1298 break; 1299 1300 default: 1301 bfa_sm_fault(lps->bfa, event); 1302 } 1303 } 1304 1305 /* 1306 * login complete 1307 */ 1308 static void 1309 bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event) 1310 { 1311 bfa_trc(lps->bfa, lps->bfa_tag); 1312 bfa_trc(lps->bfa, event); 1313 1314 switch (event) { 1315 case BFA_LPS_SM_LOGOUT: 1316 if (bfa_reqq_full(lps->bfa, lps->reqq)) { 1317 bfa_sm_set_state(lps, bfa_lps_sm_logowait); 1318 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe); 1319 } else { 1320 bfa_sm_set_state(lps, bfa_lps_sm_logout); 1321 bfa_lps_send_logout(lps); 1322 } 1323 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1324 BFA_PL_EID_LOGO, 0, "Logout"); 1325 break; 1326 1327 case BFA_LPS_SM_RX_CVL: 1328 bfa_sm_set_state(lps, bfa_lps_sm_init); 1329 1330 /* Let the vport module know about this event */ 1331 bfa_lps_cvl_event(lps); 1332 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1333 BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx"); 1334 break; 1335 1336 case BFA_LPS_SM_SET_N2N_PID: 1337 if (bfa_reqq_full(lps->bfa, lps->reqq)) { 1338 bfa_sm_set_state(lps, bfa_lps_sm_online_n2n_pid_wait); 1339 bfa_reqq_wait(lps->bfa, lps->reqq, &lps->wqe); 1340 } else 1341 bfa_lps_send_set_n2n_pid(lps); 1342 break; 1343 1344 case BFA_LPS_SM_OFFLINE: 1345 case BFA_LPS_SM_DELETE: 1346 bfa_sm_set_state(lps, bfa_lps_sm_init); 1347 break; 1348 1349 default: 1350 bfa_sm_fault(lps->bfa, event); 1351 } 1352 } 1353 1354 /* 1355 * login complete 1356 */ 1357 static void 1358 bfa_lps_sm_online_n2n_pid_wait(struct bfa_lps_s *lps, enum bfa_lps_event event) 1359 { 1360 bfa_trc(lps->bfa, lps->bfa_tag); 1361 bfa_trc(lps->bfa, event); 1362 1363 switch (event) { 1364 case BFA_LPS_SM_RESUME: 1365 bfa_sm_set_state(lps, bfa_lps_sm_online); 1366 bfa_lps_send_set_n2n_pid(lps); 1367 break; 1368 1369 case BFA_LPS_SM_LOGOUT: 1370 bfa_sm_set_state(lps, bfa_lps_sm_logowait); 1371 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1372 BFA_PL_EID_LOGO, 0, "Logout"); 1373 break; 1374 1375 case BFA_LPS_SM_RX_CVL: 1376 bfa_sm_set_state(lps, bfa_lps_sm_init); 1377 bfa_reqq_wcancel(&lps->wqe); 1378 1379 /* Let the vport module know about this event */ 1380 bfa_lps_cvl_event(lps); 1381 bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS, 1382 BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx"); 1383 break; 1384 1385 case BFA_LPS_SM_OFFLINE: 1386 case BFA_LPS_SM_DELETE: 1387 bfa_sm_set_state(lps, bfa_lps_sm_init); 1388 bfa_reqq_wcancel(&lps->wqe); 1389 break; 1390 1391 default: 1392 bfa_sm_fault(lps->bfa, event); 1393 } 1394 } 1395 1396 /* 1397 * logout in progress - awaiting firmware response 1398 */ 1399 static void 1400 bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event) 1401 { 1402 bfa_trc(lps->bfa, lps->bfa_tag); 1403 bfa_trc(lps->bfa, event); 1404 1405 switch (event) { 1406 case BFA_LPS_SM_FWRSP: 1407 case BFA_LPS_SM_OFFLINE: 1408 bfa_sm_set_state(lps, bfa_lps_sm_init); 1409 bfa_lps_logout_comp(lps); 1410 break; 1411 1412 case BFA_LPS_SM_DELETE: 1413 bfa_sm_set_state(lps, bfa_lps_sm_init); 1414 break; 1415 1416 default: 1417 bfa_sm_fault(lps->bfa, event); 1418 } 1419 } 1420 1421 /* 1422 * logout pending -- awaiting space in request queue 1423 */ 1424 static void 1425 bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event) 1426 { 1427 bfa_trc(lps->bfa, lps->bfa_tag); 1428 bfa_trc(lps->bfa, event); 1429 1430 switch (event) { 1431 case BFA_LPS_SM_RESUME: 1432 bfa_sm_set_state(lps, bfa_lps_sm_logout); 1433 bfa_lps_send_logout(lps); 1434 break; 1435 1436 case BFA_LPS_SM_OFFLINE: 1437 case BFA_LPS_SM_DELETE: 1438 bfa_sm_set_state(lps, bfa_lps_sm_init); 1439 bfa_reqq_wcancel(&lps->wqe); 1440 break; 1441 1442 default: 1443 bfa_sm_fault(lps->bfa, event); 1444 } 1445 } 1446 1447 1448 1449 /* 1450 * lps_pvt BFA LPS private functions 1451 */ 1452 1453 /* 1454 * return memory requirement 1455 */ 1456 void 1457 bfa_lps_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo, 1458 struct bfa_s *bfa) 1459 { 1460 struct bfa_mem_kva_s *lps_kva = BFA_MEM_LPS_KVA(bfa); 1461 1462 if (cfg->drvcfg.min_cfg) 1463 bfa_mem_kva_setup(minfo, lps_kva, 1464 sizeof(struct bfa_lps_s) * BFA_LPS_MIN_LPORTS); 1465 else 1466 bfa_mem_kva_setup(minfo, lps_kva, 1467 sizeof(struct bfa_lps_s) * BFA_LPS_MAX_LPORTS); 1468 } 1469 1470 /* 1471 * bfa module attach at initialization time 1472 */ 1473 void 1474 bfa_lps_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 1475 struct bfa_pcidev_s *pcidev) 1476 { 1477 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1478 struct bfa_lps_s *lps; 1479 int i; 1480 1481 mod->num_lps = BFA_LPS_MAX_LPORTS; 1482 if (cfg->drvcfg.min_cfg) 1483 mod->num_lps = BFA_LPS_MIN_LPORTS; 1484 else 1485 mod->num_lps = BFA_LPS_MAX_LPORTS; 1486 mod->lps_arr = lps = (struct bfa_lps_s *) bfa_mem_kva_curp(mod); 1487 1488 bfa_mem_kva_curp(mod) += mod->num_lps * sizeof(struct bfa_lps_s); 1489 1490 INIT_LIST_HEAD(&mod->lps_free_q); 1491 INIT_LIST_HEAD(&mod->lps_active_q); 1492 INIT_LIST_HEAD(&mod->lps_login_q); 1493 1494 for (i = 0; i < mod->num_lps; i++, lps++) { 1495 lps->bfa = bfa; 1496 lps->bfa_tag = (u8) i; 1497 lps->reqq = BFA_REQQ_LPS; 1498 bfa_reqq_winit(&lps->wqe, bfa_lps_reqq_resume, lps); 1499 list_add_tail(&lps->qe, &mod->lps_free_q); 1500 } 1501 } 1502 1503 /* 1504 * IOC in disabled state -- consider all lps offline 1505 */ 1506 void 1507 bfa_lps_iocdisable(struct bfa_s *bfa) 1508 { 1509 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1510 struct bfa_lps_s *lps; 1511 struct list_head *qe, *qen; 1512 1513 list_for_each_safe(qe, qen, &mod->lps_active_q) { 1514 lps = (struct bfa_lps_s *) qe; 1515 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE); 1516 } 1517 list_for_each_safe(qe, qen, &mod->lps_login_q) { 1518 lps = (struct bfa_lps_s *) qe; 1519 bfa_sm_send_event(lps, BFA_LPS_SM_OFFLINE); 1520 } 1521 list_splice_tail_init(&mod->lps_login_q, &mod->lps_active_q); 1522 } 1523 1524 /* 1525 * Firmware login response 1526 */ 1527 static void 1528 bfa_lps_login_rsp(struct bfa_s *bfa, struct bfi_lps_login_rsp_s *rsp) 1529 { 1530 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1531 struct bfa_lps_s *lps; 1532 1533 WARN_ON(rsp->bfa_tag >= mod->num_lps); 1534 lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag); 1535 1536 lps->status = rsp->status; 1537 switch (rsp->status) { 1538 case BFA_STATUS_OK: 1539 lps->fw_tag = rsp->fw_tag; 1540 lps->fport = rsp->f_port; 1541 if (lps->fport) 1542 lps->lp_pid = rsp->lp_pid; 1543 lps->npiv_en = rsp->npiv_en; 1544 lps->pr_bbcred = be16_to_cpu(rsp->bb_credit); 1545 lps->pr_pwwn = rsp->port_name; 1546 lps->pr_nwwn = rsp->node_name; 1547 lps->auth_req = rsp->auth_req; 1548 lps->lp_mac = rsp->lp_mac; 1549 lps->brcd_switch = rsp->brcd_switch; 1550 lps->fcf_mac = rsp->fcf_mac; 1551 1552 break; 1553 1554 case BFA_STATUS_FABRIC_RJT: 1555 lps->lsrjt_rsn = rsp->lsrjt_rsn; 1556 lps->lsrjt_expl = rsp->lsrjt_expl; 1557 1558 break; 1559 1560 case BFA_STATUS_EPROTOCOL: 1561 lps->ext_status = rsp->ext_status; 1562 1563 break; 1564 1565 case BFA_STATUS_VPORT_MAX: 1566 if (rsp->ext_status) 1567 bfa_lps_no_res(lps, rsp->ext_status); 1568 break; 1569 1570 default: 1571 /* Nothing to do with other status */ 1572 break; 1573 } 1574 1575 list_del(&lps->qe); 1576 list_add_tail(&lps->qe, &mod->lps_active_q); 1577 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP); 1578 } 1579 1580 static void 1581 bfa_lps_no_res(struct bfa_lps_s *first_lps, u8 count) 1582 { 1583 struct bfa_s *bfa = first_lps->bfa; 1584 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1585 struct list_head *qe, *qe_next; 1586 struct bfa_lps_s *lps; 1587 1588 bfa_trc(bfa, count); 1589 1590 qe = bfa_q_next(first_lps); 1591 1592 while (count && qe) { 1593 qe_next = bfa_q_next(qe); 1594 lps = (struct bfa_lps_s *)qe; 1595 bfa_trc(bfa, lps->bfa_tag); 1596 lps->status = first_lps->status; 1597 list_del(&lps->qe); 1598 list_add_tail(&lps->qe, &mod->lps_active_q); 1599 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP); 1600 qe = qe_next; 1601 count--; 1602 } 1603 } 1604 1605 /* 1606 * Firmware logout response 1607 */ 1608 static void 1609 bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp) 1610 { 1611 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1612 struct bfa_lps_s *lps; 1613 1614 WARN_ON(rsp->bfa_tag >= mod->num_lps); 1615 lps = BFA_LPS_FROM_TAG(mod, rsp->bfa_tag); 1616 1617 bfa_sm_send_event(lps, BFA_LPS_SM_FWRSP); 1618 } 1619 1620 /* 1621 * Firmware received a Clear virtual link request (for FCoE) 1622 */ 1623 static void 1624 bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl) 1625 { 1626 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1627 struct bfa_lps_s *lps; 1628 1629 lps = BFA_LPS_FROM_TAG(mod, cvl->bfa_tag); 1630 1631 bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL); 1632 } 1633 1634 /* 1635 * Space is available in request queue, resume queueing request to firmware. 1636 */ 1637 static void 1638 bfa_lps_reqq_resume(void *lps_arg) 1639 { 1640 struct bfa_lps_s *lps = lps_arg; 1641 1642 bfa_sm_send_event(lps, BFA_LPS_SM_RESUME); 1643 } 1644 1645 /* 1646 * lps is freed -- triggered by vport delete 1647 */ 1648 static void 1649 bfa_lps_free(struct bfa_lps_s *lps) 1650 { 1651 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa); 1652 1653 lps->lp_pid = 0; 1654 list_del(&lps->qe); 1655 list_add_tail(&lps->qe, &mod->lps_free_q); 1656 } 1657 1658 /* 1659 * send login request to firmware 1660 */ 1661 static void 1662 bfa_lps_send_login(struct bfa_lps_s *lps) 1663 { 1664 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(lps->bfa); 1665 struct bfi_lps_login_req_s *m; 1666 1667 m = bfa_reqq_next(lps->bfa, lps->reqq); 1668 WARN_ON(!m); 1669 1670 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGIN_REQ, 1671 bfa_fn_lpu(lps->bfa)); 1672 1673 m->bfa_tag = lps->bfa_tag; 1674 m->alpa = lps->alpa; 1675 m->pdu_size = cpu_to_be16(lps->pdusz); 1676 m->pwwn = lps->pwwn; 1677 m->nwwn = lps->nwwn; 1678 m->fdisc = lps->fdisc; 1679 m->auth_en = lps->auth_en; 1680 1681 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh); 1682 list_del(&lps->qe); 1683 list_add_tail(&lps->qe, &mod->lps_login_q); 1684 } 1685 1686 /* 1687 * send logout request to firmware 1688 */ 1689 static void 1690 bfa_lps_send_logout(struct bfa_lps_s *lps) 1691 { 1692 struct bfi_lps_logout_req_s *m; 1693 1694 m = bfa_reqq_next(lps->bfa, lps->reqq); 1695 WARN_ON(!m); 1696 1697 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_LOGOUT_REQ, 1698 bfa_fn_lpu(lps->bfa)); 1699 1700 m->fw_tag = lps->fw_tag; 1701 m->port_name = lps->pwwn; 1702 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh); 1703 } 1704 1705 /* 1706 * send n2n pid set request to firmware 1707 */ 1708 static void 1709 bfa_lps_send_set_n2n_pid(struct bfa_lps_s *lps) 1710 { 1711 struct bfi_lps_n2n_pid_req_s *m; 1712 1713 m = bfa_reqq_next(lps->bfa, lps->reqq); 1714 WARN_ON(!m); 1715 1716 bfi_h2i_set(m->mh, BFI_MC_LPS, BFI_LPS_H2I_N2N_PID_REQ, 1717 bfa_fn_lpu(lps->bfa)); 1718 1719 m->fw_tag = lps->fw_tag; 1720 m->lp_pid = lps->lp_pid; 1721 bfa_reqq_produce(lps->bfa, lps->reqq, m->mh); 1722 } 1723 1724 /* 1725 * Indirect login completion handler for non-fcs 1726 */ 1727 static void 1728 bfa_lps_login_comp_cb(void *arg, bfa_boolean_t complete) 1729 { 1730 struct bfa_lps_s *lps = arg; 1731 1732 if (!complete) 1733 return; 1734 1735 if (lps->fdisc) 1736 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status); 1737 else 1738 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status); 1739 } 1740 1741 /* 1742 * Login completion handler -- direct call for fcs, queue for others 1743 */ 1744 static void 1745 bfa_lps_login_comp(struct bfa_lps_s *lps) 1746 { 1747 if (!lps->bfa->fcs) { 1748 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_login_comp_cb, 1749 lps); 1750 return; 1751 } 1752 1753 if (lps->fdisc) 1754 bfa_cb_lps_fdisc_comp(lps->bfa->bfad, lps->uarg, lps->status); 1755 else 1756 bfa_cb_lps_flogi_comp(lps->bfa->bfad, lps->uarg, lps->status); 1757 } 1758 1759 /* 1760 * Indirect logout completion handler for non-fcs 1761 */ 1762 static void 1763 bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete) 1764 { 1765 struct bfa_lps_s *lps = arg; 1766 1767 if (!complete) 1768 return; 1769 1770 if (lps->fdisc) 1771 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg); 1772 else 1773 bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg); 1774 } 1775 1776 /* 1777 * Logout completion handler -- direct call for fcs, queue for others 1778 */ 1779 static void 1780 bfa_lps_logout_comp(struct bfa_lps_s *lps) 1781 { 1782 if (!lps->bfa->fcs) { 1783 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_logout_comp_cb, 1784 lps); 1785 return; 1786 } 1787 if (lps->fdisc) 1788 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg); 1789 } 1790 1791 /* 1792 * Clear virtual link completion handler for non-fcs 1793 */ 1794 static void 1795 bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete) 1796 { 1797 struct bfa_lps_s *lps = arg; 1798 1799 if (!complete) 1800 return; 1801 1802 /* Clear virtual link to base port will result in link down */ 1803 if (lps->fdisc) 1804 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg); 1805 } 1806 1807 /* 1808 * Received Clear virtual link event --direct call for fcs, 1809 * queue for others 1810 */ 1811 static void 1812 bfa_lps_cvl_event(struct bfa_lps_s *lps) 1813 { 1814 if (!lps->bfa->fcs) { 1815 bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb, 1816 lps); 1817 return; 1818 } 1819 1820 /* Clear virtual link to base port will result in link down */ 1821 if (lps->fdisc) 1822 bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg); 1823 } 1824 1825 1826 1827 /* 1828 * lps_public BFA LPS public functions 1829 */ 1830 1831 u32 1832 bfa_lps_get_max_vport(struct bfa_s *bfa) 1833 { 1834 if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT) 1835 return BFA_LPS_MAX_VPORTS_SUPP_CT; 1836 else 1837 return BFA_LPS_MAX_VPORTS_SUPP_CB; 1838 } 1839 1840 /* 1841 * Allocate a lport srvice tag. 1842 */ 1843 struct bfa_lps_s * 1844 bfa_lps_alloc(struct bfa_s *bfa) 1845 { 1846 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1847 struct bfa_lps_s *lps = NULL; 1848 1849 bfa_q_deq(&mod->lps_free_q, &lps); 1850 1851 if (lps == NULL) 1852 return NULL; 1853 1854 list_add_tail(&lps->qe, &mod->lps_active_q); 1855 1856 bfa_sm_set_state(lps, bfa_lps_sm_init); 1857 return lps; 1858 } 1859 1860 /* 1861 * Free lport service tag. This can be called anytime after an alloc. 1862 * No need to wait for any pending login/logout completions. 1863 */ 1864 void 1865 bfa_lps_delete(struct bfa_lps_s *lps) 1866 { 1867 bfa_sm_send_event(lps, BFA_LPS_SM_DELETE); 1868 } 1869 1870 /* 1871 * Initiate a lport login. 1872 */ 1873 void 1874 bfa_lps_flogi(struct bfa_lps_s *lps, void *uarg, u8 alpa, u16 pdusz, 1875 wwn_t pwwn, wwn_t nwwn, bfa_boolean_t auth_en) 1876 { 1877 lps->uarg = uarg; 1878 lps->alpa = alpa; 1879 lps->pdusz = pdusz; 1880 lps->pwwn = pwwn; 1881 lps->nwwn = nwwn; 1882 lps->fdisc = BFA_FALSE; 1883 lps->auth_en = auth_en; 1884 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN); 1885 } 1886 1887 /* 1888 * Initiate a lport fdisc login. 1889 */ 1890 void 1891 bfa_lps_fdisc(struct bfa_lps_s *lps, void *uarg, u16 pdusz, wwn_t pwwn, 1892 wwn_t nwwn) 1893 { 1894 lps->uarg = uarg; 1895 lps->alpa = 0; 1896 lps->pdusz = pdusz; 1897 lps->pwwn = pwwn; 1898 lps->nwwn = nwwn; 1899 lps->fdisc = BFA_TRUE; 1900 lps->auth_en = BFA_FALSE; 1901 bfa_sm_send_event(lps, BFA_LPS_SM_LOGIN); 1902 } 1903 1904 1905 /* 1906 * Initiate a lport FDSIC logout. 1907 */ 1908 void 1909 bfa_lps_fdisclogo(struct bfa_lps_s *lps) 1910 { 1911 bfa_sm_send_event(lps, BFA_LPS_SM_LOGOUT); 1912 } 1913 1914 u8 1915 bfa_lps_get_fwtag(struct bfa_s *bfa, u8 lp_tag) 1916 { 1917 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1918 1919 return BFA_LPS_FROM_TAG(mod, lp_tag)->fw_tag; 1920 } 1921 1922 /* 1923 * Return lport services tag given the pid 1924 */ 1925 u8 1926 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid) 1927 { 1928 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1929 struct bfa_lps_s *lps; 1930 int i; 1931 1932 for (i = 0, lps = mod->lps_arr; i < mod->num_lps; i++, lps++) { 1933 if (lps->lp_pid == pid) 1934 return lps->bfa_tag; 1935 } 1936 1937 /* Return base port tag anyway */ 1938 return 0; 1939 } 1940 1941 1942 /* 1943 * return port id assigned to the base lport 1944 */ 1945 u32 1946 bfa_lps_get_base_pid(struct bfa_s *bfa) 1947 { 1948 struct bfa_lps_mod_s *mod = BFA_LPS_MOD(bfa); 1949 1950 return BFA_LPS_FROM_TAG(mod, 0)->lp_pid; 1951 } 1952 1953 /* 1954 * Set PID in case of n2n (which is assigned during PLOGI) 1955 */ 1956 void 1957 bfa_lps_set_n2n_pid(struct bfa_lps_s *lps, uint32_t n2n_pid) 1958 { 1959 bfa_trc(lps->bfa, lps->bfa_tag); 1960 bfa_trc(lps->bfa, n2n_pid); 1961 1962 lps->lp_pid = n2n_pid; 1963 bfa_sm_send_event(lps, BFA_LPS_SM_SET_N2N_PID); 1964 } 1965 1966 /* 1967 * LPS firmware message class handler. 1968 */ 1969 void 1970 bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m) 1971 { 1972 union bfi_lps_i2h_msg_u msg; 1973 1974 bfa_trc(bfa, m->mhdr.msg_id); 1975 msg.msg = m; 1976 1977 switch (m->mhdr.msg_id) { 1978 case BFI_LPS_I2H_LOGIN_RSP: 1979 bfa_lps_login_rsp(bfa, msg.login_rsp); 1980 break; 1981 1982 case BFI_LPS_I2H_LOGOUT_RSP: 1983 bfa_lps_logout_rsp(bfa, msg.logout_rsp); 1984 break; 1985 1986 case BFI_LPS_I2H_CVL_EVENT: 1987 bfa_lps_rx_cvl_event(bfa, msg.cvl_event); 1988 break; 1989 1990 default: 1991 bfa_trc(bfa, m->mhdr.msg_id); 1992 WARN_ON(1); 1993 } 1994 } 1995 1996 static void 1997 bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event) 1998 { 1999 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2000 struct bfa_aen_entry_s *aen_entry; 2001 2002 bfad_get_aen_entry(bfad, aen_entry); 2003 if (!aen_entry) 2004 return; 2005 2006 aen_entry->aen_data.port.ioc_type = bfa_get_type(fcport->bfa); 2007 aen_entry->aen_data.port.pwwn = fcport->pwwn; 2008 2009 /* Send the AEN notification */ 2010 bfad_im_post_vendor_event(aen_entry, bfad, ++fcport->bfa->bfa_aen_seq, 2011 BFA_AEN_CAT_PORT, event); 2012 } 2013 2014 /* 2015 * FC PORT state machine functions 2016 */ 2017 static void 2018 bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport, 2019 enum bfa_fcport_sm_event event) 2020 { 2021 bfa_trc(fcport->bfa, event); 2022 2023 switch (event) { 2024 case BFA_FCPORT_SM_START: 2025 /* 2026 * Start event after IOC is configured and BFA is started. 2027 */ 2028 fcport->use_flash_cfg = BFA_TRUE; 2029 2030 if (bfa_fcport_send_enable(fcport)) { 2031 bfa_trc(fcport->bfa, BFA_TRUE); 2032 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2033 } else { 2034 bfa_trc(fcport->bfa, BFA_FALSE); 2035 bfa_sm_set_state(fcport, 2036 bfa_fcport_sm_enabling_qwait); 2037 } 2038 break; 2039 2040 case BFA_FCPORT_SM_ENABLE: 2041 /* 2042 * Port is persistently configured to be in enabled state. Do 2043 * not change state. Port enabling is done when START event is 2044 * received. 2045 */ 2046 break; 2047 2048 case BFA_FCPORT_SM_DISABLE: 2049 /* 2050 * If a port is persistently configured to be disabled, the 2051 * first event will a port disable request. 2052 */ 2053 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled); 2054 break; 2055 2056 case BFA_FCPORT_SM_HWFAIL: 2057 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2058 break; 2059 2060 default: 2061 bfa_sm_fault(fcport->bfa, event); 2062 } 2063 } 2064 2065 static void 2066 bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport, 2067 enum bfa_fcport_sm_event event) 2068 { 2069 char pwwn_buf[BFA_STRING_32]; 2070 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2071 bfa_trc(fcport->bfa, event); 2072 2073 switch (event) { 2074 case BFA_FCPORT_SM_QRESUME: 2075 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2076 bfa_fcport_send_enable(fcport); 2077 break; 2078 2079 case BFA_FCPORT_SM_STOP: 2080 bfa_reqq_wcancel(&fcport->reqq_wait); 2081 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2082 break; 2083 2084 case BFA_FCPORT_SM_ENABLE: 2085 /* 2086 * Already enable is in progress. 2087 */ 2088 break; 2089 2090 case BFA_FCPORT_SM_DISABLE: 2091 /* 2092 * Just send disable request to firmware when room becomes 2093 * available in request queue. 2094 */ 2095 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled); 2096 bfa_reqq_wcancel(&fcport->reqq_wait); 2097 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2098 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 2099 wwn2str(pwwn_buf, fcport->pwwn); 2100 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2101 "Base port disabled: WWN = %s\n", pwwn_buf); 2102 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE); 2103 break; 2104 2105 case BFA_FCPORT_SM_LINKUP: 2106 case BFA_FCPORT_SM_LINKDOWN: 2107 /* 2108 * Possible to get link events when doing back-to-back 2109 * enable/disables. 2110 */ 2111 break; 2112 2113 case BFA_FCPORT_SM_HWFAIL: 2114 bfa_reqq_wcancel(&fcport->reqq_wait); 2115 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2116 break; 2117 2118 case BFA_FCPORT_SM_FAA_MISCONFIG: 2119 bfa_fcport_reset_linkinfo(fcport); 2120 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2121 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig); 2122 break; 2123 2124 default: 2125 bfa_sm_fault(fcport->bfa, event); 2126 } 2127 } 2128 2129 static void 2130 bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport, 2131 enum bfa_fcport_sm_event event) 2132 { 2133 char pwwn_buf[BFA_STRING_32]; 2134 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2135 bfa_trc(fcport->bfa, event); 2136 2137 switch (event) { 2138 case BFA_FCPORT_SM_FWRSP: 2139 case BFA_FCPORT_SM_LINKDOWN: 2140 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown); 2141 break; 2142 2143 case BFA_FCPORT_SM_LINKUP: 2144 bfa_fcport_update_linkinfo(fcport); 2145 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup); 2146 2147 WARN_ON(!fcport->event_cbfn); 2148 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE); 2149 break; 2150 2151 case BFA_FCPORT_SM_ENABLE: 2152 /* 2153 * Already being enabled. 2154 */ 2155 break; 2156 2157 case BFA_FCPORT_SM_DISABLE: 2158 if (bfa_fcport_send_disable(fcport)) 2159 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling); 2160 else 2161 bfa_sm_set_state(fcport, 2162 bfa_fcport_sm_disabling_qwait); 2163 2164 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2165 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 2166 wwn2str(pwwn_buf, fcport->pwwn); 2167 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2168 "Base port disabled: WWN = %s\n", pwwn_buf); 2169 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE); 2170 break; 2171 2172 case BFA_FCPORT_SM_STOP: 2173 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2174 break; 2175 2176 case BFA_FCPORT_SM_HWFAIL: 2177 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2178 break; 2179 2180 case BFA_FCPORT_SM_FAA_MISCONFIG: 2181 bfa_fcport_reset_linkinfo(fcport); 2182 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2183 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig); 2184 break; 2185 2186 default: 2187 bfa_sm_fault(fcport->bfa, event); 2188 } 2189 } 2190 2191 static void 2192 bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport, 2193 enum bfa_fcport_sm_event event) 2194 { 2195 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event; 2196 char pwwn_buf[BFA_STRING_32]; 2197 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2198 2199 bfa_trc(fcport->bfa, event); 2200 2201 switch (event) { 2202 case BFA_FCPORT_SM_LINKUP: 2203 bfa_fcport_update_linkinfo(fcport); 2204 bfa_sm_set_state(fcport, bfa_fcport_sm_linkup); 2205 WARN_ON(!fcport->event_cbfn); 2206 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2207 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup"); 2208 if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) { 2209 2210 bfa_trc(fcport->bfa, 2211 pevent->link_state.attr.vc_fcf.fcf.fipenabled); 2212 bfa_trc(fcport->bfa, 2213 pevent->link_state.attr.vc_fcf.fcf.fipfailed); 2214 2215 if (pevent->link_state.attr.vc_fcf.fcf.fipfailed) 2216 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2217 BFA_PL_EID_FIP_FCF_DISC, 0, 2218 "FIP FCF Discovery Failed"); 2219 else 2220 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2221 BFA_PL_EID_FIP_FCF_DISC, 0, 2222 "FIP FCF Discovered"); 2223 } 2224 2225 bfa_fcport_scn(fcport, BFA_PORT_LINKUP, BFA_FALSE); 2226 wwn2str(pwwn_buf, fcport->pwwn); 2227 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2228 "Base port online: WWN = %s\n", pwwn_buf); 2229 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE); 2230 2231 /* If QoS is enabled and it is not online, send AEN */ 2232 if (fcport->cfg.qos_enabled && 2233 fcport->qos_attr.state != BFA_QOS_ONLINE) 2234 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG); 2235 break; 2236 2237 case BFA_FCPORT_SM_LINKDOWN: 2238 /* 2239 * Possible to get link down event. 2240 */ 2241 break; 2242 2243 case BFA_FCPORT_SM_ENABLE: 2244 /* 2245 * Already enabled. 2246 */ 2247 break; 2248 2249 case BFA_FCPORT_SM_DISABLE: 2250 if (bfa_fcport_send_disable(fcport)) 2251 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling); 2252 else 2253 bfa_sm_set_state(fcport, 2254 bfa_fcport_sm_disabling_qwait); 2255 2256 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2257 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 2258 wwn2str(pwwn_buf, fcport->pwwn); 2259 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2260 "Base port disabled: WWN = %s\n", pwwn_buf); 2261 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE); 2262 break; 2263 2264 case BFA_FCPORT_SM_STOP: 2265 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2266 break; 2267 2268 case BFA_FCPORT_SM_HWFAIL: 2269 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2270 break; 2271 2272 case BFA_FCPORT_SM_FAA_MISCONFIG: 2273 bfa_fcport_reset_linkinfo(fcport); 2274 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2275 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig); 2276 break; 2277 2278 default: 2279 bfa_sm_fault(fcport->bfa, event); 2280 } 2281 } 2282 2283 static void 2284 bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport, 2285 enum bfa_fcport_sm_event event) 2286 { 2287 char pwwn_buf[BFA_STRING_32]; 2288 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2289 2290 bfa_trc(fcport->bfa, event); 2291 2292 switch (event) { 2293 case BFA_FCPORT_SM_ENABLE: 2294 /* 2295 * Already enabled. 2296 */ 2297 break; 2298 2299 case BFA_FCPORT_SM_DISABLE: 2300 if (bfa_fcport_send_disable(fcport)) 2301 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling); 2302 else 2303 bfa_sm_set_state(fcport, 2304 bfa_fcport_sm_disabling_qwait); 2305 2306 bfa_fcport_reset_linkinfo(fcport); 2307 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE); 2308 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2309 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 2310 wwn2str(pwwn_buf, fcport->pwwn); 2311 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2312 "Base port offline: WWN = %s\n", pwwn_buf); 2313 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE); 2314 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2315 "Base port disabled: WWN = %s\n", pwwn_buf); 2316 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE); 2317 break; 2318 2319 case BFA_FCPORT_SM_LINKDOWN: 2320 bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown); 2321 bfa_fcport_reset_linkinfo(fcport); 2322 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE); 2323 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2324 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown"); 2325 wwn2str(pwwn_buf, fcport->pwwn); 2326 if (BFA_PORT_IS_DISABLED(fcport->bfa)) { 2327 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2328 "Base port offline: WWN = %s\n", pwwn_buf); 2329 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE); 2330 } else { 2331 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 2332 "Base port (WWN = %s) " 2333 "lost fabric connectivity\n", pwwn_buf); 2334 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2335 } 2336 break; 2337 2338 case BFA_FCPORT_SM_STOP: 2339 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2340 bfa_fcport_reset_linkinfo(fcport); 2341 wwn2str(pwwn_buf, fcport->pwwn); 2342 if (BFA_PORT_IS_DISABLED(fcport->bfa)) { 2343 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2344 "Base port offline: WWN = %s\n", pwwn_buf); 2345 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE); 2346 } else { 2347 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 2348 "Base port (WWN = %s) " 2349 "lost fabric connectivity\n", pwwn_buf); 2350 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2351 } 2352 break; 2353 2354 case BFA_FCPORT_SM_HWFAIL: 2355 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2356 bfa_fcport_reset_linkinfo(fcport); 2357 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE); 2358 wwn2str(pwwn_buf, fcport->pwwn); 2359 if (BFA_PORT_IS_DISABLED(fcport->bfa)) { 2360 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2361 "Base port offline: WWN = %s\n", pwwn_buf); 2362 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE); 2363 } else { 2364 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 2365 "Base port (WWN = %s) " 2366 "lost fabric connectivity\n", pwwn_buf); 2367 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2368 } 2369 break; 2370 2371 case BFA_FCPORT_SM_FAA_MISCONFIG: 2372 bfa_fcport_reset_linkinfo(fcport); 2373 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2374 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig); 2375 break; 2376 2377 default: 2378 bfa_sm_fault(fcport->bfa, event); 2379 } 2380 } 2381 2382 static void 2383 bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport, 2384 enum bfa_fcport_sm_event event) 2385 { 2386 bfa_trc(fcport->bfa, event); 2387 2388 switch (event) { 2389 case BFA_FCPORT_SM_QRESUME: 2390 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling); 2391 bfa_fcport_send_disable(fcport); 2392 break; 2393 2394 case BFA_FCPORT_SM_STOP: 2395 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2396 bfa_reqq_wcancel(&fcport->reqq_wait); 2397 break; 2398 2399 case BFA_FCPORT_SM_ENABLE: 2400 bfa_sm_set_state(fcport, bfa_fcport_sm_toggling_qwait); 2401 break; 2402 2403 case BFA_FCPORT_SM_DISABLE: 2404 /* 2405 * Already being disabled. 2406 */ 2407 break; 2408 2409 case BFA_FCPORT_SM_LINKUP: 2410 case BFA_FCPORT_SM_LINKDOWN: 2411 /* 2412 * Possible to get link events when doing back-to-back 2413 * enable/disables. 2414 */ 2415 break; 2416 2417 case BFA_FCPORT_SM_HWFAIL: 2418 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2419 bfa_reqq_wcancel(&fcport->reqq_wait); 2420 break; 2421 2422 case BFA_FCPORT_SM_FAA_MISCONFIG: 2423 bfa_fcport_reset_linkinfo(fcport); 2424 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT); 2425 bfa_sm_set_state(fcport, bfa_fcport_sm_faa_misconfig); 2426 break; 2427 2428 default: 2429 bfa_sm_fault(fcport->bfa, event); 2430 } 2431 } 2432 2433 static void 2434 bfa_fcport_sm_toggling_qwait(struct bfa_fcport_s *fcport, 2435 enum bfa_fcport_sm_event event) 2436 { 2437 bfa_trc(fcport->bfa, event); 2438 2439 switch (event) { 2440 case BFA_FCPORT_SM_QRESUME: 2441 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling); 2442 bfa_fcport_send_disable(fcport); 2443 if (bfa_fcport_send_enable(fcport)) 2444 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2445 else 2446 bfa_sm_set_state(fcport, 2447 bfa_fcport_sm_enabling_qwait); 2448 break; 2449 2450 case BFA_FCPORT_SM_STOP: 2451 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2452 bfa_reqq_wcancel(&fcport->reqq_wait); 2453 break; 2454 2455 case BFA_FCPORT_SM_ENABLE: 2456 break; 2457 2458 case BFA_FCPORT_SM_DISABLE: 2459 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait); 2460 break; 2461 2462 case BFA_FCPORT_SM_LINKUP: 2463 case BFA_FCPORT_SM_LINKDOWN: 2464 /* 2465 * Possible to get link events when doing back-to-back 2466 * enable/disables. 2467 */ 2468 break; 2469 2470 case BFA_FCPORT_SM_HWFAIL: 2471 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2472 bfa_reqq_wcancel(&fcport->reqq_wait); 2473 break; 2474 2475 default: 2476 bfa_sm_fault(fcport->bfa, event); 2477 } 2478 } 2479 2480 static void 2481 bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport, 2482 enum bfa_fcport_sm_event event) 2483 { 2484 char pwwn_buf[BFA_STRING_32]; 2485 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2486 bfa_trc(fcport->bfa, event); 2487 2488 switch (event) { 2489 case BFA_FCPORT_SM_FWRSP: 2490 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled); 2491 break; 2492 2493 case BFA_FCPORT_SM_DISABLE: 2494 /* 2495 * Already being disabled. 2496 */ 2497 break; 2498 2499 case BFA_FCPORT_SM_ENABLE: 2500 if (bfa_fcport_send_enable(fcport)) 2501 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2502 else 2503 bfa_sm_set_state(fcport, 2504 bfa_fcport_sm_enabling_qwait); 2505 2506 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2507 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable"); 2508 wwn2str(pwwn_buf, fcport->pwwn); 2509 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2510 "Base port enabled: WWN = %s\n", pwwn_buf); 2511 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE); 2512 break; 2513 2514 case BFA_FCPORT_SM_STOP: 2515 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2516 break; 2517 2518 case BFA_FCPORT_SM_LINKUP: 2519 case BFA_FCPORT_SM_LINKDOWN: 2520 /* 2521 * Possible to get link events when doing back-to-back 2522 * enable/disables. 2523 */ 2524 break; 2525 2526 case BFA_FCPORT_SM_HWFAIL: 2527 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2528 break; 2529 2530 default: 2531 bfa_sm_fault(fcport->bfa, event); 2532 } 2533 } 2534 2535 static void 2536 bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport, 2537 enum bfa_fcport_sm_event event) 2538 { 2539 char pwwn_buf[BFA_STRING_32]; 2540 struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad; 2541 bfa_trc(fcport->bfa, event); 2542 2543 switch (event) { 2544 case BFA_FCPORT_SM_START: 2545 /* 2546 * Ignore start event for a port that is disabled. 2547 */ 2548 break; 2549 2550 case BFA_FCPORT_SM_STOP: 2551 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2552 break; 2553 2554 case BFA_FCPORT_SM_ENABLE: 2555 if (bfa_fcport_send_enable(fcport)) 2556 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2557 else 2558 bfa_sm_set_state(fcport, 2559 bfa_fcport_sm_enabling_qwait); 2560 2561 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2562 BFA_PL_EID_PORT_ENABLE, 0, "Port Enable"); 2563 wwn2str(pwwn_buf, fcport->pwwn); 2564 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 2565 "Base port enabled: WWN = %s\n", pwwn_buf); 2566 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE); 2567 break; 2568 2569 case BFA_FCPORT_SM_DISABLE: 2570 /* 2571 * Already disabled. 2572 */ 2573 break; 2574 2575 case BFA_FCPORT_SM_HWFAIL: 2576 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2577 break; 2578 2579 case BFA_FCPORT_SM_DPORTENABLE: 2580 bfa_sm_set_state(fcport, bfa_fcport_sm_dport); 2581 break; 2582 2583 case BFA_FCPORT_SM_DDPORTENABLE: 2584 bfa_sm_set_state(fcport, bfa_fcport_sm_ddport); 2585 break; 2586 2587 default: 2588 bfa_sm_fault(fcport->bfa, event); 2589 } 2590 } 2591 2592 static void 2593 bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport, 2594 enum bfa_fcport_sm_event event) 2595 { 2596 bfa_trc(fcport->bfa, event); 2597 2598 switch (event) { 2599 case BFA_FCPORT_SM_START: 2600 if (bfa_fcport_send_enable(fcport)) 2601 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2602 else 2603 bfa_sm_set_state(fcport, 2604 bfa_fcport_sm_enabling_qwait); 2605 break; 2606 2607 default: 2608 /* 2609 * Ignore all other events. 2610 */ 2611 ; 2612 } 2613 } 2614 2615 /* 2616 * Port is enabled. IOC is down/failed. 2617 */ 2618 static void 2619 bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport, 2620 enum bfa_fcport_sm_event event) 2621 { 2622 bfa_trc(fcport->bfa, event); 2623 2624 switch (event) { 2625 case BFA_FCPORT_SM_START: 2626 if (bfa_fcport_send_enable(fcport)) 2627 bfa_sm_set_state(fcport, bfa_fcport_sm_enabling); 2628 else 2629 bfa_sm_set_state(fcport, 2630 bfa_fcport_sm_enabling_qwait); 2631 break; 2632 2633 default: 2634 /* 2635 * Ignore all events. 2636 */ 2637 ; 2638 } 2639 } 2640 2641 /* 2642 * Port is disabled. IOC is down/failed. 2643 */ 2644 static void 2645 bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport, 2646 enum bfa_fcport_sm_event event) 2647 { 2648 bfa_trc(fcport->bfa, event); 2649 2650 switch (event) { 2651 case BFA_FCPORT_SM_START: 2652 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled); 2653 break; 2654 2655 case BFA_FCPORT_SM_ENABLE: 2656 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2657 break; 2658 2659 default: 2660 /* 2661 * Ignore all events. 2662 */ 2663 ; 2664 } 2665 } 2666 2667 static void 2668 bfa_fcport_sm_dport(struct bfa_fcport_s *fcport, enum bfa_fcport_sm_event event) 2669 { 2670 bfa_trc(fcport->bfa, event); 2671 2672 switch (event) { 2673 case BFA_FCPORT_SM_DPORTENABLE: 2674 case BFA_FCPORT_SM_DISABLE: 2675 case BFA_FCPORT_SM_ENABLE: 2676 case BFA_FCPORT_SM_START: 2677 /* 2678 * Ignore event for a port that is dport 2679 */ 2680 break; 2681 2682 case BFA_FCPORT_SM_STOP: 2683 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2684 break; 2685 2686 case BFA_FCPORT_SM_HWFAIL: 2687 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2688 break; 2689 2690 case BFA_FCPORT_SM_DPORTDISABLE: 2691 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled); 2692 break; 2693 2694 default: 2695 bfa_sm_fault(fcport->bfa, event); 2696 } 2697 } 2698 2699 static void 2700 bfa_fcport_sm_ddport(struct bfa_fcport_s *fcport, 2701 enum bfa_fcport_sm_event event) 2702 { 2703 bfa_trc(fcport->bfa, event); 2704 2705 switch (event) { 2706 case BFA_FCPORT_SM_DISABLE: 2707 case BFA_FCPORT_SM_DDPORTDISABLE: 2708 bfa_sm_set_state(fcport, bfa_fcport_sm_disabled); 2709 break; 2710 2711 case BFA_FCPORT_SM_DPORTENABLE: 2712 case BFA_FCPORT_SM_DPORTDISABLE: 2713 case BFA_FCPORT_SM_ENABLE: 2714 case BFA_FCPORT_SM_START: 2715 /* 2716 * Ignore event for a port that is ddport 2717 */ 2718 break; 2719 2720 case BFA_FCPORT_SM_STOP: 2721 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2722 break; 2723 2724 case BFA_FCPORT_SM_HWFAIL: 2725 bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail); 2726 break; 2727 2728 default: 2729 bfa_sm_fault(fcport->bfa, event); 2730 } 2731 } 2732 2733 static void 2734 bfa_fcport_sm_faa_misconfig(struct bfa_fcport_s *fcport, 2735 enum bfa_fcport_sm_event event) 2736 { 2737 bfa_trc(fcport->bfa, event); 2738 2739 switch (event) { 2740 case BFA_FCPORT_SM_DPORTENABLE: 2741 case BFA_FCPORT_SM_ENABLE: 2742 case BFA_FCPORT_SM_START: 2743 /* 2744 * Ignore event for a port as there is FAA misconfig 2745 */ 2746 break; 2747 2748 case BFA_FCPORT_SM_DISABLE: 2749 if (bfa_fcport_send_disable(fcport)) 2750 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling); 2751 else 2752 bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait); 2753 2754 bfa_fcport_reset_linkinfo(fcport); 2755 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE); 2756 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 2757 BFA_PL_EID_PORT_DISABLE, 0, "Port Disable"); 2758 bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE); 2759 break; 2760 2761 case BFA_FCPORT_SM_STOP: 2762 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped); 2763 break; 2764 2765 case BFA_FCPORT_SM_HWFAIL: 2766 bfa_fcport_reset_linkinfo(fcport); 2767 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE); 2768 bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown); 2769 break; 2770 2771 default: 2772 bfa_sm_fault(fcport->bfa, event); 2773 } 2774 } 2775 2776 /* 2777 * Link state is down 2778 */ 2779 static void 2780 bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln, 2781 enum bfa_fcport_ln_sm_event event) 2782 { 2783 bfa_trc(ln->fcport->bfa, event); 2784 2785 switch (event) { 2786 case BFA_FCPORT_LN_SM_LINKUP: 2787 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf); 2788 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP); 2789 break; 2790 2791 default: 2792 bfa_sm_fault(ln->fcport->bfa, event); 2793 } 2794 } 2795 2796 /* 2797 * Link state is waiting for down notification 2798 */ 2799 static void 2800 bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln, 2801 enum bfa_fcport_ln_sm_event event) 2802 { 2803 bfa_trc(ln->fcport->bfa, event); 2804 2805 switch (event) { 2806 case BFA_FCPORT_LN_SM_LINKUP: 2807 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf); 2808 break; 2809 2810 case BFA_FCPORT_LN_SM_NOTIFICATION: 2811 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn); 2812 break; 2813 2814 default: 2815 bfa_sm_fault(ln->fcport->bfa, event); 2816 } 2817 } 2818 2819 /* 2820 * Link state is waiting for down notification and there is a pending up 2821 */ 2822 static void 2823 bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln, 2824 enum bfa_fcport_ln_sm_event event) 2825 { 2826 bfa_trc(ln->fcport->bfa, event); 2827 2828 switch (event) { 2829 case BFA_FCPORT_LN_SM_LINKDOWN: 2830 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf); 2831 break; 2832 2833 case BFA_FCPORT_LN_SM_NOTIFICATION: 2834 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf); 2835 bfa_fcport_queue_cb(ln, BFA_PORT_LINKUP); 2836 break; 2837 2838 default: 2839 bfa_sm_fault(ln->fcport->bfa, event); 2840 } 2841 } 2842 2843 /* 2844 * Link state is up 2845 */ 2846 static void 2847 bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln, 2848 enum bfa_fcport_ln_sm_event event) 2849 { 2850 bfa_trc(ln->fcport->bfa, event); 2851 2852 switch (event) { 2853 case BFA_FCPORT_LN_SM_LINKDOWN: 2854 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf); 2855 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN); 2856 break; 2857 2858 default: 2859 bfa_sm_fault(ln->fcport->bfa, event); 2860 } 2861 } 2862 2863 /* 2864 * Link state is waiting for up notification 2865 */ 2866 static void 2867 bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln, 2868 enum bfa_fcport_ln_sm_event event) 2869 { 2870 bfa_trc(ln->fcport->bfa, event); 2871 2872 switch (event) { 2873 case BFA_FCPORT_LN_SM_LINKDOWN: 2874 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf); 2875 break; 2876 2877 case BFA_FCPORT_LN_SM_NOTIFICATION: 2878 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up); 2879 break; 2880 2881 default: 2882 bfa_sm_fault(ln->fcport->bfa, event); 2883 } 2884 } 2885 2886 /* 2887 * Link state is waiting for up notification and there is a pending down 2888 */ 2889 static void 2890 bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln, 2891 enum bfa_fcport_ln_sm_event event) 2892 { 2893 bfa_trc(ln->fcport->bfa, event); 2894 2895 switch (event) { 2896 case BFA_FCPORT_LN_SM_LINKUP: 2897 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf); 2898 break; 2899 2900 case BFA_FCPORT_LN_SM_NOTIFICATION: 2901 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf); 2902 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN); 2903 break; 2904 2905 default: 2906 bfa_sm_fault(ln->fcport->bfa, event); 2907 } 2908 } 2909 2910 /* 2911 * Link state is waiting for up notification and there are pending down and up 2912 */ 2913 static void 2914 bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln, 2915 enum bfa_fcport_ln_sm_event event) 2916 { 2917 bfa_trc(ln->fcport->bfa, event); 2918 2919 switch (event) { 2920 case BFA_FCPORT_LN_SM_LINKDOWN: 2921 bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf); 2922 break; 2923 2924 case BFA_FCPORT_LN_SM_NOTIFICATION: 2925 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf); 2926 bfa_fcport_queue_cb(ln, BFA_PORT_LINKDOWN); 2927 break; 2928 2929 default: 2930 bfa_sm_fault(ln->fcport->bfa, event); 2931 } 2932 } 2933 2934 static void 2935 __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete) 2936 { 2937 struct bfa_fcport_ln_s *ln = cbarg; 2938 2939 if (complete) 2940 ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event); 2941 else 2942 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION); 2943 } 2944 2945 /* 2946 * Send SCN notification to upper layers. 2947 * trunk - false if caller is fcport to ignore fcport event in trunked mode 2948 */ 2949 static void 2950 bfa_fcport_scn(struct bfa_fcport_s *fcport, enum bfa_port_linkstate event, 2951 bfa_boolean_t trunk) 2952 { 2953 if (fcport->cfg.trunked && !trunk) 2954 return; 2955 2956 switch (event) { 2957 case BFA_PORT_LINKUP: 2958 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP); 2959 break; 2960 case BFA_PORT_LINKDOWN: 2961 bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN); 2962 break; 2963 default: 2964 WARN_ON(1); 2965 } 2966 } 2967 2968 static void 2969 bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_port_linkstate event) 2970 { 2971 struct bfa_fcport_s *fcport = ln->fcport; 2972 2973 if (fcport->bfa->fcs) { 2974 fcport->event_cbfn(fcport->event_cbarg, event); 2975 bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION); 2976 } else { 2977 ln->ln_event = event; 2978 bfa_cb_queue(fcport->bfa, &ln->ln_qe, 2979 __bfa_cb_fcport_event, ln); 2980 } 2981 } 2982 2983 #define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \ 2984 BFA_CACHELINE_SZ)) 2985 2986 void 2987 bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo, 2988 struct bfa_s *bfa) 2989 { 2990 struct bfa_mem_dma_s *fcport_dma = BFA_MEM_FCPORT_DMA(bfa); 2991 2992 bfa_mem_dma_setup(minfo, fcport_dma, FCPORT_STATS_DMA_SZ); 2993 } 2994 2995 static void 2996 bfa_fcport_qresume(void *cbarg) 2997 { 2998 struct bfa_fcport_s *fcport = cbarg; 2999 3000 bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME); 3001 } 3002 3003 static void 3004 bfa_fcport_mem_claim(struct bfa_fcport_s *fcport) 3005 { 3006 struct bfa_mem_dma_s *fcport_dma = &fcport->fcport_dma; 3007 3008 fcport->stats_kva = bfa_mem_dma_virt(fcport_dma); 3009 fcport->stats_pa = bfa_mem_dma_phys(fcport_dma); 3010 fcport->stats = (union bfa_fcport_stats_u *) 3011 bfa_mem_dma_virt(fcport_dma); 3012 } 3013 3014 /* 3015 * Memory initialization. 3016 */ 3017 void 3018 bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 3019 struct bfa_pcidev_s *pcidev) 3020 { 3021 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3022 struct bfa_port_cfg_s *port_cfg = &fcport->cfg; 3023 struct bfa_fcport_ln_s *ln = &fcport->ln; 3024 3025 fcport->bfa = bfa; 3026 ln->fcport = fcport; 3027 3028 bfa_fcport_mem_claim(fcport); 3029 3030 bfa_sm_set_state(fcport, bfa_fcport_sm_uninit); 3031 bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn); 3032 3033 /* 3034 * initialize time stamp for stats reset 3035 */ 3036 fcport->stats_reset_time = ktime_get_seconds(); 3037 fcport->stats_dma_ready = BFA_FALSE; 3038 3039 /* 3040 * initialize and set default configuration 3041 */ 3042 port_cfg->topology = BFA_PORT_TOPOLOGY_P2P; 3043 port_cfg->speed = BFA_PORT_SPEED_AUTO; 3044 port_cfg->trunked = BFA_FALSE; 3045 port_cfg->maxfrsize = 0; 3046 3047 port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS; 3048 port_cfg->qos_bw.high = BFA_QOS_BW_HIGH; 3049 port_cfg->qos_bw.med = BFA_QOS_BW_MED; 3050 port_cfg->qos_bw.low = BFA_QOS_BW_LOW; 3051 3052 fcport->fec_state = BFA_FEC_OFFLINE; 3053 3054 INIT_LIST_HEAD(&fcport->stats_pending_q); 3055 INIT_LIST_HEAD(&fcport->statsclr_pending_q); 3056 3057 bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport); 3058 } 3059 3060 void 3061 bfa_fcport_start(struct bfa_s *bfa) 3062 { 3063 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START); 3064 } 3065 3066 /* 3067 * Called when IOC failure is detected. 3068 */ 3069 void 3070 bfa_fcport_iocdisable(struct bfa_s *bfa) 3071 { 3072 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3073 3074 bfa_sm_send_event(fcport, BFA_FCPORT_SM_HWFAIL); 3075 bfa_trunk_iocdisable(bfa); 3076 } 3077 3078 /* 3079 * Update loop info in fcport for SCN online 3080 */ 3081 static void 3082 bfa_fcport_update_loop_info(struct bfa_fcport_s *fcport, 3083 struct bfa_fcport_loop_info_s *loop_info) 3084 { 3085 fcport->myalpa = loop_info->myalpa; 3086 fcport->alpabm_valid = 3087 loop_info->alpabm_val; 3088 memcpy(fcport->alpabm.alpa_bm, 3089 loop_info->alpabm.alpa_bm, 3090 sizeof(struct fc_alpabm_s)); 3091 } 3092 3093 static void 3094 bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport) 3095 { 3096 struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event; 3097 struct bfa_fcport_trunk_s *trunk = &fcport->trunk; 3098 3099 fcport->speed = pevent->link_state.speed; 3100 fcport->topology = pevent->link_state.topology; 3101 3102 if (fcport->topology == BFA_PORT_TOPOLOGY_LOOP) { 3103 bfa_fcport_update_loop_info(fcport, 3104 &pevent->link_state.attr.loop_info); 3105 return; 3106 } 3107 3108 /* QoS Details */ 3109 fcport->qos_attr = pevent->link_state.qos_attr; 3110 fcport->qos_vc_attr = pevent->link_state.attr.vc_fcf.qos_vc_attr; 3111 3112 if (fcport->cfg.bb_cr_enabled) 3113 fcport->bbcr_attr = pevent->link_state.attr.bbcr_attr; 3114 3115 fcport->fec_state = pevent->link_state.fec_state; 3116 3117 /* 3118 * update trunk state if applicable 3119 */ 3120 if (!fcport->cfg.trunked) 3121 trunk->attr.state = BFA_TRUNK_DISABLED; 3122 3123 /* update FCoE specific */ 3124 fcport->fcoe_vlan = 3125 be16_to_cpu(pevent->link_state.attr.vc_fcf.fcf.vlan); 3126 3127 bfa_trc(fcport->bfa, fcport->speed); 3128 bfa_trc(fcport->bfa, fcport->topology); 3129 } 3130 3131 static void 3132 bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport) 3133 { 3134 fcport->speed = BFA_PORT_SPEED_UNKNOWN; 3135 fcport->topology = BFA_PORT_TOPOLOGY_NONE; 3136 fcport->fec_state = BFA_FEC_OFFLINE; 3137 } 3138 3139 /* 3140 * Send port enable message to firmware. 3141 */ 3142 static bfa_boolean_t 3143 bfa_fcport_send_enable(struct bfa_fcport_s *fcport) 3144 { 3145 struct bfi_fcport_enable_req_s *m; 3146 3147 /* 3148 * Increment message tag before queue check, so that responses to old 3149 * requests are discarded. 3150 */ 3151 fcport->msgtag++; 3152 3153 /* 3154 * check for room in queue to send request now 3155 */ 3156 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT); 3157 if (!m) { 3158 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT, 3159 &fcport->reqq_wait); 3160 return BFA_FALSE; 3161 } 3162 3163 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ, 3164 bfa_fn_lpu(fcport->bfa)); 3165 m->nwwn = fcport->nwwn; 3166 m->pwwn = fcport->pwwn; 3167 m->port_cfg = fcport->cfg; 3168 m->msgtag = fcport->msgtag; 3169 m->port_cfg.maxfrsize = cpu_to_be16(fcport->cfg.maxfrsize); 3170 m->use_flash_cfg = fcport->use_flash_cfg; 3171 bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa); 3172 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo); 3173 bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi); 3174 3175 /* 3176 * queue I/O message to firmware 3177 */ 3178 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh); 3179 return BFA_TRUE; 3180 } 3181 3182 /* 3183 * Send port disable message to firmware. 3184 */ 3185 static bfa_boolean_t 3186 bfa_fcport_send_disable(struct bfa_fcport_s *fcport) 3187 { 3188 struct bfi_fcport_req_s *m; 3189 3190 /* 3191 * Increment message tag before queue check, so that responses to old 3192 * requests are discarded. 3193 */ 3194 fcport->msgtag++; 3195 3196 /* 3197 * check for room in queue to send request now 3198 */ 3199 m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT); 3200 if (!m) { 3201 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT, 3202 &fcport->reqq_wait); 3203 return BFA_FALSE; 3204 } 3205 3206 bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ, 3207 bfa_fn_lpu(fcport->bfa)); 3208 m->msgtag = fcport->msgtag; 3209 3210 /* 3211 * queue I/O message to firmware 3212 */ 3213 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, m->mh); 3214 3215 return BFA_TRUE; 3216 } 3217 3218 static void 3219 bfa_fcport_set_wwns(struct bfa_fcport_s *fcport) 3220 { 3221 fcport->pwwn = fcport->bfa->ioc.attr->pwwn; 3222 fcport->nwwn = fcport->bfa->ioc.attr->nwwn; 3223 3224 bfa_trc(fcport->bfa, fcport->pwwn); 3225 bfa_trc(fcport->bfa, fcport->nwwn); 3226 } 3227 3228 static void 3229 bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d, 3230 struct bfa_qos_stats_s *s) 3231 { 3232 u32 *dip = (u32 *) d; 3233 __be32 *sip = (__be32 *) s; 3234 int i; 3235 3236 /* Now swap the 32 bit fields */ 3237 for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i) 3238 dip[i] = be32_to_cpu(sip[i]); 3239 } 3240 3241 static void 3242 bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d, 3243 struct bfa_fcoe_stats_s *s) 3244 { 3245 u32 *dip = (u32 *) d; 3246 __be32 *sip = (__be32 *) s; 3247 int i; 3248 3249 for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32)); 3250 i = i + 2) { 3251 #ifdef __BIG_ENDIAN 3252 dip[i] = be32_to_cpu(sip[i]); 3253 dip[i + 1] = be32_to_cpu(sip[i + 1]); 3254 #else 3255 dip[i] = be32_to_cpu(sip[i + 1]); 3256 dip[i + 1] = be32_to_cpu(sip[i]); 3257 #endif 3258 } 3259 } 3260 3261 static void 3262 __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete) 3263 { 3264 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg; 3265 struct bfa_cb_pending_q_s *cb; 3266 struct list_head *qe, *qen; 3267 union bfa_fcport_stats_u *ret; 3268 3269 if (complete) { 3270 time64_t time = ktime_get_seconds(); 3271 3272 list_for_each_safe(qe, qen, &fcport->stats_pending_q) { 3273 bfa_q_deq(&fcport->stats_pending_q, &qe); 3274 cb = (struct bfa_cb_pending_q_s *)qe; 3275 if (fcport->stats_status == BFA_STATUS_OK) { 3276 ret = (union bfa_fcport_stats_u *)cb->data; 3277 /* Swap FC QoS or FCoE stats */ 3278 if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) 3279 bfa_fcport_qos_stats_swap(&ret->fcqos, 3280 &fcport->stats->fcqos); 3281 else { 3282 bfa_fcport_fcoe_stats_swap(&ret->fcoe, 3283 &fcport->stats->fcoe); 3284 ret->fcoe.secs_reset = 3285 time - fcport->stats_reset_time; 3286 } 3287 } 3288 bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe, 3289 fcport->stats_status); 3290 } 3291 fcport->stats_status = BFA_STATUS_OK; 3292 } else { 3293 INIT_LIST_HEAD(&fcport->stats_pending_q); 3294 fcport->stats_status = BFA_STATUS_OK; 3295 } 3296 } 3297 3298 static void 3299 bfa_fcport_stats_get_timeout(void *cbarg) 3300 { 3301 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg; 3302 3303 bfa_trc(fcport->bfa, fcport->stats_qfull); 3304 3305 if (fcport->stats_qfull) { 3306 bfa_reqq_wcancel(&fcport->stats_reqq_wait); 3307 fcport->stats_qfull = BFA_FALSE; 3308 } 3309 3310 fcport->stats_status = BFA_STATUS_ETIMER; 3311 __bfa_cb_fcport_stats_get(fcport, BFA_TRUE); 3312 } 3313 3314 static void 3315 bfa_fcport_send_stats_get(void *cbarg) 3316 { 3317 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg; 3318 struct bfi_fcport_req_s *msg; 3319 3320 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT); 3321 3322 if (!msg) { 3323 fcport->stats_qfull = BFA_TRUE; 3324 bfa_reqq_winit(&fcport->stats_reqq_wait, 3325 bfa_fcport_send_stats_get, fcport); 3326 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT, 3327 &fcport->stats_reqq_wait); 3328 return; 3329 } 3330 fcport->stats_qfull = BFA_FALSE; 3331 3332 memset(msg, 0, sizeof(struct bfi_fcport_req_s)); 3333 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ, 3334 bfa_fn_lpu(fcport->bfa)); 3335 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh); 3336 } 3337 3338 static void 3339 __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete) 3340 { 3341 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg; 3342 struct bfa_cb_pending_q_s *cb; 3343 struct list_head *qe, *qen; 3344 3345 if (complete) { 3346 /* 3347 * re-initialize time stamp for stats reset 3348 */ 3349 fcport->stats_reset_time = ktime_get_seconds(); 3350 list_for_each_safe(qe, qen, &fcport->statsclr_pending_q) { 3351 bfa_q_deq(&fcport->statsclr_pending_q, &qe); 3352 cb = (struct bfa_cb_pending_q_s *)qe; 3353 bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe, 3354 fcport->stats_status); 3355 } 3356 fcport->stats_status = BFA_STATUS_OK; 3357 } else { 3358 INIT_LIST_HEAD(&fcport->statsclr_pending_q); 3359 fcport->stats_status = BFA_STATUS_OK; 3360 } 3361 } 3362 3363 static void 3364 bfa_fcport_stats_clr_timeout(void *cbarg) 3365 { 3366 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg; 3367 3368 bfa_trc(fcport->bfa, fcport->stats_qfull); 3369 3370 if (fcport->stats_qfull) { 3371 bfa_reqq_wcancel(&fcport->stats_reqq_wait); 3372 fcport->stats_qfull = BFA_FALSE; 3373 } 3374 3375 fcport->stats_status = BFA_STATUS_ETIMER; 3376 __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE); 3377 } 3378 3379 static void 3380 bfa_fcport_send_stats_clear(void *cbarg) 3381 { 3382 struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg; 3383 struct bfi_fcport_req_s *msg; 3384 3385 msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT); 3386 3387 if (!msg) { 3388 fcport->stats_qfull = BFA_TRUE; 3389 bfa_reqq_winit(&fcport->stats_reqq_wait, 3390 bfa_fcport_send_stats_clear, fcport); 3391 bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT, 3392 &fcport->stats_reqq_wait); 3393 return; 3394 } 3395 fcport->stats_qfull = BFA_FALSE; 3396 3397 memset(msg, 0, sizeof(struct bfi_fcport_req_s)); 3398 bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ, 3399 bfa_fn_lpu(fcport->bfa)); 3400 bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT, msg->mh); 3401 } 3402 3403 /* 3404 * Handle trunk SCN event from firmware. 3405 */ 3406 static void 3407 bfa_trunk_scn(struct bfa_fcport_s *fcport, struct bfi_fcport_trunk_scn_s *scn) 3408 { 3409 struct bfa_fcport_trunk_s *trunk = &fcport->trunk; 3410 struct bfi_fcport_trunk_link_s *tlink; 3411 struct bfa_trunk_link_attr_s *lattr; 3412 enum bfa_trunk_state state_prev; 3413 int i; 3414 int link_bm = 0; 3415 3416 bfa_trc(fcport->bfa, fcport->cfg.trunked); 3417 WARN_ON(scn->trunk_state != BFA_TRUNK_ONLINE && 3418 scn->trunk_state != BFA_TRUNK_OFFLINE); 3419 3420 bfa_trc(fcport->bfa, trunk->attr.state); 3421 bfa_trc(fcport->bfa, scn->trunk_state); 3422 bfa_trc(fcport->bfa, scn->trunk_speed); 3423 3424 /* 3425 * Save off new state for trunk attribute query 3426 */ 3427 state_prev = trunk->attr.state; 3428 if (fcport->cfg.trunked && (trunk->attr.state != BFA_TRUNK_DISABLED)) 3429 trunk->attr.state = scn->trunk_state; 3430 trunk->attr.speed = scn->trunk_speed; 3431 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) { 3432 lattr = &trunk->attr.link_attr[i]; 3433 tlink = &scn->tlink[i]; 3434 3435 lattr->link_state = tlink->state; 3436 lattr->trunk_wwn = tlink->trunk_wwn; 3437 lattr->fctl = tlink->fctl; 3438 lattr->speed = tlink->speed; 3439 lattr->deskew = be32_to_cpu(tlink->deskew); 3440 3441 if (tlink->state == BFA_TRUNK_LINK_STATE_UP) { 3442 fcport->speed = tlink->speed; 3443 fcport->topology = BFA_PORT_TOPOLOGY_P2P; 3444 link_bm |= 1 << i; 3445 } 3446 3447 bfa_trc(fcport->bfa, lattr->link_state); 3448 bfa_trc(fcport->bfa, lattr->trunk_wwn); 3449 bfa_trc(fcport->bfa, lattr->fctl); 3450 bfa_trc(fcport->bfa, lattr->speed); 3451 bfa_trc(fcport->bfa, lattr->deskew); 3452 } 3453 3454 switch (link_bm) { 3455 case 3: 3456 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 3457 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,1)"); 3458 break; 3459 case 2: 3460 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 3461 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(-,1)"); 3462 break; 3463 case 1: 3464 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 3465 BFA_PL_EID_TRUNK_SCN, 0, "Trunk up(0,-)"); 3466 break; 3467 default: 3468 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL, 3469 BFA_PL_EID_TRUNK_SCN, 0, "Trunk down"); 3470 } 3471 3472 /* 3473 * Notify upper layers if trunk state changed. 3474 */ 3475 if ((state_prev != trunk->attr.state) || 3476 (scn->trunk_state == BFA_TRUNK_OFFLINE)) { 3477 bfa_fcport_scn(fcport, (scn->trunk_state == BFA_TRUNK_ONLINE) ? 3478 BFA_PORT_LINKUP : BFA_PORT_LINKDOWN, BFA_TRUE); 3479 } 3480 } 3481 3482 static void 3483 bfa_trunk_iocdisable(struct bfa_s *bfa) 3484 { 3485 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3486 int i = 0; 3487 3488 /* 3489 * In trunked mode, notify upper layers that link is down 3490 */ 3491 if (fcport->cfg.trunked) { 3492 if (fcport->trunk.attr.state == BFA_TRUNK_ONLINE) 3493 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_TRUE); 3494 3495 fcport->trunk.attr.state = BFA_TRUNK_OFFLINE; 3496 fcport->trunk.attr.speed = BFA_PORT_SPEED_UNKNOWN; 3497 for (i = 0; i < BFA_TRUNK_MAX_PORTS; i++) { 3498 fcport->trunk.attr.link_attr[i].trunk_wwn = 0; 3499 fcport->trunk.attr.link_attr[i].fctl = 3500 BFA_TRUNK_LINK_FCTL_NORMAL; 3501 fcport->trunk.attr.link_attr[i].link_state = 3502 BFA_TRUNK_LINK_STATE_DN_LINKDN; 3503 fcport->trunk.attr.link_attr[i].speed = 3504 BFA_PORT_SPEED_UNKNOWN; 3505 fcport->trunk.attr.link_attr[i].deskew = 0; 3506 } 3507 } 3508 } 3509 3510 /* 3511 * Called to initialize port attributes 3512 */ 3513 void 3514 bfa_fcport_init(struct bfa_s *bfa) 3515 { 3516 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3517 3518 /* 3519 * Initialize port attributes from IOC hardware data. 3520 */ 3521 bfa_fcport_set_wwns(fcport); 3522 if (fcport->cfg.maxfrsize == 0) 3523 fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc); 3524 fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc); 3525 fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc); 3526 3527 if (bfa_fcport_is_pbcdisabled(bfa)) 3528 bfa->modules.port.pbc_disabled = BFA_TRUE; 3529 3530 WARN_ON(!fcport->cfg.maxfrsize); 3531 WARN_ON(!fcport->cfg.rx_bbcredit); 3532 WARN_ON(!fcport->speed_sup); 3533 } 3534 3535 /* 3536 * Firmware message handler. 3537 */ 3538 void 3539 bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg) 3540 { 3541 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3542 union bfi_fcport_i2h_msg_u i2hmsg; 3543 3544 i2hmsg.msg = msg; 3545 fcport->event_arg.i2hmsg = i2hmsg; 3546 3547 bfa_trc(bfa, msg->mhdr.msg_id); 3548 bfa_trc(bfa, bfa_sm_to_state(hal_port_sm_table, fcport->sm)); 3549 3550 switch (msg->mhdr.msg_id) { 3551 case BFI_FCPORT_I2H_ENABLE_RSP: 3552 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) { 3553 3554 fcport->stats_dma_ready = BFA_TRUE; 3555 if (fcport->use_flash_cfg) { 3556 fcport->cfg = i2hmsg.penable_rsp->port_cfg; 3557 fcport->cfg.maxfrsize = 3558 cpu_to_be16(fcport->cfg.maxfrsize); 3559 fcport->cfg.path_tov = 3560 cpu_to_be16(fcport->cfg.path_tov); 3561 fcport->cfg.q_depth = 3562 cpu_to_be16(fcport->cfg.q_depth); 3563 3564 if (fcport->cfg.trunked) 3565 fcport->trunk.attr.state = 3566 BFA_TRUNK_OFFLINE; 3567 else 3568 fcport->trunk.attr.state = 3569 BFA_TRUNK_DISABLED; 3570 fcport->qos_attr.qos_bw = 3571 i2hmsg.penable_rsp->port_cfg.qos_bw; 3572 fcport->use_flash_cfg = BFA_FALSE; 3573 } 3574 3575 if (fcport->cfg.qos_enabled) 3576 fcport->qos_attr.state = BFA_QOS_OFFLINE; 3577 else 3578 fcport->qos_attr.state = BFA_QOS_DISABLED; 3579 3580 fcport->qos_attr.qos_bw_op = 3581 i2hmsg.penable_rsp->port_cfg.qos_bw; 3582 3583 if (fcport->cfg.bb_cr_enabled) 3584 fcport->bbcr_attr.state = BFA_BBCR_OFFLINE; 3585 else 3586 fcport->bbcr_attr.state = BFA_BBCR_DISABLED; 3587 3588 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP); 3589 } 3590 break; 3591 3592 case BFI_FCPORT_I2H_DISABLE_RSP: 3593 if (fcport->msgtag == i2hmsg.penable_rsp->msgtag) 3594 bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP); 3595 break; 3596 3597 case BFI_FCPORT_I2H_EVENT: 3598 if (fcport->cfg.bb_cr_enabled) 3599 fcport->bbcr_attr.state = BFA_BBCR_OFFLINE; 3600 else 3601 fcport->bbcr_attr.state = BFA_BBCR_DISABLED; 3602 3603 if (i2hmsg.event->link_state.linkstate == BFA_PORT_LINKUP) 3604 bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP); 3605 else { 3606 if (i2hmsg.event->link_state.linkstate_rsn == 3607 BFA_PORT_LINKSTATE_RSN_FAA_MISCONFIG) 3608 bfa_sm_send_event(fcport, 3609 BFA_FCPORT_SM_FAA_MISCONFIG); 3610 else 3611 bfa_sm_send_event(fcport, 3612 BFA_FCPORT_SM_LINKDOWN); 3613 } 3614 fcport->qos_attr.qos_bw_op = 3615 i2hmsg.event->link_state.qos_attr.qos_bw_op; 3616 break; 3617 3618 case BFI_FCPORT_I2H_TRUNK_SCN: 3619 bfa_trunk_scn(fcport, i2hmsg.trunk_scn); 3620 break; 3621 3622 case BFI_FCPORT_I2H_STATS_GET_RSP: 3623 /* 3624 * check for timer pop before processing the rsp 3625 */ 3626 if (list_empty(&fcport->stats_pending_q) || 3627 (fcport->stats_status == BFA_STATUS_ETIMER)) 3628 break; 3629 3630 bfa_timer_stop(&fcport->timer); 3631 fcport->stats_status = i2hmsg.pstatsget_rsp->status; 3632 __bfa_cb_fcport_stats_get(fcport, BFA_TRUE); 3633 break; 3634 3635 case BFI_FCPORT_I2H_STATS_CLEAR_RSP: 3636 /* 3637 * check for timer pop before processing the rsp 3638 */ 3639 if (list_empty(&fcport->statsclr_pending_q) || 3640 (fcport->stats_status == BFA_STATUS_ETIMER)) 3641 break; 3642 3643 bfa_timer_stop(&fcport->timer); 3644 fcport->stats_status = BFA_STATUS_OK; 3645 __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE); 3646 break; 3647 3648 case BFI_FCPORT_I2H_ENABLE_AEN: 3649 bfa_sm_send_event(fcport, BFA_FCPORT_SM_ENABLE); 3650 break; 3651 3652 case BFI_FCPORT_I2H_DISABLE_AEN: 3653 bfa_sm_send_event(fcport, BFA_FCPORT_SM_DISABLE); 3654 break; 3655 3656 default: 3657 WARN_ON(1); 3658 break; 3659 } 3660 } 3661 3662 /* 3663 * Registered callback for port events. 3664 */ 3665 void 3666 bfa_fcport_event_register(struct bfa_s *bfa, 3667 void (*cbfn) (void *cbarg, 3668 enum bfa_port_linkstate event), 3669 void *cbarg) 3670 { 3671 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3672 3673 fcport->event_cbfn = cbfn; 3674 fcport->event_cbarg = cbarg; 3675 } 3676 3677 bfa_status_t 3678 bfa_fcport_enable(struct bfa_s *bfa) 3679 { 3680 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3681 3682 if (bfa_fcport_is_pbcdisabled(bfa)) 3683 return BFA_STATUS_PBC; 3684 3685 if (bfa_ioc_is_disabled(&bfa->ioc)) 3686 return BFA_STATUS_IOC_DISABLED; 3687 3688 if (fcport->diag_busy) 3689 return BFA_STATUS_DIAG_BUSY; 3690 3691 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE); 3692 return BFA_STATUS_OK; 3693 } 3694 3695 bfa_status_t 3696 bfa_fcport_disable(struct bfa_s *bfa) 3697 { 3698 if (bfa_fcport_is_pbcdisabled(bfa)) 3699 return BFA_STATUS_PBC; 3700 3701 if (bfa_ioc_is_disabled(&bfa->ioc)) 3702 return BFA_STATUS_IOC_DISABLED; 3703 3704 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE); 3705 return BFA_STATUS_OK; 3706 } 3707 3708 /* If PBC is disabled on port, return error */ 3709 bfa_status_t 3710 bfa_fcport_is_pbcdisabled(struct bfa_s *bfa) 3711 { 3712 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3713 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 3714 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp; 3715 3716 if (cfgrsp->pbc_cfg.port_enabled == BFI_PBC_PORT_DISABLED) { 3717 bfa_trc(bfa, fcport->pwwn); 3718 return BFA_STATUS_PBC; 3719 } 3720 return BFA_STATUS_OK; 3721 } 3722 3723 /* 3724 * Configure port speed. 3725 */ 3726 bfa_status_t 3727 bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_port_speed speed) 3728 { 3729 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3730 3731 bfa_trc(bfa, speed); 3732 3733 if (fcport->cfg.trunked == BFA_TRUE) 3734 return BFA_STATUS_TRUNK_ENABLED; 3735 if ((fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) && 3736 (speed == BFA_PORT_SPEED_16GBPS)) 3737 return BFA_STATUS_UNSUPP_SPEED; 3738 if ((speed != BFA_PORT_SPEED_AUTO) && (speed > fcport->speed_sup)) { 3739 bfa_trc(bfa, fcport->speed_sup); 3740 return BFA_STATUS_UNSUPP_SPEED; 3741 } 3742 3743 /* Port speed entered needs to be checked */ 3744 if (bfa_ioc_get_type(&fcport->bfa->ioc) == BFA_IOC_TYPE_FC) { 3745 /* For CT2, 1G is not supported */ 3746 if ((speed == BFA_PORT_SPEED_1GBPS) && 3747 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id))) 3748 return BFA_STATUS_UNSUPP_SPEED; 3749 3750 /* Already checked for Auto Speed and Max Speed supp */ 3751 if (!(speed == BFA_PORT_SPEED_1GBPS || 3752 speed == BFA_PORT_SPEED_2GBPS || 3753 speed == BFA_PORT_SPEED_4GBPS || 3754 speed == BFA_PORT_SPEED_8GBPS || 3755 speed == BFA_PORT_SPEED_16GBPS || 3756 speed == BFA_PORT_SPEED_AUTO)) 3757 return BFA_STATUS_UNSUPP_SPEED; 3758 } else { 3759 if (speed != BFA_PORT_SPEED_10GBPS) 3760 return BFA_STATUS_UNSUPP_SPEED; 3761 } 3762 3763 fcport->cfg.speed = speed; 3764 3765 return BFA_STATUS_OK; 3766 } 3767 3768 /* 3769 * Get current speed. 3770 */ 3771 enum bfa_port_speed 3772 bfa_fcport_get_speed(struct bfa_s *bfa) 3773 { 3774 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3775 3776 return fcport->speed; 3777 } 3778 3779 /* 3780 * Configure port topology. 3781 */ 3782 bfa_status_t 3783 bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_port_topology topology) 3784 { 3785 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3786 3787 bfa_trc(bfa, topology); 3788 bfa_trc(bfa, fcport->cfg.topology); 3789 3790 switch (topology) { 3791 case BFA_PORT_TOPOLOGY_P2P: 3792 break; 3793 3794 case BFA_PORT_TOPOLOGY_LOOP: 3795 if ((bfa_fcport_is_qos_enabled(bfa) != BFA_FALSE) || 3796 (fcport->qos_attr.state != BFA_QOS_DISABLED)) 3797 return BFA_STATUS_ERROR_QOS_ENABLED; 3798 if (fcport->cfg.ratelimit != BFA_FALSE) 3799 return BFA_STATUS_ERROR_TRL_ENABLED; 3800 if ((bfa_fcport_is_trunk_enabled(bfa) != BFA_FALSE) || 3801 (fcport->trunk.attr.state != BFA_TRUNK_DISABLED)) 3802 return BFA_STATUS_ERROR_TRUNK_ENABLED; 3803 if ((bfa_fcport_get_speed(bfa) == BFA_PORT_SPEED_16GBPS) || 3804 (fcport->cfg.speed == BFA_PORT_SPEED_16GBPS)) 3805 return BFA_STATUS_UNSUPP_SPEED; 3806 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) 3807 return BFA_STATUS_LOOP_UNSUPP_MEZZ; 3808 if (bfa_fcport_is_dport(bfa) != BFA_FALSE) 3809 return BFA_STATUS_DPORT_ERR; 3810 if (bfa_fcport_is_ddport(bfa) != BFA_FALSE) 3811 return BFA_STATUS_DPORT_ERR; 3812 break; 3813 3814 case BFA_PORT_TOPOLOGY_AUTO: 3815 break; 3816 3817 default: 3818 return BFA_STATUS_EINVAL; 3819 } 3820 3821 fcport->cfg.topology = topology; 3822 return BFA_STATUS_OK; 3823 } 3824 3825 /* 3826 * Get current topology. 3827 */ 3828 enum bfa_port_topology 3829 bfa_fcport_get_topology(struct bfa_s *bfa) 3830 { 3831 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3832 3833 return fcport->topology; 3834 } 3835 3836 /* 3837 * Get config topology. 3838 */ 3839 enum bfa_port_topology 3840 bfa_fcport_get_cfg_topology(struct bfa_s *bfa) 3841 { 3842 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3843 3844 return fcport->cfg.topology; 3845 } 3846 3847 bfa_status_t 3848 bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa) 3849 { 3850 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3851 3852 bfa_trc(bfa, alpa); 3853 bfa_trc(bfa, fcport->cfg.cfg_hardalpa); 3854 bfa_trc(bfa, fcport->cfg.hardalpa); 3855 3856 fcport->cfg.cfg_hardalpa = BFA_TRUE; 3857 fcport->cfg.hardalpa = alpa; 3858 3859 return BFA_STATUS_OK; 3860 } 3861 3862 bfa_status_t 3863 bfa_fcport_clr_hardalpa(struct bfa_s *bfa) 3864 { 3865 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3866 3867 bfa_trc(bfa, fcport->cfg.cfg_hardalpa); 3868 bfa_trc(bfa, fcport->cfg.hardalpa); 3869 3870 fcport->cfg.cfg_hardalpa = BFA_FALSE; 3871 return BFA_STATUS_OK; 3872 } 3873 3874 bfa_boolean_t 3875 bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa) 3876 { 3877 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3878 3879 *alpa = fcport->cfg.hardalpa; 3880 return fcport->cfg.cfg_hardalpa; 3881 } 3882 3883 u8 3884 bfa_fcport_get_myalpa(struct bfa_s *bfa) 3885 { 3886 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3887 3888 return fcport->myalpa; 3889 } 3890 3891 bfa_status_t 3892 bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize) 3893 { 3894 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3895 3896 bfa_trc(bfa, maxfrsize); 3897 bfa_trc(bfa, fcport->cfg.maxfrsize); 3898 3899 /* with in range */ 3900 if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ)) 3901 return BFA_STATUS_INVLD_DFSZ; 3902 3903 /* power of 2, if not the max frame size of 2112 */ 3904 if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1))) 3905 return BFA_STATUS_INVLD_DFSZ; 3906 3907 fcport->cfg.maxfrsize = maxfrsize; 3908 return BFA_STATUS_OK; 3909 } 3910 3911 u16 3912 bfa_fcport_get_maxfrsize(struct bfa_s *bfa) 3913 { 3914 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3915 3916 return fcport->cfg.maxfrsize; 3917 } 3918 3919 u8 3920 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa) 3921 { 3922 if (bfa_fcport_get_topology(bfa) != BFA_PORT_TOPOLOGY_LOOP) 3923 return (BFA_FCPORT_MOD(bfa))->cfg.rx_bbcredit; 3924 3925 else 3926 return 0; 3927 } 3928 3929 void 3930 bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit) 3931 { 3932 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3933 3934 fcport->cfg.tx_bbcredit = (u8)tx_bbcredit; 3935 } 3936 3937 /* 3938 * Get port attributes. 3939 */ 3940 3941 wwn_t 3942 bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node) 3943 { 3944 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3945 if (node) 3946 return fcport->nwwn; 3947 else 3948 return fcport->pwwn; 3949 } 3950 3951 void 3952 bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr) 3953 { 3954 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 3955 3956 memset(attr, 0, sizeof(struct bfa_port_attr_s)); 3957 3958 attr->nwwn = fcport->nwwn; 3959 attr->pwwn = fcport->pwwn; 3960 3961 attr->factorypwwn = bfa->ioc.attr->mfg_pwwn; 3962 attr->factorynwwn = bfa->ioc.attr->mfg_nwwn; 3963 3964 memcpy(&attr->pport_cfg, &fcport->cfg, 3965 sizeof(struct bfa_port_cfg_s)); 3966 /* speed attributes */ 3967 attr->pport_cfg.speed = fcport->cfg.speed; 3968 attr->speed_supported = fcport->speed_sup; 3969 attr->speed = fcport->speed; 3970 attr->cos_supported = FC_CLASS_3; 3971 3972 /* topology attributes */ 3973 attr->pport_cfg.topology = fcport->cfg.topology; 3974 attr->topology = fcport->topology; 3975 attr->pport_cfg.trunked = fcport->cfg.trunked; 3976 3977 /* beacon attributes */ 3978 attr->beacon = fcport->beacon; 3979 attr->link_e2e_beacon = fcport->link_e2e_beacon; 3980 3981 attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa); 3982 attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa); 3983 attr->port_state = bfa_sm_to_state(hal_port_sm_table, fcport->sm); 3984 3985 attr->fec_state = fcport->fec_state; 3986 3987 /* PBC Disabled State */ 3988 if (bfa_fcport_is_pbcdisabled(bfa)) 3989 attr->port_state = BFA_PORT_ST_PREBOOT_DISABLED; 3990 else { 3991 if (bfa_ioc_is_disabled(&fcport->bfa->ioc)) 3992 attr->port_state = BFA_PORT_ST_IOCDIS; 3993 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc)) 3994 attr->port_state = BFA_PORT_ST_FWMISMATCH; 3995 } 3996 3997 /* FCoE vlan */ 3998 attr->fcoe_vlan = fcport->fcoe_vlan; 3999 } 4000 4001 #define BFA_FCPORT_STATS_TOV 1000 4002 4003 /* 4004 * Fetch port statistics (FCQoS or FCoE). 4005 */ 4006 bfa_status_t 4007 bfa_fcport_get_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb) 4008 { 4009 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4010 4011 if (!bfa_iocfc_is_operational(bfa) || 4012 !fcport->stats_dma_ready) 4013 return BFA_STATUS_IOC_NON_OP; 4014 4015 if (!list_empty(&fcport->statsclr_pending_q)) 4016 return BFA_STATUS_DEVBUSY; 4017 4018 if (list_empty(&fcport->stats_pending_q)) { 4019 list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q); 4020 bfa_fcport_send_stats_get(fcport); 4021 bfa_timer_start(bfa, &fcport->timer, 4022 bfa_fcport_stats_get_timeout, 4023 fcport, BFA_FCPORT_STATS_TOV); 4024 } else 4025 list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q); 4026 4027 return BFA_STATUS_OK; 4028 } 4029 4030 /* 4031 * Reset port statistics (FCQoS or FCoE). 4032 */ 4033 bfa_status_t 4034 bfa_fcport_clear_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb) 4035 { 4036 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4037 4038 if (!bfa_iocfc_is_operational(bfa) || 4039 !fcport->stats_dma_ready) 4040 return BFA_STATUS_IOC_NON_OP; 4041 4042 if (!list_empty(&fcport->stats_pending_q)) 4043 return BFA_STATUS_DEVBUSY; 4044 4045 if (list_empty(&fcport->statsclr_pending_q)) { 4046 list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q); 4047 bfa_fcport_send_stats_clear(fcport); 4048 bfa_timer_start(bfa, &fcport->timer, 4049 bfa_fcport_stats_clr_timeout, 4050 fcport, BFA_FCPORT_STATS_TOV); 4051 } else 4052 list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q); 4053 4054 return BFA_STATUS_OK; 4055 } 4056 4057 /* 4058 * Fetch port attributes. 4059 */ 4060 bfa_boolean_t 4061 bfa_fcport_is_disabled(struct bfa_s *bfa) 4062 { 4063 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4064 4065 return bfa_sm_to_state(hal_port_sm_table, fcport->sm) == 4066 BFA_PORT_ST_DISABLED; 4067 4068 } 4069 4070 bfa_boolean_t 4071 bfa_fcport_is_dport(struct bfa_s *bfa) 4072 { 4073 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4074 4075 return (bfa_sm_to_state(hal_port_sm_table, fcport->sm) == 4076 BFA_PORT_ST_DPORT); 4077 } 4078 4079 bfa_boolean_t 4080 bfa_fcport_is_ddport(struct bfa_s *bfa) 4081 { 4082 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4083 4084 return (bfa_sm_to_state(hal_port_sm_table, fcport->sm) == 4085 BFA_PORT_ST_DDPORT); 4086 } 4087 4088 bfa_status_t 4089 bfa_fcport_set_qos_bw(struct bfa_s *bfa, struct bfa_qos_bw_s *qos_bw) 4090 { 4091 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4092 enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa); 4093 4094 bfa_trc(bfa, ioc_type); 4095 4096 if ((qos_bw->high == 0) || (qos_bw->med == 0) || (qos_bw->low == 0)) 4097 return BFA_STATUS_QOS_BW_INVALID; 4098 4099 if ((qos_bw->high + qos_bw->med + qos_bw->low) != 100) 4100 return BFA_STATUS_QOS_BW_INVALID; 4101 4102 if ((qos_bw->med > qos_bw->high) || (qos_bw->low > qos_bw->med) || 4103 (qos_bw->low > qos_bw->high)) 4104 return BFA_STATUS_QOS_BW_INVALID; 4105 4106 if ((ioc_type == BFA_IOC_TYPE_FC) && 4107 (fcport->cfg.topology != BFA_PORT_TOPOLOGY_LOOP)) 4108 fcport->cfg.qos_bw = *qos_bw; 4109 4110 return BFA_STATUS_OK; 4111 } 4112 4113 bfa_boolean_t 4114 bfa_fcport_is_ratelim(struct bfa_s *bfa) 4115 { 4116 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4117 4118 return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE; 4119 4120 } 4121 4122 /* 4123 * Enable/Disable FAA feature in port config 4124 */ 4125 void 4126 bfa_fcport_cfg_faa(struct bfa_s *bfa, u8 state) 4127 { 4128 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4129 4130 bfa_trc(bfa, state); 4131 fcport->cfg.faa_state = state; 4132 } 4133 4134 /* 4135 * Get default minimum ratelim speed 4136 */ 4137 enum bfa_port_speed 4138 bfa_fcport_get_ratelim_speed(struct bfa_s *bfa) 4139 { 4140 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4141 4142 bfa_trc(bfa, fcport->cfg.trl_def_speed); 4143 return fcport->cfg.trl_def_speed; 4144 4145 } 4146 4147 void 4148 bfa_fcport_beacon(void *dev, bfa_boolean_t beacon, 4149 bfa_boolean_t link_e2e_beacon) 4150 { 4151 struct bfa_s *bfa = dev; 4152 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4153 4154 bfa_trc(bfa, beacon); 4155 bfa_trc(bfa, link_e2e_beacon); 4156 bfa_trc(bfa, fcport->beacon); 4157 bfa_trc(bfa, fcport->link_e2e_beacon); 4158 4159 fcport->beacon = beacon; 4160 fcport->link_e2e_beacon = link_e2e_beacon; 4161 } 4162 4163 bfa_boolean_t 4164 bfa_fcport_is_linkup(struct bfa_s *bfa) 4165 { 4166 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4167 4168 return (!fcport->cfg.trunked && 4169 bfa_sm_cmp_state(fcport, bfa_fcport_sm_linkup)) || 4170 (fcport->cfg.trunked && 4171 fcport->trunk.attr.state == BFA_TRUNK_ONLINE); 4172 } 4173 4174 bfa_boolean_t 4175 bfa_fcport_is_qos_enabled(struct bfa_s *bfa) 4176 { 4177 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4178 4179 return fcport->cfg.qos_enabled; 4180 } 4181 4182 bfa_boolean_t 4183 bfa_fcport_is_trunk_enabled(struct bfa_s *bfa) 4184 { 4185 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4186 4187 return fcport->cfg.trunked; 4188 } 4189 4190 bfa_status_t 4191 bfa_fcport_cfg_bbcr(struct bfa_s *bfa, bfa_boolean_t on_off, u8 bb_scn) 4192 { 4193 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4194 4195 bfa_trc(bfa, on_off); 4196 4197 if (bfa_ioc_get_type(&fcport->bfa->ioc) != BFA_IOC_TYPE_FC) 4198 return BFA_STATUS_BBCR_FC_ONLY; 4199 4200 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type) && 4201 (bfa->ioc.attr->card_type != BFA_MFG_TYPE_CHINOOK)) 4202 return BFA_STATUS_CMD_NOTSUPP_MEZZ; 4203 4204 if (on_off) { 4205 if (fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) 4206 return BFA_STATUS_TOPOLOGY_LOOP; 4207 4208 if (fcport->cfg.qos_enabled) 4209 return BFA_STATUS_ERROR_QOS_ENABLED; 4210 4211 if (fcport->cfg.trunked) 4212 return BFA_STATUS_TRUNK_ENABLED; 4213 4214 if ((fcport->cfg.speed != BFA_PORT_SPEED_AUTO) && 4215 (fcport->cfg.speed < bfa_ioc_speed_sup(&bfa->ioc))) 4216 return BFA_STATUS_ERR_BBCR_SPEED_UNSUPPORT; 4217 4218 if (bfa_ioc_speed_sup(&bfa->ioc) < BFA_PORT_SPEED_8GBPS) 4219 return BFA_STATUS_FEATURE_NOT_SUPPORTED; 4220 4221 if (fcport->cfg.bb_cr_enabled) { 4222 if (bb_scn != fcport->cfg.bb_scn) 4223 return BFA_STATUS_BBCR_CFG_NO_CHANGE; 4224 else 4225 return BFA_STATUS_NO_CHANGE; 4226 } 4227 4228 if ((bb_scn == 0) || (bb_scn > BFA_BB_SCN_MAX)) 4229 bb_scn = BFA_BB_SCN_DEF; 4230 4231 fcport->cfg.bb_cr_enabled = on_off; 4232 fcport->cfg.bb_scn = bb_scn; 4233 } else { 4234 if (!fcport->cfg.bb_cr_enabled) 4235 return BFA_STATUS_NO_CHANGE; 4236 4237 fcport->cfg.bb_cr_enabled = on_off; 4238 fcport->cfg.bb_scn = 0; 4239 } 4240 4241 return BFA_STATUS_OK; 4242 } 4243 4244 bfa_status_t 4245 bfa_fcport_get_bbcr_attr(struct bfa_s *bfa, 4246 struct bfa_bbcr_attr_s *bbcr_attr) 4247 { 4248 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); 4249 4250 if (bfa_ioc_get_type(&fcport->bfa->ioc) != BFA_IOC_TYPE_FC) 4251 return BFA_STATUS_BBCR_FC_ONLY; 4252 4253 if (fcport->cfg.topology == BFA_PORT_TOPOLOGY_LOOP) 4254 return BFA_STATUS_TOPOLOGY_LOOP; 4255 4256 *bbcr_attr = fcport->bbcr_attr; 4257 4258 return BFA_STATUS_OK; 4259 } 4260 4261 void 4262 bfa_fcport_dportenable(struct bfa_s *bfa) 4263 { 4264 /* 4265 * Assume caller check for port is in disable state 4266 */ 4267 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTENABLE); 4268 bfa_port_set_dportenabled(&bfa->modules.port, BFA_TRUE); 4269 } 4270 4271 void 4272 bfa_fcport_dportdisable(struct bfa_s *bfa) 4273 { 4274 /* 4275 * Assume caller check for port is in disable state 4276 */ 4277 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DPORTDISABLE); 4278 bfa_port_set_dportenabled(&bfa->modules.port, BFA_FALSE); 4279 } 4280 4281 static void 4282 bfa_fcport_ddportenable(struct bfa_s *bfa) 4283 { 4284 /* 4285 * Assume caller check for port is in disable state 4286 */ 4287 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DDPORTENABLE); 4288 } 4289 4290 static void 4291 bfa_fcport_ddportdisable(struct bfa_s *bfa) 4292 { 4293 /* 4294 * Assume caller check for port is in disable state 4295 */ 4296 bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DDPORTDISABLE); 4297 } 4298 4299 /* 4300 * Rport State machine functions 4301 */ 4302 /* 4303 * Beginning state, only online event expected. 4304 */ 4305 static void 4306 bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event) 4307 { 4308 bfa_trc(rp->bfa, rp->rport_tag); 4309 bfa_trc(rp->bfa, event); 4310 4311 switch (event) { 4312 case BFA_RPORT_SM_CREATE: 4313 bfa_stats(rp, sm_un_cr); 4314 bfa_sm_set_state(rp, bfa_rport_sm_created); 4315 break; 4316 4317 default: 4318 bfa_stats(rp, sm_un_unexp); 4319 bfa_sm_fault(rp->bfa, event); 4320 } 4321 } 4322 4323 static void 4324 bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event) 4325 { 4326 bfa_trc(rp->bfa, rp->rport_tag); 4327 bfa_trc(rp->bfa, event); 4328 4329 switch (event) { 4330 case BFA_RPORT_SM_ONLINE: 4331 bfa_stats(rp, sm_cr_on); 4332 if (bfa_rport_send_fwcreate(rp)) 4333 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate); 4334 else 4335 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull); 4336 break; 4337 4338 case BFA_RPORT_SM_DELETE: 4339 bfa_stats(rp, sm_cr_del); 4340 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4341 bfa_rport_free(rp); 4342 break; 4343 4344 case BFA_RPORT_SM_HWFAIL: 4345 bfa_stats(rp, sm_cr_hwf); 4346 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4347 break; 4348 4349 default: 4350 bfa_stats(rp, sm_cr_unexp); 4351 bfa_sm_fault(rp->bfa, event); 4352 } 4353 } 4354 4355 /* 4356 * Waiting for rport create response from firmware. 4357 */ 4358 static void 4359 bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event) 4360 { 4361 bfa_trc(rp->bfa, rp->rport_tag); 4362 bfa_trc(rp->bfa, event); 4363 4364 switch (event) { 4365 case BFA_RPORT_SM_FWRSP: 4366 bfa_stats(rp, sm_fwc_rsp); 4367 bfa_sm_set_state(rp, bfa_rport_sm_online); 4368 bfa_rport_online_cb(rp); 4369 break; 4370 4371 case BFA_RPORT_SM_DELETE: 4372 bfa_stats(rp, sm_fwc_del); 4373 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending); 4374 break; 4375 4376 case BFA_RPORT_SM_OFFLINE: 4377 bfa_stats(rp, sm_fwc_off); 4378 bfa_sm_set_state(rp, bfa_rport_sm_offline_pending); 4379 break; 4380 4381 case BFA_RPORT_SM_HWFAIL: 4382 bfa_stats(rp, sm_fwc_hwf); 4383 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4384 break; 4385 4386 default: 4387 bfa_stats(rp, sm_fwc_unexp); 4388 bfa_sm_fault(rp->bfa, event); 4389 } 4390 } 4391 4392 /* 4393 * Request queue is full, awaiting queue resume to send create request. 4394 */ 4395 static void 4396 bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event) 4397 { 4398 bfa_trc(rp->bfa, rp->rport_tag); 4399 bfa_trc(rp->bfa, event); 4400 4401 switch (event) { 4402 case BFA_RPORT_SM_QRESUME: 4403 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate); 4404 bfa_rport_send_fwcreate(rp); 4405 break; 4406 4407 case BFA_RPORT_SM_DELETE: 4408 bfa_stats(rp, sm_fwc_del); 4409 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4410 bfa_reqq_wcancel(&rp->reqq_wait); 4411 bfa_rport_free(rp); 4412 break; 4413 4414 case BFA_RPORT_SM_OFFLINE: 4415 bfa_stats(rp, sm_fwc_off); 4416 bfa_sm_set_state(rp, bfa_rport_sm_offline); 4417 bfa_reqq_wcancel(&rp->reqq_wait); 4418 bfa_rport_offline_cb(rp); 4419 break; 4420 4421 case BFA_RPORT_SM_HWFAIL: 4422 bfa_stats(rp, sm_fwc_hwf); 4423 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4424 bfa_reqq_wcancel(&rp->reqq_wait); 4425 break; 4426 4427 default: 4428 bfa_stats(rp, sm_fwc_unexp); 4429 bfa_sm_fault(rp->bfa, event); 4430 } 4431 } 4432 4433 /* 4434 * Online state - normal parking state. 4435 */ 4436 static void 4437 bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event) 4438 { 4439 struct bfi_rport_qos_scn_s *qos_scn; 4440 4441 bfa_trc(rp->bfa, rp->rport_tag); 4442 bfa_trc(rp->bfa, event); 4443 4444 switch (event) { 4445 case BFA_RPORT_SM_OFFLINE: 4446 bfa_stats(rp, sm_on_off); 4447 if (bfa_rport_send_fwdelete(rp)) 4448 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete); 4449 else 4450 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull); 4451 break; 4452 4453 case BFA_RPORT_SM_DELETE: 4454 bfa_stats(rp, sm_on_del); 4455 if (bfa_rport_send_fwdelete(rp)) 4456 bfa_sm_set_state(rp, bfa_rport_sm_deleting); 4457 else 4458 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull); 4459 break; 4460 4461 case BFA_RPORT_SM_HWFAIL: 4462 bfa_stats(rp, sm_on_hwf); 4463 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4464 break; 4465 4466 case BFA_RPORT_SM_SET_SPEED: 4467 bfa_rport_send_fwspeed(rp); 4468 break; 4469 4470 case BFA_RPORT_SM_QOS_SCN: 4471 qos_scn = (struct bfi_rport_qos_scn_s *) rp->event_arg.fw_msg; 4472 rp->qos_attr = qos_scn->new_qos_attr; 4473 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_flow_id); 4474 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_flow_id); 4475 bfa_trc(rp->bfa, qos_scn->old_qos_attr.qos_priority); 4476 bfa_trc(rp->bfa, qos_scn->new_qos_attr.qos_priority); 4477 4478 qos_scn->old_qos_attr.qos_flow_id = 4479 be32_to_cpu(qos_scn->old_qos_attr.qos_flow_id); 4480 qos_scn->new_qos_attr.qos_flow_id = 4481 be32_to_cpu(qos_scn->new_qos_attr.qos_flow_id); 4482 4483 if (qos_scn->old_qos_attr.qos_flow_id != 4484 qos_scn->new_qos_attr.qos_flow_id) 4485 bfa_cb_rport_qos_scn_flowid(rp->rport_drv, 4486 qos_scn->old_qos_attr, 4487 qos_scn->new_qos_attr); 4488 if (qos_scn->old_qos_attr.qos_priority != 4489 qos_scn->new_qos_attr.qos_priority) 4490 bfa_cb_rport_qos_scn_prio(rp->rport_drv, 4491 qos_scn->old_qos_attr, 4492 qos_scn->new_qos_attr); 4493 break; 4494 4495 default: 4496 bfa_stats(rp, sm_on_unexp); 4497 bfa_sm_fault(rp->bfa, event); 4498 } 4499 } 4500 4501 /* 4502 * Firmware rport is being deleted - awaiting f/w response. 4503 */ 4504 static void 4505 bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event) 4506 { 4507 bfa_trc(rp->bfa, rp->rport_tag); 4508 bfa_trc(rp->bfa, event); 4509 4510 switch (event) { 4511 case BFA_RPORT_SM_FWRSP: 4512 bfa_stats(rp, sm_fwd_rsp); 4513 bfa_sm_set_state(rp, bfa_rport_sm_offline); 4514 bfa_rport_offline_cb(rp); 4515 break; 4516 4517 case BFA_RPORT_SM_DELETE: 4518 bfa_stats(rp, sm_fwd_del); 4519 bfa_sm_set_state(rp, bfa_rport_sm_deleting); 4520 break; 4521 4522 case BFA_RPORT_SM_HWFAIL: 4523 bfa_stats(rp, sm_fwd_hwf); 4524 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4525 bfa_rport_offline_cb(rp); 4526 break; 4527 4528 default: 4529 bfa_stats(rp, sm_fwd_unexp); 4530 bfa_sm_fault(rp->bfa, event); 4531 } 4532 } 4533 4534 static void 4535 bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event) 4536 { 4537 bfa_trc(rp->bfa, rp->rport_tag); 4538 bfa_trc(rp->bfa, event); 4539 4540 switch (event) { 4541 case BFA_RPORT_SM_QRESUME: 4542 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete); 4543 bfa_rport_send_fwdelete(rp); 4544 break; 4545 4546 case BFA_RPORT_SM_DELETE: 4547 bfa_stats(rp, sm_fwd_del); 4548 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull); 4549 break; 4550 4551 case BFA_RPORT_SM_HWFAIL: 4552 bfa_stats(rp, sm_fwd_hwf); 4553 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4554 bfa_reqq_wcancel(&rp->reqq_wait); 4555 bfa_rport_offline_cb(rp); 4556 break; 4557 4558 default: 4559 bfa_stats(rp, sm_fwd_unexp); 4560 bfa_sm_fault(rp->bfa, event); 4561 } 4562 } 4563 4564 /* 4565 * Offline state. 4566 */ 4567 static void 4568 bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event) 4569 { 4570 bfa_trc(rp->bfa, rp->rport_tag); 4571 bfa_trc(rp->bfa, event); 4572 4573 switch (event) { 4574 case BFA_RPORT_SM_DELETE: 4575 bfa_stats(rp, sm_off_del); 4576 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4577 bfa_rport_free(rp); 4578 break; 4579 4580 case BFA_RPORT_SM_ONLINE: 4581 bfa_stats(rp, sm_off_on); 4582 if (bfa_rport_send_fwcreate(rp)) 4583 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate); 4584 else 4585 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull); 4586 break; 4587 4588 case BFA_RPORT_SM_HWFAIL: 4589 bfa_stats(rp, sm_off_hwf); 4590 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4591 break; 4592 4593 case BFA_RPORT_SM_OFFLINE: 4594 bfa_rport_offline_cb(rp); 4595 break; 4596 4597 default: 4598 bfa_stats(rp, sm_off_unexp); 4599 bfa_sm_fault(rp->bfa, event); 4600 } 4601 } 4602 4603 /* 4604 * Rport is deleted, waiting for firmware response to delete. 4605 */ 4606 static void 4607 bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event) 4608 { 4609 bfa_trc(rp->bfa, rp->rport_tag); 4610 bfa_trc(rp->bfa, event); 4611 4612 switch (event) { 4613 case BFA_RPORT_SM_FWRSP: 4614 bfa_stats(rp, sm_del_fwrsp); 4615 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4616 bfa_rport_free(rp); 4617 break; 4618 4619 case BFA_RPORT_SM_HWFAIL: 4620 bfa_stats(rp, sm_del_hwf); 4621 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4622 bfa_rport_free(rp); 4623 break; 4624 4625 default: 4626 bfa_sm_fault(rp->bfa, event); 4627 } 4628 } 4629 4630 static void 4631 bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event) 4632 { 4633 bfa_trc(rp->bfa, rp->rport_tag); 4634 bfa_trc(rp->bfa, event); 4635 4636 switch (event) { 4637 case BFA_RPORT_SM_QRESUME: 4638 bfa_stats(rp, sm_del_fwrsp); 4639 bfa_sm_set_state(rp, bfa_rport_sm_deleting); 4640 bfa_rport_send_fwdelete(rp); 4641 break; 4642 4643 case BFA_RPORT_SM_HWFAIL: 4644 bfa_stats(rp, sm_del_hwf); 4645 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4646 bfa_reqq_wcancel(&rp->reqq_wait); 4647 bfa_rport_free(rp); 4648 break; 4649 4650 default: 4651 bfa_sm_fault(rp->bfa, event); 4652 } 4653 } 4654 4655 /* 4656 * Waiting for rport create response from firmware. A delete is pending. 4657 */ 4658 static void 4659 bfa_rport_sm_delete_pending(struct bfa_rport_s *rp, 4660 enum bfa_rport_event event) 4661 { 4662 bfa_trc(rp->bfa, rp->rport_tag); 4663 bfa_trc(rp->bfa, event); 4664 4665 switch (event) { 4666 case BFA_RPORT_SM_FWRSP: 4667 bfa_stats(rp, sm_delp_fwrsp); 4668 if (bfa_rport_send_fwdelete(rp)) 4669 bfa_sm_set_state(rp, bfa_rport_sm_deleting); 4670 else 4671 bfa_sm_set_state(rp, bfa_rport_sm_deleting_qfull); 4672 break; 4673 4674 case BFA_RPORT_SM_HWFAIL: 4675 bfa_stats(rp, sm_delp_hwf); 4676 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4677 bfa_rport_free(rp); 4678 break; 4679 4680 default: 4681 bfa_stats(rp, sm_delp_unexp); 4682 bfa_sm_fault(rp->bfa, event); 4683 } 4684 } 4685 4686 /* 4687 * Waiting for rport create response from firmware. Rport offline is pending. 4688 */ 4689 static void 4690 bfa_rport_sm_offline_pending(struct bfa_rport_s *rp, 4691 enum bfa_rport_event event) 4692 { 4693 bfa_trc(rp->bfa, rp->rport_tag); 4694 bfa_trc(rp->bfa, event); 4695 4696 switch (event) { 4697 case BFA_RPORT_SM_FWRSP: 4698 bfa_stats(rp, sm_offp_fwrsp); 4699 if (bfa_rport_send_fwdelete(rp)) 4700 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete); 4701 else 4702 bfa_sm_set_state(rp, bfa_rport_sm_fwdelete_qfull); 4703 break; 4704 4705 case BFA_RPORT_SM_DELETE: 4706 bfa_stats(rp, sm_offp_del); 4707 bfa_sm_set_state(rp, bfa_rport_sm_delete_pending); 4708 break; 4709 4710 case BFA_RPORT_SM_HWFAIL: 4711 bfa_stats(rp, sm_offp_hwf); 4712 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable); 4713 bfa_rport_offline_cb(rp); 4714 break; 4715 4716 default: 4717 bfa_stats(rp, sm_offp_unexp); 4718 bfa_sm_fault(rp->bfa, event); 4719 } 4720 } 4721 4722 /* 4723 * IOC h/w failed. 4724 */ 4725 static void 4726 bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event) 4727 { 4728 bfa_trc(rp->bfa, rp->rport_tag); 4729 bfa_trc(rp->bfa, event); 4730 4731 switch (event) { 4732 case BFA_RPORT_SM_OFFLINE: 4733 bfa_stats(rp, sm_iocd_off); 4734 bfa_rport_offline_cb(rp); 4735 break; 4736 4737 case BFA_RPORT_SM_DELETE: 4738 bfa_stats(rp, sm_iocd_del); 4739 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4740 bfa_rport_free(rp); 4741 break; 4742 4743 case BFA_RPORT_SM_ONLINE: 4744 bfa_stats(rp, sm_iocd_on); 4745 if (bfa_rport_send_fwcreate(rp)) 4746 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate); 4747 else 4748 bfa_sm_set_state(rp, bfa_rport_sm_fwcreate_qfull); 4749 break; 4750 4751 case BFA_RPORT_SM_HWFAIL: 4752 break; 4753 4754 default: 4755 bfa_stats(rp, sm_iocd_unexp); 4756 bfa_sm_fault(rp->bfa, event); 4757 } 4758 } 4759 4760 4761 4762 /* 4763 * bfa_rport_private BFA rport private functions 4764 */ 4765 4766 static void 4767 __bfa_cb_rport_online(void *cbarg, bfa_boolean_t complete) 4768 { 4769 struct bfa_rport_s *rp = cbarg; 4770 4771 if (complete) 4772 bfa_cb_rport_online(rp->rport_drv); 4773 } 4774 4775 static void 4776 __bfa_cb_rport_offline(void *cbarg, bfa_boolean_t complete) 4777 { 4778 struct bfa_rport_s *rp = cbarg; 4779 4780 if (complete) 4781 bfa_cb_rport_offline(rp->rport_drv); 4782 } 4783 4784 static void 4785 bfa_rport_qresume(void *cbarg) 4786 { 4787 struct bfa_rport_s *rp = cbarg; 4788 4789 bfa_sm_send_event(rp, BFA_RPORT_SM_QRESUME); 4790 } 4791 4792 void 4793 bfa_rport_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo, 4794 struct bfa_s *bfa) 4795 { 4796 struct bfa_mem_kva_s *rport_kva = BFA_MEM_RPORT_KVA(bfa); 4797 4798 if (cfg->fwcfg.num_rports < BFA_RPORT_MIN) 4799 cfg->fwcfg.num_rports = BFA_RPORT_MIN; 4800 4801 /* kva memory */ 4802 bfa_mem_kva_setup(minfo, rport_kva, 4803 cfg->fwcfg.num_rports * sizeof(struct bfa_rport_s)); 4804 } 4805 4806 void 4807 bfa_rport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 4808 struct bfa_pcidev_s *pcidev) 4809 { 4810 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa); 4811 struct bfa_rport_s *rp; 4812 u16 i; 4813 4814 INIT_LIST_HEAD(&mod->rp_free_q); 4815 INIT_LIST_HEAD(&mod->rp_active_q); 4816 INIT_LIST_HEAD(&mod->rp_unused_q); 4817 4818 rp = (struct bfa_rport_s *) bfa_mem_kva_curp(mod); 4819 mod->rps_list = rp; 4820 mod->num_rports = cfg->fwcfg.num_rports; 4821 4822 WARN_ON(!mod->num_rports || 4823 (mod->num_rports & (mod->num_rports - 1))); 4824 4825 for (i = 0; i < mod->num_rports; i++, rp++) { 4826 memset(rp, 0, sizeof(struct bfa_rport_s)); 4827 rp->bfa = bfa; 4828 rp->rport_tag = i; 4829 bfa_sm_set_state(rp, bfa_rport_sm_uninit); 4830 4831 /* 4832 * - is unused 4833 */ 4834 if (i) 4835 list_add_tail(&rp->qe, &mod->rp_free_q); 4836 4837 bfa_reqq_winit(&rp->reqq_wait, bfa_rport_qresume, rp); 4838 } 4839 4840 /* 4841 * consume memory 4842 */ 4843 bfa_mem_kva_curp(mod) = (u8 *) rp; 4844 } 4845 4846 void 4847 bfa_rport_iocdisable(struct bfa_s *bfa) 4848 { 4849 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa); 4850 struct bfa_rport_s *rport; 4851 struct list_head *qe, *qen; 4852 4853 /* Enqueue unused rport resources to free_q */ 4854 list_splice_tail_init(&mod->rp_unused_q, &mod->rp_free_q); 4855 4856 list_for_each_safe(qe, qen, &mod->rp_active_q) { 4857 rport = (struct bfa_rport_s *) qe; 4858 bfa_sm_send_event(rport, BFA_RPORT_SM_HWFAIL); 4859 } 4860 } 4861 4862 static struct bfa_rport_s * 4863 bfa_rport_alloc(struct bfa_rport_mod_s *mod) 4864 { 4865 struct bfa_rport_s *rport; 4866 4867 bfa_q_deq(&mod->rp_free_q, &rport); 4868 if (rport) 4869 list_add_tail(&rport->qe, &mod->rp_active_q); 4870 4871 return rport; 4872 } 4873 4874 static void 4875 bfa_rport_free(struct bfa_rport_s *rport) 4876 { 4877 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(rport->bfa); 4878 4879 WARN_ON(!bfa_q_is_on_q(&mod->rp_active_q, rport)); 4880 list_del(&rport->qe); 4881 list_add_tail(&rport->qe, &mod->rp_free_q); 4882 } 4883 4884 static bfa_boolean_t 4885 bfa_rport_send_fwcreate(struct bfa_rport_s *rp) 4886 { 4887 struct bfi_rport_create_req_s *m; 4888 4889 /* 4890 * check for room in queue to send request now 4891 */ 4892 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT); 4893 if (!m) { 4894 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait); 4895 return BFA_FALSE; 4896 } 4897 4898 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_CREATE_REQ, 4899 bfa_fn_lpu(rp->bfa)); 4900 m->bfa_handle = rp->rport_tag; 4901 m->max_frmsz = cpu_to_be16(rp->rport_info.max_frmsz); 4902 m->pid = rp->rport_info.pid; 4903 m->lp_fwtag = bfa_lps_get_fwtag(rp->bfa, (u8)rp->rport_info.lp_tag); 4904 m->local_pid = rp->rport_info.local_pid; 4905 m->fc_class = rp->rport_info.fc_class; 4906 m->vf_en = rp->rport_info.vf_en; 4907 m->vf_id = rp->rport_info.vf_id; 4908 m->cisc = rp->rport_info.cisc; 4909 4910 /* 4911 * queue I/O message to firmware 4912 */ 4913 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh); 4914 return BFA_TRUE; 4915 } 4916 4917 static bfa_boolean_t 4918 bfa_rport_send_fwdelete(struct bfa_rport_s *rp) 4919 { 4920 struct bfi_rport_delete_req_s *m; 4921 4922 /* 4923 * check for room in queue to send request now 4924 */ 4925 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT); 4926 if (!m) { 4927 bfa_reqq_wait(rp->bfa, BFA_REQQ_RPORT, &rp->reqq_wait); 4928 return BFA_FALSE; 4929 } 4930 4931 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_DELETE_REQ, 4932 bfa_fn_lpu(rp->bfa)); 4933 m->fw_handle = rp->fw_handle; 4934 4935 /* 4936 * queue I/O message to firmware 4937 */ 4938 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh); 4939 return BFA_TRUE; 4940 } 4941 4942 static bfa_boolean_t 4943 bfa_rport_send_fwspeed(struct bfa_rport_s *rp) 4944 { 4945 struct bfa_rport_speed_req_s *m; 4946 4947 /* 4948 * check for room in queue to send request now 4949 */ 4950 m = bfa_reqq_next(rp->bfa, BFA_REQQ_RPORT); 4951 if (!m) { 4952 bfa_trc(rp->bfa, rp->rport_info.speed); 4953 return BFA_FALSE; 4954 } 4955 4956 bfi_h2i_set(m->mh, BFI_MC_RPORT, BFI_RPORT_H2I_SET_SPEED_REQ, 4957 bfa_fn_lpu(rp->bfa)); 4958 m->fw_handle = rp->fw_handle; 4959 m->speed = (u8)rp->rport_info.speed; 4960 4961 /* 4962 * queue I/O message to firmware 4963 */ 4964 bfa_reqq_produce(rp->bfa, BFA_REQQ_RPORT, m->mh); 4965 return BFA_TRUE; 4966 } 4967 4968 4969 4970 /* 4971 * bfa_rport_public 4972 */ 4973 4974 /* 4975 * Rport interrupt processing. 4976 */ 4977 void 4978 bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m) 4979 { 4980 union bfi_rport_i2h_msg_u msg; 4981 struct bfa_rport_s *rp; 4982 4983 bfa_trc(bfa, m->mhdr.msg_id); 4984 4985 msg.msg = m; 4986 4987 switch (m->mhdr.msg_id) { 4988 case BFI_RPORT_I2H_CREATE_RSP: 4989 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle); 4990 rp->fw_handle = msg.create_rsp->fw_handle; 4991 rp->qos_attr = msg.create_rsp->qos_attr; 4992 bfa_rport_set_lunmask(bfa, rp); 4993 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK); 4994 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP); 4995 break; 4996 4997 case BFI_RPORT_I2H_DELETE_RSP: 4998 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle); 4999 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK); 5000 bfa_rport_unset_lunmask(bfa, rp); 5001 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP); 5002 break; 5003 5004 case BFI_RPORT_I2H_QOS_SCN: 5005 rp = BFA_RPORT_FROM_TAG(bfa, msg.qos_scn_evt->bfa_handle); 5006 rp->event_arg.fw_msg = msg.qos_scn_evt; 5007 bfa_sm_send_event(rp, BFA_RPORT_SM_QOS_SCN); 5008 break; 5009 5010 case BFI_RPORT_I2H_LIP_SCN_ONLINE: 5011 bfa_fcport_update_loop_info(BFA_FCPORT_MOD(bfa), 5012 &msg.lip_scn->loop_info); 5013 bfa_cb_rport_scn_online(bfa); 5014 break; 5015 5016 case BFI_RPORT_I2H_LIP_SCN_OFFLINE: 5017 bfa_cb_rport_scn_offline(bfa); 5018 break; 5019 5020 case BFI_RPORT_I2H_NO_DEV: 5021 rp = BFA_RPORT_FROM_TAG(bfa, msg.lip_scn->bfa_handle); 5022 bfa_cb_rport_scn_no_dev(rp->rport_drv); 5023 break; 5024 5025 default: 5026 bfa_trc(bfa, m->mhdr.msg_id); 5027 WARN_ON(1); 5028 } 5029 } 5030 5031 void 5032 bfa_rport_res_recfg(struct bfa_s *bfa, u16 num_rport_fw) 5033 { 5034 struct bfa_rport_mod_s *mod = BFA_RPORT_MOD(bfa); 5035 struct list_head *qe; 5036 int i; 5037 5038 for (i = 0; i < (mod->num_rports - num_rport_fw); i++) { 5039 bfa_q_deq_tail(&mod->rp_free_q, &qe); 5040 list_add_tail(qe, &mod->rp_unused_q); 5041 } 5042 } 5043 5044 /* 5045 * bfa_rport_api 5046 */ 5047 5048 struct bfa_rport_s * 5049 bfa_rport_create(struct bfa_s *bfa, void *rport_drv) 5050 { 5051 struct bfa_rport_s *rp; 5052 5053 rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa)); 5054 5055 if (rp == NULL) 5056 return NULL; 5057 5058 rp->bfa = bfa; 5059 rp->rport_drv = rport_drv; 5060 memset(&rp->stats, 0, sizeof(rp->stats)); 5061 5062 WARN_ON(!bfa_sm_cmp_state(rp, bfa_rport_sm_uninit)); 5063 bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE); 5064 5065 return rp; 5066 } 5067 5068 void 5069 bfa_rport_online(struct bfa_rport_s *rport, struct bfa_rport_info_s *rport_info) 5070 { 5071 WARN_ON(rport_info->max_frmsz == 0); 5072 5073 /* 5074 * Some JBODs are seen to be not setting PDU size correctly in PLOGI 5075 * responses. Default to minimum size. 5076 */ 5077 if (rport_info->max_frmsz == 0) { 5078 bfa_trc(rport->bfa, rport->rport_tag); 5079 rport_info->max_frmsz = FC_MIN_PDUSZ; 5080 } 5081 5082 rport->rport_info = *rport_info; 5083 bfa_sm_send_event(rport, BFA_RPORT_SM_ONLINE); 5084 } 5085 5086 void 5087 bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed) 5088 { 5089 WARN_ON(speed == 0); 5090 WARN_ON(speed == BFA_PORT_SPEED_AUTO); 5091 5092 if (rport) { 5093 rport->rport_info.speed = speed; 5094 bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED); 5095 } 5096 } 5097 5098 /* Set Rport LUN Mask */ 5099 void 5100 bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp) 5101 { 5102 struct bfa_lps_mod_s *lps_mod = BFA_LPS_MOD(bfa); 5103 wwn_t lp_wwn, rp_wwn; 5104 u8 lp_tag = (u8)rp->rport_info.lp_tag; 5105 5106 rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn; 5107 lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn; 5108 5109 BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask = 5110 rp->lun_mask = BFA_TRUE; 5111 bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn, rp->rport_tag, lp_tag); 5112 } 5113 5114 /* Unset Rport LUN mask */ 5115 void 5116 bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp) 5117 { 5118 struct bfa_lps_mod_s *lps_mod = BFA_LPS_MOD(bfa); 5119 wwn_t lp_wwn, rp_wwn; 5120 5121 rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn; 5122 lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn; 5123 5124 BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask = 5125 rp->lun_mask = BFA_FALSE; 5126 bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn, 5127 BFA_RPORT_TAG_INVALID, BFA_LP_TAG_INVALID); 5128 } 5129 5130 /* 5131 * SGPG related functions 5132 */ 5133 5134 /* 5135 * Compute and return memory needed by FCP(im) module. 5136 */ 5137 void 5138 bfa_sgpg_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo, 5139 struct bfa_s *bfa) 5140 { 5141 struct bfa_sgpg_mod_s *sgpg_mod = BFA_SGPG_MOD(bfa); 5142 struct bfa_mem_kva_s *sgpg_kva = BFA_MEM_SGPG_KVA(bfa); 5143 struct bfa_mem_dma_s *seg_ptr; 5144 u16 nsegs, idx, per_seg_sgpg, num_sgpg; 5145 u32 sgpg_sz = sizeof(struct bfi_sgpg_s); 5146 5147 if (cfg->drvcfg.num_sgpgs < BFA_SGPG_MIN) 5148 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN; 5149 else if (cfg->drvcfg.num_sgpgs > BFA_SGPG_MAX) 5150 cfg->drvcfg.num_sgpgs = BFA_SGPG_MAX; 5151 5152 num_sgpg = cfg->drvcfg.num_sgpgs; 5153 5154 nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz); 5155 per_seg_sgpg = BFI_MEM_NREQS_SEG(sgpg_sz); 5156 5157 bfa_mem_dma_seg_iter(sgpg_mod, seg_ptr, nsegs, idx) { 5158 if (num_sgpg >= per_seg_sgpg) { 5159 num_sgpg -= per_seg_sgpg; 5160 bfa_mem_dma_setup(minfo, seg_ptr, 5161 per_seg_sgpg * sgpg_sz); 5162 } else 5163 bfa_mem_dma_setup(minfo, seg_ptr, 5164 num_sgpg * sgpg_sz); 5165 } 5166 5167 /* kva memory */ 5168 bfa_mem_kva_setup(minfo, sgpg_kva, 5169 cfg->drvcfg.num_sgpgs * sizeof(struct bfa_sgpg_s)); 5170 } 5171 5172 void 5173 bfa_sgpg_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 5174 struct bfa_pcidev_s *pcidev) 5175 { 5176 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa); 5177 struct bfa_sgpg_s *hsgpg; 5178 struct bfi_sgpg_s *sgpg; 5179 u64 align_len; 5180 struct bfa_mem_dma_s *seg_ptr; 5181 u32 sgpg_sz = sizeof(struct bfi_sgpg_s); 5182 u16 i, idx, nsegs, per_seg_sgpg, num_sgpg; 5183 5184 union { 5185 u64 pa; 5186 union bfi_addr_u addr; 5187 } sgpg_pa, sgpg_pa_tmp; 5188 5189 INIT_LIST_HEAD(&mod->sgpg_q); 5190 INIT_LIST_HEAD(&mod->sgpg_wait_q); 5191 5192 bfa_trc(bfa, cfg->drvcfg.num_sgpgs); 5193 5194 mod->free_sgpgs = mod->num_sgpgs = cfg->drvcfg.num_sgpgs; 5195 5196 num_sgpg = cfg->drvcfg.num_sgpgs; 5197 nsegs = BFI_MEM_DMA_NSEGS(num_sgpg, sgpg_sz); 5198 5199 /* dma/kva mem claim */ 5200 hsgpg = (struct bfa_sgpg_s *) bfa_mem_kva_curp(mod); 5201 5202 bfa_mem_dma_seg_iter(mod, seg_ptr, nsegs, idx) { 5203 5204 if (!bfa_mem_dma_virt(seg_ptr)) 5205 break; 5206 5207 align_len = BFA_SGPG_ROUNDUP(bfa_mem_dma_phys(seg_ptr)) - 5208 bfa_mem_dma_phys(seg_ptr); 5209 5210 sgpg = (struct bfi_sgpg_s *) 5211 (((u8 *) bfa_mem_dma_virt(seg_ptr)) + align_len); 5212 sgpg_pa.pa = bfa_mem_dma_phys(seg_ptr) + align_len; 5213 WARN_ON(sgpg_pa.pa & (sgpg_sz - 1)); 5214 5215 per_seg_sgpg = (seg_ptr->mem_len - (u32)align_len) / sgpg_sz; 5216 5217 for (i = 0; num_sgpg > 0 && i < per_seg_sgpg; i++, num_sgpg--) { 5218 memset(hsgpg, 0, sizeof(*hsgpg)); 5219 memset(sgpg, 0, sizeof(*sgpg)); 5220 5221 hsgpg->sgpg = sgpg; 5222 sgpg_pa_tmp.pa = bfa_sgaddr_le(sgpg_pa.pa); 5223 hsgpg->sgpg_pa = sgpg_pa_tmp.addr; 5224 list_add_tail(&hsgpg->qe, &mod->sgpg_q); 5225 5226 sgpg++; 5227 hsgpg++; 5228 sgpg_pa.pa += sgpg_sz; 5229 } 5230 } 5231 5232 bfa_mem_kva_curp(mod) = (u8 *) hsgpg; 5233 } 5234 5235 bfa_status_t 5236 bfa_sgpg_malloc(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpgs) 5237 { 5238 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa); 5239 struct bfa_sgpg_s *hsgpg; 5240 int i; 5241 5242 if (mod->free_sgpgs < nsgpgs) 5243 return BFA_STATUS_ENOMEM; 5244 5245 for (i = 0; i < nsgpgs; i++) { 5246 bfa_q_deq(&mod->sgpg_q, &hsgpg); 5247 WARN_ON(!hsgpg); 5248 list_add_tail(&hsgpg->qe, sgpg_q); 5249 } 5250 5251 mod->free_sgpgs -= nsgpgs; 5252 return BFA_STATUS_OK; 5253 } 5254 5255 void 5256 bfa_sgpg_mfree(struct bfa_s *bfa, struct list_head *sgpg_q, int nsgpg) 5257 { 5258 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa); 5259 struct bfa_sgpg_wqe_s *wqe; 5260 5261 mod->free_sgpgs += nsgpg; 5262 WARN_ON(mod->free_sgpgs > mod->num_sgpgs); 5263 5264 list_splice_tail_init(sgpg_q, &mod->sgpg_q); 5265 5266 if (list_empty(&mod->sgpg_wait_q)) 5267 return; 5268 5269 /* 5270 * satisfy as many waiting requests as possible 5271 */ 5272 do { 5273 wqe = bfa_q_first(&mod->sgpg_wait_q); 5274 if (mod->free_sgpgs < wqe->nsgpg) 5275 nsgpg = mod->free_sgpgs; 5276 else 5277 nsgpg = wqe->nsgpg; 5278 bfa_sgpg_malloc(bfa, &wqe->sgpg_q, nsgpg); 5279 wqe->nsgpg -= nsgpg; 5280 if (wqe->nsgpg == 0) { 5281 list_del(&wqe->qe); 5282 wqe->cbfn(wqe->cbarg); 5283 } 5284 } while (mod->free_sgpgs && !list_empty(&mod->sgpg_wait_q)); 5285 } 5286 5287 void 5288 bfa_sgpg_wait(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe, int nsgpg) 5289 { 5290 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa); 5291 5292 WARN_ON(nsgpg <= 0); 5293 WARN_ON(nsgpg <= mod->free_sgpgs); 5294 5295 wqe->nsgpg_total = wqe->nsgpg = nsgpg; 5296 5297 /* 5298 * allocate any left to this one first 5299 */ 5300 if (mod->free_sgpgs) { 5301 /* 5302 * no one else is waiting for SGPG 5303 */ 5304 WARN_ON(!list_empty(&mod->sgpg_wait_q)); 5305 list_splice_tail_init(&mod->sgpg_q, &wqe->sgpg_q); 5306 wqe->nsgpg -= mod->free_sgpgs; 5307 mod->free_sgpgs = 0; 5308 } 5309 5310 list_add_tail(&wqe->qe, &mod->sgpg_wait_q); 5311 } 5312 5313 void 5314 bfa_sgpg_wcancel(struct bfa_s *bfa, struct bfa_sgpg_wqe_s *wqe) 5315 { 5316 struct bfa_sgpg_mod_s *mod = BFA_SGPG_MOD(bfa); 5317 5318 WARN_ON(!bfa_q_is_on_q(&mod->sgpg_wait_q, wqe)); 5319 list_del(&wqe->qe); 5320 5321 if (wqe->nsgpg_total != wqe->nsgpg) 5322 bfa_sgpg_mfree(bfa, &wqe->sgpg_q, 5323 wqe->nsgpg_total - wqe->nsgpg); 5324 } 5325 5326 void 5327 bfa_sgpg_winit(struct bfa_sgpg_wqe_s *wqe, void (*cbfn) (void *cbarg), 5328 void *cbarg) 5329 { 5330 INIT_LIST_HEAD(&wqe->sgpg_q); 5331 wqe->cbfn = cbfn; 5332 wqe->cbarg = cbarg; 5333 } 5334 5335 /* 5336 * UF related functions 5337 */ 5338 /* 5339 ***************************************************************************** 5340 * Internal functions 5341 ***************************************************************************** 5342 */ 5343 static void 5344 __bfa_cb_uf_recv(void *cbarg, bfa_boolean_t complete) 5345 { 5346 struct bfa_uf_s *uf = cbarg; 5347 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(uf->bfa); 5348 5349 if (complete) 5350 ufm->ufrecv(ufm->cbarg, uf); 5351 } 5352 5353 static void 5354 claim_uf_post_msgs(struct bfa_uf_mod_s *ufm) 5355 { 5356 struct bfi_uf_buf_post_s *uf_bp_msg; 5357 u16 i; 5358 u16 buf_len; 5359 5360 ufm->uf_buf_posts = (struct bfi_uf_buf_post_s *) bfa_mem_kva_curp(ufm); 5361 uf_bp_msg = ufm->uf_buf_posts; 5362 5363 for (i = 0, uf_bp_msg = ufm->uf_buf_posts; i < ufm->num_ufs; 5364 i++, uf_bp_msg++) { 5365 memset(uf_bp_msg, 0, sizeof(struct bfi_uf_buf_post_s)); 5366 5367 uf_bp_msg->buf_tag = i; 5368 buf_len = sizeof(struct bfa_uf_buf_s); 5369 uf_bp_msg->buf_len = cpu_to_be16(buf_len); 5370 bfi_h2i_set(uf_bp_msg->mh, BFI_MC_UF, BFI_UF_H2I_BUF_POST, 5371 bfa_fn_lpu(ufm->bfa)); 5372 bfa_alen_set(&uf_bp_msg->alen, buf_len, ufm_pbs_pa(ufm, i)); 5373 } 5374 5375 /* 5376 * advance pointer beyond consumed memory 5377 */ 5378 bfa_mem_kva_curp(ufm) = (u8 *) uf_bp_msg; 5379 } 5380 5381 static void 5382 claim_ufs(struct bfa_uf_mod_s *ufm) 5383 { 5384 u16 i; 5385 struct bfa_uf_s *uf; 5386 5387 /* 5388 * Claim block of memory for UF list 5389 */ 5390 ufm->uf_list = (struct bfa_uf_s *) bfa_mem_kva_curp(ufm); 5391 5392 /* 5393 * Initialize UFs and queue it in UF free queue 5394 */ 5395 for (i = 0, uf = ufm->uf_list; i < ufm->num_ufs; i++, uf++) { 5396 memset(uf, 0, sizeof(struct bfa_uf_s)); 5397 uf->bfa = ufm->bfa; 5398 uf->uf_tag = i; 5399 uf->pb_len = BFA_PER_UF_DMA_SZ; 5400 uf->buf_kva = bfa_mem_get_dmabuf_kva(ufm, i, BFA_PER_UF_DMA_SZ); 5401 uf->buf_pa = ufm_pbs_pa(ufm, i); 5402 list_add_tail(&uf->qe, &ufm->uf_free_q); 5403 } 5404 5405 /* 5406 * advance memory pointer 5407 */ 5408 bfa_mem_kva_curp(ufm) = (u8 *) uf; 5409 } 5410 5411 static void 5412 uf_mem_claim(struct bfa_uf_mod_s *ufm) 5413 { 5414 claim_ufs(ufm); 5415 claim_uf_post_msgs(ufm); 5416 } 5417 5418 void 5419 bfa_uf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo, 5420 struct bfa_s *bfa) 5421 { 5422 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa); 5423 struct bfa_mem_kva_s *uf_kva = BFA_MEM_UF_KVA(bfa); 5424 u32 num_ufs = cfg->fwcfg.num_uf_bufs; 5425 struct bfa_mem_dma_s *seg_ptr; 5426 u16 nsegs, idx, per_seg_uf = 0; 5427 5428 nsegs = BFI_MEM_DMA_NSEGS(num_ufs, BFA_PER_UF_DMA_SZ); 5429 per_seg_uf = BFI_MEM_NREQS_SEG(BFA_PER_UF_DMA_SZ); 5430 5431 bfa_mem_dma_seg_iter(ufm, seg_ptr, nsegs, idx) { 5432 if (num_ufs >= per_seg_uf) { 5433 num_ufs -= per_seg_uf; 5434 bfa_mem_dma_setup(minfo, seg_ptr, 5435 per_seg_uf * BFA_PER_UF_DMA_SZ); 5436 } else 5437 bfa_mem_dma_setup(minfo, seg_ptr, 5438 num_ufs * BFA_PER_UF_DMA_SZ); 5439 } 5440 5441 /* kva memory */ 5442 bfa_mem_kva_setup(minfo, uf_kva, cfg->fwcfg.num_uf_bufs * 5443 (sizeof(struct bfa_uf_s) + sizeof(struct bfi_uf_buf_post_s))); 5444 } 5445 5446 void 5447 bfa_uf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 5448 struct bfa_pcidev_s *pcidev) 5449 { 5450 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa); 5451 5452 ufm->bfa = bfa; 5453 ufm->num_ufs = cfg->fwcfg.num_uf_bufs; 5454 INIT_LIST_HEAD(&ufm->uf_free_q); 5455 INIT_LIST_HEAD(&ufm->uf_posted_q); 5456 INIT_LIST_HEAD(&ufm->uf_unused_q); 5457 5458 uf_mem_claim(ufm); 5459 } 5460 5461 static struct bfa_uf_s * 5462 bfa_uf_get(struct bfa_uf_mod_s *uf_mod) 5463 { 5464 struct bfa_uf_s *uf; 5465 5466 bfa_q_deq(&uf_mod->uf_free_q, &uf); 5467 return uf; 5468 } 5469 5470 static void 5471 bfa_uf_put(struct bfa_uf_mod_s *uf_mod, struct bfa_uf_s *uf) 5472 { 5473 list_add_tail(&uf->qe, &uf_mod->uf_free_q); 5474 } 5475 5476 static bfa_status_t 5477 bfa_uf_post(struct bfa_uf_mod_s *ufm, struct bfa_uf_s *uf) 5478 { 5479 struct bfi_uf_buf_post_s *uf_post_msg; 5480 5481 uf_post_msg = bfa_reqq_next(ufm->bfa, BFA_REQQ_FCXP); 5482 if (!uf_post_msg) 5483 return BFA_STATUS_FAILED; 5484 5485 memcpy(uf_post_msg, &ufm->uf_buf_posts[uf->uf_tag], 5486 sizeof(struct bfi_uf_buf_post_s)); 5487 bfa_reqq_produce(ufm->bfa, BFA_REQQ_FCXP, uf_post_msg->mh); 5488 5489 bfa_trc(ufm->bfa, uf->uf_tag); 5490 5491 list_add_tail(&uf->qe, &ufm->uf_posted_q); 5492 return BFA_STATUS_OK; 5493 } 5494 5495 static void 5496 bfa_uf_post_all(struct bfa_uf_mod_s *uf_mod) 5497 { 5498 struct bfa_uf_s *uf; 5499 5500 while ((uf = bfa_uf_get(uf_mod)) != NULL) { 5501 if (bfa_uf_post(uf_mod, uf) != BFA_STATUS_OK) 5502 break; 5503 } 5504 } 5505 5506 static void 5507 uf_recv(struct bfa_s *bfa, struct bfi_uf_frm_rcvd_s *m) 5508 { 5509 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa); 5510 u16 uf_tag = m->buf_tag; 5511 struct bfa_uf_s *uf = &ufm->uf_list[uf_tag]; 5512 struct bfa_uf_buf_s *uf_buf; 5513 uint8_t *buf; 5514 5515 uf_buf = (struct bfa_uf_buf_s *) 5516 bfa_mem_get_dmabuf_kva(ufm, uf_tag, uf->pb_len); 5517 buf = &uf_buf->d[0]; 5518 5519 m->frm_len = be16_to_cpu(m->frm_len); 5520 m->xfr_len = be16_to_cpu(m->xfr_len); 5521 5522 list_del(&uf->qe); /* dequeue from posted queue */ 5523 5524 uf->data_ptr = buf; 5525 uf->data_len = m->xfr_len; 5526 5527 WARN_ON(uf->data_len < sizeof(struct fchs_s)); 5528 5529 if (uf->data_len == sizeof(struct fchs_s)) { 5530 bfa_plog_fchdr(bfa->plog, BFA_PL_MID_HAL_UF, BFA_PL_EID_RX, 5531 uf->data_len, (struct fchs_s *)buf); 5532 } else { 5533 u32 pld_w0 = *((u32 *) (buf + sizeof(struct fchs_s))); 5534 bfa_plog_fchdr_and_pl(bfa->plog, BFA_PL_MID_HAL_UF, 5535 BFA_PL_EID_RX, uf->data_len, 5536 (struct fchs_s *)buf, pld_w0); 5537 } 5538 5539 if (bfa->fcs) 5540 __bfa_cb_uf_recv(uf, BFA_TRUE); 5541 else 5542 bfa_cb_queue(bfa, &uf->hcb_qe, __bfa_cb_uf_recv, uf); 5543 } 5544 5545 void 5546 bfa_uf_iocdisable(struct bfa_s *bfa) 5547 { 5548 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa); 5549 struct bfa_uf_s *uf; 5550 struct list_head *qe, *qen; 5551 5552 /* Enqueue unused uf resources to free_q */ 5553 list_splice_tail_init(&ufm->uf_unused_q, &ufm->uf_free_q); 5554 5555 list_for_each_safe(qe, qen, &ufm->uf_posted_q) { 5556 uf = (struct bfa_uf_s *) qe; 5557 list_del(&uf->qe); 5558 bfa_uf_put(ufm, uf); 5559 } 5560 } 5561 5562 void 5563 bfa_uf_start(struct bfa_s *bfa) 5564 { 5565 bfa_uf_post_all(BFA_UF_MOD(bfa)); 5566 } 5567 5568 /* 5569 * Register handler for all unsolicted receive frames. 5570 * 5571 * @param[in] bfa BFA instance 5572 * @param[in] ufrecv receive handler function 5573 * @param[in] cbarg receive handler arg 5574 */ 5575 void 5576 bfa_uf_recv_register(struct bfa_s *bfa, bfa_cb_uf_recv_t ufrecv, void *cbarg) 5577 { 5578 struct bfa_uf_mod_s *ufm = BFA_UF_MOD(bfa); 5579 5580 ufm->ufrecv = ufrecv; 5581 ufm->cbarg = cbarg; 5582 } 5583 5584 /* 5585 * Free an unsolicited frame back to BFA. 5586 * 5587 * @param[in] uf unsolicited frame to be freed 5588 * 5589 * @return None 5590 */ 5591 void 5592 bfa_uf_free(struct bfa_uf_s *uf) 5593 { 5594 bfa_uf_put(BFA_UF_MOD(uf->bfa), uf); 5595 bfa_uf_post_all(BFA_UF_MOD(uf->bfa)); 5596 } 5597 5598 5599 5600 /* 5601 * uf_pub BFA uf module public functions 5602 */ 5603 void 5604 bfa_uf_isr(struct bfa_s *bfa, struct bfi_msg_s *msg) 5605 { 5606 bfa_trc(bfa, msg->mhdr.msg_id); 5607 5608 switch (msg->mhdr.msg_id) { 5609 case BFI_UF_I2H_FRM_RCVD: 5610 uf_recv(bfa, (struct bfi_uf_frm_rcvd_s *) msg); 5611 break; 5612 5613 default: 5614 bfa_trc(bfa, msg->mhdr.msg_id); 5615 WARN_ON(1); 5616 } 5617 } 5618 5619 void 5620 bfa_uf_res_recfg(struct bfa_s *bfa, u16 num_uf_fw) 5621 { 5622 struct bfa_uf_mod_s *mod = BFA_UF_MOD(bfa); 5623 struct list_head *qe; 5624 int i; 5625 5626 for (i = 0; i < (mod->num_ufs - num_uf_fw); i++) { 5627 bfa_q_deq_tail(&mod->uf_free_q, &qe); 5628 list_add_tail(qe, &mod->uf_unused_q); 5629 } 5630 } 5631 5632 /* 5633 * Dport forward declaration 5634 */ 5635 5636 enum bfa_dport_test_state_e { 5637 BFA_DPORT_ST_DISABLED = 0, /*!< dport is disabled */ 5638 BFA_DPORT_ST_INP = 1, /*!< test in progress */ 5639 BFA_DPORT_ST_COMP = 2, /*!< test complete successfully */ 5640 BFA_DPORT_ST_NO_SFP = 3, /*!< sfp is not present */ 5641 BFA_DPORT_ST_NOTSTART = 4, /*!< test not start dport is enabled */ 5642 }; 5643 5644 /* 5645 * BFA DPORT state machine events 5646 */ 5647 enum bfa_dport_sm_event { 5648 BFA_DPORT_SM_ENABLE = 1, /* dport enable event */ 5649 BFA_DPORT_SM_DISABLE = 2, /* dport disable event */ 5650 BFA_DPORT_SM_FWRSP = 3, /* fw enable/disable rsp */ 5651 BFA_DPORT_SM_QRESUME = 4, /* CQ space available */ 5652 BFA_DPORT_SM_HWFAIL = 5, /* IOC h/w failure */ 5653 BFA_DPORT_SM_START = 6, /* re-start dport test */ 5654 BFA_DPORT_SM_REQFAIL = 7, /* request failure */ 5655 BFA_DPORT_SM_SCN = 8, /* state change notify frm fw */ 5656 }; 5657 5658 static void bfa_dport_sm_disabled(struct bfa_dport_s *dport, 5659 enum bfa_dport_sm_event event); 5660 static void bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport, 5661 enum bfa_dport_sm_event event); 5662 static void bfa_dport_sm_enabling(struct bfa_dport_s *dport, 5663 enum bfa_dport_sm_event event); 5664 static void bfa_dport_sm_enabled(struct bfa_dport_s *dport, 5665 enum bfa_dport_sm_event event); 5666 static void bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport, 5667 enum bfa_dport_sm_event event); 5668 static void bfa_dport_sm_disabling(struct bfa_dport_s *dport, 5669 enum bfa_dport_sm_event event); 5670 static void bfa_dport_sm_starting_qwait(struct bfa_dport_s *dport, 5671 enum bfa_dport_sm_event event); 5672 static void bfa_dport_sm_starting(struct bfa_dport_s *dport, 5673 enum bfa_dport_sm_event event); 5674 static void bfa_dport_sm_dynamic_disabling(struct bfa_dport_s *dport, 5675 enum bfa_dport_sm_event event); 5676 static void bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s *dport, 5677 enum bfa_dport_sm_event event); 5678 static void bfa_dport_qresume(void *cbarg); 5679 static void bfa_dport_req_comp(struct bfa_dport_s *dport, 5680 struct bfi_diag_dport_rsp_s *msg); 5681 static void bfa_dport_scn(struct bfa_dport_s *dport, 5682 struct bfi_diag_dport_scn_s *msg); 5683 5684 /* 5685 * BFA fcdiag module 5686 */ 5687 #define BFA_DIAG_QTEST_TOV 1000 /* msec */ 5688 5689 /* 5690 * Set port status to busy 5691 */ 5692 static void 5693 bfa_fcdiag_set_busy_status(struct bfa_fcdiag_s *fcdiag) 5694 { 5695 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(fcdiag->bfa); 5696 5697 if (fcdiag->lb.lock) 5698 fcport->diag_busy = BFA_TRUE; 5699 else 5700 fcport->diag_busy = BFA_FALSE; 5701 } 5702 5703 void 5704 bfa_fcdiag_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 5705 struct bfa_pcidev_s *pcidev) 5706 { 5707 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5708 struct bfa_dport_s *dport = &fcdiag->dport; 5709 5710 fcdiag->bfa = bfa; 5711 fcdiag->trcmod = bfa->trcmod; 5712 /* The common DIAG attach bfa_diag_attach() will do all memory claim */ 5713 dport->bfa = bfa; 5714 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 5715 bfa_reqq_winit(&dport->reqq_wait, bfa_dport_qresume, dport); 5716 dport->cbfn = NULL; 5717 dport->cbarg = NULL; 5718 dport->test_state = BFA_DPORT_ST_DISABLED; 5719 memset(&dport->result, 0, sizeof(struct bfa_diag_dport_result_s)); 5720 } 5721 5722 void 5723 bfa_fcdiag_iocdisable(struct bfa_s *bfa) 5724 { 5725 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5726 struct bfa_dport_s *dport = &fcdiag->dport; 5727 5728 bfa_trc(fcdiag, fcdiag->lb.lock); 5729 if (fcdiag->lb.lock) { 5730 fcdiag->lb.status = BFA_STATUS_IOC_FAILURE; 5731 fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status); 5732 fcdiag->lb.lock = 0; 5733 bfa_fcdiag_set_busy_status(fcdiag); 5734 } 5735 5736 bfa_sm_send_event(dport, BFA_DPORT_SM_HWFAIL); 5737 } 5738 5739 static void 5740 bfa_fcdiag_queuetest_timeout(void *cbarg) 5741 { 5742 struct bfa_fcdiag_s *fcdiag = cbarg; 5743 struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result; 5744 5745 bfa_trc(fcdiag, fcdiag->qtest.all); 5746 bfa_trc(fcdiag, fcdiag->qtest.count); 5747 5748 fcdiag->qtest.timer_active = 0; 5749 5750 res->status = BFA_STATUS_ETIMER; 5751 res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count; 5752 if (fcdiag->qtest.all) 5753 res->queue = fcdiag->qtest.all; 5754 5755 bfa_trc(fcdiag, BFA_STATUS_ETIMER); 5756 fcdiag->qtest.status = BFA_STATUS_ETIMER; 5757 fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status); 5758 fcdiag->qtest.lock = 0; 5759 } 5760 5761 static bfa_status_t 5762 bfa_fcdiag_queuetest_send(struct bfa_fcdiag_s *fcdiag) 5763 { 5764 u32 i; 5765 struct bfi_diag_qtest_req_s *req; 5766 5767 req = bfa_reqq_next(fcdiag->bfa, fcdiag->qtest.queue); 5768 if (!req) 5769 return BFA_STATUS_DEVBUSY; 5770 5771 /* build host command */ 5772 bfi_h2i_set(req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_QTEST, 5773 bfa_fn_lpu(fcdiag->bfa)); 5774 5775 for (i = 0; i < BFI_LMSG_PL_WSZ; i++) 5776 req->data[i] = QTEST_PAT_DEFAULT; 5777 5778 bfa_trc(fcdiag, fcdiag->qtest.queue); 5779 /* ring door bell */ 5780 bfa_reqq_produce(fcdiag->bfa, fcdiag->qtest.queue, req->mh); 5781 return BFA_STATUS_OK; 5782 } 5783 5784 static void 5785 bfa_fcdiag_queuetest_comp(struct bfa_fcdiag_s *fcdiag, 5786 bfi_diag_qtest_rsp_t *rsp) 5787 { 5788 struct bfa_diag_qtest_result_s *res = fcdiag->qtest.result; 5789 bfa_status_t status = BFA_STATUS_OK; 5790 int i; 5791 5792 /* Check timer, should still be active */ 5793 if (!fcdiag->qtest.timer_active) { 5794 bfa_trc(fcdiag, fcdiag->qtest.timer_active); 5795 return; 5796 } 5797 5798 /* update count */ 5799 fcdiag->qtest.count--; 5800 5801 /* Check result */ 5802 for (i = 0; i < BFI_LMSG_PL_WSZ; i++) { 5803 if (rsp->data[i] != ~(QTEST_PAT_DEFAULT)) { 5804 res->status = BFA_STATUS_DATACORRUPTED; 5805 break; 5806 } 5807 } 5808 5809 if (res->status == BFA_STATUS_OK) { 5810 if (fcdiag->qtest.count > 0) { 5811 status = bfa_fcdiag_queuetest_send(fcdiag); 5812 if (status == BFA_STATUS_OK) 5813 return; 5814 else 5815 res->status = status; 5816 } else if (fcdiag->qtest.all > 0 && 5817 fcdiag->qtest.queue < (BFI_IOC_MAX_CQS - 1)) { 5818 fcdiag->qtest.count = QTEST_CNT_DEFAULT; 5819 fcdiag->qtest.queue++; 5820 status = bfa_fcdiag_queuetest_send(fcdiag); 5821 if (status == BFA_STATUS_OK) 5822 return; 5823 else 5824 res->status = status; 5825 } 5826 } 5827 5828 /* Stop timer when we comp all queue */ 5829 if (fcdiag->qtest.timer_active) { 5830 bfa_timer_stop(&fcdiag->qtest.timer); 5831 fcdiag->qtest.timer_active = 0; 5832 } 5833 res->queue = fcdiag->qtest.queue; 5834 res->count = QTEST_CNT_DEFAULT - fcdiag->qtest.count; 5835 bfa_trc(fcdiag, res->count); 5836 bfa_trc(fcdiag, res->status); 5837 fcdiag->qtest.status = res->status; 5838 fcdiag->qtest.cbfn(fcdiag->qtest.cbarg, fcdiag->qtest.status); 5839 fcdiag->qtest.lock = 0; 5840 } 5841 5842 static void 5843 bfa_fcdiag_loopback_comp(struct bfa_fcdiag_s *fcdiag, 5844 struct bfi_diag_lb_rsp_s *rsp) 5845 { 5846 struct bfa_diag_loopback_result_s *res = fcdiag->lb.result; 5847 5848 res->numtxmfrm = be32_to_cpu(rsp->res.numtxmfrm); 5849 res->numosffrm = be32_to_cpu(rsp->res.numosffrm); 5850 res->numrcvfrm = be32_to_cpu(rsp->res.numrcvfrm); 5851 res->badfrminf = be32_to_cpu(rsp->res.badfrminf); 5852 res->badfrmnum = be32_to_cpu(rsp->res.badfrmnum); 5853 res->status = rsp->res.status; 5854 fcdiag->lb.status = rsp->res.status; 5855 bfa_trc(fcdiag, fcdiag->lb.status); 5856 fcdiag->lb.cbfn(fcdiag->lb.cbarg, fcdiag->lb.status); 5857 fcdiag->lb.lock = 0; 5858 bfa_fcdiag_set_busy_status(fcdiag); 5859 } 5860 5861 static bfa_status_t 5862 bfa_fcdiag_loopback_send(struct bfa_fcdiag_s *fcdiag, 5863 struct bfa_diag_loopback_s *loopback) 5864 { 5865 struct bfi_diag_lb_req_s *lb_req; 5866 5867 lb_req = bfa_reqq_next(fcdiag->bfa, BFA_REQQ_DIAG); 5868 if (!lb_req) 5869 return BFA_STATUS_DEVBUSY; 5870 5871 /* build host command */ 5872 bfi_h2i_set(lb_req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_LOOPBACK, 5873 bfa_fn_lpu(fcdiag->bfa)); 5874 5875 lb_req->lb_mode = loopback->lb_mode; 5876 lb_req->speed = loopback->speed; 5877 lb_req->loopcnt = loopback->loopcnt; 5878 lb_req->pattern = loopback->pattern; 5879 5880 /* ring door bell */ 5881 bfa_reqq_produce(fcdiag->bfa, BFA_REQQ_DIAG, lb_req->mh); 5882 5883 bfa_trc(fcdiag, loopback->lb_mode); 5884 bfa_trc(fcdiag, loopback->speed); 5885 bfa_trc(fcdiag, loopback->loopcnt); 5886 bfa_trc(fcdiag, loopback->pattern); 5887 return BFA_STATUS_OK; 5888 } 5889 5890 /* 5891 * cpe/rme intr handler 5892 */ 5893 void 5894 bfa_fcdiag_intr(struct bfa_s *bfa, struct bfi_msg_s *msg) 5895 { 5896 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5897 5898 switch (msg->mhdr.msg_id) { 5899 case BFI_DIAG_I2H_LOOPBACK: 5900 bfa_fcdiag_loopback_comp(fcdiag, 5901 (struct bfi_diag_lb_rsp_s *) msg); 5902 break; 5903 case BFI_DIAG_I2H_QTEST: 5904 bfa_fcdiag_queuetest_comp(fcdiag, (bfi_diag_qtest_rsp_t *)msg); 5905 break; 5906 case BFI_DIAG_I2H_DPORT: 5907 bfa_dport_req_comp(&fcdiag->dport, 5908 (struct bfi_diag_dport_rsp_s *)msg); 5909 break; 5910 case BFI_DIAG_I2H_DPORT_SCN: 5911 bfa_dport_scn(&fcdiag->dport, 5912 (struct bfi_diag_dport_scn_s *)msg); 5913 break; 5914 default: 5915 bfa_trc(fcdiag, msg->mhdr.msg_id); 5916 WARN_ON(1); 5917 } 5918 } 5919 5920 /* 5921 * Loopback test 5922 * 5923 * @param[in] *bfa - bfa data struct 5924 * @param[in] opmode - port operation mode 5925 * @param[in] speed - port speed 5926 * @param[in] lpcnt - loop count 5927 * @param[in] pat - pattern to build packet 5928 * @param[in] *result - pt to bfa_diag_loopback_result_t data struct 5929 * @param[in] cbfn - callback function 5930 * @param[in] cbarg - callback functioin arg 5931 * 5932 * @param[out] 5933 */ 5934 bfa_status_t 5935 bfa_fcdiag_loopback(struct bfa_s *bfa, enum bfa_port_opmode opmode, 5936 enum bfa_port_speed speed, u32 lpcnt, u32 pat, 5937 struct bfa_diag_loopback_result_s *result, bfa_cb_diag_t cbfn, 5938 void *cbarg) 5939 { 5940 struct bfa_diag_loopback_s loopback; 5941 struct bfa_port_attr_s attr; 5942 bfa_status_t status; 5943 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 5944 5945 if (!bfa_iocfc_is_operational(bfa)) 5946 return BFA_STATUS_IOC_NON_OP; 5947 5948 /* if port is PBC disabled, return error */ 5949 if (bfa_fcport_is_pbcdisabled(bfa)) { 5950 bfa_trc(fcdiag, BFA_STATUS_PBC); 5951 return BFA_STATUS_PBC; 5952 } 5953 5954 if (bfa_fcport_is_disabled(bfa) == BFA_FALSE) { 5955 bfa_trc(fcdiag, opmode); 5956 return BFA_STATUS_PORT_NOT_DISABLED; 5957 } 5958 5959 /* 5960 * Check if input speed is supported by the port mode 5961 */ 5962 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) { 5963 if (!(speed == BFA_PORT_SPEED_1GBPS || 5964 speed == BFA_PORT_SPEED_2GBPS || 5965 speed == BFA_PORT_SPEED_4GBPS || 5966 speed == BFA_PORT_SPEED_8GBPS || 5967 speed == BFA_PORT_SPEED_16GBPS || 5968 speed == BFA_PORT_SPEED_AUTO)) { 5969 bfa_trc(fcdiag, speed); 5970 return BFA_STATUS_UNSUPP_SPEED; 5971 } 5972 bfa_fcport_get_attr(bfa, &attr); 5973 bfa_trc(fcdiag, attr.speed_supported); 5974 if (speed > attr.speed_supported) 5975 return BFA_STATUS_UNSUPP_SPEED; 5976 } else { 5977 if (speed != BFA_PORT_SPEED_10GBPS) { 5978 bfa_trc(fcdiag, speed); 5979 return BFA_STATUS_UNSUPP_SPEED; 5980 } 5981 } 5982 5983 /* 5984 * For CT2, 1G is not supported 5985 */ 5986 if ((speed == BFA_PORT_SPEED_1GBPS) && 5987 (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id))) { 5988 bfa_trc(fcdiag, speed); 5989 return BFA_STATUS_UNSUPP_SPEED; 5990 } 5991 5992 /* For Mezz card, port speed entered needs to be checked */ 5993 if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) { 5994 if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) { 5995 if (!(speed == BFA_PORT_SPEED_1GBPS || 5996 speed == BFA_PORT_SPEED_2GBPS || 5997 speed == BFA_PORT_SPEED_4GBPS || 5998 speed == BFA_PORT_SPEED_8GBPS || 5999 speed == BFA_PORT_SPEED_16GBPS || 6000 speed == BFA_PORT_SPEED_AUTO)) 6001 return BFA_STATUS_UNSUPP_SPEED; 6002 } else { 6003 if (speed != BFA_PORT_SPEED_10GBPS) 6004 return BFA_STATUS_UNSUPP_SPEED; 6005 } 6006 } 6007 /* check to see if fcport is dport */ 6008 if (bfa_fcport_is_dport(bfa)) { 6009 bfa_trc(fcdiag, fcdiag->lb.lock); 6010 return BFA_STATUS_DPORT_ENABLED; 6011 } 6012 /* check to see if there is another destructive diag cmd running */ 6013 if (fcdiag->lb.lock) { 6014 bfa_trc(fcdiag, fcdiag->lb.lock); 6015 return BFA_STATUS_DEVBUSY; 6016 } 6017 6018 fcdiag->lb.lock = 1; 6019 loopback.lb_mode = opmode; 6020 loopback.speed = speed; 6021 loopback.loopcnt = lpcnt; 6022 loopback.pattern = pat; 6023 fcdiag->lb.result = result; 6024 fcdiag->lb.cbfn = cbfn; 6025 fcdiag->lb.cbarg = cbarg; 6026 memset(result, 0, sizeof(struct bfa_diag_loopback_result_s)); 6027 bfa_fcdiag_set_busy_status(fcdiag); 6028 6029 /* Send msg to fw */ 6030 status = bfa_fcdiag_loopback_send(fcdiag, &loopback); 6031 return status; 6032 } 6033 6034 /* 6035 * DIAG queue test command 6036 * 6037 * @param[in] *bfa - bfa data struct 6038 * @param[in] force - 1: don't do ioc op checking 6039 * @param[in] queue - queue no. to test 6040 * @param[in] *result - pt to bfa_diag_qtest_result_t data struct 6041 * @param[in] cbfn - callback function 6042 * @param[in] *cbarg - callback functioin arg 6043 * 6044 * @param[out] 6045 */ 6046 bfa_status_t 6047 bfa_fcdiag_queuetest(struct bfa_s *bfa, u32 force, u32 queue, 6048 struct bfa_diag_qtest_result_s *result, bfa_cb_diag_t cbfn, 6049 void *cbarg) 6050 { 6051 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 6052 bfa_status_t status; 6053 bfa_trc(fcdiag, force); 6054 bfa_trc(fcdiag, queue); 6055 6056 if (!force && !bfa_iocfc_is_operational(bfa)) 6057 return BFA_STATUS_IOC_NON_OP; 6058 6059 /* check to see if there is another destructive diag cmd running */ 6060 if (fcdiag->qtest.lock) { 6061 bfa_trc(fcdiag, fcdiag->qtest.lock); 6062 return BFA_STATUS_DEVBUSY; 6063 } 6064 6065 /* Initialization */ 6066 fcdiag->qtest.lock = 1; 6067 fcdiag->qtest.cbfn = cbfn; 6068 fcdiag->qtest.cbarg = cbarg; 6069 fcdiag->qtest.result = result; 6070 fcdiag->qtest.count = QTEST_CNT_DEFAULT; 6071 6072 /* Init test results */ 6073 fcdiag->qtest.result->status = BFA_STATUS_OK; 6074 fcdiag->qtest.result->count = 0; 6075 6076 /* send */ 6077 if (queue < BFI_IOC_MAX_CQS) { 6078 fcdiag->qtest.result->queue = (u8)queue; 6079 fcdiag->qtest.queue = (u8)queue; 6080 fcdiag->qtest.all = 0; 6081 } else { 6082 fcdiag->qtest.result->queue = 0; 6083 fcdiag->qtest.queue = 0; 6084 fcdiag->qtest.all = 1; 6085 } 6086 status = bfa_fcdiag_queuetest_send(fcdiag); 6087 6088 /* Start a timer */ 6089 if (status == BFA_STATUS_OK) { 6090 bfa_timer_start(bfa, &fcdiag->qtest.timer, 6091 bfa_fcdiag_queuetest_timeout, fcdiag, 6092 BFA_DIAG_QTEST_TOV); 6093 fcdiag->qtest.timer_active = 1; 6094 } 6095 return status; 6096 } 6097 6098 /* 6099 * DIAG PLB is running 6100 * 6101 * @param[in] *bfa - bfa data struct 6102 * 6103 * @param[out] 6104 */ 6105 bfa_status_t 6106 bfa_fcdiag_lb_is_running(struct bfa_s *bfa) 6107 { 6108 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 6109 return fcdiag->lb.lock ? BFA_STATUS_DIAG_BUSY : BFA_STATUS_OK; 6110 } 6111 6112 /* 6113 * D-port 6114 */ 6115 #define bfa_dport_result_start(__dport, __mode) do { \ 6116 (__dport)->result.start_time = ktime_get_real_seconds(); \ 6117 (__dport)->result.status = DPORT_TEST_ST_INPRG; \ 6118 (__dport)->result.mode = (__mode); \ 6119 (__dport)->result.rp_pwwn = (__dport)->rp_pwwn; \ 6120 (__dport)->result.rp_nwwn = (__dport)->rp_nwwn; \ 6121 (__dport)->result.lpcnt = (__dport)->lpcnt; \ 6122 } while (0) 6123 6124 static bfa_boolean_t bfa_dport_send_req(struct bfa_dport_s *dport, 6125 enum bfi_dport_req req); 6126 static void 6127 bfa_cb_fcdiag_dport(struct bfa_dport_s *dport, bfa_status_t bfa_status) 6128 { 6129 if (dport->cbfn != NULL) { 6130 dport->cbfn(dport->cbarg, bfa_status); 6131 dport->cbfn = NULL; 6132 dport->cbarg = NULL; 6133 } 6134 } 6135 6136 static void 6137 bfa_dport_sm_disabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event) 6138 { 6139 bfa_trc(dport->bfa, event); 6140 6141 switch (event) { 6142 case BFA_DPORT_SM_ENABLE: 6143 bfa_fcport_dportenable(dport->bfa); 6144 if (bfa_dport_send_req(dport, BFI_DPORT_ENABLE)) 6145 bfa_sm_set_state(dport, bfa_dport_sm_enabling); 6146 else 6147 bfa_sm_set_state(dport, bfa_dport_sm_enabling_qwait); 6148 break; 6149 6150 case BFA_DPORT_SM_DISABLE: 6151 /* Already disabled */ 6152 break; 6153 6154 case BFA_DPORT_SM_HWFAIL: 6155 /* ignore */ 6156 break; 6157 6158 case BFA_DPORT_SM_SCN: 6159 if (dport->i2hmsg.scn.state == BFI_DPORT_SCN_DDPORT_ENABLE) { 6160 bfa_fcport_ddportenable(dport->bfa); 6161 dport->dynamic = BFA_TRUE; 6162 dport->test_state = BFA_DPORT_ST_NOTSTART; 6163 bfa_sm_set_state(dport, bfa_dport_sm_enabled); 6164 } else { 6165 bfa_trc(dport->bfa, dport->i2hmsg.scn.state); 6166 WARN_ON(1); 6167 } 6168 break; 6169 6170 default: 6171 bfa_sm_fault(dport->bfa, event); 6172 } 6173 } 6174 6175 static void 6176 bfa_dport_sm_enabling_qwait(struct bfa_dport_s *dport, 6177 enum bfa_dport_sm_event event) 6178 { 6179 bfa_trc(dport->bfa, event); 6180 6181 switch (event) { 6182 case BFA_DPORT_SM_QRESUME: 6183 bfa_sm_set_state(dport, bfa_dport_sm_enabling); 6184 bfa_dport_send_req(dport, BFI_DPORT_ENABLE); 6185 break; 6186 6187 case BFA_DPORT_SM_HWFAIL: 6188 bfa_reqq_wcancel(&dport->reqq_wait); 6189 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6190 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED); 6191 break; 6192 6193 default: 6194 bfa_sm_fault(dport->bfa, event); 6195 } 6196 } 6197 6198 static void 6199 bfa_dport_sm_enabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event) 6200 { 6201 bfa_trc(dport->bfa, event); 6202 6203 switch (event) { 6204 case BFA_DPORT_SM_FWRSP: 6205 memset(&dport->result, 0, 6206 sizeof(struct bfa_diag_dport_result_s)); 6207 if (dport->i2hmsg.rsp.status == BFA_STATUS_DPORT_INV_SFP) { 6208 dport->test_state = BFA_DPORT_ST_NO_SFP; 6209 } else { 6210 dport->test_state = BFA_DPORT_ST_INP; 6211 bfa_dport_result_start(dport, BFA_DPORT_OPMODE_AUTO); 6212 } 6213 bfa_sm_set_state(dport, bfa_dport_sm_enabled); 6214 break; 6215 6216 case BFA_DPORT_SM_REQFAIL: 6217 dport->test_state = BFA_DPORT_ST_DISABLED; 6218 bfa_fcport_dportdisable(dport->bfa); 6219 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6220 break; 6221 6222 case BFA_DPORT_SM_HWFAIL: 6223 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6224 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED); 6225 break; 6226 6227 default: 6228 bfa_sm_fault(dport->bfa, event); 6229 } 6230 } 6231 6232 static void 6233 bfa_dport_sm_enabled(struct bfa_dport_s *dport, enum bfa_dport_sm_event event) 6234 { 6235 bfa_trc(dport->bfa, event); 6236 6237 switch (event) { 6238 case BFA_DPORT_SM_START: 6239 if (bfa_dport_send_req(dport, BFI_DPORT_START)) 6240 bfa_sm_set_state(dport, bfa_dport_sm_starting); 6241 else 6242 bfa_sm_set_state(dport, bfa_dport_sm_starting_qwait); 6243 break; 6244 6245 case BFA_DPORT_SM_DISABLE: 6246 bfa_fcport_dportdisable(dport->bfa); 6247 if (bfa_dport_send_req(dport, BFI_DPORT_DISABLE)) 6248 bfa_sm_set_state(dport, bfa_dport_sm_disabling); 6249 else 6250 bfa_sm_set_state(dport, bfa_dport_sm_disabling_qwait); 6251 break; 6252 6253 case BFA_DPORT_SM_HWFAIL: 6254 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6255 break; 6256 6257 case BFA_DPORT_SM_SCN: 6258 switch (dport->i2hmsg.scn.state) { 6259 case BFI_DPORT_SCN_TESTCOMP: 6260 dport->test_state = BFA_DPORT_ST_COMP; 6261 break; 6262 6263 case BFI_DPORT_SCN_TESTSTART: 6264 dport->test_state = BFA_DPORT_ST_INP; 6265 break; 6266 6267 case BFI_DPORT_SCN_TESTSKIP: 6268 case BFI_DPORT_SCN_SUBTESTSTART: 6269 /* no state change */ 6270 break; 6271 6272 case BFI_DPORT_SCN_SFP_REMOVED: 6273 dport->test_state = BFA_DPORT_ST_NO_SFP; 6274 break; 6275 6276 case BFI_DPORT_SCN_DDPORT_DISABLE: 6277 bfa_fcport_ddportdisable(dport->bfa); 6278 6279 if (bfa_dport_send_req(dport, BFI_DPORT_DYN_DISABLE)) 6280 bfa_sm_set_state(dport, 6281 bfa_dport_sm_dynamic_disabling); 6282 else 6283 bfa_sm_set_state(dport, 6284 bfa_dport_sm_dynamic_disabling_qwait); 6285 break; 6286 6287 case BFI_DPORT_SCN_FCPORT_DISABLE: 6288 bfa_fcport_ddportdisable(dport->bfa); 6289 6290 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6291 dport->dynamic = BFA_FALSE; 6292 break; 6293 6294 default: 6295 bfa_trc(dport->bfa, dport->i2hmsg.scn.state); 6296 bfa_sm_fault(dport->bfa, event); 6297 } 6298 break; 6299 default: 6300 bfa_sm_fault(dport->bfa, event); 6301 } 6302 } 6303 6304 static void 6305 bfa_dport_sm_disabling_qwait(struct bfa_dport_s *dport, 6306 enum bfa_dport_sm_event event) 6307 { 6308 bfa_trc(dport->bfa, event); 6309 6310 switch (event) { 6311 case BFA_DPORT_SM_QRESUME: 6312 bfa_sm_set_state(dport, bfa_dport_sm_disabling); 6313 bfa_dport_send_req(dport, BFI_DPORT_DISABLE); 6314 break; 6315 6316 case BFA_DPORT_SM_HWFAIL: 6317 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6318 bfa_reqq_wcancel(&dport->reqq_wait); 6319 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK); 6320 break; 6321 6322 case BFA_DPORT_SM_SCN: 6323 /* ignore */ 6324 break; 6325 6326 default: 6327 bfa_sm_fault(dport->bfa, event); 6328 } 6329 } 6330 6331 static void 6332 bfa_dport_sm_disabling(struct bfa_dport_s *dport, enum bfa_dport_sm_event event) 6333 { 6334 bfa_trc(dport->bfa, event); 6335 6336 switch (event) { 6337 case BFA_DPORT_SM_FWRSP: 6338 dport->test_state = BFA_DPORT_ST_DISABLED; 6339 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6340 break; 6341 6342 case BFA_DPORT_SM_HWFAIL: 6343 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6344 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK); 6345 break; 6346 6347 case BFA_DPORT_SM_SCN: 6348 /* no state change */ 6349 break; 6350 6351 default: 6352 bfa_sm_fault(dport->bfa, event); 6353 } 6354 } 6355 6356 static void 6357 bfa_dport_sm_starting_qwait(struct bfa_dport_s *dport, 6358 enum bfa_dport_sm_event event) 6359 { 6360 bfa_trc(dport->bfa, event); 6361 6362 switch (event) { 6363 case BFA_DPORT_SM_QRESUME: 6364 bfa_sm_set_state(dport, bfa_dport_sm_starting); 6365 bfa_dport_send_req(dport, BFI_DPORT_START); 6366 break; 6367 6368 case BFA_DPORT_SM_HWFAIL: 6369 bfa_reqq_wcancel(&dport->reqq_wait); 6370 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6371 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED); 6372 break; 6373 6374 default: 6375 bfa_sm_fault(dport->bfa, event); 6376 } 6377 } 6378 6379 static void 6380 bfa_dport_sm_starting(struct bfa_dport_s *dport, enum bfa_dport_sm_event event) 6381 { 6382 bfa_trc(dport->bfa, event); 6383 6384 switch (event) { 6385 case BFA_DPORT_SM_FWRSP: 6386 memset(&dport->result, 0, 6387 sizeof(struct bfa_diag_dport_result_s)); 6388 if (dport->i2hmsg.rsp.status == BFA_STATUS_DPORT_INV_SFP) { 6389 dport->test_state = BFA_DPORT_ST_NO_SFP; 6390 } else { 6391 dport->test_state = BFA_DPORT_ST_INP; 6392 bfa_dport_result_start(dport, BFA_DPORT_OPMODE_MANU); 6393 } 6394 fallthrough; 6395 6396 case BFA_DPORT_SM_REQFAIL: 6397 bfa_sm_set_state(dport, bfa_dport_sm_enabled); 6398 break; 6399 6400 case BFA_DPORT_SM_HWFAIL: 6401 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6402 bfa_cb_fcdiag_dport(dport, BFA_STATUS_FAILED); 6403 break; 6404 6405 default: 6406 bfa_sm_fault(dport->bfa, event); 6407 } 6408 } 6409 6410 static void 6411 bfa_dport_sm_dynamic_disabling(struct bfa_dport_s *dport, 6412 enum bfa_dport_sm_event event) 6413 { 6414 bfa_trc(dport->bfa, event); 6415 6416 switch (event) { 6417 case BFA_DPORT_SM_SCN: 6418 switch (dport->i2hmsg.scn.state) { 6419 case BFI_DPORT_SCN_DDPORT_DISABLED: 6420 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6421 dport->dynamic = BFA_FALSE; 6422 bfa_fcport_enable(dport->bfa); 6423 break; 6424 6425 default: 6426 bfa_trc(dport->bfa, dport->i2hmsg.scn.state); 6427 bfa_sm_fault(dport->bfa, event); 6428 6429 } 6430 break; 6431 6432 case BFA_DPORT_SM_HWFAIL: 6433 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6434 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK); 6435 break; 6436 6437 default: 6438 bfa_sm_fault(dport->bfa, event); 6439 } 6440 } 6441 6442 static void 6443 bfa_dport_sm_dynamic_disabling_qwait(struct bfa_dport_s *dport, 6444 enum bfa_dport_sm_event event) 6445 { 6446 bfa_trc(dport->bfa, event); 6447 6448 switch (event) { 6449 case BFA_DPORT_SM_QRESUME: 6450 bfa_sm_set_state(dport, bfa_dport_sm_dynamic_disabling); 6451 bfa_dport_send_req(dport, BFI_DPORT_DYN_DISABLE); 6452 break; 6453 6454 case BFA_DPORT_SM_HWFAIL: 6455 bfa_sm_set_state(dport, bfa_dport_sm_disabled); 6456 bfa_reqq_wcancel(&dport->reqq_wait); 6457 bfa_cb_fcdiag_dport(dport, BFA_STATUS_OK); 6458 break; 6459 6460 case BFA_DPORT_SM_SCN: 6461 /* ignore */ 6462 break; 6463 6464 default: 6465 bfa_sm_fault(dport->bfa, event); 6466 } 6467 } 6468 6469 static bfa_boolean_t 6470 bfa_dport_send_req(struct bfa_dport_s *dport, enum bfi_dport_req req) 6471 { 6472 struct bfi_diag_dport_req_s *m; 6473 6474 /* 6475 * check for room in queue to send request now 6476 */ 6477 m = bfa_reqq_next(dport->bfa, BFA_REQQ_DIAG); 6478 if (!m) { 6479 bfa_reqq_wait(dport->bfa, BFA_REQQ_PORT, &dport->reqq_wait); 6480 return BFA_FALSE; 6481 } 6482 6483 bfi_h2i_set(m->mh, BFI_MC_DIAG, BFI_DIAG_H2I_DPORT, 6484 bfa_fn_lpu(dport->bfa)); 6485 m->req = req; 6486 if ((req == BFI_DPORT_ENABLE) || (req == BFI_DPORT_START)) { 6487 m->lpcnt = cpu_to_be32(dport->lpcnt); 6488 m->payload = cpu_to_be32(dport->payload); 6489 } 6490 6491 /* 6492 * queue I/O message to firmware 6493 */ 6494 bfa_reqq_produce(dport->bfa, BFA_REQQ_DIAG, m->mh); 6495 6496 return BFA_TRUE; 6497 } 6498 6499 static void 6500 bfa_dport_qresume(void *cbarg) 6501 { 6502 struct bfa_dport_s *dport = cbarg; 6503 6504 bfa_sm_send_event(dport, BFA_DPORT_SM_QRESUME); 6505 } 6506 6507 static void 6508 bfa_dport_req_comp(struct bfa_dport_s *dport, struct bfi_diag_dport_rsp_s *msg) 6509 { 6510 msg->status = cpu_to_be32(msg->status); 6511 dport->i2hmsg.rsp.status = msg->status; 6512 dport->rp_pwwn = msg->pwwn; 6513 dport->rp_nwwn = msg->nwwn; 6514 6515 if ((msg->status == BFA_STATUS_OK) || 6516 (msg->status == BFA_STATUS_DPORT_NO_SFP)) { 6517 bfa_trc(dport->bfa, msg->status); 6518 bfa_trc(dport->bfa, dport->rp_pwwn); 6519 bfa_trc(dport->bfa, dport->rp_nwwn); 6520 bfa_sm_send_event(dport, BFA_DPORT_SM_FWRSP); 6521 6522 } else { 6523 bfa_trc(dport->bfa, msg->status); 6524 bfa_sm_send_event(dport, BFA_DPORT_SM_REQFAIL); 6525 } 6526 bfa_cb_fcdiag_dport(dport, msg->status); 6527 } 6528 6529 static bfa_boolean_t 6530 bfa_dport_is_sending_req(struct bfa_dport_s *dport) 6531 { 6532 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabling) || 6533 bfa_sm_cmp_state(dport, bfa_dport_sm_enabling_qwait) || 6534 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling) || 6535 bfa_sm_cmp_state(dport, bfa_dport_sm_disabling_qwait) || 6536 bfa_sm_cmp_state(dport, bfa_dport_sm_starting) || 6537 bfa_sm_cmp_state(dport, bfa_dport_sm_starting_qwait)) { 6538 return BFA_TRUE; 6539 } else { 6540 return BFA_FALSE; 6541 } 6542 } 6543 6544 static void 6545 bfa_dport_scn(struct bfa_dport_s *dport, struct bfi_diag_dport_scn_s *msg) 6546 { 6547 int i; 6548 uint8_t subtesttype; 6549 6550 bfa_trc(dport->bfa, msg->state); 6551 dport->i2hmsg.scn.state = msg->state; 6552 6553 switch (dport->i2hmsg.scn.state) { 6554 case BFI_DPORT_SCN_TESTCOMP: 6555 dport->result.end_time = ktime_get_real_seconds(); 6556 bfa_trc(dport->bfa, dport->result.end_time); 6557 6558 dport->result.status = msg->info.testcomp.status; 6559 bfa_trc(dport->bfa, dport->result.status); 6560 6561 dport->result.roundtrip_latency = 6562 cpu_to_be32(msg->info.testcomp.latency); 6563 dport->result.est_cable_distance = 6564 cpu_to_be32(msg->info.testcomp.distance); 6565 dport->result.buffer_required = 6566 be16_to_cpu(msg->info.testcomp.numbuffer); 6567 6568 dport->result.frmsz = be16_to_cpu(msg->info.testcomp.frm_sz); 6569 dport->result.speed = msg->info.testcomp.speed; 6570 6571 bfa_trc(dport->bfa, dport->result.roundtrip_latency); 6572 bfa_trc(dport->bfa, dport->result.est_cable_distance); 6573 bfa_trc(dport->bfa, dport->result.buffer_required); 6574 bfa_trc(dport->bfa, dport->result.frmsz); 6575 bfa_trc(dport->bfa, dport->result.speed); 6576 6577 for (i = DPORT_TEST_ELOOP; i < DPORT_TEST_MAX; i++) { 6578 dport->result.subtest[i].status = 6579 msg->info.testcomp.subtest_status[i]; 6580 bfa_trc(dport->bfa, dport->result.subtest[i].status); 6581 } 6582 break; 6583 6584 case BFI_DPORT_SCN_TESTSKIP: 6585 case BFI_DPORT_SCN_DDPORT_ENABLE: 6586 memset(&dport->result, 0, 6587 sizeof(struct bfa_diag_dport_result_s)); 6588 break; 6589 6590 case BFI_DPORT_SCN_TESTSTART: 6591 memset(&dport->result, 0, 6592 sizeof(struct bfa_diag_dport_result_s)); 6593 dport->rp_pwwn = msg->info.teststart.pwwn; 6594 dport->rp_nwwn = msg->info.teststart.nwwn; 6595 dport->lpcnt = cpu_to_be32(msg->info.teststart.numfrm); 6596 bfa_dport_result_start(dport, msg->info.teststart.mode); 6597 break; 6598 6599 case BFI_DPORT_SCN_SUBTESTSTART: 6600 subtesttype = msg->info.teststart.type; 6601 dport->result.subtest[subtesttype].start_time = 6602 ktime_get_real_seconds(); 6603 dport->result.subtest[subtesttype].status = 6604 DPORT_TEST_ST_INPRG; 6605 6606 bfa_trc(dport->bfa, subtesttype); 6607 bfa_trc(dport->bfa, 6608 dport->result.subtest[subtesttype].start_time); 6609 break; 6610 6611 case BFI_DPORT_SCN_SFP_REMOVED: 6612 case BFI_DPORT_SCN_DDPORT_DISABLED: 6613 case BFI_DPORT_SCN_DDPORT_DISABLE: 6614 case BFI_DPORT_SCN_FCPORT_DISABLE: 6615 dport->result.status = DPORT_TEST_ST_IDLE; 6616 break; 6617 6618 default: 6619 bfa_sm_fault(dport->bfa, msg->state); 6620 } 6621 6622 bfa_sm_send_event(dport, BFA_DPORT_SM_SCN); 6623 } 6624 6625 /* 6626 * Dport enable 6627 * 6628 * @param[in] *bfa - bfa data struct 6629 */ 6630 bfa_status_t 6631 bfa_dport_enable(struct bfa_s *bfa, u32 lpcnt, u32 pat, 6632 bfa_cb_diag_t cbfn, void *cbarg) 6633 { 6634 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 6635 struct bfa_dport_s *dport = &fcdiag->dport; 6636 6637 /* 6638 * Dport is not support in MEZZ card 6639 */ 6640 if (bfa_mfg_is_mezz(dport->bfa->ioc.attr->card_type)) { 6641 bfa_trc(dport->bfa, BFA_STATUS_PBC); 6642 return BFA_STATUS_CMD_NOTSUPP_MEZZ; 6643 } 6644 6645 /* 6646 * Dport is supported in CT2 or above 6647 */ 6648 if (!(bfa_asic_id_ct2(dport->bfa->ioc.pcidev.device_id))) { 6649 bfa_trc(dport->bfa, dport->bfa->ioc.pcidev.device_id); 6650 return BFA_STATUS_FEATURE_NOT_SUPPORTED; 6651 } 6652 6653 /* 6654 * Check to see if IOC is down 6655 */ 6656 if (!bfa_iocfc_is_operational(bfa)) 6657 return BFA_STATUS_IOC_NON_OP; 6658 6659 /* if port is PBC disabled, return error */ 6660 if (bfa_fcport_is_pbcdisabled(bfa)) { 6661 bfa_trc(dport->bfa, BFA_STATUS_PBC); 6662 return BFA_STATUS_PBC; 6663 } 6664 6665 /* 6666 * Check if port mode is FC port 6667 */ 6668 if (bfa_ioc_get_type(&bfa->ioc) != BFA_IOC_TYPE_FC) { 6669 bfa_trc(dport->bfa, bfa_ioc_get_type(&bfa->ioc)); 6670 return BFA_STATUS_CMD_NOTSUPP_CNA; 6671 } 6672 6673 /* 6674 * Check if port is in LOOP mode 6675 */ 6676 if ((bfa_fcport_get_cfg_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP) || 6677 (bfa_fcport_get_topology(bfa) == BFA_PORT_TOPOLOGY_LOOP)) { 6678 bfa_trc(dport->bfa, 0); 6679 return BFA_STATUS_TOPOLOGY_LOOP; 6680 } 6681 6682 /* 6683 * Check if port is TRUNK mode 6684 */ 6685 if (bfa_fcport_is_trunk_enabled(bfa)) { 6686 bfa_trc(dport->bfa, 0); 6687 return BFA_STATUS_ERROR_TRUNK_ENABLED; 6688 } 6689 6690 /* 6691 * Check if diag loopback is running 6692 */ 6693 if (bfa_fcdiag_lb_is_running(bfa)) { 6694 bfa_trc(dport->bfa, 0); 6695 return BFA_STATUS_DIAG_BUSY; 6696 } 6697 6698 /* 6699 * Check to see if port is disable or in dport state 6700 */ 6701 if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) && 6702 (bfa_fcport_is_dport(bfa) == BFA_FALSE)) { 6703 bfa_trc(dport->bfa, 0); 6704 return BFA_STATUS_PORT_NOT_DISABLED; 6705 } 6706 6707 /* 6708 * Check if dport is in dynamic mode 6709 */ 6710 if (dport->dynamic) 6711 return BFA_STATUS_DDPORT_ERR; 6712 6713 /* 6714 * Check if dport is busy 6715 */ 6716 if (bfa_dport_is_sending_req(dport)) 6717 return BFA_STATUS_DEVBUSY; 6718 6719 /* 6720 * Check if dport is already enabled 6721 */ 6722 if (bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) { 6723 bfa_trc(dport->bfa, 0); 6724 return BFA_STATUS_DPORT_ENABLED; 6725 } 6726 6727 bfa_trc(dport->bfa, lpcnt); 6728 bfa_trc(dport->bfa, pat); 6729 dport->lpcnt = (lpcnt) ? lpcnt : DPORT_ENABLE_LOOPCNT_DEFAULT; 6730 dport->payload = (pat) ? pat : LB_PATTERN_DEFAULT; 6731 dport->cbfn = cbfn; 6732 dport->cbarg = cbarg; 6733 6734 bfa_sm_send_event(dport, BFA_DPORT_SM_ENABLE); 6735 return BFA_STATUS_OK; 6736 } 6737 6738 /* 6739 * Dport disable 6740 * 6741 * @param[in] *bfa - bfa data struct 6742 */ 6743 bfa_status_t 6744 bfa_dport_disable(struct bfa_s *bfa, bfa_cb_diag_t cbfn, void *cbarg) 6745 { 6746 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 6747 struct bfa_dport_s *dport = &fcdiag->dport; 6748 6749 if (bfa_ioc_is_disabled(&bfa->ioc)) 6750 return BFA_STATUS_IOC_DISABLED; 6751 6752 /* if port is PBC disabled, return error */ 6753 if (bfa_fcport_is_pbcdisabled(bfa)) { 6754 bfa_trc(dport->bfa, BFA_STATUS_PBC); 6755 return BFA_STATUS_PBC; 6756 } 6757 6758 /* 6759 * Check if dport is in dynamic mode 6760 */ 6761 if (dport->dynamic) { 6762 return BFA_STATUS_DDPORT_ERR; 6763 } 6764 6765 /* 6766 * Check to see if port is disable or in dport state 6767 */ 6768 if ((bfa_fcport_is_disabled(bfa) == BFA_FALSE) && 6769 (bfa_fcport_is_dport(bfa) == BFA_FALSE)) { 6770 bfa_trc(dport->bfa, 0); 6771 return BFA_STATUS_PORT_NOT_DISABLED; 6772 } 6773 6774 /* 6775 * Check if dport is busy 6776 */ 6777 if (bfa_dport_is_sending_req(dport)) 6778 return BFA_STATUS_DEVBUSY; 6779 6780 /* 6781 * Check if dport is already disabled 6782 */ 6783 if (bfa_sm_cmp_state(dport, bfa_dport_sm_disabled)) { 6784 bfa_trc(dport->bfa, 0); 6785 return BFA_STATUS_DPORT_DISABLED; 6786 } 6787 6788 dport->cbfn = cbfn; 6789 dport->cbarg = cbarg; 6790 6791 bfa_sm_send_event(dport, BFA_DPORT_SM_DISABLE); 6792 return BFA_STATUS_OK; 6793 } 6794 6795 /* 6796 * Dport start -- restart dport test 6797 * 6798 * @param[in] *bfa - bfa data struct 6799 */ 6800 bfa_status_t 6801 bfa_dport_start(struct bfa_s *bfa, u32 lpcnt, u32 pat, 6802 bfa_cb_diag_t cbfn, void *cbarg) 6803 { 6804 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 6805 struct bfa_dport_s *dport = &fcdiag->dport; 6806 6807 /* 6808 * Check to see if IOC is down 6809 */ 6810 if (!bfa_iocfc_is_operational(bfa)) 6811 return BFA_STATUS_IOC_NON_OP; 6812 6813 /* 6814 * Check if dport is in dynamic mode 6815 */ 6816 if (dport->dynamic) 6817 return BFA_STATUS_DDPORT_ERR; 6818 6819 /* 6820 * Check if dport is busy 6821 */ 6822 if (bfa_dport_is_sending_req(dport)) 6823 return BFA_STATUS_DEVBUSY; 6824 6825 /* 6826 * Check if dport is in enabled state. 6827 * Test can only be restart when previous test has completed 6828 */ 6829 if (!bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) { 6830 bfa_trc(dport->bfa, 0); 6831 return BFA_STATUS_DPORT_DISABLED; 6832 6833 } else { 6834 if (dport->test_state == BFA_DPORT_ST_NO_SFP) 6835 return BFA_STATUS_DPORT_INV_SFP; 6836 6837 if (dport->test_state == BFA_DPORT_ST_INP) 6838 return BFA_STATUS_DEVBUSY; 6839 6840 WARN_ON(dport->test_state != BFA_DPORT_ST_COMP); 6841 } 6842 6843 bfa_trc(dport->bfa, lpcnt); 6844 bfa_trc(dport->bfa, pat); 6845 6846 dport->lpcnt = (lpcnt) ? lpcnt : DPORT_ENABLE_LOOPCNT_DEFAULT; 6847 dport->payload = (pat) ? pat : LB_PATTERN_DEFAULT; 6848 6849 dport->cbfn = cbfn; 6850 dport->cbarg = cbarg; 6851 6852 bfa_sm_send_event(dport, BFA_DPORT_SM_START); 6853 return BFA_STATUS_OK; 6854 } 6855 6856 /* 6857 * Dport show -- return dport test result 6858 * 6859 * @param[in] *bfa - bfa data struct 6860 */ 6861 bfa_status_t 6862 bfa_dport_show(struct bfa_s *bfa, struct bfa_diag_dport_result_s *result) 6863 { 6864 struct bfa_fcdiag_s *fcdiag = BFA_FCDIAG_MOD(bfa); 6865 struct bfa_dport_s *dport = &fcdiag->dport; 6866 6867 /* 6868 * Check to see if IOC is down 6869 */ 6870 if (!bfa_iocfc_is_operational(bfa)) 6871 return BFA_STATUS_IOC_NON_OP; 6872 6873 /* 6874 * Check if dport is busy 6875 */ 6876 if (bfa_dport_is_sending_req(dport)) 6877 return BFA_STATUS_DEVBUSY; 6878 6879 /* 6880 * Check if dport is in enabled state. 6881 */ 6882 if (!bfa_sm_cmp_state(dport, bfa_dport_sm_enabled)) { 6883 bfa_trc(dport->bfa, 0); 6884 return BFA_STATUS_DPORT_DISABLED; 6885 6886 } 6887 6888 /* 6889 * Check if there is SFP 6890 */ 6891 if (dport->test_state == BFA_DPORT_ST_NO_SFP) 6892 return BFA_STATUS_DPORT_INV_SFP; 6893 6894 memcpy(result, &dport->result, sizeof(struct bfa_diag_dport_result_s)); 6895 6896 return BFA_STATUS_OK; 6897 } 6898