1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Linux network driver for QLogic BR-series Converged Network Adapter. 4 */ 5 /* 6 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 7 * Copyright (c) 2014-2015 QLogic Corporation 8 * All rights reserved 9 * www.qlogic.com 10 */ 11 #include "bna.h" 12 13 static inline int 14 ethport_can_be_up(struct bna_ethport *ethport) 15 { 16 int ready = 0; 17 if (ethport->bna->enet.type == BNA_ENET_T_REGULAR) 18 ready = ((ethport->flags & BNA_ETHPORT_F_ADMIN_UP) && 19 (ethport->flags & BNA_ETHPORT_F_RX_STARTED) && 20 (ethport->flags & BNA_ETHPORT_F_PORT_ENABLED)); 21 else 22 ready = ((ethport->flags & BNA_ETHPORT_F_ADMIN_UP) && 23 (ethport->flags & BNA_ETHPORT_F_RX_STARTED) && 24 !(ethport->flags & BNA_ETHPORT_F_PORT_ENABLED)); 25 return ready; 26 } 27 28 #define ethport_is_up ethport_can_be_up 29 30 enum bna_ethport_event { 31 ETHPORT_E_START = 1, 32 ETHPORT_E_STOP = 2, 33 ETHPORT_E_FAIL = 3, 34 ETHPORT_E_UP = 4, 35 ETHPORT_E_DOWN = 5, 36 ETHPORT_E_FWRESP_UP_OK = 6, 37 ETHPORT_E_FWRESP_DOWN = 7, 38 ETHPORT_E_FWRESP_UP_FAIL = 8, 39 }; 40 41 enum bna_enet_event { 42 ENET_E_START = 1, 43 ENET_E_STOP = 2, 44 ENET_E_FAIL = 3, 45 ENET_E_PAUSE_CFG = 4, 46 ENET_E_MTU_CFG = 5, 47 ENET_E_FWRESP_PAUSE = 6, 48 ENET_E_CHLD_STOPPED = 7, 49 }; 50 51 enum bna_ioceth_event { 52 IOCETH_E_ENABLE = 1, 53 IOCETH_E_DISABLE = 2, 54 IOCETH_E_IOC_RESET = 3, 55 IOCETH_E_IOC_FAILED = 4, 56 IOCETH_E_IOC_READY = 5, 57 IOCETH_E_ENET_ATTR_RESP = 6, 58 IOCETH_E_ENET_STOPPED = 7, 59 IOCETH_E_IOC_DISABLED = 8, 60 }; 61 62 #define bna_stats_copy(_name, _type) \ 63 do { \ 64 count = sizeof(struct bfi_enet_stats_ ## _type) / sizeof(u64); \ 65 stats_src = (u64 *)&bna->stats.hw_stats_kva->_name ## _stats; \ 66 stats_dst = (u64 *)&bna->stats.hw_stats._name ## _stats; \ 67 for (i = 0; i < count; i++) \ 68 stats_dst[i] = be64_to_cpu(stats_src[i]); \ 69 } while (0) \ 70 71 /* 72 * FW response handlers 73 */ 74 75 static void 76 bna_bfi_ethport_enable_aen(struct bna_ethport *ethport, 77 struct bfi_msgq_mhdr *msghdr) 78 { 79 ethport->flags |= BNA_ETHPORT_F_PORT_ENABLED; 80 81 if (ethport_can_be_up(ethport)) 82 bfa_fsm_send_event(ethport, ETHPORT_E_UP); 83 } 84 85 static void 86 bna_bfi_ethport_disable_aen(struct bna_ethport *ethport, 87 struct bfi_msgq_mhdr *msghdr) 88 { 89 int ethport_up = ethport_is_up(ethport); 90 91 ethport->flags &= ~BNA_ETHPORT_F_PORT_ENABLED; 92 93 if (ethport_up) 94 bfa_fsm_send_event(ethport, ETHPORT_E_DOWN); 95 } 96 97 static void 98 bna_bfi_ethport_admin_rsp(struct bna_ethport *ethport, 99 struct bfi_msgq_mhdr *msghdr) 100 { 101 struct bfi_enet_enable_req *admin_req = 102 ðport->bfi_enet_cmd.admin_req; 103 struct bfi_enet_rsp *rsp = 104 container_of(msghdr, struct bfi_enet_rsp, mh); 105 106 switch (admin_req->enable) { 107 case BNA_STATUS_T_ENABLED: 108 if (rsp->error == BFI_ENET_CMD_OK) 109 bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_OK); 110 else { 111 ethport->flags &= ~BNA_ETHPORT_F_PORT_ENABLED; 112 bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_FAIL); 113 } 114 break; 115 116 case BNA_STATUS_T_DISABLED: 117 bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_DOWN); 118 ethport->link_status = BNA_LINK_DOWN; 119 ethport->link_cbfn(ethport->bna->bnad, BNA_LINK_DOWN); 120 break; 121 } 122 } 123 124 static void 125 bna_bfi_ethport_lpbk_rsp(struct bna_ethport *ethport, 126 struct bfi_msgq_mhdr *msghdr) 127 { 128 struct bfi_enet_diag_lb_req *diag_lb_req = 129 ðport->bfi_enet_cmd.lpbk_req; 130 struct bfi_enet_rsp *rsp = 131 container_of(msghdr, struct bfi_enet_rsp, mh); 132 133 switch (diag_lb_req->enable) { 134 case BNA_STATUS_T_ENABLED: 135 if (rsp->error == BFI_ENET_CMD_OK) 136 bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_OK); 137 else { 138 ethport->flags &= ~BNA_ETHPORT_F_ADMIN_UP; 139 bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_UP_FAIL); 140 } 141 break; 142 143 case BNA_STATUS_T_DISABLED: 144 bfa_fsm_send_event(ethport, ETHPORT_E_FWRESP_DOWN); 145 break; 146 } 147 } 148 149 static void 150 bna_bfi_pause_set_rsp(struct bna_enet *enet, struct bfi_msgq_mhdr *msghdr) 151 { 152 bfa_fsm_send_event(enet, ENET_E_FWRESP_PAUSE); 153 } 154 155 static void 156 bna_bfi_attr_get_rsp(struct bna_ioceth *ioceth, 157 struct bfi_msgq_mhdr *msghdr) 158 { 159 struct bfi_enet_attr_rsp *rsp = 160 container_of(msghdr, struct bfi_enet_attr_rsp, mh); 161 162 /** 163 * Store only if not set earlier, since BNAD can override the HW 164 * attributes 165 */ 166 if (!ioceth->attr.fw_query_complete) { 167 ioceth->attr.num_txq = ntohl(rsp->max_cfg); 168 ioceth->attr.num_rxp = ntohl(rsp->max_cfg); 169 ioceth->attr.num_ucmac = ntohl(rsp->max_ucmac); 170 ioceth->attr.num_mcmac = BFI_ENET_MAX_MCAM; 171 ioceth->attr.max_rit_size = ntohl(rsp->rit_size); 172 ioceth->attr.fw_query_complete = true; 173 } 174 175 bfa_fsm_send_event(ioceth, IOCETH_E_ENET_ATTR_RESP); 176 } 177 178 static void 179 bna_bfi_stats_get_rsp(struct bna *bna, struct bfi_msgq_mhdr *msghdr) 180 { 181 struct bfi_enet_stats_req *stats_req = &bna->stats_mod.stats_get; 182 u64 *stats_src; 183 u64 *stats_dst; 184 u32 tx_enet_mask = ntohl(stats_req->tx_enet_mask); 185 u32 rx_enet_mask = ntohl(stats_req->rx_enet_mask); 186 int count; 187 int i; 188 189 bna_stats_copy(mac, mac); 190 bna_stats_copy(bpc, bpc); 191 bna_stats_copy(rad, rad); 192 bna_stats_copy(rlb, rad); 193 bna_stats_copy(fc_rx, fc_rx); 194 bna_stats_copy(fc_tx, fc_tx); 195 196 stats_src = (u64 *)&(bna->stats.hw_stats_kva->rxf_stats[0]); 197 198 /* Copy Rxf stats to SW area, scatter them while copying */ 199 for (i = 0; i < BFI_ENET_CFG_MAX; i++) { 200 stats_dst = (u64 *)&(bna->stats.hw_stats.rxf_stats[i]); 201 memset(stats_dst, 0, sizeof(struct bfi_enet_stats_rxf)); 202 if (rx_enet_mask & BIT(i)) { 203 int k; 204 count = sizeof(struct bfi_enet_stats_rxf) / 205 sizeof(u64); 206 for (k = 0; k < count; k++) { 207 stats_dst[k] = be64_to_cpu(*stats_src); 208 stats_src++; 209 } 210 } 211 } 212 213 /* Copy Txf stats to SW area, scatter them while copying */ 214 for (i = 0; i < BFI_ENET_CFG_MAX; i++) { 215 stats_dst = (u64 *)&(bna->stats.hw_stats.txf_stats[i]); 216 memset(stats_dst, 0, sizeof(struct bfi_enet_stats_txf)); 217 if (tx_enet_mask & BIT(i)) { 218 int k; 219 count = sizeof(struct bfi_enet_stats_txf) / 220 sizeof(u64); 221 for (k = 0; k < count; k++) { 222 stats_dst[k] = be64_to_cpu(*stats_src); 223 stats_src++; 224 } 225 } 226 } 227 228 bna->stats_mod.stats_get_busy = false; 229 bnad_cb_stats_get(bna->bnad, BNA_CB_SUCCESS, &bna->stats); 230 } 231 232 static void 233 bna_bfi_ethport_linkup_aen(struct bna_ethport *ethport, 234 struct bfi_msgq_mhdr *msghdr) 235 { 236 ethport->link_status = BNA_LINK_UP; 237 238 /* Dispatch events */ 239 ethport->link_cbfn(ethport->bna->bnad, ethport->link_status); 240 } 241 242 static void 243 bna_bfi_ethport_linkdown_aen(struct bna_ethport *ethport, 244 struct bfi_msgq_mhdr *msghdr) 245 { 246 ethport->link_status = BNA_LINK_DOWN; 247 248 /* Dispatch events */ 249 ethport->link_cbfn(ethport->bna->bnad, BNA_LINK_DOWN); 250 } 251 252 static void 253 bna_err_handler(struct bna *bna, u32 intr_status) 254 { 255 if (BNA_IS_HALT_INTR(bna, intr_status)) 256 bna_halt_clear(bna); 257 258 bfa_nw_ioc_error_isr(&bna->ioceth.ioc); 259 } 260 261 void 262 bna_mbox_handler(struct bna *bna, u32 intr_status) 263 { 264 if (BNA_IS_ERR_INTR(bna, intr_status)) { 265 bna_err_handler(bna, intr_status); 266 return; 267 } 268 if (BNA_IS_MBOX_INTR(bna, intr_status)) 269 bfa_nw_ioc_mbox_isr(&bna->ioceth.ioc); 270 } 271 272 static void 273 bna_msgq_rsp_handler(void *arg, struct bfi_msgq_mhdr *msghdr) 274 { 275 struct bna *bna = (struct bna *)arg; 276 struct bna_tx *tx; 277 struct bna_rx *rx; 278 279 switch (msghdr->msg_id) { 280 case BFI_ENET_I2H_RX_CFG_SET_RSP: 281 bna_rx_from_rid(bna, msghdr->enet_id, rx); 282 if (rx) 283 bna_bfi_rx_enet_start_rsp(rx, msghdr); 284 break; 285 286 case BFI_ENET_I2H_RX_CFG_CLR_RSP: 287 bna_rx_from_rid(bna, msghdr->enet_id, rx); 288 if (rx) 289 bna_bfi_rx_enet_stop_rsp(rx, msghdr); 290 break; 291 292 case BFI_ENET_I2H_RIT_CFG_RSP: 293 case BFI_ENET_I2H_RSS_CFG_RSP: 294 case BFI_ENET_I2H_RSS_ENABLE_RSP: 295 case BFI_ENET_I2H_RX_PROMISCUOUS_RSP: 296 case BFI_ENET_I2H_RX_DEFAULT_RSP: 297 case BFI_ENET_I2H_MAC_UCAST_CLR_RSP: 298 case BFI_ENET_I2H_MAC_UCAST_ADD_RSP: 299 case BFI_ENET_I2H_MAC_UCAST_DEL_RSP: 300 case BFI_ENET_I2H_MAC_MCAST_DEL_RSP: 301 case BFI_ENET_I2H_MAC_MCAST_FILTER_RSP: 302 case BFI_ENET_I2H_RX_VLAN_SET_RSP: 303 case BFI_ENET_I2H_RX_VLAN_STRIP_ENABLE_RSP: 304 bna_rx_from_rid(bna, msghdr->enet_id, rx); 305 if (rx) 306 bna_bfi_rxf_cfg_rsp(&rx->rxf, msghdr); 307 break; 308 309 case BFI_ENET_I2H_MAC_UCAST_SET_RSP: 310 bna_rx_from_rid(bna, msghdr->enet_id, rx); 311 if (rx) 312 bna_bfi_rxf_ucast_set_rsp(&rx->rxf, msghdr); 313 break; 314 315 case BFI_ENET_I2H_MAC_MCAST_ADD_RSP: 316 bna_rx_from_rid(bna, msghdr->enet_id, rx); 317 if (rx) 318 bna_bfi_rxf_mcast_add_rsp(&rx->rxf, msghdr); 319 break; 320 321 case BFI_ENET_I2H_TX_CFG_SET_RSP: 322 bna_tx_from_rid(bna, msghdr->enet_id, tx); 323 if (tx) 324 bna_bfi_tx_enet_start_rsp(tx, msghdr); 325 break; 326 327 case BFI_ENET_I2H_TX_CFG_CLR_RSP: 328 bna_tx_from_rid(bna, msghdr->enet_id, tx); 329 if (tx) 330 bna_bfi_tx_enet_stop_rsp(tx, msghdr); 331 break; 332 333 case BFI_ENET_I2H_PORT_ADMIN_RSP: 334 bna_bfi_ethport_admin_rsp(&bna->ethport, msghdr); 335 break; 336 337 case BFI_ENET_I2H_DIAG_LOOPBACK_RSP: 338 bna_bfi_ethport_lpbk_rsp(&bna->ethport, msghdr); 339 break; 340 341 case BFI_ENET_I2H_SET_PAUSE_RSP: 342 bna_bfi_pause_set_rsp(&bna->enet, msghdr); 343 break; 344 345 case BFI_ENET_I2H_GET_ATTR_RSP: 346 bna_bfi_attr_get_rsp(&bna->ioceth, msghdr); 347 break; 348 349 case BFI_ENET_I2H_STATS_GET_RSP: 350 bna_bfi_stats_get_rsp(bna, msghdr); 351 break; 352 353 case BFI_ENET_I2H_STATS_CLR_RSP: 354 /* No-op */ 355 break; 356 357 case BFI_ENET_I2H_LINK_UP_AEN: 358 bna_bfi_ethport_linkup_aen(&bna->ethport, msghdr); 359 break; 360 361 case BFI_ENET_I2H_LINK_DOWN_AEN: 362 bna_bfi_ethport_linkdown_aen(&bna->ethport, msghdr); 363 break; 364 365 case BFI_ENET_I2H_PORT_ENABLE_AEN: 366 bna_bfi_ethport_enable_aen(&bna->ethport, msghdr); 367 break; 368 369 case BFI_ENET_I2H_PORT_DISABLE_AEN: 370 bna_bfi_ethport_disable_aen(&bna->ethport, msghdr); 371 break; 372 373 case BFI_ENET_I2H_BW_UPDATE_AEN: 374 bna_bfi_bw_update_aen(&bna->tx_mod); 375 break; 376 377 default: 378 break; 379 } 380 } 381 382 /* ETHPORT */ 383 384 #define call_ethport_stop_cbfn(_ethport) \ 385 do { \ 386 if ((_ethport)->stop_cbfn) { \ 387 void (*cbfn)(struct bna_enet *); \ 388 cbfn = (_ethport)->stop_cbfn; \ 389 (_ethport)->stop_cbfn = NULL; \ 390 cbfn(&(_ethport)->bna->enet); \ 391 } \ 392 } while (0) 393 394 #define call_ethport_adminup_cbfn(ethport, status) \ 395 do { \ 396 if ((ethport)->adminup_cbfn) { \ 397 void (*cbfn)(struct bnad *, enum bna_cb_status); \ 398 cbfn = (ethport)->adminup_cbfn; \ 399 (ethport)->adminup_cbfn = NULL; \ 400 cbfn((ethport)->bna->bnad, status); \ 401 } \ 402 } while (0) 403 404 static void 405 bna_bfi_ethport_admin_up(struct bna_ethport *ethport) 406 { 407 struct bfi_enet_enable_req *admin_up_req = 408 ðport->bfi_enet_cmd.admin_req; 409 410 bfi_msgq_mhdr_set(admin_up_req->mh, BFI_MC_ENET, 411 BFI_ENET_H2I_PORT_ADMIN_UP_REQ, 0, 0); 412 admin_up_req->mh.num_entries = htons( 413 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_enable_req))); 414 admin_up_req->enable = BNA_STATUS_T_ENABLED; 415 416 bfa_msgq_cmd_set(ðport->msgq_cmd, NULL, NULL, 417 sizeof(struct bfi_enet_enable_req), &admin_up_req->mh); 418 bfa_msgq_cmd_post(ðport->bna->msgq, ðport->msgq_cmd); 419 } 420 421 static void 422 bna_bfi_ethport_admin_down(struct bna_ethport *ethport) 423 { 424 struct bfi_enet_enable_req *admin_down_req = 425 ðport->bfi_enet_cmd.admin_req; 426 427 bfi_msgq_mhdr_set(admin_down_req->mh, BFI_MC_ENET, 428 BFI_ENET_H2I_PORT_ADMIN_UP_REQ, 0, 0); 429 admin_down_req->mh.num_entries = htons( 430 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_enable_req))); 431 admin_down_req->enable = BNA_STATUS_T_DISABLED; 432 433 bfa_msgq_cmd_set(ðport->msgq_cmd, NULL, NULL, 434 sizeof(struct bfi_enet_enable_req), &admin_down_req->mh); 435 bfa_msgq_cmd_post(ðport->bna->msgq, ðport->msgq_cmd); 436 } 437 438 static void 439 bna_bfi_ethport_lpbk_up(struct bna_ethport *ethport) 440 { 441 struct bfi_enet_diag_lb_req *lpbk_up_req = 442 ðport->bfi_enet_cmd.lpbk_req; 443 444 bfi_msgq_mhdr_set(lpbk_up_req->mh, BFI_MC_ENET, 445 BFI_ENET_H2I_DIAG_LOOPBACK_REQ, 0, 0); 446 lpbk_up_req->mh.num_entries = htons( 447 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_diag_lb_req))); 448 lpbk_up_req->mode = (ethport->bna->enet.type == 449 BNA_ENET_T_LOOPBACK_INTERNAL) ? 450 BFI_ENET_DIAG_LB_OPMODE_EXT : 451 BFI_ENET_DIAG_LB_OPMODE_CBL; 452 lpbk_up_req->enable = BNA_STATUS_T_ENABLED; 453 454 bfa_msgq_cmd_set(ðport->msgq_cmd, NULL, NULL, 455 sizeof(struct bfi_enet_diag_lb_req), &lpbk_up_req->mh); 456 bfa_msgq_cmd_post(ðport->bna->msgq, ðport->msgq_cmd); 457 } 458 459 static void 460 bna_bfi_ethport_lpbk_down(struct bna_ethport *ethport) 461 { 462 struct bfi_enet_diag_lb_req *lpbk_down_req = 463 ðport->bfi_enet_cmd.lpbk_req; 464 465 bfi_msgq_mhdr_set(lpbk_down_req->mh, BFI_MC_ENET, 466 BFI_ENET_H2I_DIAG_LOOPBACK_REQ, 0, 0); 467 lpbk_down_req->mh.num_entries = htons( 468 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_diag_lb_req))); 469 lpbk_down_req->enable = BNA_STATUS_T_DISABLED; 470 471 bfa_msgq_cmd_set(ðport->msgq_cmd, NULL, NULL, 472 sizeof(struct bfi_enet_diag_lb_req), &lpbk_down_req->mh); 473 bfa_msgq_cmd_post(ðport->bna->msgq, ðport->msgq_cmd); 474 } 475 476 static void 477 bna_bfi_ethport_up(struct bna_ethport *ethport) 478 { 479 if (ethport->bna->enet.type == BNA_ENET_T_REGULAR) 480 bna_bfi_ethport_admin_up(ethport); 481 else 482 bna_bfi_ethport_lpbk_up(ethport); 483 } 484 485 static void 486 bna_bfi_ethport_down(struct bna_ethport *ethport) 487 { 488 if (ethport->bna->enet.type == BNA_ENET_T_REGULAR) 489 bna_bfi_ethport_admin_down(ethport); 490 else 491 bna_bfi_ethport_lpbk_down(ethport); 492 } 493 494 bfa_fsm_state_decl(bna_ethport, stopped, struct bna_ethport, 495 enum bna_ethport_event); 496 bfa_fsm_state_decl(bna_ethport, down, struct bna_ethport, 497 enum bna_ethport_event); 498 bfa_fsm_state_decl(bna_ethport, up_resp_wait, struct bna_ethport, 499 enum bna_ethport_event); 500 bfa_fsm_state_decl(bna_ethport, down_resp_wait, struct bna_ethport, 501 enum bna_ethport_event); 502 bfa_fsm_state_decl(bna_ethport, up, struct bna_ethport, 503 enum bna_ethport_event); 504 bfa_fsm_state_decl(bna_ethport, last_resp_wait, struct bna_ethport, 505 enum bna_ethport_event); 506 507 static void 508 bna_ethport_sm_stopped_entry(struct bna_ethport *ethport) 509 { 510 call_ethport_stop_cbfn(ethport); 511 } 512 513 static void 514 bna_ethport_sm_stopped(struct bna_ethport *ethport, 515 enum bna_ethport_event event) 516 { 517 switch (event) { 518 case ETHPORT_E_START: 519 bfa_fsm_set_state(ethport, bna_ethport_sm_down); 520 break; 521 522 case ETHPORT_E_STOP: 523 call_ethport_stop_cbfn(ethport); 524 break; 525 526 case ETHPORT_E_FAIL: 527 /* No-op */ 528 break; 529 530 case ETHPORT_E_DOWN: 531 /* This event is received due to Rx objects failing */ 532 /* No-op */ 533 break; 534 535 default: 536 bfa_sm_fault(event); 537 } 538 } 539 540 static void 541 bna_ethport_sm_down_entry(struct bna_ethport *ethport) 542 { 543 } 544 545 static void 546 bna_ethport_sm_down(struct bna_ethport *ethport, 547 enum bna_ethport_event event) 548 { 549 switch (event) { 550 case ETHPORT_E_STOP: 551 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 552 break; 553 554 case ETHPORT_E_FAIL: 555 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 556 break; 557 558 case ETHPORT_E_UP: 559 bfa_fsm_set_state(ethport, bna_ethport_sm_up_resp_wait); 560 bna_bfi_ethport_up(ethport); 561 break; 562 563 default: 564 bfa_sm_fault(event); 565 } 566 } 567 568 static void 569 bna_ethport_sm_up_resp_wait_entry(struct bna_ethport *ethport) 570 { 571 } 572 573 static void 574 bna_ethport_sm_up_resp_wait(struct bna_ethport *ethport, 575 enum bna_ethport_event event) 576 { 577 switch (event) { 578 case ETHPORT_E_STOP: 579 bfa_fsm_set_state(ethport, bna_ethport_sm_last_resp_wait); 580 break; 581 582 case ETHPORT_E_FAIL: 583 call_ethport_adminup_cbfn(ethport, BNA_CB_FAIL); 584 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 585 break; 586 587 case ETHPORT_E_DOWN: 588 call_ethport_adminup_cbfn(ethport, BNA_CB_INTERRUPT); 589 bfa_fsm_set_state(ethport, bna_ethport_sm_down_resp_wait); 590 break; 591 592 case ETHPORT_E_FWRESP_UP_OK: 593 call_ethport_adminup_cbfn(ethport, BNA_CB_SUCCESS); 594 bfa_fsm_set_state(ethport, bna_ethport_sm_up); 595 break; 596 597 case ETHPORT_E_FWRESP_UP_FAIL: 598 call_ethport_adminup_cbfn(ethport, BNA_CB_FAIL); 599 bfa_fsm_set_state(ethport, bna_ethport_sm_down); 600 break; 601 602 case ETHPORT_E_FWRESP_DOWN: 603 /* down_resp_wait -> up_resp_wait transition on ETHPORT_E_UP */ 604 bna_bfi_ethport_up(ethport); 605 break; 606 607 default: 608 bfa_sm_fault(event); 609 } 610 } 611 612 static void 613 bna_ethport_sm_down_resp_wait_entry(struct bna_ethport *ethport) 614 { 615 /** 616 * NOTE: Do not call bna_bfi_ethport_down() here. That will over step 617 * mbox due to up_resp_wait -> down_resp_wait transition on event 618 * ETHPORT_E_DOWN 619 */ 620 } 621 622 static void 623 bna_ethport_sm_down_resp_wait(struct bna_ethport *ethport, 624 enum bna_ethport_event event) 625 { 626 switch (event) { 627 case ETHPORT_E_STOP: 628 bfa_fsm_set_state(ethport, bna_ethport_sm_last_resp_wait); 629 break; 630 631 case ETHPORT_E_FAIL: 632 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 633 break; 634 635 case ETHPORT_E_UP: 636 bfa_fsm_set_state(ethport, bna_ethport_sm_up_resp_wait); 637 break; 638 639 case ETHPORT_E_FWRESP_UP_OK: 640 /* up_resp_wait->down_resp_wait transition on ETHPORT_E_DOWN */ 641 bna_bfi_ethport_down(ethport); 642 break; 643 644 case ETHPORT_E_FWRESP_UP_FAIL: 645 case ETHPORT_E_FWRESP_DOWN: 646 bfa_fsm_set_state(ethport, bna_ethport_sm_down); 647 break; 648 649 default: 650 bfa_sm_fault(event); 651 } 652 } 653 654 static void 655 bna_ethport_sm_up_entry(struct bna_ethport *ethport) 656 { 657 } 658 659 static void 660 bna_ethport_sm_up(struct bna_ethport *ethport, 661 enum bna_ethport_event event) 662 { 663 switch (event) { 664 case ETHPORT_E_STOP: 665 bfa_fsm_set_state(ethport, bna_ethport_sm_last_resp_wait); 666 bna_bfi_ethport_down(ethport); 667 break; 668 669 case ETHPORT_E_FAIL: 670 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 671 break; 672 673 case ETHPORT_E_DOWN: 674 bfa_fsm_set_state(ethport, bna_ethport_sm_down_resp_wait); 675 bna_bfi_ethport_down(ethport); 676 break; 677 678 default: 679 bfa_sm_fault(event); 680 } 681 } 682 683 static void 684 bna_ethport_sm_last_resp_wait_entry(struct bna_ethport *ethport) 685 { 686 } 687 688 static void 689 bna_ethport_sm_last_resp_wait(struct bna_ethport *ethport, 690 enum bna_ethport_event event) 691 { 692 switch (event) { 693 case ETHPORT_E_FAIL: 694 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 695 break; 696 697 case ETHPORT_E_DOWN: 698 /** 699 * This event is received due to Rx objects stopping in 700 * parallel to ethport 701 */ 702 /* No-op */ 703 break; 704 705 case ETHPORT_E_FWRESP_UP_OK: 706 /* up_resp_wait->last_resp_wait transition on ETHPORT_T_STOP */ 707 bna_bfi_ethport_down(ethport); 708 break; 709 710 case ETHPORT_E_FWRESP_UP_FAIL: 711 case ETHPORT_E_FWRESP_DOWN: 712 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 713 break; 714 715 default: 716 bfa_sm_fault(event); 717 } 718 } 719 720 static void 721 bna_ethport_init(struct bna_ethport *ethport, struct bna *bna) 722 { 723 ethport->flags |= (BNA_ETHPORT_F_ADMIN_UP | BNA_ETHPORT_F_PORT_ENABLED); 724 ethport->bna = bna; 725 726 ethport->link_status = BNA_LINK_DOWN; 727 ethport->link_cbfn = bnad_cb_ethport_link_status; 728 729 ethport->rx_started_count = 0; 730 731 ethport->stop_cbfn = NULL; 732 ethport->adminup_cbfn = NULL; 733 734 bfa_fsm_set_state(ethport, bna_ethport_sm_stopped); 735 } 736 737 static void 738 bna_ethport_uninit(struct bna_ethport *ethport) 739 { 740 ethport->flags &= ~BNA_ETHPORT_F_ADMIN_UP; 741 ethport->flags &= ~BNA_ETHPORT_F_PORT_ENABLED; 742 743 ethport->bna = NULL; 744 } 745 746 static void 747 bna_ethport_start(struct bna_ethport *ethport) 748 { 749 bfa_fsm_send_event(ethport, ETHPORT_E_START); 750 } 751 752 static void 753 bna_enet_cb_ethport_stopped(struct bna_enet *enet) 754 { 755 bfa_wc_down(&enet->chld_stop_wc); 756 } 757 758 static void 759 bna_ethport_stop(struct bna_ethport *ethport) 760 { 761 ethport->stop_cbfn = bna_enet_cb_ethport_stopped; 762 bfa_fsm_send_event(ethport, ETHPORT_E_STOP); 763 } 764 765 static void 766 bna_ethport_fail(struct bna_ethport *ethport) 767 { 768 /* Reset the physical port status to enabled */ 769 ethport->flags |= BNA_ETHPORT_F_PORT_ENABLED; 770 771 if (ethport->link_status != BNA_LINK_DOWN) { 772 ethport->link_status = BNA_LINK_DOWN; 773 ethport->link_cbfn(ethport->bna->bnad, BNA_LINK_DOWN); 774 } 775 bfa_fsm_send_event(ethport, ETHPORT_E_FAIL); 776 } 777 778 /* Should be called only when ethport is disabled */ 779 void 780 bna_ethport_cb_rx_started(struct bna_ethport *ethport) 781 { 782 ethport->rx_started_count++; 783 784 if (ethport->rx_started_count == 1) { 785 ethport->flags |= BNA_ETHPORT_F_RX_STARTED; 786 787 if (ethport_can_be_up(ethport)) 788 bfa_fsm_send_event(ethport, ETHPORT_E_UP); 789 } 790 } 791 792 void 793 bna_ethport_cb_rx_stopped(struct bna_ethport *ethport) 794 { 795 int ethport_up = ethport_is_up(ethport); 796 797 ethport->rx_started_count--; 798 799 if (ethport->rx_started_count == 0) { 800 ethport->flags &= ~BNA_ETHPORT_F_RX_STARTED; 801 802 if (ethport_up) 803 bfa_fsm_send_event(ethport, ETHPORT_E_DOWN); 804 } 805 } 806 807 /* ENET */ 808 809 #define bna_enet_chld_start(enet) \ 810 do { \ 811 enum bna_tx_type tx_type = \ 812 ((enet)->type == BNA_ENET_T_REGULAR) ? \ 813 BNA_TX_T_REGULAR : BNA_TX_T_LOOPBACK; \ 814 enum bna_rx_type rx_type = \ 815 ((enet)->type == BNA_ENET_T_REGULAR) ? \ 816 BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK; \ 817 bna_ethport_start(&(enet)->bna->ethport); \ 818 bna_tx_mod_start(&(enet)->bna->tx_mod, tx_type); \ 819 bna_rx_mod_start(&(enet)->bna->rx_mod, rx_type); \ 820 } while (0) 821 822 #define bna_enet_chld_stop(enet) \ 823 do { \ 824 enum bna_tx_type tx_type = \ 825 ((enet)->type == BNA_ENET_T_REGULAR) ? \ 826 BNA_TX_T_REGULAR : BNA_TX_T_LOOPBACK; \ 827 enum bna_rx_type rx_type = \ 828 ((enet)->type == BNA_ENET_T_REGULAR) ? \ 829 BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK; \ 830 bfa_wc_init(&(enet)->chld_stop_wc, bna_enet_cb_chld_stopped, (enet));\ 831 bfa_wc_up(&(enet)->chld_stop_wc); \ 832 bna_ethport_stop(&(enet)->bna->ethport); \ 833 bfa_wc_up(&(enet)->chld_stop_wc); \ 834 bna_tx_mod_stop(&(enet)->bna->tx_mod, tx_type); \ 835 bfa_wc_up(&(enet)->chld_stop_wc); \ 836 bna_rx_mod_stop(&(enet)->bna->rx_mod, rx_type); \ 837 bfa_wc_wait(&(enet)->chld_stop_wc); \ 838 } while (0) 839 840 #define bna_enet_chld_fail(enet) \ 841 do { \ 842 bna_ethport_fail(&(enet)->bna->ethport); \ 843 bna_tx_mod_fail(&(enet)->bna->tx_mod); \ 844 bna_rx_mod_fail(&(enet)->bna->rx_mod); \ 845 } while (0) 846 847 #define bna_enet_rx_start(enet) \ 848 do { \ 849 enum bna_rx_type rx_type = \ 850 ((enet)->type == BNA_ENET_T_REGULAR) ? \ 851 BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK; \ 852 bna_rx_mod_start(&(enet)->bna->rx_mod, rx_type); \ 853 } while (0) 854 855 #define bna_enet_rx_stop(enet) \ 856 do { \ 857 enum bna_rx_type rx_type = \ 858 ((enet)->type == BNA_ENET_T_REGULAR) ? \ 859 BNA_RX_T_REGULAR : BNA_RX_T_LOOPBACK; \ 860 bfa_wc_init(&(enet)->chld_stop_wc, bna_enet_cb_chld_stopped, (enet));\ 861 bfa_wc_up(&(enet)->chld_stop_wc); \ 862 bna_rx_mod_stop(&(enet)->bna->rx_mod, rx_type); \ 863 bfa_wc_wait(&(enet)->chld_stop_wc); \ 864 } while (0) 865 866 #define call_enet_stop_cbfn(enet) \ 867 do { \ 868 if ((enet)->stop_cbfn) { \ 869 void (*cbfn)(void *); \ 870 void *cbarg; \ 871 cbfn = (enet)->stop_cbfn; \ 872 cbarg = (enet)->stop_cbarg; \ 873 (enet)->stop_cbfn = NULL; \ 874 (enet)->stop_cbarg = NULL; \ 875 cbfn(cbarg); \ 876 } \ 877 } while (0) 878 879 #define call_enet_mtu_cbfn(enet) \ 880 do { \ 881 if ((enet)->mtu_cbfn) { \ 882 void (*cbfn)(struct bnad *); \ 883 cbfn = (enet)->mtu_cbfn; \ 884 (enet)->mtu_cbfn = NULL; \ 885 cbfn((enet)->bna->bnad); \ 886 } \ 887 } while (0) 888 889 static void bna_enet_cb_chld_stopped(void *arg); 890 static void bna_bfi_pause_set(struct bna_enet *enet); 891 892 bfa_fsm_state_decl(bna_enet, stopped, struct bna_enet, 893 enum bna_enet_event); 894 bfa_fsm_state_decl(bna_enet, pause_init_wait, struct bna_enet, 895 enum bna_enet_event); 896 bfa_fsm_state_decl(bna_enet, last_resp_wait, struct bna_enet, 897 enum bna_enet_event); 898 bfa_fsm_state_decl(bna_enet, started, struct bna_enet, 899 enum bna_enet_event); 900 bfa_fsm_state_decl(bna_enet, cfg_wait, struct bna_enet, 901 enum bna_enet_event); 902 bfa_fsm_state_decl(bna_enet, cfg_stop_wait, struct bna_enet, 903 enum bna_enet_event); 904 bfa_fsm_state_decl(bna_enet, chld_stop_wait, struct bna_enet, 905 enum bna_enet_event); 906 907 static void 908 bna_enet_sm_stopped_entry(struct bna_enet *enet) 909 { 910 call_enet_mtu_cbfn(enet); 911 call_enet_stop_cbfn(enet); 912 } 913 914 static void 915 bna_enet_sm_stopped(struct bna_enet *enet, enum bna_enet_event event) 916 { 917 switch (event) { 918 case ENET_E_START: 919 bfa_fsm_set_state(enet, bna_enet_sm_pause_init_wait); 920 break; 921 922 case ENET_E_STOP: 923 call_enet_stop_cbfn(enet); 924 break; 925 926 case ENET_E_FAIL: 927 /* No-op */ 928 break; 929 930 case ENET_E_PAUSE_CFG: 931 break; 932 933 case ENET_E_MTU_CFG: 934 call_enet_mtu_cbfn(enet); 935 break; 936 937 case ENET_E_CHLD_STOPPED: 938 /** 939 * This event is received due to Ethport, Tx and Rx objects 940 * failing 941 */ 942 /* No-op */ 943 break; 944 945 default: 946 bfa_sm_fault(event); 947 } 948 } 949 950 static void 951 bna_enet_sm_pause_init_wait_entry(struct bna_enet *enet) 952 { 953 bna_bfi_pause_set(enet); 954 } 955 956 static void 957 bna_enet_sm_pause_init_wait(struct bna_enet *enet, 958 enum bna_enet_event event) 959 { 960 switch (event) { 961 case ENET_E_STOP: 962 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 963 bfa_fsm_set_state(enet, bna_enet_sm_last_resp_wait); 964 break; 965 966 case ENET_E_FAIL: 967 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 968 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 969 break; 970 971 case ENET_E_PAUSE_CFG: 972 enet->flags |= BNA_ENET_F_PAUSE_CHANGED; 973 break; 974 975 case ENET_E_MTU_CFG: 976 /* No-op */ 977 break; 978 979 case ENET_E_FWRESP_PAUSE: 980 if (enet->flags & BNA_ENET_F_PAUSE_CHANGED) { 981 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 982 bna_bfi_pause_set(enet); 983 } else { 984 bfa_fsm_set_state(enet, bna_enet_sm_started); 985 bna_enet_chld_start(enet); 986 } 987 break; 988 989 default: 990 bfa_sm_fault(event); 991 } 992 } 993 994 static void 995 bna_enet_sm_last_resp_wait_entry(struct bna_enet *enet) 996 { 997 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 998 } 999 1000 static void 1001 bna_enet_sm_last_resp_wait(struct bna_enet *enet, 1002 enum bna_enet_event event) 1003 { 1004 switch (event) { 1005 case ENET_E_FAIL: 1006 case ENET_E_FWRESP_PAUSE: 1007 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1008 break; 1009 1010 default: 1011 bfa_sm_fault(event); 1012 } 1013 } 1014 1015 static void 1016 bna_enet_sm_started_entry(struct bna_enet *enet) 1017 { 1018 /** 1019 * NOTE: Do not call bna_enet_chld_start() here, since it will be 1020 * inadvertently called during cfg_wait->started transition as well 1021 */ 1022 call_enet_mtu_cbfn(enet); 1023 } 1024 1025 static void 1026 bna_enet_sm_started(struct bna_enet *enet, 1027 enum bna_enet_event event) 1028 { 1029 switch (event) { 1030 case ENET_E_STOP: 1031 bfa_fsm_set_state(enet, bna_enet_sm_chld_stop_wait); 1032 break; 1033 1034 case ENET_E_FAIL: 1035 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1036 bna_enet_chld_fail(enet); 1037 break; 1038 1039 case ENET_E_PAUSE_CFG: 1040 bfa_fsm_set_state(enet, bna_enet_sm_cfg_wait); 1041 bna_bfi_pause_set(enet); 1042 break; 1043 1044 case ENET_E_MTU_CFG: 1045 bfa_fsm_set_state(enet, bna_enet_sm_cfg_wait); 1046 bna_enet_rx_stop(enet); 1047 break; 1048 1049 default: 1050 bfa_sm_fault(event); 1051 } 1052 } 1053 1054 static void 1055 bna_enet_sm_cfg_wait_entry(struct bna_enet *enet) 1056 { 1057 } 1058 1059 static void 1060 bna_enet_sm_cfg_wait(struct bna_enet *enet, 1061 enum bna_enet_event event) 1062 { 1063 switch (event) { 1064 case ENET_E_STOP: 1065 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 1066 enet->flags &= ~BNA_ENET_F_MTU_CHANGED; 1067 bfa_fsm_set_state(enet, bna_enet_sm_cfg_stop_wait); 1068 break; 1069 1070 case ENET_E_FAIL: 1071 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 1072 enet->flags &= ~BNA_ENET_F_MTU_CHANGED; 1073 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1074 bna_enet_chld_fail(enet); 1075 break; 1076 1077 case ENET_E_PAUSE_CFG: 1078 enet->flags |= BNA_ENET_F_PAUSE_CHANGED; 1079 break; 1080 1081 case ENET_E_MTU_CFG: 1082 enet->flags |= BNA_ENET_F_MTU_CHANGED; 1083 break; 1084 1085 case ENET_E_CHLD_STOPPED: 1086 bna_enet_rx_start(enet); 1087 fallthrough; 1088 case ENET_E_FWRESP_PAUSE: 1089 if (enet->flags & BNA_ENET_F_PAUSE_CHANGED) { 1090 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 1091 bna_bfi_pause_set(enet); 1092 } else if (enet->flags & BNA_ENET_F_MTU_CHANGED) { 1093 enet->flags &= ~BNA_ENET_F_MTU_CHANGED; 1094 bna_enet_rx_stop(enet); 1095 } else { 1096 bfa_fsm_set_state(enet, bna_enet_sm_started); 1097 } 1098 break; 1099 1100 default: 1101 bfa_sm_fault(event); 1102 } 1103 } 1104 1105 static void 1106 bna_enet_sm_cfg_stop_wait_entry(struct bna_enet *enet) 1107 { 1108 enet->flags &= ~BNA_ENET_F_PAUSE_CHANGED; 1109 enet->flags &= ~BNA_ENET_F_MTU_CHANGED; 1110 } 1111 1112 static void 1113 bna_enet_sm_cfg_stop_wait(struct bna_enet *enet, 1114 enum bna_enet_event event) 1115 { 1116 switch (event) { 1117 case ENET_E_FAIL: 1118 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1119 bna_enet_chld_fail(enet); 1120 break; 1121 1122 case ENET_E_FWRESP_PAUSE: 1123 case ENET_E_CHLD_STOPPED: 1124 bfa_fsm_set_state(enet, bna_enet_sm_chld_stop_wait); 1125 break; 1126 1127 default: 1128 bfa_sm_fault(event); 1129 } 1130 } 1131 1132 static void 1133 bna_enet_sm_chld_stop_wait_entry(struct bna_enet *enet) 1134 { 1135 bna_enet_chld_stop(enet); 1136 } 1137 1138 static void 1139 bna_enet_sm_chld_stop_wait(struct bna_enet *enet, 1140 enum bna_enet_event event) 1141 { 1142 switch (event) { 1143 case ENET_E_FAIL: 1144 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1145 bna_enet_chld_fail(enet); 1146 break; 1147 1148 case ENET_E_CHLD_STOPPED: 1149 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1150 break; 1151 1152 default: 1153 bfa_sm_fault(event); 1154 } 1155 } 1156 1157 static void 1158 bna_bfi_pause_set(struct bna_enet *enet) 1159 { 1160 struct bfi_enet_set_pause_req *pause_req = &enet->pause_req; 1161 1162 bfi_msgq_mhdr_set(pause_req->mh, BFI_MC_ENET, 1163 BFI_ENET_H2I_SET_PAUSE_REQ, 0, 0); 1164 pause_req->mh.num_entries = htons( 1165 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_set_pause_req))); 1166 pause_req->tx_pause = enet->pause_config.tx_pause; 1167 pause_req->rx_pause = enet->pause_config.rx_pause; 1168 1169 bfa_msgq_cmd_set(&enet->msgq_cmd, NULL, NULL, 1170 sizeof(struct bfi_enet_set_pause_req), &pause_req->mh); 1171 bfa_msgq_cmd_post(&enet->bna->msgq, &enet->msgq_cmd); 1172 } 1173 1174 static void 1175 bna_enet_cb_chld_stopped(void *arg) 1176 { 1177 struct bna_enet *enet = (struct bna_enet *)arg; 1178 1179 bfa_fsm_send_event(enet, ENET_E_CHLD_STOPPED); 1180 } 1181 1182 static void 1183 bna_enet_init(struct bna_enet *enet, struct bna *bna) 1184 { 1185 enet->bna = bna; 1186 enet->flags = 0; 1187 enet->mtu = 0; 1188 enet->type = BNA_ENET_T_REGULAR; 1189 1190 enet->stop_cbfn = NULL; 1191 enet->stop_cbarg = NULL; 1192 1193 enet->mtu_cbfn = NULL; 1194 1195 bfa_fsm_set_state(enet, bna_enet_sm_stopped); 1196 } 1197 1198 static void 1199 bna_enet_uninit(struct bna_enet *enet) 1200 { 1201 enet->flags = 0; 1202 1203 enet->bna = NULL; 1204 } 1205 1206 static void 1207 bna_enet_start(struct bna_enet *enet) 1208 { 1209 enet->flags |= BNA_ENET_F_IOCETH_READY; 1210 if (enet->flags & BNA_ENET_F_ENABLED) 1211 bfa_fsm_send_event(enet, ENET_E_START); 1212 } 1213 1214 static void 1215 bna_ioceth_cb_enet_stopped(void *arg) 1216 { 1217 struct bna_ioceth *ioceth = (struct bna_ioceth *)arg; 1218 1219 bfa_fsm_send_event(ioceth, IOCETH_E_ENET_STOPPED); 1220 } 1221 1222 static void 1223 bna_enet_stop(struct bna_enet *enet) 1224 { 1225 enet->stop_cbfn = bna_ioceth_cb_enet_stopped; 1226 enet->stop_cbarg = &enet->bna->ioceth; 1227 1228 enet->flags &= ~BNA_ENET_F_IOCETH_READY; 1229 bfa_fsm_send_event(enet, ENET_E_STOP); 1230 } 1231 1232 static void 1233 bna_enet_fail(struct bna_enet *enet) 1234 { 1235 enet->flags &= ~BNA_ENET_F_IOCETH_READY; 1236 bfa_fsm_send_event(enet, ENET_E_FAIL); 1237 } 1238 1239 void 1240 bna_enet_cb_tx_stopped(struct bna_enet *enet) 1241 { 1242 bfa_wc_down(&enet->chld_stop_wc); 1243 } 1244 1245 void 1246 bna_enet_cb_rx_stopped(struct bna_enet *enet) 1247 { 1248 bfa_wc_down(&enet->chld_stop_wc); 1249 } 1250 1251 int 1252 bna_enet_mtu_get(struct bna_enet *enet) 1253 { 1254 return enet->mtu; 1255 } 1256 1257 void 1258 bna_enet_enable(struct bna_enet *enet) 1259 { 1260 if (enet->fsm != bna_enet_sm_stopped) 1261 return; 1262 1263 enet->flags |= BNA_ENET_F_ENABLED; 1264 1265 if (enet->flags & BNA_ENET_F_IOCETH_READY) 1266 bfa_fsm_send_event(enet, ENET_E_START); 1267 } 1268 1269 void 1270 bna_enet_disable(struct bna_enet *enet, enum bna_cleanup_type type, 1271 void (*cbfn)(void *)) 1272 { 1273 if (type == BNA_SOFT_CLEANUP) { 1274 (*cbfn)(enet->bna->bnad); 1275 return; 1276 } 1277 1278 enet->stop_cbfn = cbfn; 1279 enet->stop_cbarg = enet->bna->bnad; 1280 1281 enet->flags &= ~BNA_ENET_F_ENABLED; 1282 1283 bfa_fsm_send_event(enet, ENET_E_STOP); 1284 } 1285 1286 void 1287 bna_enet_pause_config(struct bna_enet *enet, 1288 struct bna_pause_config *pause_config) 1289 { 1290 enet->pause_config = *pause_config; 1291 1292 bfa_fsm_send_event(enet, ENET_E_PAUSE_CFG); 1293 } 1294 1295 void 1296 bna_enet_mtu_set(struct bna_enet *enet, int mtu, 1297 void (*cbfn)(struct bnad *)) 1298 { 1299 enet->mtu = mtu; 1300 1301 enet->mtu_cbfn = cbfn; 1302 1303 bfa_fsm_send_event(enet, ENET_E_MTU_CFG); 1304 } 1305 1306 void 1307 bna_enet_perm_mac_get(struct bna_enet *enet, u8 *mac) 1308 { 1309 bfa_nw_ioc_get_mac(&enet->bna->ioceth.ioc, mac); 1310 } 1311 1312 /* IOCETH */ 1313 1314 #define enable_mbox_intr(_ioceth) \ 1315 do { \ 1316 u32 intr_status; \ 1317 bna_intr_status_get((_ioceth)->bna, intr_status); \ 1318 bnad_cb_mbox_intr_enable((_ioceth)->bna->bnad); \ 1319 bna_mbox_intr_enable((_ioceth)->bna); \ 1320 } while (0) 1321 1322 #define disable_mbox_intr(_ioceth) \ 1323 do { \ 1324 bna_mbox_intr_disable((_ioceth)->bna); \ 1325 bnad_cb_mbox_intr_disable((_ioceth)->bna->bnad); \ 1326 } while (0) 1327 1328 #define call_ioceth_stop_cbfn(_ioceth) \ 1329 do { \ 1330 if ((_ioceth)->stop_cbfn) { \ 1331 void (*cbfn)(struct bnad *); \ 1332 struct bnad *cbarg; \ 1333 cbfn = (_ioceth)->stop_cbfn; \ 1334 cbarg = (_ioceth)->stop_cbarg; \ 1335 (_ioceth)->stop_cbfn = NULL; \ 1336 (_ioceth)->stop_cbarg = NULL; \ 1337 cbfn(cbarg); \ 1338 } \ 1339 } while (0) 1340 1341 #define bna_stats_mod_uninit(_stats_mod) \ 1342 do { \ 1343 } while (0) 1344 1345 #define bna_stats_mod_start(_stats_mod) \ 1346 do { \ 1347 (_stats_mod)->ioc_ready = true; \ 1348 } while (0) 1349 1350 #define bna_stats_mod_stop(_stats_mod) \ 1351 do { \ 1352 (_stats_mod)->ioc_ready = false; \ 1353 } while (0) 1354 1355 #define bna_stats_mod_fail(_stats_mod) \ 1356 do { \ 1357 (_stats_mod)->ioc_ready = false; \ 1358 (_stats_mod)->stats_get_busy = false; \ 1359 (_stats_mod)->stats_clr_busy = false; \ 1360 } while (0) 1361 1362 static void bna_bfi_attr_get(struct bna_ioceth *ioceth); 1363 1364 bfa_fsm_state_decl(bna_ioceth, stopped, struct bna_ioceth, 1365 enum bna_ioceth_event); 1366 bfa_fsm_state_decl(bna_ioceth, ioc_ready_wait, struct bna_ioceth, 1367 enum bna_ioceth_event); 1368 bfa_fsm_state_decl(bna_ioceth, enet_attr_wait, struct bna_ioceth, 1369 enum bna_ioceth_event); 1370 bfa_fsm_state_decl(bna_ioceth, ready, struct bna_ioceth, 1371 enum bna_ioceth_event); 1372 bfa_fsm_state_decl(bna_ioceth, last_resp_wait, struct bna_ioceth, 1373 enum bna_ioceth_event); 1374 bfa_fsm_state_decl(bna_ioceth, enet_stop_wait, struct bna_ioceth, 1375 enum bna_ioceth_event); 1376 bfa_fsm_state_decl(bna_ioceth, ioc_disable_wait, struct bna_ioceth, 1377 enum bna_ioceth_event); 1378 bfa_fsm_state_decl(bna_ioceth, failed, struct bna_ioceth, 1379 enum bna_ioceth_event); 1380 1381 static void 1382 bna_ioceth_sm_stopped_entry(struct bna_ioceth *ioceth) 1383 { 1384 call_ioceth_stop_cbfn(ioceth); 1385 } 1386 1387 static void 1388 bna_ioceth_sm_stopped(struct bna_ioceth *ioceth, 1389 enum bna_ioceth_event event) 1390 { 1391 switch (event) { 1392 case IOCETH_E_ENABLE: 1393 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_ready_wait); 1394 bfa_nw_ioc_enable(&ioceth->ioc); 1395 break; 1396 1397 case IOCETH_E_DISABLE: 1398 bfa_fsm_set_state(ioceth, bna_ioceth_sm_stopped); 1399 break; 1400 1401 case IOCETH_E_IOC_RESET: 1402 enable_mbox_intr(ioceth); 1403 break; 1404 1405 case IOCETH_E_IOC_FAILED: 1406 disable_mbox_intr(ioceth); 1407 bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed); 1408 break; 1409 1410 default: 1411 bfa_sm_fault(event); 1412 } 1413 } 1414 1415 static void 1416 bna_ioceth_sm_ioc_ready_wait_entry(struct bna_ioceth *ioceth) 1417 { 1418 /** 1419 * Do not call bfa_nw_ioc_enable() here. It must be called in the 1420 * previous state due to failed -> ioc_ready_wait transition. 1421 */ 1422 } 1423 1424 static void 1425 bna_ioceth_sm_ioc_ready_wait(struct bna_ioceth *ioceth, 1426 enum bna_ioceth_event event) 1427 { 1428 switch (event) { 1429 case IOCETH_E_DISABLE: 1430 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait); 1431 bfa_nw_ioc_disable(&ioceth->ioc); 1432 break; 1433 1434 case IOCETH_E_IOC_RESET: 1435 enable_mbox_intr(ioceth); 1436 break; 1437 1438 case IOCETH_E_IOC_FAILED: 1439 disable_mbox_intr(ioceth); 1440 bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed); 1441 break; 1442 1443 case IOCETH_E_IOC_READY: 1444 bfa_fsm_set_state(ioceth, bna_ioceth_sm_enet_attr_wait); 1445 break; 1446 1447 default: 1448 bfa_sm_fault(event); 1449 } 1450 } 1451 1452 static void 1453 bna_ioceth_sm_enet_attr_wait_entry(struct bna_ioceth *ioceth) 1454 { 1455 bna_bfi_attr_get(ioceth); 1456 } 1457 1458 static void 1459 bna_ioceth_sm_enet_attr_wait(struct bna_ioceth *ioceth, 1460 enum bna_ioceth_event event) 1461 { 1462 switch (event) { 1463 case IOCETH_E_DISABLE: 1464 bfa_fsm_set_state(ioceth, bna_ioceth_sm_last_resp_wait); 1465 break; 1466 1467 case IOCETH_E_IOC_FAILED: 1468 disable_mbox_intr(ioceth); 1469 bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed); 1470 break; 1471 1472 case IOCETH_E_ENET_ATTR_RESP: 1473 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ready); 1474 break; 1475 1476 default: 1477 bfa_sm_fault(event); 1478 } 1479 } 1480 1481 static void 1482 bna_ioceth_sm_ready_entry(struct bna_ioceth *ioceth) 1483 { 1484 bna_enet_start(&ioceth->bna->enet); 1485 bna_stats_mod_start(&ioceth->bna->stats_mod); 1486 bnad_cb_ioceth_ready(ioceth->bna->bnad); 1487 } 1488 1489 static void 1490 bna_ioceth_sm_ready(struct bna_ioceth *ioceth, enum bna_ioceth_event event) 1491 { 1492 switch (event) { 1493 case IOCETH_E_DISABLE: 1494 bfa_fsm_set_state(ioceth, bna_ioceth_sm_enet_stop_wait); 1495 break; 1496 1497 case IOCETH_E_IOC_FAILED: 1498 disable_mbox_intr(ioceth); 1499 bna_enet_fail(&ioceth->bna->enet); 1500 bna_stats_mod_fail(&ioceth->bna->stats_mod); 1501 bfa_fsm_set_state(ioceth, bna_ioceth_sm_failed); 1502 break; 1503 1504 default: 1505 bfa_sm_fault(event); 1506 } 1507 } 1508 1509 static void 1510 bna_ioceth_sm_last_resp_wait_entry(struct bna_ioceth *ioceth) 1511 { 1512 } 1513 1514 static void 1515 bna_ioceth_sm_last_resp_wait(struct bna_ioceth *ioceth, 1516 enum bna_ioceth_event event) 1517 { 1518 switch (event) { 1519 case IOCETH_E_IOC_FAILED: 1520 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait); 1521 disable_mbox_intr(ioceth); 1522 bfa_nw_ioc_disable(&ioceth->ioc); 1523 break; 1524 1525 case IOCETH_E_ENET_ATTR_RESP: 1526 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait); 1527 bfa_nw_ioc_disable(&ioceth->ioc); 1528 break; 1529 1530 default: 1531 bfa_sm_fault(event); 1532 } 1533 } 1534 1535 static void 1536 bna_ioceth_sm_enet_stop_wait_entry(struct bna_ioceth *ioceth) 1537 { 1538 bna_stats_mod_stop(&ioceth->bna->stats_mod); 1539 bna_enet_stop(&ioceth->bna->enet); 1540 } 1541 1542 static void 1543 bna_ioceth_sm_enet_stop_wait(struct bna_ioceth *ioceth, 1544 enum bna_ioceth_event event) 1545 { 1546 switch (event) { 1547 case IOCETH_E_IOC_FAILED: 1548 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait); 1549 disable_mbox_intr(ioceth); 1550 bna_enet_fail(&ioceth->bna->enet); 1551 bna_stats_mod_fail(&ioceth->bna->stats_mod); 1552 bfa_nw_ioc_disable(&ioceth->ioc); 1553 break; 1554 1555 case IOCETH_E_ENET_STOPPED: 1556 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait); 1557 bfa_nw_ioc_disable(&ioceth->ioc); 1558 break; 1559 1560 default: 1561 bfa_sm_fault(event); 1562 } 1563 } 1564 1565 static void 1566 bna_ioceth_sm_ioc_disable_wait_entry(struct bna_ioceth *ioceth) 1567 { 1568 } 1569 1570 static void 1571 bna_ioceth_sm_ioc_disable_wait(struct bna_ioceth *ioceth, 1572 enum bna_ioceth_event event) 1573 { 1574 switch (event) { 1575 case IOCETH_E_IOC_DISABLED: 1576 disable_mbox_intr(ioceth); 1577 bfa_fsm_set_state(ioceth, bna_ioceth_sm_stopped); 1578 break; 1579 1580 case IOCETH_E_ENET_STOPPED: 1581 /* This event is received due to enet failing */ 1582 /* No-op */ 1583 break; 1584 1585 default: 1586 bfa_sm_fault(event); 1587 } 1588 } 1589 1590 static void 1591 bna_ioceth_sm_failed_entry(struct bna_ioceth *ioceth) 1592 { 1593 bnad_cb_ioceth_failed(ioceth->bna->bnad); 1594 } 1595 1596 static void 1597 bna_ioceth_sm_failed(struct bna_ioceth *ioceth, 1598 enum bna_ioceth_event event) 1599 { 1600 switch (event) { 1601 case IOCETH_E_DISABLE: 1602 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_disable_wait); 1603 bfa_nw_ioc_disable(&ioceth->ioc); 1604 break; 1605 1606 case IOCETH_E_IOC_RESET: 1607 enable_mbox_intr(ioceth); 1608 bfa_fsm_set_state(ioceth, bna_ioceth_sm_ioc_ready_wait); 1609 break; 1610 1611 case IOCETH_E_IOC_FAILED: 1612 break; 1613 1614 default: 1615 bfa_sm_fault(event); 1616 } 1617 } 1618 1619 static void 1620 bna_bfi_attr_get(struct bna_ioceth *ioceth) 1621 { 1622 struct bfi_enet_attr_req *attr_req = &ioceth->attr_req; 1623 1624 bfi_msgq_mhdr_set(attr_req->mh, BFI_MC_ENET, 1625 BFI_ENET_H2I_GET_ATTR_REQ, 0, 0); 1626 attr_req->mh.num_entries = htons( 1627 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_attr_req))); 1628 bfa_msgq_cmd_set(&ioceth->msgq_cmd, NULL, NULL, 1629 sizeof(struct bfi_enet_attr_req), &attr_req->mh); 1630 bfa_msgq_cmd_post(&ioceth->bna->msgq, &ioceth->msgq_cmd); 1631 } 1632 1633 /* IOC callback functions */ 1634 1635 static void 1636 bna_cb_ioceth_enable(void *arg, enum bfa_status error) 1637 { 1638 struct bna_ioceth *ioceth = (struct bna_ioceth *)arg; 1639 1640 if (error) 1641 bfa_fsm_send_event(ioceth, IOCETH_E_IOC_FAILED); 1642 else 1643 bfa_fsm_send_event(ioceth, IOCETH_E_IOC_READY); 1644 } 1645 1646 static void 1647 bna_cb_ioceth_disable(void *arg) 1648 { 1649 struct bna_ioceth *ioceth = (struct bna_ioceth *)arg; 1650 1651 bfa_fsm_send_event(ioceth, IOCETH_E_IOC_DISABLED); 1652 } 1653 1654 static void 1655 bna_cb_ioceth_hbfail(void *arg) 1656 { 1657 struct bna_ioceth *ioceth = (struct bna_ioceth *)arg; 1658 1659 bfa_fsm_send_event(ioceth, IOCETH_E_IOC_FAILED); 1660 } 1661 1662 static void 1663 bna_cb_ioceth_reset(void *arg) 1664 { 1665 struct bna_ioceth *ioceth = (struct bna_ioceth *)arg; 1666 1667 bfa_fsm_send_event(ioceth, IOCETH_E_IOC_RESET); 1668 } 1669 1670 static struct bfa_ioc_cbfn bna_ioceth_cbfn = { 1671 .enable_cbfn = bna_cb_ioceth_enable, 1672 .disable_cbfn = bna_cb_ioceth_disable, 1673 .hbfail_cbfn = bna_cb_ioceth_hbfail, 1674 .reset_cbfn = bna_cb_ioceth_reset 1675 }; 1676 1677 static void bna_attr_init(struct bna_ioceth *ioceth) 1678 { 1679 ioceth->attr.num_txq = BFI_ENET_DEF_TXQ; 1680 ioceth->attr.num_rxp = BFI_ENET_DEF_RXP; 1681 ioceth->attr.num_ucmac = BFI_ENET_DEF_UCAM; 1682 ioceth->attr.num_mcmac = BFI_ENET_MAX_MCAM; 1683 ioceth->attr.max_rit_size = BFI_ENET_DEF_RITSZ; 1684 ioceth->attr.fw_query_complete = false; 1685 } 1686 1687 static void 1688 bna_ioceth_init(struct bna_ioceth *ioceth, struct bna *bna, 1689 struct bna_res_info *res_info) 1690 { 1691 u64 dma; 1692 u8 *kva; 1693 1694 ioceth->bna = bna; 1695 1696 /** 1697 * Attach IOC and claim: 1698 * 1. DMA memory for IOC attributes 1699 * 2. Kernel memory for FW trace 1700 */ 1701 bfa_nw_ioc_attach(&ioceth->ioc, ioceth, &bna_ioceth_cbfn); 1702 bfa_nw_ioc_pci_init(&ioceth->ioc, &bna->pcidev, BFI_PCIFN_CLASS_ETH); 1703 1704 BNA_GET_DMA_ADDR( 1705 &res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.mdl[0].dma, dma); 1706 kva = res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.mdl[0].kva; 1707 bfa_nw_ioc_mem_claim(&ioceth->ioc, kva, dma); 1708 1709 kva = res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.mdl[0].kva; 1710 bfa_nw_ioc_debug_memclaim(&ioceth->ioc, kva); 1711 1712 /** 1713 * Attach common modules (Diag, SFP, CEE, Port) and claim respective 1714 * DMA memory. 1715 */ 1716 BNA_GET_DMA_ADDR( 1717 &res_info[BNA_RES_MEM_T_COM].res_u.mem_info.mdl[0].dma, dma); 1718 kva = res_info[BNA_RES_MEM_T_COM].res_u.mem_info.mdl[0].kva; 1719 bfa_nw_cee_attach(&bna->cee, &ioceth->ioc, bna); 1720 bfa_nw_cee_mem_claim(&bna->cee, kva, dma); 1721 kva += bfa_nw_cee_meminfo(); 1722 dma += bfa_nw_cee_meminfo(); 1723 1724 bfa_nw_flash_attach(&bna->flash, &ioceth->ioc, bna); 1725 bfa_nw_flash_memclaim(&bna->flash, kva, dma); 1726 kva += bfa_nw_flash_meminfo(); 1727 dma += bfa_nw_flash_meminfo(); 1728 1729 bfa_msgq_attach(&bna->msgq, &ioceth->ioc); 1730 bfa_msgq_memclaim(&bna->msgq, kva, dma); 1731 bfa_msgq_regisr(&bna->msgq, BFI_MC_ENET, bna_msgq_rsp_handler, bna); 1732 kva += bfa_msgq_meminfo(); 1733 dma += bfa_msgq_meminfo(); 1734 1735 ioceth->stop_cbfn = NULL; 1736 ioceth->stop_cbarg = NULL; 1737 1738 bna_attr_init(ioceth); 1739 1740 bfa_fsm_set_state(ioceth, bna_ioceth_sm_stopped); 1741 } 1742 1743 static void 1744 bna_ioceth_uninit(struct bna_ioceth *ioceth) 1745 { 1746 bfa_nw_ioc_detach(&ioceth->ioc); 1747 1748 ioceth->bna = NULL; 1749 } 1750 1751 void 1752 bna_ioceth_enable(struct bna_ioceth *ioceth) 1753 { 1754 if (ioceth->fsm == bna_ioceth_sm_ready) { 1755 bnad_cb_ioceth_ready(ioceth->bna->bnad); 1756 return; 1757 } 1758 1759 if (ioceth->fsm == bna_ioceth_sm_stopped) 1760 bfa_fsm_send_event(ioceth, IOCETH_E_ENABLE); 1761 } 1762 1763 void 1764 bna_ioceth_disable(struct bna_ioceth *ioceth, enum bna_cleanup_type type) 1765 { 1766 if (type == BNA_SOFT_CLEANUP) { 1767 bnad_cb_ioceth_disabled(ioceth->bna->bnad); 1768 return; 1769 } 1770 1771 ioceth->stop_cbfn = bnad_cb_ioceth_disabled; 1772 ioceth->stop_cbarg = ioceth->bna->bnad; 1773 1774 bfa_fsm_send_event(ioceth, IOCETH_E_DISABLE); 1775 } 1776 1777 static void 1778 bna_ucam_mod_init(struct bna_ucam_mod *ucam_mod, struct bna *bna, 1779 struct bna_res_info *res_info) 1780 { 1781 int i; 1782 1783 ucam_mod->ucmac = (struct bna_mac *) 1784 res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.mdl[0].kva; 1785 1786 INIT_LIST_HEAD(&ucam_mod->free_q); 1787 for (i = 0; i < bna->ioceth.attr.num_ucmac; i++) 1788 list_add_tail(&ucam_mod->ucmac[i].qe, &ucam_mod->free_q); 1789 1790 /* A separate queue to allow synchronous setting of a list of MACs */ 1791 INIT_LIST_HEAD(&ucam_mod->del_q); 1792 for (; i < (bna->ioceth.attr.num_ucmac * 2); i++) 1793 list_add_tail(&ucam_mod->ucmac[i].qe, &ucam_mod->del_q); 1794 1795 ucam_mod->bna = bna; 1796 } 1797 1798 static void 1799 bna_ucam_mod_uninit(struct bna_ucam_mod *ucam_mod) 1800 { 1801 ucam_mod->bna = NULL; 1802 } 1803 1804 static void 1805 bna_mcam_mod_init(struct bna_mcam_mod *mcam_mod, struct bna *bna, 1806 struct bna_res_info *res_info) 1807 { 1808 int i; 1809 1810 mcam_mod->mcmac = (struct bna_mac *) 1811 res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.mdl[0].kva; 1812 1813 INIT_LIST_HEAD(&mcam_mod->free_q); 1814 for (i = 0; i < bna->ioceth.attr.num_mcmac; i++) 1815 list_add_tail(&mcam_mod->mcmac[i].qe, &mcam_mod->free_q); 1816 1817 mcam_mod->mchandle = (struct bna_mcam_handle *) 1818 res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.mdl[0].kva; 1819 1820 INIT_LIST_HEAD(&mcam_mod->free_handle_q); 1821 for (i = 0; i < bna->ioceth.attr.num_mcmac; i++) 1822 list_add_tail(&mcam_mod->mchandle[i].qe, 1823 &mcam_mod->free_handle_q); 1824 1825 /* A separate queue to allow synchronous setting of a list of MACs */ 1826 INIT_LIST_HEAD(&mcam_mod->del_q); 1827 for (; i < (bna->ioceth.attr.num_mcmac * 2); i++) 1828 list_add_tail(&mcam_mod->mcmac[i].qe, &mcam_mod->del_q); 1829 1830 mcam_mod->bna = bna; 1831 } 1832 1833 static void 1834 bna_mcam_mod_uninit(struct bna_mcam_mod *mcam_mod) 1835 { 1836 mcam_mod->bna = NULL; 1837 } 1838 1839 static void 1840 bna_bfi_stats_get(struct bna *bna) 1841 { 1842 struct bfi_enet_stats_req *stats_req = &bna->stats_mod.stats_get; 1843 1844 bna->stats_mod.stats_get_busy = true; 1845 1846 bfi_msgq_mhdr_set(stats_req->mh, BFI_MC_ENET, 1847 BFI_ENET_H2I_STATS_GET_REQ, 0, 0); 1848 stats_req->mh.num_entries = htons( 1849 bfi_msgq_num_cmd_entries(sizeof(struct bfi_enet_stats_req))); 1850 stats_req->stats_mask = htons(BFI_ENET_STATS_ALL); 1851 stats_req->tx_enet_mask = htonl(bna->tx_mod.rid_mask); 1852 stats_req->rx_enet_mask = htonl(bna->rx_mod.rid_mask); 1853 stats_req->host_buffer.a32.addr_hi = bna->stats.hw_stats_dma.msb; 1854 stats_req->host_buffer.a32.addr_lo = bna->stats.hw_stats_dma.lsb; 1855 1856 bfa_msgq_cmd_set(&bna->stats_mod.stats_get_cmd, NULL, NULL, 1857 sizeof(struct bfi_enet_stats_req), &stats_req->mh); 1858 bfa_msgq_cmd_post(&bna->msgq, &bna->stats_mod.stats_get_cmd); 1859 } 1860 1861 void 1862 bna_res_req(struct bna_res_info *res_info) 1863 { 1864 /* DMA memory for COMMON_MODULE */ 1865 res_info[BNA_RES_MEM_T_COM].res_type = BNA_RES_T_MEM; 1866 res_info[BNA_RES_MEM_T_COM].res_u.mem_info.mem_type = BNA_MEM_T_DMA; 1867 res_info[BNA_RES_MEM_T_COM].res_u.mem_info.num = 1; 1868 res_info[BNA_RES_MEM_T_COM].res_u.mem_info.len = ALIGN( 1869 (bfa_nw_cee_meminfo() + 1870 bfa_nw_flash_meminfo() + 1871 bfa_msgq_meminfo()), PAGE_SIZE); 1872 1873 /* DMA memory for retrieving IOC attributes */ 1874 res_info[BNA_RES_MEM_T_ATTR].res_type = BNA_RES_T_MEM; 1875 res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.mem_type = BNA_MEM_T_DMA; 1876 res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.num = 1; 1877 res_info[BNA_RES_MEM_T_ATTR].res_u.mem_info.len = 1878 ALIGN(bfa_nw_ioc_meminfo(), PAGE_SIZE); 1879 1880 /* Virtual memory for retreiving fw_trc */ 1881 res_info[BNA_RES_MEM_T_FWTRC].res_type = BNA_RES_T_MEM; 1882 res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.mem_type = BNA_MEM_T_KVA; 1883 res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.num = 1; 1884 res_info[BNA_RES_MEM_T_FWTRC].res_u.mem_info.len = BNA_DBG_FWTRC_LEN; 1885 1886 /* DMA memory for retreiving stats */ 1887 res_info[BNA_RES_MEM_T_STATS].res_type = BNA_RES_T_MEM; 1888 res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mem_type = BNA_MEM_T_DMA; 1889 res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.num = 1; 1890 res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.len = 1891 ALIGN(sizeof(struct bfi_enet_stats), 1892 PAGE_SIZE); 1893 } 1894 1895 void 1896 bna_mod_res_req(struct bna *bna, struct bna_res_info *res_info) 1897 { 1898 struct bna_attr *attr = &bna->ioceth.attr; 1899 1900 /* Virtual memory for Tx objects - stored by Tx module */ 1901 res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_type = BNA_RES_T_MEM; 1902 res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_u.mem_info.mem_type = 1903 BNA_MEM_T_KVA; 1904 res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_u.mem_info.num = 1; 1905 res_info[BNA_MOD_RES_MEM_T_TX_ARRAY].res_u.mem_info.len = 1906 attr->num_txq * sizeof(struct bna_tx); 1907 1908 /* Virtual memory for TxQ - stored by Tx module */ 1909 res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_type = BNA_RES_T_MEM; 1910 res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_u.mem_info.mem_type = 1911 BNA_MEM_T_KVA; 1912 res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_u.mem_info.num = 1; 1913 res_info[BNA_MOD_RES_MEM_T_TXQ_ARRAY].res_u.mem_info.len = 1914 attr->num_txq * sizeof(struct bna_txq); 1915 1916 /* Virtual memory for Rx objects - stored by Rx module */ 1917 res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_type = BNA_RES_T_MEM; 1918 res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_u.mem_info.mem_type = 1919 BNA_MEM_T_KVA; 1920 res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_u.mem_info.num = 1; 1921 res_info[BNA_MOD_RES_MEM_T_RX_ARRAY].res_u.mem_info.len = 1922 attr->num_rxp * sizeof(struct bna_rx); 1923 1924 /* Virtual memory for RxPath - stored by Rx module */ 1925 res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_type = BNA_RES_T_MEM; 1926 res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_u.mem_info.mem_type = 1927 BNA_MEM_T_KVA; 1928 res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_u.mem_info.num = 1; 1929 res_info[BNA_MOD_RES_MEM_T_RXP_ARRAY].res_u.mem_info.len = 1930 attr->num_rxp * sizeof(struct bna_rxp); 1931 1932 /* Virtual memory for RxQ - stored by Rx module */ 1933 res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_type = BNA_RES_T_MEM; 1934 res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_u.mem_info.mem_type = 1935 BNA_MEM_T_KVA; 1936 res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_u.mem_info.num = 1; 1937 res_info[BNA_MOD_RES_MEM_T_RXQ_ARRAY].res_u.mem_info.len = 1938 (attr->num_rxp * 2) * sizeof(struct bna_rxq); 1939 1940 /* Virtual memory for Unicast MAC address - stored by ucam module */ 1941 res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_type = BNA_RES_T_MEM; 1942 res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.mem_type = 1943 BNA_MEM_T_KVA; 1944 res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.num = 1; 1945 res_info[BNA_MOD_RES_MEM_T_UCMAC_ARRAY].res_u.mem_info.len = 1946 (attr->num_ucmac * 2) * sizeof(struct bna_mac); 1947 1948 /* Virtual memory for Multicast MAC address - stored by mcam module */ 1949 res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_type = BNA_RES_T_MEM; 1950 res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.mem_type = 1951 BNA_MEM_T_KVA; 1952 res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.num = 1; 1953 res_info[BNA_MOD_RES_MEM_T_MCMAC_ARRAY].res_u.mem_info.len = 1954 (attr->num_mcmac * 2) * sizeof(struct bna_mac); 1955 1956 /* Virtual memory for Multicast handle - stored by mcam module */ 1957 res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_type = BNA_RES_T_MEM; 1958 res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.mem_type = 1959 BNA_MEM_T_KVA; 1960 res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.num = 1; 1961 res_info[BNA_MOD_RES_MEM_T_MCHANDLE_ARRAY].res_u.mem_info.len = 1962 attr->num_mcmac * sizeof(struct bna_mcam_handle); 1963 } 1964 1965 void 1966 bna_init(struct bna *bna, struct bnad *bnad, 1967 struct bfa_pcidev *pcidev, struct bna_res_info *res_info) 1968 { 1969 bna->bnad = bnad; 1970 bna->pcidev = *pcidev; 1971 1972 bna->stats.hw_stats_kva = (struct bfi_enet_stats *) 1973 res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mdl[0].kva; 1974 bna->stats.hw_stats_dma.msb = 1975 res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mdl[0].dma.msb; 1976 bna->stats.hw_stats_dma.lsb = 1977 res_info[BNA_RES_MEM_T_STATS].res_u.mem_info.mdl[0].dma.lsb; 1978 1979 bna_reg_addr_init(bna, &bna->pcidev); 1980 1981 /* Also initializes diag, cee, sfp, phy_port, msgq */ 1982 bna_ioceth_init(&bna->ioceth, bna, res_info); 1983 1984 bna_enet_init(&bna->enet, bna); 1985 bna_ethport_init(&bna->ethport, bna); 1986 } 1987 1988 void 1989 bna_mod_init(struct bna *bna, struct bna_res_info *res_info) 1990 { 1991 bna_tx_mod_init(&bna->tx_mod, bna, res_info); 1992 1993 bna_rx_mod_init(&bna->rx_mod, bna, res_info); 1994 1995 bna_ucam_mod_init(&bna->ucam_mod, bna, res_info); 1996 1997 bna_mcam_mod_init(&bna->mcam_mod, bna, res_info); 1998 1999 bna->default_mode_rid = BFI_INVALID_RID; 2000 bna->promisc_rid = BFI_INVALID_RID; 2001 2002 bna->mod_flags |= BNA_MOD_F_INIT_DONE; 2003 } 2004 2005 void 2006 bna_uninit(struct bna *bna) 2007 { 2008 if (bna->mod_flags & BNA_MOD_F_INIT_DONE) { 2009 bna_mcam_mod_uninit(&bna->mcam_mod); 2010 bna_ucam_mod_uninit(&bna->ucam_mod); 2011 bna_rx_mod_uninit(&bna->rx_mod); 2012 bna_tx_mod_uninit(&bna->tx_mod); 2013 bna->mod_flags &= ~BNA_MOD_F_INIT_DONE; 2014 } 2015 2016 bna_stats_mod_uninit(&bna->stats_mod); 2017 bna_ethport_uninit(&bna->ethport); 2018 bna_enet_uninit(&bna->enet); 2019 2020 bna_ioceth_uninit(&bna->ioceth); 2021 2022 bna->bnad = NULL; 2023 } 2024 2025 int 2026 bna_num_txq_set(struct bna *bna, int num_txq) 2027 { 2028 if (bna->ioceth.attr.fw_query_complete && 2029 (num_txq <= bna->ioceth.attr.num_txq)) { 2030 bna->ioceth.attr.num_txq = num_txq; 2031 return BNA_CB_SUCCESS; 2032 } 2033 2034 return BNA_CB_FAIL; 2035 } 2036 2037 int 2038 bna_num_rxp_set(struct bna *bna, int num_rxp) 2039 { 2040 if (bna->ioceth.attr.fw_query_complete && 2041 (num_rxp <= bna->ioceth.attr.num_rxp)) { 2042 bna->ioceth.attr.num_rxp = num_rxp; 2043 return BNA_CB_SUCCESS; 2044 } 2045 2046 return BNA_CB_FAIL; 2047 } 2048 2049 struct bna_mac * 2050 bna_cam_mod_mac_get(struct list_head *head) 2051 { 2052 struct bna_mac *mac; 2053 2054 mac = list_first_entry_or_null(head, struct bna_mac, qe); 2055 if (mac) 2056 list_del(&mac->qe); 2057 2058 return mac; 2059 } 2060 2061 struct bna_mcam_handle * 2062 bna_mcam_mod_handle_get(struct bna_mcam_mod *mcam_mod) 2063 { 2064 struct bna_mcam_handle *handle; 2065 2066 handle = list_first_entry_or_null(&mcam_mod->free_handle_q, 2067 struct bna_mcam_handle, qe); 2068 if (handle) 2069 list_del(&handle->qe); 2070 2071 return handle; 2072 } 2073 2074 void 2075 bna_mcam_mod_handle_put(struct bna_mcam_mod *mcam_mod, 2076 struct bna_mcam_handle *handle) 2077 { 2078 list_add_tail(&handle->qe, &mcam_mod->free_handle_q); 2079 } 2080 2081 void 2082 bna_hw_stats_get(struct bna *bna) 2083 { 2084 if (!bna->stats_mod.ioc_ready) { 2085 bnad_cb_stats_get(bna->bnad, BNA_CB_FAIL, &bna->stats); 2086 return; 2087 } 2088 if (bna->stats_mod.stats_get_busy) { 2089 bnad_cb_stats_get(bna->bnad, BNA_CB_BUSY, &bna->stats); 2090 return; 2091 } 2092 2093 bna_bfi_stats_get(bna); 2094 } 2095