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