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

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