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 "bfa_modules.h" 13 #include "bfi_reg.h" 14 15 BFA_TRC_FILE(HAL, CORE); 16 17 /* 18 * Message handlers for various modules. 19 */ 20 static bfa_isr_func_t bfa_isrs[BFI_MC_MAX] = { 21 bfa_isr_unhandled, /* NONE */ 22 bfa_isr_unhandled, /* BFI_MC_IOC */ 23 bfa_fcdiag_intr, /* BFI_MC_DIAG */ 24 bfa_isr_unhandled, /* BFI_MC_FLASH */ 25 bfa_isr_unhandled, /* BFI_MC_CEE */ 26 bfa_fcport_isr, /* BFI_MC_FCPORT */ 27 bfa_isr_unhandled, /* BFI_MC_IOCFC */ 28 bfa_isr_unhandled, /* BFI_MC_LL */ 29 bfa_uf_isr, /* BFI_MC_UF */ 30 bfa_fcxp_isr, /* BFI_MC_FCXP */ 31 bfa_lps_isr, /* BFI_MC_LPS */ 32 bfa_rport_isr, /* BFI_MC_RPORT */ 33 bfa_itn_isr, /* BFI_MC_ITN */ 34 bfa_isr_unhandled, /* BFI_MC_IOIM_READ */ 35 bfa_isr_unhandled, /* BFI_MC_IOIM_WRITE */ 36 bfa_isr_unhandled, /* BFI_MC_IOIM_IO */ 37 bfa_ioim_isr, /* BFI_MC_IOIM */ 38 bfa_ioim_good_comp_isr, /* BFI_MC_IOIM_IOCOM */ 39 bfa_tskim_isr, /* BFI_MC_TSKIM */ 40 bfa_isr_unhandled, /* BFI_MC_SBOOT */ 41 bfa_isr_unhandled, /* BFI_MC_IPFC */ 42 bfa_isr_unhandled, /* BFI_MC_PORT */ 43 bfa_isr_unhandled, /* --------- */ 44 bfa_isr_unhandled, /* --------- */ 45 bfa_isr_unhandled, /* --------- */ 46 bfa_isr_unhandled, /* --------- */ 47 bfa_isr_unhandled, /* --------- */ 48 bfa_isr_unhandled, /* --------- */ 49 bfa_isr_unhandled, /* --------- */ 50 bfa_isr_unhandled, /* --------- */ 51 bfa_isr_unhandled, /* --------- */ 52 bfa_isr_unhandled, /* --------- */ 53 }; 54 /* 55 * Message handlers for mailbox command classes 56 */ 57 static bfa_ioc_mbox_mcfunc_t bfa_mbox_isrs[BFI_MC_MAX] = { 58 NULL, 59 NULL, /* BFI_MC_IOC */ 60 NULL, /* BFI_MC_DIAG */ 61 NULL, /* BFI_MC_FLASH */ 62 NULL, /* BFI_MC_CEE */ 63 NULL, /* BFI_MC_PORT */ 64 bfa_iocfc_isr, /* BFI_MC_IOCFC */ 65 NULL, 66 }; 67 68 69 70 void 71 __bfa_trc(struct bfa_trc_mod_s *trcm, int fileno, int line, u64 data) 72 { 73 int tail = trcm->tail; 74 struct bfa_trc_s *trc = &trcm->trc[tail]; 75 76 if (trcm->stopped) 77 return; 78 79 trc->fileno = (u16) fileno; 80 trc->line = (u16) line; 81 trc->data.u64 = data; 82 trc->timestamp = BFA_TRC_TS(trcm); 83 84 trcm->tail = (trcm->tail + 1) & (BFA_TRC_MAX - 1); 85 if (trcm->tail == trcm->head) 86 trcm->head = (trcm->head + 1) & (BFA_TRC_MAX - 1); 87 } 88 89 static void 90 bfa_com_port_attach(struct bfa_s *bfa) 91 { 92 struct bfa_port_s *port = &bfa->modules.port; 93 struct bfa_mem_dma_s *port_dma = BFA_MEM_PORT_DMA(bfa); 94 95 bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod); 96 bfa_port_mem_claim(port, port_dma->kva_curp, port_dma->dma_curp); 97 } 98 99 /* 100 * ablk module attach 101 */ 102 static void 103 bfa_com_ablk_attach(struct bfa_s *bfa) 104 { 105 struct bfa_ablk_s *ablk = &bfa->modules.ablk; 106 struct bfa_mem_dma_s *ablk_dma = BFA_MEM_ABLK_DMA(bfa); 107 108 bfa_ablk_attach(ablk, &bfa->ioc); 109 bfa_ablk_memclaim(ablk, ablk_dma->kva_curp, ablk_dma->dma_curp); 110 } 111 112 static void 113 bfa_com_cee_attach(struct bfa_s *bfa) 114 { 115 struct bfa_cee_s *cee = &bfa->modules.cee; 116 struct bfa_mem_dma_s *cee_dma = BFA_MEM_CEE_DMA(bfa); 117 118 cee->trcmod = bfa->trcmod; 119 bfa_cee_attach(cee, &bfa->ioc, bfa); 120 bfa_cee_mem_claim(cee, cee_dma->kva_curp, cee_dma->dma_curp); 121 } 122 123 static void 124 bfa_com_sfp_attach(struct bfa_s *bfa) 125 { 126 struct bfa_sfp_s *sfp = BFA_SFP_MOD(bfa); 127 struct bfa_mem_dma_s *sfp_dma = BFA_MEM_SFP_DMA(bfa); 128 129 bfa_sfp_attach(sfp, &bfa->ioc, bfa, bfa->trcmod); 130 bfa_sfp_memclaim(sfp, sfp_dma->kva_curp, sfp_dma->dma_curp); 131 } 132 133 static void 134 bfa_com_flash_attach(struct bfa_s *bfa, bfa_boolean_t mincfg) 135 { 136 struct bfa_flash_s *flash = BFA_FLASH(bfa); 137 struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa); 138 139 bfa_flash_attach(flash, &bfa->ioc, bfa, bfa->trcmod, mincfg); 140 bfa_flash_memclaim(flash, flash_dma->kva_curp, 141 flash_dma->dma_curp, mincfg); 142 } 143 144 static void 145 bfa_com_diag_attach(struct bfa_s *bfa) 146 { 147 struct bfa_diag_s *diag = BFA_DIAG_MOD(bfa); 148 struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa); 149 150 bfa_diag_attach(diag, &bfa->ioc, bfa, bfa_fcport_beacon, bfa->trcmod); 151 bfa_diag_memclaim(diag, diag_dma->kva_curp, diag_dma->dma_curp); 152 } 153 154 static void 155 bfa_com_phy_attach(struct bfa_s *bfa, bfa_boolean_t mincfg) 156 { 157 struct bfa_phy_s *phy = BFA_PHY(bfa); 158 struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa); 159 160 bfa_phy_attach(phy, &bfa->ioc, bfa, bfa->trcmod, mincfg); 161 bfa_phy_memclaim(phy, phy_dma->kva_curp, phy_dma->dma_curp, mincfg); 162 } 163 164 static void 165 bfa_com_fru_attach(struct bfa_s *bfa, bfa_boolean_t mincfg) 166 { 167 struct bfa_fru_s *fru = BFA_FRU(bfa); 168 struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa); 169 170 bfa_fru_attach(fru, &bfa->ioc, bfa, bfa->trcmod, mincfg); 171 bfa_fru_memclaim(fru, fru_dma->kva_curp, fru_dma->dma_curp, mincfg); 172 } 173 174 /* 175 * BFA IOC FC related definitions 176 */ 177 178 /* 179 * IOC local definitions 180 */ 181 #define BFA_IOCFC_TOV 5000 /* msecs */ 182 183 enum { 184 BFA_IOCFC_ACT_NONE = 0, 185 BFA_IOCFC_ACT_INIT = 1, 186 BFA_IOCFC_ACT_STOP = 2, 187 BFA_IOCFC_ACT_DISABLE = 3, 188 BFA_IOCFC_ACT_ENABLE = 4, 189 }; 190 191 #define DEF_CFG_NUM_FABRICS 1 192 #define DEF_CFG_NUM_LPORTS 256 193 #define DEF_CFG_NUM_CQS 4 194 #define DEF_CFG_NUM_IOIM_REQS (BFA_IOIM_MAX) 195 #define DEF_CFG_NUM_TSKIM_REQS 128 196 #define DEF_CFG_NUM_FCXP_REQS 64 197 #define DEF_CFG_NUM_UF_BUFS 64 198 #define DEF_CFG_NUM_RPORTS 1024 199 #define DEF_CFG_NUM_ITNIMS (DEF_CFG_NUM_RPORTS) 200 #define DEF_CFG_NUM_TINS 256 201 202 #define DEF_CFG_NUM_SGPGS 2048 203 #define DEF_CFG_NUM_REQQ_ELEMS 256 204 #define DEF_CFG_NUM_RSPQ_ELEMS 64 205 #define DEF_CFG_NUM_SBOOT_TGTS 16 206 #define DEF_CFG_NUM_SBOOT_LUNS 16 207 208 /* 209 * IOCFC state machine definitions/declarations 210 */ 211 bfa_fsm_state_decl(bfa_iocfc, stopped, struct bfa_iocfc_s, enum iocfc_event); 212 bfa_fsm_state_decl(bfa_iocfc, initing, struct bfa_iocfc_s, enum iocfc_event); 213 bfa_fsm_state_decl(bfa_iocfc, dconf_read, struct bfa_iocfc_s, enum iocfc_event); 214 bfa_fsm_state_decl(bfa_iocfc, init_cfg_wait, 215 struct bfa_iocfc_s, enum iocfc_event); 216 bfa_fsm_state_decl(bfa_iocfc, init_cfg_done, 217 struct bfa_iocfc_s, enum iocfc_event); 218 bfa_fsm_state_decl(bfa_iocfc, operational, 219 struct bfa_iocfc_s, enum iocfc_event); 220 bfa_fsm_state_decl(bfa_iocfc, dconf_write, 221 struct bfa_iocfc_s, enum iocfc_event); 222 bfa_fsm_state_decl(bfa_iocfc, stopping, struct bfa_iocfc_s, enum iocfc_event); 223 bfa_fsm_state_decl(bfa_iocfc, enabling, struct bfa_iocfc_s, enum iocfc_event); 224 bfa_fsm_state_decl(bfa_iocfc, cfg_wait, struct bfa_iocfc_s, enum iocfc_event); 225 bfa_fsm_state_decl(bfa_iocfc, disabling, struct bfa_iocfc_s, enum iocfc_event); 226 bfa_fsm_state_decl(bfa_iocfc, disabled, struct bfa_iocfc_s, enum iocfc_event); 227 bfa_fsm_state_decl(bfa_iocfc, failed, struct bfa_iocfc_s, enum iocfc_event); 228 bfa_fsm_state_decl(bfa_iocfc, init_failed, 229 struct bfa_iocfc_s, enum iocfc_event); 230 231 /* 232 * forward declaration for IOC FC functions 233 */ 234 static void bfa_iocfc_start_submod(struct bfa_s *bfa); 235 static void bfa_iocfc_disable_submod(struct bfa_s *bfa); 236 static void bfa_iocfc_send_cfg(void *bfa_arg); 237 static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status); 238 static void bfa_iocfc_disable_cbfn(void *bfa_arg); 239 static void bfa_iocfc_hbfail_cbfn(void *bfa_arg); 240 static void bfa_iocfc_reset_cbfn(void *bfa_arg); 241 static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn; 242 static void bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete); 243 static void bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl); 244 static void bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl); 245 static void bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl); 246 247 static void 248 bfa_iocfc_sm_stopped_entry(struct bfa_iocfc_s *iocfc) 249 { 250 } 251 252 static void 253 bfa_iocfc_sm_stopped(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 254 { 255 bfa_trc(iocfc->bfa, event); 256 257 switch (event) { 258 case IOCFC_E_INIT: 259 case IOCFC_E_ENABLE: 260 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_initing); 261 break; 262 default: 263 bfa_sm_fault(iocfc->bfa, event); 264 break; 265 } 266 } 267 268 static void 269 bfa_iocfc_sm_initing_entry(struct bfa_iocfc_s *iocfc) 270 { 271 bfa_ioc_enable(&iocfc->bfa->ioc); 272 } 273 274 static void 275 bfa_iocfc_sm_initing(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 276 { 277 bfa_trc(iocfc->bfa, event); 278 279 switch (event) { 280 case IOCFC_E_IOC_ENABLED: 281 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read); 282 break; 283 284 case IOCFC_E_DISABLE: 285 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 286 break; 287 288 case IOCFC_E_STOP: 289 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping); 290 break; 291 292 case IOCFC_E_IOC_FAILED: 293 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed); 294 break; 295 default: 296 bfa_sm_fault(iocfc->bfa, event); 297 break; 298 } 299 } 300 301 static void 302 bfa_iocfc_sm_dconf_read_entry(struct bfa_iocfc_s *iocfc) 303 { 304 bfa_dconf_modinit(iocfc->bfa); 305 } 306 307 static void 308 bfa_iocfc_sm_dconf_read(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 309 { 310 bfa_trc(iocfc->bfa, event); 311 312 switch (event) { 313 case IOCFC_E_DCONF_DONE: 314 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_wait); 315 break; 316 317 case IOCFC_E_DISABLE: 318 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 319 break; 320 321 case IOCFC_E_STOP: 322 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping); 323 break; 324 325 case IOCFC_E_IOC_FAILED: 326 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed); 327 break; 328 default: 329 bfa_sm_fault(iocfc->bfa, event); 330 break; 331 } 332 } 333 334 static void 335 bfa_iocfc_sm_init_cfg_wait_entry(struct bfa_iocfc_s *iocfc) 336 { 337 bfa_iocfc_send_cfg(iocfc->bfa); 338 } 339 340 static void 341 bfa_iocfc_sm_init_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 342 { 343 bfa_trc(iocfc->bfa, event); 344 345 switch (event) { 346 case IOCFC_E_CFG_DONE: 347 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_done); 348 break; 349 350 case IOCFC_E_DISABLE: 351 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 352 break; 353 354 case IOCFC_E_STOP: 355 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping); 356 break; 357 358 case IOCFC_E_IOC_FAILED: 359 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed); 360 break; 361 default: 362 bfa_sm_fault(iocfc->bfa, event); 363 break; 364 } 365 } 366 367 static void 368 bfa_iocfc_sm_init_cfg_done_entry(struct bfa_iocfc_s *iocfc) 369 { 370 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK; 371 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe, 372 bfa_iocfc_init_cb, iocfc->bfa); 373 } 374 375 static void 376 bfa_iocfc_sm_init_cfg_done(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 377 { 378 bfa_trc(iocfc->bfa, event); 379 380 switch (event) { 381 case IOCFC_E_START: 382 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational); 383 break; 384 case IOCFC_E_STOP: 385 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping); 386 break; 387 case IOCFC_E_DISABLE: 388 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 389 break; 390 case IOCFC_E_IOC_FAILED: 391 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed); 392 break; 393 default: 394 bfa_sm_fault(iocfc->bfa, event); 395 break; 396 } 397 } 398 399 static void 400 bfa_iocfc_sm_operational_entry(struct bfa_iocfc_s *iocfc) 401 { 402 bfa_fcport_init(iocfc->bfa); 403 bfa_iocfc_start_submod(iocfc->bfa); 404 } 405 406 static void 407 bfa_iocfc_sm_operational(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 408 { 409 bfa_trc(iocfc->bfa, event); 410 411 switch (event) { 412 case IOCFC_E_STOP: 413 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write); 414 break; 415 case IOCFC_E_DISABLE: 416 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 417 break; 418 case IOCFC_E_IOC_FAILED: 419 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed); 420 break; 421 default: 422 bfa_sm_fault(iocfc->bfa, event); 423 break; 424 } 425 } 426 427 static void 428 bfa_iocfc_sm_dconf_write_entry(struct bfa_iocfc_s *iocfc) 429 { 430 bfa_dconf_modexit(iocfc->bfa); 431 } 432 433 static void 434 bfa_iocfc_sm_dconf_write(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 435 { 436 bfa_trc(iocfc->bfa, event); 437 438 switch (event) { 439 case IOCFC_E_DCONF_DONE: 440 case IOCFC_E_IOC_FAILED: 441 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping); 442 break; 443 default: 444 bfa_sm_fault(iocfc->bfa, event); 445 break; 446 } 447 } 448 449 static void 450 bfa_iocfc_sm_stopping_entry(struct bfa_iocfc_s *iocfc) 451 { 452 bfa_ioc_disable(&iocfc->bfa->ioc); 453 } 454 455 static void 456 bfa_iocfc_sm_stopping(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 457 { 458 bfa_trc(iocfc->bfa, event); 459 460 switch (event) { 461 case IOCFC_E_IOC_DISABLED: 462 bfa_isr_disable(iocfc->bfa); 463 bfa_iocfc_disable_submod(iocfc->bfa); 464 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped); 465 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK; 466 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.stop_hcb_qe, 467 bfa_iocfc_stop_cb, iocfc->bfa); 468 break; 469 470 case IOCFC_E_IOC_ENABLED: 471 case IOCFC_E_DCONF_DONE: 472 case IOCFC_E_CFG_DONE: 473 break; 474 475 default: 476 bfa_sm_fault(iocfc->bfa, event); 477 break; 478 } 479 } 480 481 static void 482 bfa_iocfc_sm_enabling_entry(struct bfa_iocfc_s *iocfc) 483 { 484 bfa_ioc_enable(&iocfc->bfa->ioc); 485 } 486 487 static void 488 bfa_iocfc_sm_enabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 489 { 490 bfa_trc(iocfc->bfa, event); 491 492 switch (event) { 493 case IOCFC_E_IOC_ENABLED: 494 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait); 495 break; 496 497 case IOCFC_E_DISABLE: 498 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 499 break; 500 501 case IOCFC_E_STOP: 502 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write); 503 break; 504 505 case IOCFC_E_IOC_FAILED: 506 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed); 507 508 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE) 509 break; 510 511 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED; 512 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe, 513 bfa_iocfc_enable_cb, iocfc->bfa); 514 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE; 515 break; 516 default: 517 bfa_sm_fault(iocfc->bfa, event); 518 break; 519 } 520 } 521 522 static void 523 bfa_iocfc_sm_cfg_wait_entry(struct bfa_iocfc_s *iocfc) 524 { 525 bfa_iocfc_send_cfg(iocfc->bfa); 526 } 527 528 static void 529 bfa_iocfc_sm_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 530 { 531 bfa_trc(iocfc->bfa, event); 532 533 switch (event) { 534 case IOCFC_E_CFG_DONE: 535 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational); 536 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE) 537 break; 538 539 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK; 540 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe, 541 bfa_iocfc_enable_cb, iocfc->bfa); 542 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE; 543 break; 544 case IOCFC_E_DISABLE: 545 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 546 break; 547 548 case IOCFC_E_STOP: 549 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write); 550 break; 551 case IOCFC_E_IOC_FAILED: 552 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed); 553 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE) 554 break; 555 556 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED; 557 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe, 558 bfa_iocfc_enable_cb, iocfc->bfa); 559 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE; 560 break; 561 default: 562 bfa_sm_fault(iocfc->bfa, event); 563 break; 564 } 565 } 566 567 static void 568 bfa_iocfc_sm_disabling_entry(struct bfa_iocfc_s *iocfc) 569 { 570 bfa_ioc_disable(&iocfc->bfa->ioc); 571 } 572 573 static void 574 bfa_iocfc_sm_disabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 575 { 576 bfa_trc(iocfc->bfa, event); 577 578 switch (event) { 579 case IOCFC_E_IOC_DISABLED: 580 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabled); 581 break; 582 case IOCFC_E_IOC_ENABLED: 583 case IOCFC_E_DCONF_DONE: 584 case IOCFC_E_CFG_DONE: 585 break; 586 default: 587 bfa_sm_fault(iocfc->bfa, event); 588 break; 589 } 590 } 591 592 static void 593 bfa_iocfc_sm_disabled_entry(struct bfa_iocfc_s *iocfc) 594 { 595 bfa_isr_disable(iocfc->bfa); 596 bfa_iocfc_disable_submod(iocfc->bfa); 597 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK; 598 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe, 599 bfa_iocfc_disable_cb, iocfc->bfa); 600 } 601 602 static void 603 bfa_iocfc_sm_disabled(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 604 { 605 bfa_trc(iocfc->bfa, event); 606 607 switch (event) { 608 case IOCFC_E_STOP: 609 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write); 610 break; 611 case IOCFC_E_ENABLE: 612 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_enabling); 613 break; 614 default: 615 bfa_sm_fault(iocfc->bfa, event); 616 break; 617 } 618 } 619 620 static void 621 bfa_iocfc_sm_failed_entry(struct bfa_iocfc_s *iocfc) 622 { 623 bfa_isr_disable(iocfc->bfa); 624 bfa_iocfc_disable_submod(iocfc->bfa); 625 } 626 627 static void 628 bfa_iocfc_sm_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 629 { 630 bfa_trc(iocfc->bfa, event); 631 632 switch (event) { 633 case IOCFC_E_STOP: 634 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write); 635 break; 636 case IOCFC_E_DISABLE: 637 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling); 638 break; 639 case IOCFC_E_IOC_ENABLED: 640 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait); 641 break; 642 case IOCFC_E_IOC_FAILED: 643 break; 644 default: 645 bfa_sm_fault(iocfc->bfa, event); 646 break; 647 } 648 } 649 650 static void 651 bfa_iocfc_sm_init_failed_entry(struct bfa_iocfc_s *iocfc) 652 { 653 bfa_isr_disable(iocfc->bfa); 654 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED; 655 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe, 656 bfa_iocfc_init_cb, iocfc->bfa); 657 } 658 659 static void 660 bfa_iocfc_sm_init_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event) 661 { 662 bfa_trc(iocfc->bfa, event); 663 664 switch (event) { 665 case IOCFC_E_STOP: 666 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping); 667 break; 668 case IOCFC_E_DISABLE: 669 bfa_ioc_disable(&iocfc->bfa->ioc); 670 break; 671 case IOCFC_E_IOC_ENABLED: 672 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read); 673 break; 674 case IOCFC_E_IOC_DISABLED: 675 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped); 676 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK; 677 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe, 678 bfa_iocfc_disable_cb, iocfc->bfa); 679 break; 680 case IOCFC_E_IOC_FAILED: 681 break; 682 default: 683 bfa_sm_fault(iocfc->bfa, event); 684 break; 685 } 686 } 687 688 /* 689 * BFA Interrupt handling functions 690 */ 691 static void 692 bfa_reqq_resume(struct bfa_s *bfa, int qid) 693 { 694 struct list_head *waitq, *qe, *qen; 695 struct bfa_reqq_wait_s *wqe; 696 697 waitq = bfa_reqq(bfa, qid); 698 list_for_each_safe(qe, qen, waitq) { 699 /* 700 * Callback only as long as there is room in request queue 701 */ 702 if (bfa_reqq_full(bfa, qid)) 703 break; 704 705 list_del(qe); 706 wqe = (struct bfa_reqq_wait_s *) qe; 707 wqe->qresume(wqe->cbarg); 708 } 709 } 710 711 static bfa_boolean_t 712 bfa_isr_rspq(struct bfa_s *bfa, int qid) 713 { 714 struct bfi_msg_s *m; 715 u32 pi, ci; 716 struct list_head *waitq; 717 bfa_boolean_t ret; 718 719 ci = bfa_rspq_ci(bfa, qid); 720 pi = bfa_rspq_pi(bfa, qid); 721 722 ret = (ci != pi); 723 724 while (ci != pi) { 725 m = bfa_rspq_elem(bfa, qid, ci); 726 WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX); 727 728 bfa_isrs[m->mhdr.msg_class] (bfa, m); 729 CQ_INCR(ci, bfa->iocfc.cfg.drvcfg.num_rspq_elems); 730 } 731 732 /* 733 * acknowledge RME completions and update CI 734 */ 735 bfa_isr_rspq_ack(bfa, qid, ci); 736 737 /* 738 * Resume any pending requests in the corresponding reqq. 739 */ 740 waitq = bfa_reqq(bfa, qid); 741 if (!list_empty(waitq)) 742 bfa_reqq_resume(bfa, qid); 743 744 return ret; 745 } 746 747 static inline void 748 bfa_isr_reqq(struct bfa_s *bfa, int qid) 749 { 750 struct list_head *waitq; 751 752 bfa_isr_reqq_ack(bfa, qid); 753 754 /* 755 * Resume any pending requests in the corresponding reqq. 756 */ 757 waitq = bfa_reqq(bfa, qid); 758 if (!list_empty(waitq)) 759 bfa_reqq_resume(bfa, qid); 760 } 761 762 void 763 bfa_msix_all(struct bfa_s *bfa, int vec) 764 { 765 u32 intr, qintr; 766 int queue; 767 768 intr = readl(bfa->iocfc.bfa_regs.intr_status); 769 if (!intr) 770 return; 771 772 /* 773 * RME completion queue interrupt 774 */ 775 qintr = intr & __HFN_INT_RME_MASK; 776 if (qintr && bfa->queue_process) { 777 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++) 778 bfa_isr_rspq(bfa, queue); 779 } 780 781 intr &= ~qintr; 782 if (!intr) 783 return; 784 785 /* 786 * CPE completion queue interrupt 787 */ 788 qintr = intr & __HFN_INT_CPE_MASK; 789 if (qintr && bfa->queue_process) { 790 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++) 791 bfa_isr_reqq(bfa, queue); 792 } 793 intr &= ~qintr; 794 if (!intr) 795 return; 796 797 bfa_msix_lpu_err(bfa, intr); 798 } 799 800 bfa_boolean_t 801 bfa_intx(struct bfa_s *bfa) 802 { 803 u32 intr, qintr; 804 int queue; 805 bfa_boolean_t rspq_comp = BFA_FALSE; 806 807 intr = readl(bfa->iocfc.bfa_regs.intr_status); 808 809 qintr = intr & (__HFN_INT_RME_MASK | __HFN_INT_CPE_MASK); 810 if (qintr) 811 writel(qintr, bfa->iocfc.bfa_regs.intr_status); 812 813 /* 814 * Unconditional RME completion queue interrupt 815 */ 816 if (bfa->queue_process) { 817 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++) 818 if (bfa_isr_rspq(bfa, queue)) 819 rspq_comp = BFA_TRUE; 820 } 821 822 if (!intr) 823 return (qintr | rspq_comp) ? BFA_TRUE : BFA_FALSE; 824 825 /* 826 * CPE completion queue interrupt 827 */ 828 qintr = intr & __HFN_INT_CPE_MASK; 829 if (qintr && bfa->queue_process) { 830 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++) 831 bfa_isr_reqq(bfa, queue); 832 } 833 intr &= ~qintr; 834 if (!intr) 835 return BFA_TRUE; 836 837 if (bfa->intr_enabled) 838 bfa_msix_lpu_err(bfa, intr); 839 840 return BFA_TRUE; 841 } 842 843 void 844 bfa_isr_enable(struct bfa_s *bfa) 845 { 846 u32 umsk; 847 int port_id = bfa_ioc_portid(&bfa->ioc); 848 849 bfa_trc(bfa, bfa_ioc_pcifn(&bfa->ioc)); 850 bfa_trc(bfa, port_id); 851 852 bfa_msix_ctrl_install(bfa); 853 854 if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) { 855 umsk = __HFN_INT_ERR_MASK_CT2; 856 umsk |= port_id == 0 ? 857 __HFN_INT_FN0_MASK_CT2 : __HFN_INT_FN1_MASK_CT2; 858 } else { 859 umsk = __HFN_INT_ERR_MASK; 860 umsk |= port_id == 0 ? __HFN_INT_FN0_MASK : __HFN_INT_FN1_MASK; 861 } 862 863 writel(umsk, bfa->iocfc.bfa_regs.intr_status); 864 writel(~umsk, bfa->iocfc.bfa_regs.intr_mask); 865 bfa->iocfc.intr_mask = ~umsk; 866 bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0); 867 868 /* 869 * Set the flag indicating successful enabling of interrupts 870 */ 871 bfa->intr_enabled = BFA_TRUE; 872 } 873 874 void 875 bfa_isr_disable(struct bfa_s *bfa) 876 { 877 bfa->intr_enabled = BFA_FALSE; 878 bfa_isr_mode_set(bfa, BFA_FALSE); 879 writel(-1L, bfa->iocfc.bfa_regs.intr_mask); 880 bfa_msix_uninstall(bfa); 881 } 882 883 void 884 bfa_msix_reqq(struct bfa_s *bfa, int vec) 885 { 886 bfa_isr_reqq(bfa, vec - bfa->iocfc.hwif.cpe_vec_q0); 887 } 888 889 void 890 bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m) 891 { 892 bfa_trc(bfa, m->mhdr.msg_class); 893 bfa_trc(bfa, m->mhdr.msg_id); 894 bfa_trc(bfa, m->mhdr.mtag.i2htok); 895 WARN_ON(1); 896 bfa_trc_stop(bfa->trcmod); 897 } 898 899 void 900 bfa_msix_rspq(struct bfa_s *bfa, int vec) 901 { 902 bfa_isr_rspq(bfa, vec - bfa->iocfc.hwif.rme_vec_q0); 903 } 904 905 void 906 bfa_msix_lpu_err(struct bfa_s *bfa, int vec) 907 { 908 u32 intr, curr_value; 909 bfa_boolean_t lpu_isr, halt_isr, pss_isr; 910 911 intr = readl(bfa->iocfc.bfa_regs.intr_status); 912 913 if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) { 914 halt_isr = intr & __HFN_INT_CPQ_HALT_CT2; 915 pss_isr = intr & __HFN_INT_ERR_PSS_CT2; 916 lpu_isr = intr & (__HFN_INT_MBOX_LPU0_CT2 | 917 __HFN_INT_MBOX_LPU1_CT2); 918 intr &= __HFN_INT_ERR_MASK_CT2; 919 } else { 920 halt_isr = bfa_asic_id_ct(bfa->ioc.pcidev.device_id) ? 921 (intr & __HFN_INT_LL_HALT) : 0; 922 pss_isr = intr & __HFN_INT_ERR_PSS; 923 lpu_isr = intr & (__HFN_INT_MBOX_LPU0 | __HFN_INT_MBOX_LPU1); 924 intr &= __HFN_INT_ERR_MASK; 925 } 926 927 if (lpu_isr) 928 bfa_ioc_mbox_isr(&bfa->ioc); 929 930 if (intr) { 931 if (halt_isr) { 932 /* 933 * If LL_HALT bit is set then FW Init Halt LL Port 934 * Register needs to be cleared as well so Interrupt 935 * Status Register will be cleared. 936 */ 937 curr_value = readl(bfa->ioc.ioc_regs.ll_halt); 938 curr_value &= ~__FW_INIT_HALT_P; 939 writel(curr_value, bfa->ioc.ioc_regs.ll_halt); 940 } 941 942 if (pss_isr) { 943 /* 944 * ERR_PSS bit needs to be cleared as well in case 945 * interrups are shared so driver's interrupt handler is 946 * still called even though it is already masked out. 947 */ 948 curr_value = readl( 949 bfa->ioc.ioc_regs.pss_err_status_reg); 950 writel(curr_value, 951 bfa->ioc.ioc_regs.pss_err_status_reg); 952 } 953 954 writel(intr, bfa->iocfc.bfa_regs.intr_status); 955 bfa_ioc_error_isr(&bfa->ioc); 956 } 957 } 958 959 /* 960 * BFA IOC FC related functions 961 */ 962 963 /* 964 * BFA IOC private functions 965 */ 966 967 /* 968 * Use the Mailbox interface to send BFI_IOCFC_H2I_CFG_REQ 969 */ 970 static void 971 bfa_iocfc_send_cfg(void *bfa_arg) 972 { 973 struct bfa_s *bfa = bfa_arg; 974 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 975 struct bfi_iocfc_cfg_req_s cfg_req; 976 struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo; 977 struct bfa_iocfc_cfg_s *cfg = &iocfc->cfg; 978 int i; 979 980 WARN_ON(cfg->fwcfg.num_cqs > BFI_IOC_MAX_CQS); 981 bfa_trc(bfa, cfg->fwcfg.num_cqs); 982 983 bfa_iocfc_reset_queues(bfa); 984 985 /* 986 * initialize IOC configuration info 987 */ 988 cfg_info->single_msix_vec = 0; 989 if (bfa->msix.nvecs == 1) 990 cfg_info->single_msix_vec = 1; 991 cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG; 992 cfg_info->num_cqs = cfg->fwcfg.num_cqs; 993 cfg_info->num_ioim_reqs = cpu_to_be16(bfa_fcpim_get_throttle_cfg(bfa, 994 cfg->fwcfg.num_ioim_reqs)); 995 cfg_info->num_fwtio_reqs = cpu_to_be16(cfg->fwcfg.num_fwtio_reqs); 996 997 bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa); 998 /* 999 * dma map REQ and RSP circular queues and shadow pointers 1000 */ 1001 for (i = 0; i < cfg->fwcfg.num_cqs; i++) { 1002 bfa_dma_be_addr_set(cfg_info->req_cq_ba[i], 1003 iocfc->req_cq_ba[i].pa); 1004 bfa_dma_be_addr_set(cfg_info->req_shadow_ci[i], 1005 iocfc->req_cq_shadow_ci[i].pa); 1006 cfg_info->req_cq_elems[i] = 1007 cpu_to_be16(cfg->drvcfg.num_reqq_elems); 1008 1009 bfa_dma_be_addr_set(cfg_info->rsp_cq_ba[i], 1010 iocfc->rsp_cq_ba[i].pa); 1011 bfa_dma_be_addr_set(cfg_info->rsp_shadow_pi[i], 1012 iocfc->rsp_cq_shadow_pi[i].pa); 1013 cfg_info->rsp_cq_elems[i] = 1014 cpu_to_be16(cfg->drvcfg.num_rspq_elems); 1015 } 1016 1017 /* 1018 * Enable interrupt coalescing if it is driver init path 1019 * and not ioc disable/enable path. 1020 */ 1021 if (bfa_fsm_cmp_state(iocfc, bfa_iocfc_sm_init_cfg_wait)) 1022 cfg_info->intr_attr.coalesce = BFA_TRUE; 1023 1024 /* 1025 * dma map IOC configuration itself 1026 */ 1027 bfi_h2i_set(cfg_req.mh, BFI_MC_IOCFC, BFI_IOCFC_H2I_CFG_REQ, 1028 bfa_fn_lpu(bfa)); 1029 bfa_dma_be_addr_set(cfg_req.ioc_cfg_dma_addr, iocfc->cfg_info.pa); 1030 1031 bfa_ioc_mbox_send(&bfa->ioc, &cfg_req, 1032 sizeof(struct bfi_iocfc_cfg_req_s)); 1033 } 1034 1035 static void 1036 bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 1037 struct bfa_pcidev_s *pcidev) 1038 { 1039 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1040 1041 bfa->bfad = bfad; 1042 iocfc->bfa = bfa; 1043 iocfc->cfg = *cfg; 1044 1045 /* 1046 * Initialize chip specific handlers. 1047 */ 1048 if (bfa_asic_id_ctc(bfa_ioc_devid(&bfa->ioc))) { 1049 iocfc->hwif.hw_reginit = bfa_hwct_reginit; 1050 iocfc->hwif.hw_reqq_ack = bfa_hwct_reqq_ack; 1051 iocfc->hwif.hw_rspq_ack = bfa_hwct_rspq_ack; 1052 iocfc->hwif.hw_msix_init = bfa_hwct_msix_init; 1053 iocfc->hwif.hw_msix_ctrl_install = bfa_hwct_msix_ctrl_install; 1054 iocfc->hwif.hw_msix_queue_install = bfa_hwct_msix_queue_install; 1055 iocfc->hwif.hw_msix_uninstall = bfa_hwct_msix_uninstall; 1056 iocfc->hwif.hw_isr_mode_set = bfa_hwct_isr_mode_set; 1057 iocfc->hwif.hw_msix_getvecs = bfa_hwct_msix_getvecs; 1058 iocfc->hwif.hw_msix_get_rme_range = bfa_hwct_msix_get_rme_range; 1059 iocfc->hwif.rme_vec_q0 = BFI_MSIX_RME_QMIN_CT; 1060 iocfc->hwif.cpe_vec_q0 = BFI_MSIX_CPE_QMIN_CT; 1061 } else { 1062 iocfc->hwif.hw_reginit = bfa_hwcb_reginit; 1063 iocfc->hwif.hw_reqq_ack = NULL; 1064 iocfc->hwif.hw_rspq_ack = bfa_hwcb_rspq_ack; 1065 iocfc->hwif.hw_msix_init = bfa_hwcb_msix_init; 1066 iocfc->hwif.hw_msix_ctrl_install = bfa_hwcb_msix_ctrl_install; 1067 iocfc->hwif.hw_msix_queue_install = bfa_hwcb_msix_queue_install; 1068 iocfc->hwif.hw_msix_uninstall = bfa_hwcb_msix_uninstall; 1069 iocfc->hwif.hw_isr_mode_set = bfa_hwcb_isr_mode_set; 1070 iocfc->hwif.hw_msix_getvecs = bfa_hwcb_msix_getvecs; 1071 iocfc->hwif.hw_msix_get_rme_range = bfa_hwcb_msix_get_rme_range; 1072 iocfc->hwif.rme_vec_q0 = BFI_MSIX_RME_QMIN_CB + 1073 bfa_ioc_pcifn(&bfa->ioc) * BFI_IOC_MAX_CQS; 1074 iocfc->hwif.cpe_vec_q0 = BFI_MSIX_CPE_QMIN_CB + 1075 bfa_ioc_pcifn(&bfa->ioc) * BFI_IOC_MAX_CQS; 1076 } 1077 1078 if (bfa_asic_id_ct2(bfa_ioc_devid(&bfa->ioc))) { 1079 iocfc->hwif.hw_reginit = bfa_hwct2_reginit; 1080 iocfc->hwif.hw_isr_mode_set = NULL; 1081 iocfc->hwif.hw_rspq_ack = bfa_hwct2_rspq_ack; 1082 } 1083 1084 iocfc->hwif.hw_reginit(bfa); 1085 bfa->msix.nvecs = 0; 1086 } 1087 1088 static void 1089 bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg) 1090 { 1091 u8 *dm_kva = NULL; 1092 u64 dm_pa = 0; 1093 int i, per_reqq_sz, per_rspq_sz; 1094 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1095 struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa); 1096 struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa); 1097 struct bfa_mem_dma_s *reqq_dma, *rspq_dma; 1098 1099 /* First allocate dma memory for IOC */ 1100 bfa_ioc_mem_claim(&bfa->ioc, bfa_mem_dma_virt(ioc_dma), 1101 bfa_mem_dma_phys(ioc_dma)); 1102 1103 /* Claim DMA-able memory for the request/response queues */ 1104 per_reqq_sz = BFA_ROUNDUP((cfg->drvcfg.num_reqq_elems * BFI_LMSG_SZ), 1105 BFA_DMA_ALIGN_SZ); 1106 per_rspq_sz = BFA_ROUNDUP((cfg->drvcfg.num_rspq_elems * BFI_LMSG_SZ), 1107 BFA_DMA_ALIGN_SZ); 1108 1109 for (i = 0; i < cfg->fwcfg.num_cqs; i++) { 1110 reqq_dma = BFA_MEM_REQQ_DMA(bfa, i); 1111 iocfc->req_cq_ba[i].kva = bfa_mem_dma_virt(reqq_dma); 1112 iocfc->req_cq_ba[i].pa = bfa_mem_dma_phys(reqq_dma); 1113 memset(iocfc->req_cq_ba[i].kva, 0, per_reqq_sz); 1114 1115 rspq_dma = BFA_MEM_RSPQ_DMA(bfa, i); 1116 iocfc->rsp_cq_ba[i].kva = bfa_mem_dma_virt(rspq_dma); 1117 iocfc->rsp_cq_ba[i].pa = bfa_mem_dma_phys(rspq_dma); 1118 memset(iocfc->rsp_cq_ba[i].kva, 0, per_rspq_sz); 1119 } 1120 1121 /* Claim IOCFC dma memory - for shadow CI/PI */ 1122 dm_kva = bfa_mem_dma_virt(iocfc_dma); 1123 dm_pa = bfa_mem_dma_phys(iocfc_dma); 1124 1125 for (i = 0; i < cfg->fwcfg.num_cqs; i++) { 1126 iocfc->req_cq_shadow_ci[i].kva = dm_kva; 1127 iocfc->req_cq_shadow_ci[i].pa = dm_pa; 1128 dm_kva += BFA_CACHELINE_SZ; 1129 dm_pa += BFA_CACHELINE_SZ; 1130 1131 iocfc->rsp_cq_shadow_pi[i].kva = dm_kva; 1132 iocfc->rsp_cq_shadow_pi[i].pa = dm_pa; 1133 dm_kva += BFA_CACHELINE_SZ; 1134 dm_pa += BFA_CACHELINE_SZ; 1135 } 1136 1137 /* Claim IOCFC dma memory - for the config info page */ 1138 bfa->iocfc.cfg_info.kva = dm_kva; 1139 bfa->iocfc.cfg_info.pa = dm_pa; 1140 bfa->iocfc.cfginfo = (struct bfi_iocfc_cfg_s *) dm_kva; 1141 dm_kva += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ); 1142 dm_pa += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ); 1143 1144 /* Claim IOCFC dma memory - for the config response */ 1145 bfa->iocfc.cfgrsp_dma.kva = dm_kva; 1146 bfa->iocfc.cfgrsp_dma.pa = dm_pa; 1147 bfa->iocfc.cfgrsp = (struct bfi_iocfc_cfgrsp_s *) dm_kva; 1148 dm_kva += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s), 1149 BFA_CACHELINE_SZ); 1150 dm_pa += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s), 1151 BFA_CACHELINE_SZ); 1152 1153 /* Claim IOCFC kva memory */ 1154 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc)); 1155 bfa_mem_kva_curp(iocfc) += BFA_DBG_FWTRC_LEN; 1156 } 1157 1158 /* 1159 * Start BFA submodules. 1160 */ 1161 static void 1162 bfa_iocfc_start_submod(struct bfa_s *bfa) 1163 { 1164 int i; 1165 1166 bfa->queue_process = BFA_TRUE; 1167 for (i = 0; i < BFI_IOC_MAX_CQS; i++) 1168 bfa_isr_rspq_ack(bfa, i, bfa_rspq_ci(bfa, i)); 1169 1170 bfa_fcport_start(bfa); 1171 bfa_uf_start(bfa); 1172 /* 1173 * bfa_init() with flash read is complete. now invalidate the stale 1174 * content of lun mask like unit attention, rp tag and lp tag. 1175 */ 1176 bfa_ioim_lm_init(BFA_FCP_MOD(bfa)->bfa); 1177 1178 bfa->iocfc.submod_enabled = BFA_TRUE; 1179 } 1180 1181 /* 1182 * Disable BFA submodules. 1183 */ 1184 static void 1185 bfa_iocfc_disable_submod(struct bfa_s *bfa) 1186 { 1187 if (bfa->iocfc.submod_enabled == BFA_FALSE) 1188 return; 1189 1190 bfa_fcdiag_iocdisable(bfa); 1191 bfa_fcport_iocdisable(bfa); 1192 bfa_fcxp_iocdisable(bfa); 1193 bfa_lps_iocdisable(bfa); 1194 bfa_rport_iocdisable(bfa); 1195 bfa_fcp_iocdisable(bfa); 1196 bfa_dconf_iocdisable(bfa); 1197 1198 bfa->iocfc.submod_enabled = BFA_FALSE; 1199 } 1200 1201 static void 1202 bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete) 1203 { 1204 struct bfa_s *bfa = bfa_arg; 1205 1206 if (complete) 1207 bfa_cb_init(bfa->bfad, bfa->iocfc.op_status); 1208 } 1209 1210 static void 1211 bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl) 1212 { 1213 struct bfa_s *bfa = bfa_arg; 1214 struct bfad_s *bfad = bfa->bfad; 1215 1216 if (compl) 1217 complete(&bfad->comp); 1218 } 1219 1220 static void 1221 bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl) 1222 { 1223 struct bfa_s *bfa = bfa_arg; 1224 struct bfad_s *bfad = bfa->bfad; 1225 1226 if (compl) 1227 complete(&bfad->enable_comp); 1228 } 1229 1230 static void 1231 bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl) 1232 { 1233 struct bfa_s *bfa = bfa_arg; 1234 struct bfad_s *bfad = bfa->bfad; 1235 1236 if (compl) 1237 complete(&bfad->disable_comp); 1238 } 1239 1240 /* 1241 * configure queue registers from firmware response 1242 */ 1243 static void 1244 bfa_iocfc_qreg(struct bfa_s *bfa, struct bfi_iocfc_qreg_s *qreg) 1245 { 1246 int i; 1247 struct bfa_iocfc_regs_s *r = &bfa->iocfc.bfa_regs; 1248 void __iomem *kva = bfa_ioc_bar0(&bfa->ioc); 1249 1250 for (i = 0; i < BFI_IOC_MAX_CQS; i++) { 1251 bfa->iocfc.hw_qid[i] = qreg->hw_qid[i]; 1252 r->cpe_q_ci[i] = kva + be32_to_cpu(qreg->cpe_q_ci_off[i]); 1253 r->cpe_q_pi[i] = kva + be32_to_cpu(qreg->cpe_q_pi_off[i]); 1254 r->cpe_q_ctrl[i] = kva + be32_to_cpu(qreg->cpe_qctl_off[i]); 1255 r->rme_q_ci[i] = kva + be32_to_cpu(qreg->rme_q_ci_off[i]); 1256 r->rme_q_pi[i] = kva + be32_to_cpu(qreg->rme_q_pi_off[i]); 1257 r->rme_q_ctrl[i] = kva + be32_to_cpu(qreg->rme_qctl_off[i]); 1258 } 1259 } 1260 1261 static void 1262 bfa_iocfc_res_recfg(struct bfa_s *bfa, struct bfa_iocfc_fwcfg_s *fwcfg) 1263 { 1264 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1265 struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo; 1266 1267 bfa_fcxp_res_recfg(bfa, fwcfg->num_fcxp_reqs); 1268 bfa_uf_res_recfg(bfa, fwcfg->num_uf_bufs); 1269 bfa_rport_res_recfg(bfa, fwcfg->num_rports); 1270 bfa_fcp_res_recfg(bfa, cpu_to_be16(cfg_info->num_ioim_reqs), 1271 fwcfg->num_ioim_reqs); 1272 bfa_tskim_res_recfg(bfa, fwcfg->num_tskim_reqs); 1273 } 1274 1275 /* 1276 * Update BFA configuration from firmware configuration. 1277 */ 1278 static void 1279 bfa_iocfc_cfgrsp(struct bfa_s *bfa) 1280 { 1281 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1282 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp; 1283 struct bfa_iocfc_fwcfg_s *fwcfg = &cfgrsp->fwcfg; 1284 1285 fwcfg->num_cqs = fwcfg->num_cqs; 1286 fwcfg->num_ioim_reqs = be16_to_cpu(fwcfg->num_ioim_reqs); 1287 fwcfg->num_fwtio_reqs = be16_to_cpu(fwcfg->num_fwtio_reqs); 1288 fwcfg->num_tskim_reqs = be16_to_cpu(fwcfg->num_tskim_reqs); 1289 fwcfg->num_fcxp_reqs = be16_to_cpu(fwcfg->num_fcxp_reqs); 1290 fwcfg->num_uf_bufs = be16_to_cpu(fwcfg->num_uf_bufs); 1291 fwcfg->num_rports = be16_to_cpu(fwcfg->num_rports); 1292 1293 /* 1294 * configure queue register offsets as learnt from firmware 1295 */ 1296 bfa_iocfc_qreg(bfa, &cfgrsp->qreg); 1297 1298 /* 1299 * Re-configure resources as learnt from Firmware 1300 */ 1301 bfa_iocfc_res_recfg(bfa, fwcfg); 1302 1303 /* 1304 * Install MSIX queue handlers 1305 */ 1306 bfa_msix_queue_install(bfa); 1307 1308 if (bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn != 0) { 1309 bfa->ioc.attr->pwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn; 1310 bfa->ioc.attr->nwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_nwwn; 1311 bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE); 1312 } 1313 } 1314 1315 void 1316 bfa_iocfc_reset_queues(struct bfa_s *bfa) 1317 { 1318 int q; 1319 1320 for (q = 0; q < BFI_IOC_MAX_CQS; q++) { 1321 bfa_reqq_ci(bfa, q) = 0; 1322 bfa_reqq_pi(bfa, q) = 0; 1323 bfa_rspq_ci(bfa, q) = 0; 1324 bfa_rspq_pi(bfa, q) = 0; 1325 } 1326 } 1327 1328 /* 1329 * Process FAA pwwn msg from fw. 1330 */ 1331 static void 1332 bfa_iocfc_process_faa_addr(struct bfa_s *bfa, struct bfi_faa_addr_msg_s *msg) 1333 { 1334 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1335 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp; 1336 1337 cfgrsp->pbc_cfg.pbc_pwwn = msg->pwwn; 1338 cfgrsp->pbc_cfg.pbc_nwwn = msg->nwwn; 1339 1340 bfa->ioc.attr->pwwn = msg->pwwn; 1341 bfa->ioc.attr->nwwn = msg->nwwn; 1342 bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE); 1343 } 1344 1345 /* Fabric Assigned Address specific functions */ 1346 1347 /* 1348 * Check whether IOC is ready before sending command down 1349 */ 1350 static bfa_status_t 1351 bfa_faa_validate_request(struct bfa_s *bfa) 1352 { 1353 enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa); 1354 u32 card_type = bfa->ioc.attr->card_type; 1355 1356 if (bfa_ioc_is_operational(&bfa->ioc)) { 1357 if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type)) 1358 return BFA_STATUS_FEATURE_NOT_SUPPORTED; 1359 } else { 1360 return BFA_STATUS_IOC_NON_OP; 1361 } 1362 1363 return BFA_STATUS_OK; 1364 } 1365 1366 bfa_status_t 1367 bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr, 1368 bfa_cb_iocfc_t cbfn, void *cbarg) 1369 { 1370 struct bfi_faa_query_s faa_attr_req; 1371 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1372 bfa_status_t status; 1373 1374 status = bfa_faa_validate_request(bfa); 1375 if (status != BFA_STATUS_OK) 1376 return status; 1377 1378 if (iocfc->faa_args.busy == BFA_TRUE) 1379 return BFA_STATUS_DEVBUSY; 1380 1381 iocfc->faa_args.faa_attr = attr; 1382 iocfc->faa_args.faa_cb.faa_cbfn = cbfn; 1383 iocfc->faa_args.faa_cb.faa_cbarg = cbarg; 1384 1385 iocfc->faa_args.busy = BFA_TRUE; 1386 memset(&faa_attr_req, 0, sizeof(struct bfi_faa_query_s)); 1387 bfi_h2i_set(faa_attr_req.mh, BFI_MC_IOCFC, 1388 BFI_IOCFC_H2I_FAA_QUERY_REQ, bfa_fn_lpu(bfa)); 1389 1390 bfa_ioc_mbox_send(&bfa->ioc, &faa_attr_req, 1391 sizeof(struct bfi_faa_query_s)); 1392 1393 return BFA_STATUS_OK; 1394 } 1395 1396 /* 1397 * FAA query response 1398 */ 1399 static void 1400 bfa_faa_query_reply(struct bfa_iocfc_s *iocfc, 1401 bfi_faa_query_rsp_t *rsp) 1402 { 1403 void *cbarg = iocfc->faa_args.faa_cb.faa_cbarg; 1404 1405 if (iocfc->faa_args.faa_attr) { 1406 iocfc->faa_args.faa_attr->faa = rsp->faa; 1407 iocfc->faa_args.faa_attr->faa_state = rsp->faa_status; 1408 iocfc->faa_args.faa_attr->pwwn_source = rsp->addr_source; 1409 } 1410 1411 WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn); 1412 1413 iocfc->faa_args.faa_cb.faa_cbfn(cbarg, BFA_STATUS_OK); 1414 iocfc->faa_args.busy = BFA_FALSE; 1415 } 1416 1417 /* 1418 * IOC enable request is complete 1419 */ 1420 static void 1421 bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status) 1422 { 1423 struct bfa_s *bfa = bfa_arg; 1424 1425 if (status == BFA_STATUS_OK) 1426 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_ENABLED); 1427 else 1428 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED); 1429 } 1430 1431 /* 1432 * IOC disable request is complete 1433 */ 1434 static void 1435 bfa_iocfc_disable_cbfn(void *bfa_arg) 1436 { 1437 struct bfa_s *bfa = bfa_arg; 1438 1439 bfa->queue_process = BFA_FALSE; 1440 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_DISABLED); 1441 } 1442 1443 /* 1444 * Notify sub-modules of hardware failure. 1445 */ 1446 static void 1447 bfa_iocfc_hbfail_cbfn(void *bfa_arg) 1448 { 1449 struct bfa_s *bfa = bfa_arg; 1450 1451 bfa->queue_process = BFA_FALSE; 1452 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED); 1453 } 1454 1455 /* 1456 * Actions on chip-reset completion. 1457 */ 1458 static void 1459 bfa_iocfc_reset_cbfn(void *bfa_arg) 1460 { 1461 struct bfa_s *bfa = bfa_arg; 1462 1463 bfa_iocfc_reset_queues(bfa); 1464 bfa_isr_enable(bfa); 1465 } 1466 1467 /* 1468 * Query IOC memory requirement information. 1469 */ 1470 void 1471 bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo, 1472 struct bfa_s *bfa) 1473 { 1474 int q, per_reqq_sz, per_rspq_sz; 1475 struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa); 1476 struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa); 1477 struct bfa_mem_kva_s *iocfc_kva = BFA_MEM_IOCFC_KVA(bfa); 1478 u32 dm_len = 0; 1479 1480 /* dma memory setup for IOC */ 1481 bfa_mem_dma_setup(meminfo, ioc_dma, 1482 BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ)); 1483 1484 /* dma memory setup for REQ/RSP queues */ 1485 per_reqq_sz = BFA_ROUNDUP((cfg->drvcfg.num_reqq_elems * BFI_LMSG_SZ), 1486 BFA_DMA_ALIGN_SZ); 1487 per_rspq_sz = BFA_ROUNDUP((cfg->drvcfg.num_rspq_elems * BFI_LMSG_SZ), 1488 BFA_DMA_ALIGN_SZ); 1489 1490 for (q = 0; q < cfg->fwcfg.num_cqs; q++) { 1491 bfa_mem_dma_setup(meminfo, BFA_MEM_REQQ_DMA(bfa, q), 1492 per_reqq_sz); 1493 bfa_mem_dma_setup(meminfo, BFA_MEM_RSPQ_DMA(bfa, q), 1494 per_rspq_sz); 1495 } 1496 1497 /* IOCFC dma memory - calculate Shadow CI/PI size */ 1498 for (q = 0; q < cfg->fwcfg.num_cqs; q++) 1499 dm_len += (2 * BFA_CACHELINE_SZ); 1500 1501 /* IOCFC dma memory - calculate config info / rsp size */ 1502 dm_len += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ); 1503 dm_len += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s), 1504 BFA_CACHELINE_SZ); 1505 1506 /* dma memory setup for IOCFC */ 1507 bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len); 1508 1509 /* kva memory setup for IOCFC */ 1510 bfa_mem_kva_setup(meminfo, iocfc_kva, BFA_DBG_FWTRC_LEN); 1511 } 1512 1513 /* 1514 * Query IOC memory requirement information. 1515 */ 1516 void 1517 bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 1518 struct bfa_pcidev_s *pcidev) 1519 { 1520 int i; 1521 struct bfa_ioc_s *ioc = &bfa->ioc; 1522 1523 bfa_iocfc_cbfn.enable_cbfn = bfa_iocfc_enable_cbfn; 1524 bfa_iocfc_cbfn.disable_cbfn = bfa_iocfc_disable_cbfn; 1525 bfa_iocfc_cbfn.hbfail_cbfn = bfa_iocfc_hbfail_cbfn; 1526 bfa_iocfc_cbfn.reset_cbfn = bfa_iocfc_reset_cbfn; 1527 1528 ioc->trcmod = bfa->trcmod; 1529 bfa_ioc_attach(&bfa->ioc, bfa, &bfa_iocfc_cbfn, &bfa->timer_mod); 1530 1531 bfa_ioc_pci_init(&bfa->ioc, pcidev, BFI_PCIFN_CLASS_FC); 1532 bfa_ioc_mbox_register(&bfa->ioc, bfa_mbox_isrs); 1533 1534 bfa_iocfc_init_mem(bfa, bfad, cfg, pcidev); 1535 bfa_iocfc_mem_claim(bfa, cfg); 1536 INIT_LIST_HEAD(&bfa->timer_mod.timer_q); 1537 1538 INIT_LIST_HEAD(&bfa->comp_q); 1539 for (i = 0; i < BFI_IOC_MAX_CQS; i++) 1540 INIT_LIST_HEAD(&bfa->reqq_waitq[i]); 1541 1542 bfa->iocfc.cb_reqd = BFA_FALSE; 1543 bfa->iocfc.op_status = BFA_STATUS_OK; 1544 bfa->iocfc.submod_enabled = BFA_FALSE; 1545 1546 bfa_fsm_set_state(&bfa->iocfc, bfa_iocfc_sm_stopped); 1547 } 1548 1549 /* 1550 * Query IOC memory requirement information. 1551 */ 1552 void 1553 bfa_iocfc_init(struct bfa_s *bfa) 1554 { 1555 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_INIT); 1556 } 1557 1558 /* 1559 * IOC start called from bfa_start(). Called to start IOC operations 1560 * at driver instantiation for this instance. 1561 */ 1562 void 1563 bfa_iocfc_start(struct bfa_s *bfa) 1564 { 1565 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_START); 1566 } 1567 1568 /* 1569 * IOC stop called from bfa_stop(). Called only when driver is unloaded 1570 * for this instance. 1571 */ 1572 void 1573 bfa_iocfc_stop(struct bfa_s *bfa) 1574 { 1575 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_STOP); 1576 } 1577 1578 void 1579 bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m) 1580 { 1581 struct bfa_s *bfa = bfaarg; 1582 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1583 union bfi_iocfc_i2h_msg_u *msg; 1584 1585 msg = (union bfi_iocfc_i2h_msg_u *) m; 1586 bfa_trc(bfa, msg->mh.msg_id); 1587 1588 switch (msg->mh.msg_id) { 1589 case BFI_IOCFC_I2H_CFG_REPLY: 1590 bfa_iocfc_cfgrsp(bfa); 1591 break; 1592 case BFI_IOCFC_I2H_UPDATEQ_RSP: 1593 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK); 1594 break; 1595 case BFI_IOCFC_I2H_ADDR_MSG: 1596 bfa_iocfc_process_faa_addr(bfa, 1597 (struct bfi_faa_addr_msg_s *)msg); 1598 break; 1599 case BFI_IOCFC_I2H_FAA_QUERY_RSP: 1600 bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg); 1601 break; 1602 default: 1603 WARN_ON(1); 1604 } 1605 } 1606 1607 void 1608 bfa_iocfc_get_attr(struct bfa_s *bfa, struct bfa_iocfc_attr_s *attr) 1609 { 1610 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1611 1612 attr->intr_attr.coalesce = iocfc->cfginfo->intr_attr.coalesce; 1613 1614 attr->intr_attr.delay = iocfc->cfginfo->intr_attr.delay ? 1615 be16_to_cpu(iocfc->cfginfo->intr_attr.delay) : 1616 be16_to_cpu(iocfc->cfgrsp->intr_attr.delay); 1617 1618 attr->intr_attr.latency = iocfc->cfginfo->intr_attr.latency ? 1619 be16_to_cpu(iocfc->cfginfo->intr_attr.latency) : 1620 be16_to_cpu(iocfc->cfgrsp->intr_attr.latency); 1621 1622 attr->config = iocfc->cfg; 1623 } 1624 1625 bfa_status_t 1626 bfa_iocfc_israttr_set(struct bfa_s *bfa, struct bfa_iocfc_intr_attr_s *attr) 1627 { 1628 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1629 struct bfi_iocfc_set_intr_req_s *m; 1630 1631 iocfc->cfginfo->intr_attr.coalesce = attr->coalesce; 1632 iocfc->cfginfo->intr_attr.delay = cpu_to_be16(attr->delay); 1633 iocfc->cfginfo->intr_attr.latency = cpu_to_be16(attr->latency); 1634 1635 if (!bfa_iocfc_is_operational(bfa)) 1636 return BFA_STATUS_OK; 1637 1638 m = bfa_reqq_next(bfa, BFA_REQQ_IOC); 1639 if (!m) 1640 return BFA_STATUS_DEVBUSY; 1641 1642 bfi_h2i_set(m->mh, BFI_MC_IOCFC, BFI_IOCFC_H2I_SET_INTR_REQ, 1643 bfa_fn_lpu(bfa)); 1644 m->coalesce = iocfc->cfginfo->intr_attr.coalesce; 1645 m->delay = iocfc->cfginfo->intr_attr.delay; 1646 m->latency = iocfc->cfginfo->intr_attr.latency; 1647 1648 bfa_trc(bfa, attr->delay); 1649 bfa_trc(bfa, attr->latency); 1650 1651 bfa_reqq_produce(bfa, BFA_REQQ_IOC, m->mh); 1652 return BFA_STATUS_OK; 1653 } 1654 1655 void 1656 bfa_iocfc_set_snsbase(struct bfa_s *bfa, int seg_no, u64 snsbase_pa) 1657 { 1658 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1659 1660 iocfc->cfginfo->sense_buf_len = (BFI_IOIM_SNSLEN - 1); 1661 bfa_dma_be_addr_set(iocfc->cfginfo->ioim_snsbase[seg_no], snsbase_pa); 1662 } 1663 /* 1664 * Enable IOC after it is disabled. 1665 */ 1666 void 1667 bfa_iocfc_enable(struct bfa_s *bfa) 1668 { 1669 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0, 1670 "IOC Enable"); 1671 bfa->iocfc.cb_reqd = BFA_TRUE; 1672 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_ENABLE); 1673 } 1674 1675 void 1676 bfa_iocfc_disable(struct bfa_s *bfa) 1677 { 1678 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0, 1679 "IOC Disable"); 1680 1681 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DISABLE); 1682 } 1683 1684 bfa_boolean_t 1685 bfa_iocfc_is_operational(struct bfa_s *bfa) 1686 { 1687 return bfa_ioc_is_operational(&bfa->ioc) && 1688 bfa_fsm_cmp_state(&bfa->iocfc, bfa_iocfc_sm_operational); 1689 } 1690 1691 /* 1692 * Return boot target port wwns -- read from boot information in flash. 1693 */ 1694 void 1695 bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns) 1696 { 1697 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1698 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp; 1699 int i; 1700 1701 if (cfgrsp->pbc_cfg.boot_enabled && cfgrsp->pbc_cfg.nbluns) { 1702 bfa_trc(bfa, cfgrsp->pbc_cfg.nbluns); 1703 *nwwns = cfgrsp->pbc_cfg.nbluns; 1704 for (i = 0; i < cfgrsp->pbc_cfg.nbluns; i++) 1705 wwns[i] = cfgrsp->pbc_cfg.blun[i].tgt_pwwn; 1706 1707 return; 1708 } 1709 1710 *nwwns = cfgrsp->bootwwns.nwwns; 1711 memcpy(wwns, cfgrsp->bootwwns.wwn, sizeof(cfgrsp->bootwwns.wwn)); 1712 } 1713 1714 int 1715 bfa_iocfc_get_pbc_vports(struct bfa_s *bfa, struct bfi_pbc_vport_s *pbc_vport) 1716 { 1717 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 1718 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp; 1719 1720 memcpy(pbc_vport, cfgrsp->pbc_cfg.vport, sizeof(cfgrsp->pbc_cfg.vport)); 1721 return cfgrsp->pbc_cfg.nvports; 1722 } 1723 1724 1725 /* 1726 * Use this function query the memory requirement of the BFA library. 1727 * This function needs to be called before bfa_attach() to get the 1728 * memory required of the BFA layer for a given driver configuration. 1729 * 1730 * This call will fail, if the cap is out of range compared to pre-defined 1731 * values within the BFA library 1732 * 1733 * @param[in] cfg - pointer to bfa_ioc_cfg_t. Driver layer should indicate 1734 * its configuration in this structure. 1735 * The default values for struct bfa_iocfc_cfg_s can be 1736 * fetched using bfa_cfg_get_default() API. 1737 * 1738 * If cap's boundary check fails, the library will use 1739 * the default bfa_cap_t values (and log a warning msg). 1740 * 1741 * @param[out] meminfo - pointer to bfa_meminfo_t. This content 1742 * indicates the memory type (see bfa_mem_type_t) and 1743 * amount of memory required. 1744 * 1745 * Driver should allocate the memory, populate the 1746 * starting address for each block and provide the same 1747 * structure as input parameter to bfa_attach() call. 1748 * 1749 * @param[in] bfa - pointer to the bfa structure, used while fetching the 1750 * dma, kva memory information of the bfa sub-modules. 1751 * 1752 * @return void 1753 * 1754 * Special Considerations: @note 1755 */ 1756 void 1757 bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo, 1758 struct bfa_s *bfa) 1759 { 1760 struct bfa_mem_dma_s *port_dma = BFA_MEM_PORT_DMA(bfa); 1761 struct bfa_mem_dma_s *ablk_dma = BFA_MEM_ABLK_DMA(bfa); 1762 struct bfa_mem_dma_s *cee_dma = BFA_MEM_CEE_DMA(bfa); 1763 struct bfa_mem_dma_s *sfp_dma = BFA_MEM_SFP_DMA(bfa); 1764 struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa); 1765 struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa); 1766 struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa); 1767 struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa); 1768 1769 WARN_ON((cfg == NULL) || (meminfo == NULL)); 1770 1771 memset((void *)meminfo, 0, sizeof(struct bfa_meminfo_s)); 1772 1773 /* Initialize the DMA & KVA meminfo queues */ 1774 INIT_LIST_HEAD(&meminfo->dma_info.qe); 1775 INIT_LIST_HEAD(&meminfo->kva_info.qe); 1776 1777 bfa_iocfc_meminfo(cfg, meminfo, bfa); 1778 bfa_sgpg_meminfo(cfg, meminfo, bfa); 1779 bfa_fcport_meminfo(cfg, meminfo, bfa); 1780 bfa_fcxp_meminfo(cfg, meminfo, bfa); 1781 bfa_lps_meminfo(cfg, meminfo, bfa); 1782 bfa_uf_meminfo(cfg, meminfo, bfa); 1783 bfa_rport_meminfo(cfg, meminfo, bfa); 1784 bfa_fcp_meminfo(cfg, meminfo, bfa); 1785 bfa_dconf_meminfo(cfg, meminfo, bfa); 1786 1787 /* dma info setup */ 1788 bfa_mem_dma_setup(meminfo, port_dma, bfa_port_meminfo()); 1789 bfa_mem_dma_setup(meminfo, ablk_dma, bfa_ablk_meminfo()); 1790 bfa_mem_dma_setup(meminfo, cee_dma, bfa_cee_meminfo()); 1791 bfa_mem_dma_setup(meminfo, sfp_dma, bfa_sfp_meminfo()); 1792 bfa_mem_dma_setup(meminfo, flash_dma, 1793 bfa_flash_meminfo(cfg->drvcfg.min_cfg)); 1794 bfa_mem_dma_setup(meminfo, diag_dma, bfa_diag_meminfo()); 1795 bfa_mem_dma_setup(meminfo, phy_dma, 1796 bfa_phy_meminfo(cfg->drvcfg.min_cfg)); 1797 bfa_mem_dma_setup(meminfo, fru_dma, 1798 bfa_fru_meminfo(cfg->drvcfg.min_cfg)); 1799 } 1800 1801 /* 1802 * Use this function to do attach the driver instance with the BFA 1803 * library. This function will not trigger any HW initialization 1804 * process (which will be done in bfa_init() call) 1805 * 1806 * This call will fail, if the cap is out of range compared to 1807 * pre-defined values within the BFA library 1808 * 1809 * @param[out] bfa Pointer to bfa_t. 1810 * @param[in] bfad Opaque handle back to the driver's IOC structure 1811 * @param[in] cfg Pointer to bfa_ioc_cfg_t. Should be same structure 1812 * that was used in bfa_cfg_get_meminfo(). 1813 * @param[in] meminfo Pointer to bfa_meminfo_t. The driver should 1814 * use the bfa_cfg_get_meminfo() call to 1815 * find the memory blocks required, allocate the 1816 * required memory and provide the starting addresses. 1817 * @param[in] pcidev pointer to struct bfa_pcidev_s 1818 * 1819 * @return 1820 * void 1821 * 1822 * Special Considerations: 1823 * 1824 * @note 1825 * 1826 */ 1827 void 1828 bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg, 1829 struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev) 1830 { 1831 struct bfa_mem_dma_s *dma_info, *dma_elem; 1832 struct bfa_mem_kva_s *kva_info, *kva_elem; 1833 struct list_head *dm_qe, *km_qe; 1834 1835 bfa->fcs = BFA_FALSE; 1836 1837 WARN_ON((cfg == NULL) || (meminfo == NULL)); 1838 1839 /* Initialize memory pointers for iterative allocation */ 1840 dma_info = &meminfo->dma_info; 1841 dma_info->kva_curp = dma_info->kva; 1842 dma_info->dma_curp = dma_info->dma; 1843 1844 kva_info = &meminfo->kva_info; 1845 kva_info->kva_curp = kva_info->kva; 1846 1847 list_for_each(dm_qe, &dma_info->qe) { 1848 dma_elem = (struct bfa_mem_dma_s *) dm_qe; 1849 dma_elem->kva_curp = dma_elem->kva; 1850 dma_elem->dma_curp = dma_elem->dma; 1851 } 1852 1853 list_for_each(km_qe, &kva_info->qe) { 1854 kva_elem = (struct bfa_mem_kva_s *) km_qe; 1855 kva_elem->kva_curp = kva_elem->kva; 1856 } 1857 1858 bfa_iocfc_attach(bfa, bfad, cfg, pcidev); 1859 bfa_fcdiag_attach(bfa, bfad, cfg, pcidev); 1860 bfa_sgpg_attach(bfa, bfad, cfg, pcidev); 1861 bfa_fcport_attach(bfa, bfad, cfg, pcidev); 1862 bfa_fcxp_attach(bfa, bfad, cfg, pcidev); 1863 bfa_lps_attach(bfa, bfad, cfg, pcidev); 1864 bfa_uf_attach(bfa, bfad, cfg, pcidev); 1865 bfa_rport_attach(bfa, bfad, cfg, pcidev); 1866 bfa_fcp_attach(bfa, bfad, cfg, pcidev); 1867 bfa_dconf_attach(bfa, bfad, cfg); 1868 bfa_com_port_attach(bfa); 1869 bfa_com_ablk_attach(bfa); 1870 bfa_com_cee_attach(bfa); 1871 bfa_com_sfp_attach(bfa); 1872 bfa_com_flash_attach(bfa, cfg->drvcfg.min_cfg); 1873 bfa_com_diag_attach(bfa); 1874 bfa_com_phy_attach(bfa, cfg->drvcfg.min_cfg); 1875 bfa_com_fru_attach(bfa, cfg->drvcfg.min_cfg); 1876 } 1877 1878 /* 1879 * Use this function to delete a BFA IOC. IOC should be stopped (by 1880 * calling bfa_stop()) before this function call. 1881 * 1882 * @param[in] bfa - pointer to bfa_t. 1883 * 1884 * @return 1885 * void 1886 * 1887 * Special Considerations: 1888 * 1889 * @note 1890 */ 1891 void 1892 bfa_detach(struct bfa_s *bfa) 1893 { 1894 bfa_ioc_detach(&bfa->ioc); 1895 } 1896 1897 void 1898 bfa_comp_deq(struct bfa_s *bfa, struct list_head *comp_q) 1899 { 1900 INIT_LIST_HEAD(comp_q); 1901 list_splice_tail_init(&bfa->comp_q, comp_q); 1902 } 1903 1904 void 1905 bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q) 1906 { 1907 struct list_head *qe; 1908 struct list_head *qen; 1909 struct bfa_cb_qe_s *hcb_qe; 1910 bfa_cb_cbfn_status_t cbfn; 1911 1912 list_for_each_safe(qe, qen, comp_q) { 1913 hcb_qe = (struct bfa_cb_qe_s *) qe; 1914 if (hcb_qe->pre_rmv) { 1915 /* qe is invalid after return, dequeue before cbfn() */ 1916 list_del(qe); 1917 cbfn = (bfa_cb_cbfn_status_t)(hcb_qe->cbfn); 1918 cbfn(hcb_qe->cbarg, hcb_qe->fw_status); 1919 } else 1920 hcb_qe->cbfn(hcb_qe->cbarg, BFA_TRUE); 1921 } 1922 } 1923 1924 void 1925 bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q) 1926 { 1927 struct list_head *qe; 1928 struct bfa_cb_qe_s *hcb_qe; 1929 1930 while (!list_empty(comp_q)) { 1931 bfa_q_deq(comp_q, &qe); 1932 hcb_qe = (struct bfa_cb_qe_s *) qe; 1933 WARN_ON(hcb_qe->pre_rmv); 1934 hcb_qe->cbfn(hcb_qe->cbarg, BFA_FALSE); 1935 } 1936 } 1937 1938 /* 1939 * Return the list of PCI vendor/device id lists supported by this 1940 * BFA instance. 1941 */ 1942 void 1943 bfa_get_pciids(struct bfa_pciid_s **pciids, int *npciids) 1944 { 1945 static struct bfa_pciid_s __pciids[] = { 1946 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_FC_8G2P}, 1947 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_FC_8G1P}, 1948 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_CT}, 1949 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_CT_FC}, 1950 }; 1951 1952 *npciids = ARRAY_SIZE(__pciids); 1953 *pciids = __pciids; 1954 } 1955 1956 /* 1957 * Use this function query the default struct bfa_iocfc_cfg_s value (compiled 1958 * into BFA layer). The OS driver can then turn back and overwrite entries that 1959 * have been configured by the user. 1960 * 1961 * @param[in] cfg - pointer to bfa_ioc_cfg_t 1962 * 1963 * @return 1964 * void 1965 * 1966 * Special Considerations: 1967 * note 1968 */ 1969 void 1970 bfa_cfg_get_default(struct bfa_iocfc_cfg_s *cfg) 1971 { 1972 cfg->fwcfg.num_fabrics = DEF_CFG_NUM_FABRICS; 1973 cfg->fwcfg.num_lports = DEF_CFG_NUM_LPORTS; 1974 cfg->fwcfg.num_rports = DEF_CFG_NUM_RPORTS; 1975 cfg->fwcfg.num_ioim_reqs = DEF_CFG_NUM_IOIM_REQS; 1976 cfg->fwcfg.num_tskim_reqs = DEF_CFG_NUM_TSKIM_REQS; 1977 cfg->fwcfg.num_fcxp_reqs = DEF_CFG_NUM_FCXP_REQS; 1978 cfg->fwcfg.num_uf_bufs = DEF_CFG_NUM_UF_BUFS; 1979 cfg->fwcfg.num_cqs = DEF_CFG_NUM_CQS; 1980 cfg->fwcfg.num_fwtio_reqs = 0; 1981 1982 cfg->drvcfg.num_reqq_elems = DEF_CFG_NUM_REQQ_ELEMS; 1983 cfg->drvcfg.num_rspq_elems = DEF_CFG_NUM_RSPQ_ELEMS; 1984 cfg->drvcfg.num_sgpgs = DEF_CFG_NUM_SGPGS; 1985 cfg->drvcfg.num_sboot_tgts = DEF_CFG_NUM_SBOOT_TGTS; 1986 cfg->drvcfg.num_sboot_luns = DEF_CFG_NUM_SBOOT_LUNS; 1987 cfg->drvcfg.path_tov = BFA_FCPIM_PATHTOV_DEF; 1988 cfg->drvcfg.ioc_recover = BFA_FALSE; 1989 cfg->drvcfg.delay_comp = BFA_FALSE; 1990 1991 } 1992 1993 void 1994 bfa_cfg_get_min(struct bfa_iocfc_cfg_s *cfg) 1995 { 1996 bfa_cfg_get_default(cfg); 1997 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MIN; 1998 cfg->fwcfg.num_tskim_reqs = BFA_TSKIM_MIN; 1999 cfg->fwcfg.num_fcxp_reqs = BFA_FCXP_MIN; 2000 cfg->fwcfg.num_uf_bufs = BFA_UF_MIN; 2001 cfg->fwcfg.num_rports = BFA_RPORT_MIN; 2002 cfg->fwcfg.num_fwtio_reqs = 0; 2003 2004 cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN; 2005 cfg->drvcfg.num_reqq_elems = BFA_REQQ_NELEMS_MIN; 2006 cfg->drvcfg.num_rspq_elems = BFA_RSPQ_NELEMS_MIN; 2007 cfg->drvcfg.min_cfg = BFA_TRUE; 2008 } 2009