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