kernel/drivers/net/ethernet/brocade/bna/bna_enet.c

   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                 &ethport->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                 &ethport->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                 &ethport->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(&ethport->msgq_cmd, NULL, NULL,
 425                 sizeof(struct bfi_enet_enable_req), &admin_up_req->mh);
 426         bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->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                 &ethport->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(&ethport->msgq_cmd, NULL, NULL,
 442                 sizeof(struct bfi_enet_enable_req), &admin_down_req->mh);
 443         bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->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                 &ethport->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(&ethport->msgq_cmd, NULL, NULL,
 463                 sizeof(struct bfi_enet_diag_lb_req), &lpbk_up_req->mh);
 464         bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->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                 &ethport->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(&ethport->msgq_cmd, NULL, NULL,
 480                 sizeof(struct bfi_enet_diag_lb_req), &lpbk_down_req->mh);
 481         bfa_msgq_cmd_post(&ethport->bna->msgq, &ethport->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         bna_cb_ioceth_enable,
1680         bna_cb_ioceth_disable,
1681         bna_cb_ioceth_hbfail,
1682         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 = i; 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 = i; 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 }