drivers/net/ethernet/broadcom/bnx2x/bnx2x_stats.c

   1 /* bnx2x_stats.c: Broadcom Everest network driver.
   2  *
   3  * Copyright (c) 2007-2013 Broadcom Corporation
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation.
   8  *
   9  * Maintained by: Ariel Elior <ariel.elior@qlogic.com>
  10  * Written by: Eliezer Tamir
  11  * Based on code from Michael Chan's bnx2 driver
  12  * UDP CSUM errata workaround by Arik Gendelman
  13  * Slowpath and fastpath rework by Vladislav Zolotarov
  14  * Statistics and Link management by Yitchak Gertner
  15  *
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include "bnx2x_stats.h"
  21 #include "bnx2x_cmn.h"
  22 #include "bnx2x_sriov.h"
  23
  24 /* Statistics */
  25
  26 /*
  27  * General service functions
  28  */
  29
  30 static inline long bnx2x_hilo(u32 *hiref)
  31 {
  32         u32 lo = *(hiref + 1);
  33 #if (BITS_PER_LONG == 64)
  34         u32 hi = *hiref;
  35
  36         return HILO_U64(hi, lo);
  37 #else
  38         return lo;
  39 #endif
  40 }
  41
  42 static inline u16 bnx2x_get_port_stats_dma_len(struct bnx2x *bp)
  43 {
  44         u16 res = 0;
  45
  46         /* 'newest' convention - shmem2 cotains the size of the port stats */
  47         if (SHMEM2_HAS(bp, sizeof_port_stats)) {
  48                 u32 size = SHMEM2_RD(bp, sizeof_port_stats);
  49                 if (size)
  50                         res = size;
  51
  52                 /* prevent newer BC from causing buffer overflow */
  53                 if (res > sizeof(struct host_port_stats))
  54                         res = sizeof(struct host_port_stats);
  55         }
  56
  57         /* Older convention - all BCs support the port stats' fields up until
  58          * the 'not_used' field
  59          */
  60         if (!res) {
  61                 res = offsetof(struct host_port_stats, not_used) + 4;
  62
  63                 /* if PFC stats are supported by the MFW, DMA them as well */
  64                 if (bp->flags & BC_SUPPORTS_PFC_STATS) {
  65                         res += offsetof(struct host_port_stats,
  66                                         pfc_frames_rx_lo) -
  67                                offsetof(struct host_port_stats,
  68                                         pfc_frames_tx_hi) + 4 ;
  69                 }
  70         }
  71
  72         res >>= 2;
  73
  74         WARN_ON(res > 2 * DMAE_LEN32_RD_MAX);
  75         return res;
  76 }
  77
  78 /*
  79  * Init service functions
  80  */
  81
  82 static void bnx2x_dp_stats(struct bnx2x *bp)
  83 {
  84         int i;
  85
  86         DP(BNX2X_MSG_STATS, "dumping stats:\n"
  87            "fw_stats_req\n"
  88            "    hdr\n"
  89            "        cmd_num %d\n"
  90            "        reserved0 %d\n"
  91            "        drv_stats_counter %d\n"
  92            "        reserved1 %d\n"
  93            "        stats_counters_addrs %x %x\n",
  94            bp->fw_stats_req->hdr.cmd_num,
  95            bp->fw_stats_req->hdr.reserved0,
  96            bp->fw_stats_req->hdr.drv_stats_counter,
  97            bp->fw_stats_req->hdr.reserved1,
  98            bp->fw_stats_req->hdr.stats_counters_addrs.hi,
  99            bp->fw_stats_req->hdr.stats_counters_addrs.lo);
 100
 101         for (i = 0; i < bp->fw_stats_req->hdr.cmd_num; i++) {
 102                 DP(BNX2X_MSG_STATS,
 103                    "query[%d]\n"
 104                    "              kind %d\n"
 105                    "              index %d\n"
 106                    "              funcID %d\n"
 107                    "              reserved %d\n"
 108                    "              address %x %x\n",
 109                    i, bp->fw_stats_req->query[i].kind,
 110                    bp->fw_stats_req->query[i].index,
 111                    bp->fw_stats_req->query[i].funcID,
 112                    bp->fw_stats_req->query[i].reserved,
 113                    bp->fw_stats_req->query[i].address.hi,
 114                    bp->fw_stats_req->query[i].address.lo);
 115         }
 116 }
 117
 118 /* Post the next statistics ramrod. Protect it with the spin in
 119  * order to ensure the strict order between statistics ramrods
 120  * (each ramrod has a sequence number passed in a
 121  * bp->fw_stats_req->hdr.drv_stats_counter and ramrods must be
 122  * sent in order).
 123  */
 124 static void bnx2x_storm_stats_post(struct bnx2x *bp)
 125 {
 126         int rc;
 127
 128         if (bp->stats_pending)
 129                 return;
 130
 131         bp->fw_stats_req->hdr.drv_stats_counter =
 132                 cpu_to_le16(bp->stats_counter++);
 133
 134         DP(BNX2X_MSG_STATS, "Sending statistics ramrod %d\n",
 135            le16_to_cpu(bp->fw_stats_req->hdr.drv_stats_counter));
 136
 137         /* adjust the ramrod to include VF queues statistics */
 138         bnx2x_iov_adjust_stats_req(bp);
 139         bnx2x_dp_stats(bp);
 140
 141         /* send FW stats ramrod */
 142         rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_COMMON_STAT_QUERY, 0,
 143                            U64_HI(bp->fw_stats_req_mapping),
 144                            U64_LO(bp->fw_stats_req_mapping),
 145                            NONE_CONNECTION_TYPE);
 146         if (rc == 0)
 147                 bp->stats_pending = 1;
 148 }
 149
 150 static void bnx2x_hw_stats_post(struct bnx2x *bp)
 151 {
 152         struct dmae_command *dmae = &bp->stats_dmae;
 153         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
 154
 155         *stats_comp = DMAE_COMP_VAL;
 156         if (CHIP_REV_IS_SLOW(bp))
 157                 return;
 158
 159         /* Update MCP's statistics if possible */
 160         if (bp->func_stx)
 161                 memcpy(bnx2x_sp(bp, func_stats), &bp->func_stats,
 162                        sizeof(bp->func_stats));
 163
 164         /* loader */
 165         if (bp->executer_idx) {
 166                 int loader_idx = PMF_DMAE_C(bp);
 167                 u32 opcode =  bnx2x_dmae_opcode(bp, DMAE_SRC_PCI, DMAE_DST_GRC,
 168                                                  true, DMAE_COMP_GRC);
 169                 opcode = bnx2x_dmae_opcode_clr_src_reset(opcode);
 170
 171                 memset(dmae, 0, sizeof(struct dmae_command));
 172                 dmae->opcode = opcode;
 173                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, dmae[0]));
 174                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, dmae[0]));
 175                 dmae->dst_addr_lo = (DMAE_REG_CMD_MEM +
 176                                      sizeof(struct dmae_command) *
 177                                      (loader_idx + 1)) >> 2;
 178                 dmae->dst_addr_hi = 0;
 179                 dmae->len = sizeof(struct dmae_command) >> 2;
 180                 if (CHIP_IS_E1(bp))
 181                         dmae->len--;
 182                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx + 1] >> 2;
 183                 dmae->comp_addr_hi = 0;
 184                 dmae->comp_val = 1;
 185
 186                 *stats_comp = 0;
 187                 bnx2x_post_dmae(bp, dmae, loader_idx);
 188
 189         } else if (bp->func_stx) {
 190                 *stats_comp = 0;
 191                 bnx2x_issue_dmae_with_comp(bp, dmae, stats_comp);
 192         }
 193 }
 194
 195 static void bnx2x_stats_comp(struct bnx2x *bp)
 196 {
 197         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
 198         int cnt = 10;
 199
 200         might_sleep();
 201         while (*stats_comp != DMAE_COMP_VAL) {
 202                 if (!cnt) {
 203                         BNX2X_ERR("timeout waiting for stats finished\n");
 204                         break;
 205                 }
 206                 cnt--;
 207                 usleep_range(1000, 2000);
 208         }
 209 }
 210
 211 /*
 212  * Statistics service functions
 213  */
 214
 215 /* should be called under stats_sema */
 216 static void bnx2x_stats_pmf_update(struct bnx2x *bp)
 217 {
 218         struct dmae_command *dmae;
 219         u32 opcode;
 220         int loader_idx = PMF_DMAE_C(bp);
 221         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
 222
 223         /* sanity */
 224         if (!bp->port.pmf || !bp->port.port_stx) {
 225                 BNX2X_ERR("BUG!\n");
 226                 return;
 227         }
 228
 229         bp->executer_idx = 0;
 230
 231         opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_GRC, DMAE_DST_PCI, false, 0);
 232
 233         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 234         dmae->opcode = bnx2x_dmae_opcode_add_comp(opcode, DMAE_COMP_GRC);
 235         dmae->src_addr_lo = bp->port.port_stx >> 2;
 236         dmae->src_addr_hi = 0;
 237         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
 238         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
 239         dmae->len = DMAE_LEN32_RD_MAX;
 240         dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 241         dmae->comp_addr_hi = 0;
 242         dmae->comp_val = 1;
 243
 244         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 245         dmae->opcode = bnx2x_dmae_opcode_add_comp(opcode, DMAE_COMP_PCI);
 246         dmae->src_addr_lo = (bp->port.port_stx >> 2) + DMAE_LEN32_RD_MAX;
 247         dmae->src_addr_hi = 0;
 248         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats) +
 249                                    DMAE_LEN32_RD_MAX * 4);
 250         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats) +
 251                                    DMAE_LEN32_RD_MAX * 4);
 252         dmae->len = bnx2x_get_port_stats_dma_len(bp) - DMAE_LEN32_RD_MAX;
 253
 254         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
 255         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
 256         dmae->comp_val = DMAE_COMP_VAL;
 257
 258         *stats_comp = 0;
 259         bnx2x_hw_stats_post(bp);
 260         bnx2x_stats_comp(bp);
 261 }
 262
 263 static void bnx2x_port_stats_init(struct bnx2x *bp)
 264 {
 265         struct dmae_command *dmae;
 266         int port = BP_PORT(bp);
 267         u32 opcode;
 268         int loader_idx = PMF_DMAE_C(bp);
 269         u32 mac_addr;
 270         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
 271
 272         /* sanity */
 273         if (!bp->link_vars.link_up || !bp->port.pmf) {
 274                 BNX2X_ERR("BUG!\n");
 275                 return;
 276         }
 277
 278         bp->executer_idx = 0;
 279
 280         /* MCP */
 281         opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_PCI, DMAE_DST_GRC,
 282                                     true, DMAE_COMP_GRC);
 283
 284         if (bp->port.port_stx) {
 285
 286                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 287                 dmae->opcode = opcode;
 288                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
 289                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
 290                 dmae->dst_addr_lo = bp->port.port_stx >> 2;
 291                 dmae->dst_addr_hi = 0;
 292                 dmae->len = bnx2x_get_port_stats_dma_len(bp);
 293                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 294                 dmae->comp_addr_hi = 0;
 295                 dmae->comp_val = 1;
 296         }
 297
 298         if (bp->func_stx) {
 299
 300                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 301                 dmae->opcode = opcode;
 302                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
 303                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
 304                 dmae->dst_addr_lo = bp->func_stx >> 2;
 305                 dmae->dst_addr_hi = 0;
 306                 dmae->len = sizeof(struct host_func_stats) >> 2;
 307                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 308                 dmae->comp_addr_hi = 0;
 309                 dmae->comp_val = 1;
 310         }
 311
 312         /* MAC */
 313         opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_GRC, DMAE_DST_PCI,
 314                                    true, DMAE_COMP_GRC);
 315
 316         /* EMAC is special */
 317         if (bp->link_vars.mac_type == MAC_TYPE_EMAC) {
 318                 mac_addr = (port ? GRCBASE_EMAC1 : GRCBASE_EMAC0);
 319
 320                 /* EMAC_REG_EMAC_RX_STAT_AC (EMAC_REG_EMAC_RX_STAT_AC_COUNT)*/
 321                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 322                 dmae->opcode = opcode;
 323                 dmae->src_addr_lo = (mac_addr +
 324                                      EMAC_REG_EMAC_RX_STAT_AC) >> 2;
 325                 dmae->src_addr_hi = 0;
 326                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
 327                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
 328                 dmae->len = EMAC_REG_EMAC_RX_STAT_AC_COUNT;
 329                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 330                 dmae->comp_addr_hi = 0;
 331                 dmae->comp_val = 1;
 332
 333                 /* EMAC_REG_EMAC_RX_STAT_AC_28 */
 334                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 335                 dmae->opcode = opcode;
 336                 dmae->src_addr_lo = (mac_addr +
 337                                      EMAC_REG_EMAC_RX_STAT_AC_28) >> 2;
 338                 dmae->src_addr_hi = 0;
 339                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
 340                      offsetof(struct emac_stats, rx_stat_falsecarriererrors));
 341                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
 342                      offsetof(struct emac_stats, rx_stat_falsecarriererrors));
 343                 dmae->len = 1;
 344                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 345                 dmae->comp_addr_hi = 0;
 346                 dmae->comp_val = 1;
 347
 348                 /* EMAC_REG_EMAC_TX_STAT_AC (EMAC_REG_EMAC_TX_STAT_AC_COUNT)*/
 349                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 350                 dmae->opcode = opcode;
 351                 dmae->src_addr_lo = (mac_addr +
 352                                      EMAC_REG_EMAC_TX_STAT_AC) >> 2;
 353                 dmae->src_addr_hi = 0;
 354                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
 355                         offsetof(struct emac_stats, tx_stat_ifhcoutoctets));
 356                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
 357                         offsetof(struct emac_stats, tx_stat_ifhcoutoctets));
 358                 dmae->len = EMAC_REG_EMAC_TX_STAT_AC_COUNT;
 359                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 360                 dmae->comp_addr_hi = 0;
 361                 dmae->comp_val = 1;
 362         } else {
 363                 u32 tx_src_addr_lo, rx_src_addr_lo;
 364                 u16 rx_len, tx_len;
 365
 366                 /* configure the params according to MAC type */
 367                 switch (bp->link_vars.mac_type) {
 368                 case MAC_TYPE_BMAC:
 369                         mac_addr = (port ? NIG_REG_INGRESS_BMAC1_MEM :
 370                                            NIG_REG_INGRESS_BMAC0_MEM);
 371
 372                         /* BIGMAC_REGISTER_TX_STAT_GTPKT ..
 373                            BIGMAC_REGISTER_TX_STAT_GTBYT */
 374                         if (CHIP_IS_E1x(bp)) {
 375                                 tx_src_addr_lo = (mac_addr +
 376                                         BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
 377                                 tx_len = (8 + BIGMAC_REGISTER_TX_STAT_GTBYT -
 378                                           BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
 379                                 rx_src_addr_lo = (mac_addr +
 380                                         BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
 381                                 rx_len = (8 + BIGMAC_REGISTER_RX_STAT_GRIPJ -
 382                                           BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
 383                         } else {
 384                                 tx_src_addr_lo = (mac_addr +
 385                                         BIGMAC2_REGISTER_TX_STAT_GTPOK) >> 2;
 386                                 tx_len = (8 + BIGMAC2_REGISTER_TX_STAT_GTBYT -
 387                                           BIGMAC2_REGISTER_TX_STAT_GTPOK) >> 2;
 388                                 rx_src_addr_lo = (mac_addr +
 389                                         BIGMAC2_REGISTER_RX_STAT_GR64) >> 2;
 390                                 rx_len = (8 + BIGMAC2_REGISTER_RX_STAT_GRIPJ -
 391                                           BIGMAC2_REGISTER_RX_STAT_GR64) >> 2;
 392                         }
 393                         break;
 394
 395                 case MAC_TYPE_UMAC: /* handled by MSTAT */
 396                 case MAC_TYPE_XMAC: /* handled by MSTAT */
 397                 default:
 398                         mac_addr = port ? GRCBASE_MSTAT1 : GRCBASE_MSTAT0;
 399                         tx_src_addr_lo = (mac_addr +
 400                                           MSTAT_REG_TX_STAT_GTXPOK_LO) >> 2;
 401                         rx_src_addr_lo = (mac_addr +
 402                                           MSTAT_REG_RX_STAT_GR64_LO) >> 2;
 403                         tx_len = sizeof(bp->slowpath->
 404                                         mac_stats.mstat_stats.stats_tx) >> 2;
 405                         rx_len = sizeof(bp->slowpath->
 406                                         mac_stats.mstat_stats.stats_rx) >> 2;
 407                         break;
 408                 }
 409
 410                 /* TX stats */
 411                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 412                 dmae->opcode = opcode;
 413                 dmae->src_addr_lo = tx_src_addr_lo;
 414                 dmae->src_addr_hi = 0;
 415                 dmae->len = tx_len;
 416                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
 417                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
 418                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 419                 dmae->comp_addr_hi = 0;
 420                 dmae->comp_val = 1;
 421
 422                 /* RX stats */
 423                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 424                 dmae->opcode = opcode;
 425                 dmae->src_addr_hi = 0;
 426                 dmae->src_addr_lo = rx_src_addr_lo;
 427                 dmae->dst_addr_lo =
 428                         U64_LO(bnx2x_sp_mapping(bp, mac_stats) + (tx_len << 2));
 429                 dmae->dst_addr_hi =
 430                         U64_HI(bnx2x_sp_mapping(bp, mac_stats) + (tx_len << 2));
 431                 dmae->len = rx_len;
 432                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 433                 dmae->comp_addr_hi = 0;
 434                 dmae->comp_val = 1;
 435         }
 436
 437         /* NIG */
 438         if (!CHIP_IS_E3(bp)) {
 439                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 440                 dmae->opcode = opcode;
 441                 dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT0 :
 442                                             NIG_REG_STAT0_EGRESS_MAC_PKT0) >> 2;
 443                 dmae->src_addr_hi = 0;
 444                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
 445                                 offsetof(struct nig_stats, egress_mac_pkt0_lo));
 446                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
 447                                 offsetof(struct nig_stats, egress_mac_pkt0_lo));
 448                 dmae->len = (2*sizeof(u32)) >> 2;
 449                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 450                 dmae->comp_addr_hi = 0;
 451                 dmae->comp_val = 1;
 452
 453                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 454                 dmae->opcode = opcode;
 455                 dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT1 :
 456                                             NIG_REG_STAT0_EGRESS_MAC_PKT1) >> 2;
 457                 dmae->src_addr_hi = 0;
 458                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
 459                                 offsetof(struct nig_stats, egress_mac_pkt1_lo));
 460                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
 461                                 offsetof(struct nig_stats, egress_mac_pkt1_lo));
 462                 dmae->len = (2*sizeof(u32)) >> 2;
 463                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
 464                 dmae->comp_addr_hi = 0;
 465                 dmae->comp_val = 1;
 466         }
 467
 468         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
 469         dmae->opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_GRC, DMAE_DST_PCI,
 470                                                  true, DMAE_COMP_PCI);
 471         dmae->src_addr_lo = (port ? NIG_REG_STAT1_BRB_DISCARD :
 472                                     NIG_REG_STAT0_BRB_DISCARD) >> 2;
 473         dmae->src_addr_hi = 0;
 474         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats));
 475         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats));
 476         dmae->len = (sizeof(struct nig_stats) - 4*sizeof(u32)) >> 2;
 477
 478         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
 479         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
 480         dmae->comp_val = DMAE_COMP_VAL;
 481
 482         *stats_comp = 0;
 483 }
 484
 485 static void bnx2x_func_stats_init(struct bnx2x *bp)
 486 {
 487         struct dmae_command *dmae = &bp->stats_dmae;
 488         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
 489
 490         /* sanity */
 491         if (!bp->func_stx) {
 492                 BNX2X_ERR("BUG!\n");
 493                 return;
 494         }
 495
 496         bp->executer_idx = 0;
 497         memset(dmae, 0, sizeof(struct dmae_command));
 498
 499         dmae->opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_PCI, DMAE_DST_GRC,
 500                                          true, DMAE_COMP_PCI);
 501         dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
 502         dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
 503         dmae->dst_addr_lo = bp->func_stx >> 2;
 504         dmae->dst_addr_hi = 0;
 505         dmae->len = sizeof(struct host_func_stats) >> 2;
 506         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
 507         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
 508         dmae->comp_val = DMAE_COMP_VAL;
 509
 510         *stats_comp = 0;
 511 }
 512
 513 /* should be called under stats_sema */
 514 static void bnx2x_stats_start(struct bnx2x *bp)
 515 {
 516         if (IS_PF(bp)) {
 517                 if (bp->port.pmf)
 518                         bnx2x_port_stats_init(bp);
 519
 520                 else if (bp->func_stx)
 521                         bnx2x_func_stats_init(bp);
 522
 523                 bnx2x_hw_stats_post(bp);
 524                 bnx2x_storm_stats_post(bp);
 525         }
 526 }
 527
 528 static void bnx2x_stats_pmf_start(struct bnx2x *bp)
 529 {
 530         bnx2x_stats_comp(bp);
 531         bnx2x_stats_pmf_update(bp);
 532         bnx2x_stats_start(bp);
 533 }
 534
 535 static void bnx2x_stats_restart(struct bnx2x *bp)
 536 {
 537         /* vfs travel through here as part of the statistics FSM, but no action
 538          * is required
 539          */
 540         if (IS_VF(bp))
 541                 return;
 542
 543         bnx2x_stats_comp(bp);
 544         bnx2x_stats_start(bp);
 545 }
 546
 547 static void bnx2x_bmac_stats_update(struct bnx2x *bp)
 548 {
 549         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
 550         struct bnx2x_eth_stats *estats = &bp->eth_stats;
 551         struct {
 552                 u32 lo;
 553                 u32 hi;
 554         } diff;
 555
 556         if (CHIP_IS_E1x(bp)) {
 557                 struct bmac1_stats *new = bnx2x_sp(bp, mac_stats.bmac1_stats);
 558
 559                 /* the macros below will use "bmac1_stats" type */
 560                 UPDATE_STAT64(rx_stat_grerb, rx_stat_ifhcinbadoctets);
 561                 UPDATE_STAT64(rx_stat_grfcs, rx_stat_dot3statsfcserrors);
 562                 UPDATE_STAT64(rx_stat_grund, rx_stat_etherstatsundersizepkts);
 563                 UPDATE_STAT64(rx_stat_grovr, rx_stat_dot3statsframestoolong);
 564                 UPDATE_STAT64(rx_stat_grfrg, rx_stat_etherstatsfragments);
 565                 UPDATE_STAT64(rx_stat_grjbr, rx_stat_etherstatsjabbers);
 566                 UPDATE_STAT64(rx_stat_grxcf, rx_stat_maccontrolframesreceived);
 567                 UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffstateentered);
 568                 UPDATE_STAT64(rx_stat_grxpf, rx_stat_mac_xpf);
 569
 570                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_outxoffsent);
 571                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_flowcontroldone);
 572                 UPDATE_STAT64(tx_stat_gt64, tx_stat_etherstatspkts64octets);
 573                 UPDATE_STAT64(tx_stat_gt127,
 574                                 tx_stat_etherstatspkts65octetsto127octets);
 575                 UPDATE_STAT64(tx_stat_gt255,
 576                                 tx_stat_etherstatspkts128octetsto255octets);
 577                 UPDATE_STAT64(tx_stat_gt511,
 578                                 tx_stat_etherstatspkts256octetsto511octets);
 579                 UPDATE_STAT64(tx_stat_gt1023,
 580                                 tx_stat_etherstatspkts512octetsto1023octets);
 581                 UPDATE_STAT64(tx_stat_gt1518,
 582                                 tx_stat_etherstatspkts1024octetsto1522octets);
 583                 UPDATE_STAT64(tx_stat_gt2047, tx_stat_mac_2047);
 584                 UPDATE_STAT64(tx_stat_gt4095, tx_stat_mac_4095);
 585                 UPDATE_STAT64(tx_stat_gt9216, tx_stat_mac_9216);
 586                 UPDATE_STAT64(tx_stat_gt16383, tx_stat_mac_16383);
 587                 UPDATE_STAT64(tx_stat_gterr,
 588                                 tx_stat_dot3statsinternalmactransmiterrors);
 589                 UPDATE_STAT64(tx_stat_gtufl, tx_stat_mac_ufl);
 590
 591         } else {
 592                 struct bmac2_stats *new = bnx2x_sp(bp, mac_stats.bmac2_stats);
 593
 594                 /* the macros below will use "bmac2_stats" type */
 595                 UPDATE_STAT64(rx_stat_grerb, rx_stat_ifhcinbadoctets);
 596                 UPDATE_STAT64(rx_stat_grfcs, rx_stat_dot3statsfcserrors);
 597                 UPDATE_STAT64(rx_stat_grund, rx_stat_etherstatsundersizepkts);
 598                 UPDATE_STAT64(rx_stat_grovr, rx_stat_dot3statsframestoolong);
 599                 UPDATE_STAT64(rx_stat_grfrg, rx_stat_etherstatsfragments);
 600                 UPDATE_STAT64(rx_stat_grjbr, rx_stat_etherstatsjabbers);
 601                 UPDATE_STAT64(rx_stat_grxcf, rx_stat_maccontrolframesreceived);
 602                 UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffstateentered);
 603                 UPDATE_STAT64(rx_stat_grxpf, rx_stat_mac_xpf);
 604                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_outxoffsent);
 605                 UPDATE_STAT64(tx_stat_gtxpf, tx_stat_flowcontroldone);
 606                 UPDATE_STAT64(tx_stat_gt64, tx_stat_etherstatspkts64octets);
 607                 UPDATE_STAT64(tx_stat_gt127,
 608                                 tx_stat_etherstatspkts65octetsto127octets);
 609                 UPDATE_STAT64(tx_stat_gt255,
 610                                 tx_stat_etherstatspkts128octetsto255octets);
 611                 UPDATE_STAT64(tx_stat_gt511,
 612                                 tx_stat_etherstatspkts256octetsto511octets);
 613                 UPDATE_STAT64(tx_stat_gt1023,
 614                                 tx_stat_etherstatspkts512octetsto1023octets);
 615                 UPDATE_STAT64(tx_stat_gt1518,
 616                                 tx_stat_etherstatspkts1024octetsto1522octets);
 617                 UPDATE_STAT64(tx_stat_gt2047, tx_stat_mac_2047);
 618                 UPDATE_STAT64(tx_stat_gt4095, tx_stat_mac_4095);
 619                 UPDATE_STAT64(tx_stat_gt9216, tx_stat_mac_9216);
 620                 UPDATE_STAT64(tx_stat_gt16383, tx_stat_mac_16383);
 621                 UPDATE_STAT64(tx_stat_gterr,
 622                                 tx_stat_dot3statsinternalmactransmiterrors);
 623                 UPDATE_STAT64(tx_stat_gtufl, tx_stat_mac_ufl);
 624
 625                 /* collect PFC stats */
 626                 pstats->pfc_frames_tx_hi = new->tx_stat_gtpp_hi;
 627                 pstats->pfc_frames_tx_lo = new->tx_stat_gtpp_lo;
 628
 629                 pstats->pfc_frames_rx_hi = new->rx_stat_grpp_hi;
 630                 pstats->pfc_frames_rx_lo = new->rx_stat_grpp_lo;
 631         }
 632
 633         estats->pause_frames_received_hi =
 634                                 pstats->mac_stx[1].rx_stat_mac_xpf_hi;
 635         estats->pause_frames_received_lo =
 636                                 pstats->mac_stx[1].rx_stat_mac_xpf_lo;
 637
 638         estats->pause_frames_sent_hi =
 639                                 pstats->mac_stx[1].tx_stat_outxoffsent_hi;
 640         estats->pause_frames_sent_lo =
 641                                 pstats->mac_stx[1].tx_stat_outxoffsent_lo;
 642
 643         estats->pfc_frames_received_hi =
 644                                 pstats->pfc_frames_rx_hi;
 645         estats->pfc_frames_received_lo =
 646                                 pstats->pfc_frames_rx_lo;
 647         estats->pfc_frames_sent_hi =
 648                                 pstats->pfc_frames_tx_hi;
 649         estats->pfc_frames_sent_lo =
 650                                 pstats->pfc_frames_tx_lo;
 651 }
 652
 653 static void bnx2x_mstat_stats_update(struct bnx2x *bp)
 654 {
 655         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
 656         struct bnx2x_eth_stats *estats = &bp->eth_stats;
 657
 658         struct mstat_stats *new = bnx2x_sp(bp, mac_stats.mstat_stats);
 659
 660         ADD_STAT64(stats_rx.rx_grerb, rx_stat_ifhcinbadoctets);
 661         ADD_STAT64(stats_rx.rx_grfcs, rx_stat_dot3statsfcserrors);
 662         ADD_STAT64(stats_rx.rx_grund, rx_stat_etherstatsundersizepkts);
 663         ADD_STAT64(stats_rx.rx_grovr, rx_stat_dot3statsframestoolong);
 664         ADD_STAT64(stats_rx.rx_grfrg, rx_stat_etherstatsfragments);
 665         ADD_STAT64(stats_rx.rx_grxcf, rx_stat_maccontrolframesreceived);
 666         ADD_STAT64(stats_rx.rx_grxpf, rx_stat_xoffstateentered);
 667         ADD_STAT64(stats_rx.rx_grxpf, rx_stat_mac_xpf);
 668         ADD_STAT64(stats_tx.tx_gtxpf, tx_stat_outxoffsent);
 669         ADD_STAT64(stats_tx.tx_gtxpf, tx_stat_flowcontroldone);
 670
 671         /* collect pfc stats */
 672         ADD_64(pstats->pfc_frames_tx_hi, new->stats_tx.tx_gtxpp_hi,
 673                 pstats->pfc_frames_tx_lo, new->stats_tx.tx_gtxpp_lo);
 674         ADD_64(pstats->pfc_frames_rx_hi, new->stats_rx.rx_grxpp_hi,
 675                 pstats->pfc_frames_rx_lo, new->stats_rx.rx_grxpp_lo);
 676
 677         ADD_STAT64(stats_tx.tx_gt64, tx_stat_etherstatspkts64octets);
 678         ADD_STAT64(stats_tx.tx_gt127,
 679                         tx_stat_etherstatspkts65octetsto127octets);
 680         ADD_STAT64(stats_tx.tx_gt255,
 681                         tx_stat_etherstatspkts128octetsto255octets);
 682         ADD_STAT64(stats_tx.tx_gt511,
 683                         tx_stat_etherstatspkts256octetsto511octets);
 684         ADD_STAT64(stats_tx.tx_gt1023,
 685                         tx_stat_etherstatspkts512octetsto1023octets);
 686         ADD_STAT64(stats_tx.tx_gt1518,
 687                         tx_stat_etherstatspkts1024octetsto1522octets);
 688         ADD_STAT64(stats_tx.tx_gt2047, tx_stat_mac_2047);
 689
 690         ADD_STAT64(stats_tx.tx_gt4095, tx_stat_mac_4095);
 691         ADD_STAT64(stats_tx.tx_gt9216, tx_stat_mac_9216);
 692         ADD_STAT64(stats_tx.tx_gt16383, tx_stat_mac_16383);
 693
 694         ADD_STAT64(stats_tx.tx_gterr,
 695                         tx_stat_dot3statsinternalmactransmiterrors);
 696         ADD_STAT64(stats_tx.tx_gtufl, tx_stat_mac_ufl);
 697
 698         estats->etherstatspkts1024octetsto1522octets_hi =
 699             pstats->mac_stx[1].tx_stat_etherstatspkts1024octetsto1522octets_hi;
 700         estats->etherstatspkts1024octetsto1522octets_lo =
 701             pstats->mac_stx[1].tx_stat_etherstatspkts1024octetsto1522octets_lo;
 702
 703         estats->etherstatspktsover1522octets_hi =
 704             pstats->mac_stx[1].tx_stat_mac_2047_hi;
 705         estats->etherstatspktsover1522octets_lo =
 706             pstats->mac_stx[1].tx_stat_mac_2047_lo;
 707
 708         ADD_64(estats->etherstatspktsover1522octets_hi,
 709                pstats->mac_stx[1].tx_stat_mac_4095_hi,
 710                estats->etherstatspktsover1522octets_lo,
 711                pstats->mac_stx[1].tx_stat_mac_4095_lo);
 712
 713         ADD_64(estats->etherstatspktsover1522octets_hi,
 714                pstats->mac_stx[1].tx_stat_mac_9216_hi,
 715                estats->etherstatspktsover1522octets_lo,
 716                pstats->mac_stx[1].tx_stat_mac_9216_lo);
 717
 718         ADD_64(estats->etherstatspktsover1522octets_hi,
 719                pstats->mac_stx[1].tx_stat_mac_16383_hi,
 720                estats->etherstatspktsover1522octets_lo,
 721                pstats->mac_stx[1].tx_stat_mac_16383_lo);
 722
 723         estats->pause_frames_received_hi =
 724                                 pstats->mac_stx[1].rx_stat_mac_xpf_hi;
 725         estats->pause_frames_received_lo =
 726                                 pstats->mac_stx[1].rx_stat_mac_xpf_lo;
 727
 728         estats->pause_frames_sent_hi =
 729                                 pstats->mac_stx[1].tx_stat_outxoffsent_hi;
 730         estats->pause_frames_sent_lo =
 731                                 pstats->mac_stx[1].tx_stat_outxoffsent_lo;
 732
 733         estats->pfc_frames_received_hi =
 734                                 pstats->pfc_frames_rx_hi;
 735         estats->pfc_frames_received_lo =
 736                                 pstats->pfc_frames_rx_lo;
 737         estats->pfc_frames_sent_hi =
 738                                 pstats->pfc_frames_tx_hi;
 739         estats->pfc_frames_sent_lo =
 740                                 pstats->pfc_frames_tx_lo;
 741 }
 742
 743 static void bnx2x_emac_stats_update(struct bnx2x *bp)
 744 {
 745         struct emac_stats *new = bnx2x_sp(bp, mac_stats.emac_stats);
 746         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
 747         struct bnx2x_eth_stats *estats = &bp->eth_stats;
 748
 749         UPDATE_EXTEND_STAT(rx_stat_ifhcinbadoctets);
 750         UPDATE_EXTEND_STAT(tx_stat_ifhcoutbadoctets);
 751         UPDATE_EXTEND_STAT(rx_stat_dot3statsfcserrors);
 752         UPDATE_EXTEND_STAT(rx_stat_dot3statsalignmenterrors);
 753         UPDATE_EXTEND_STAT(rx_stat_dot3statscarriersenseerrors);
 754         UPDATE_EXTEND_STAT(rx_stat_falsecarriererrors);
 755         UPDATE_EXTEND_STAT(rx_stat_etherstatsundersizepkts);
 756         UPDATE_EXTEND_STAT(rx_stat_dot3statsframestoolong);
 757         UPDATE_EXTEND_STAT(rx_stat_etherstatsfragments);
 758         UPDATE_EXTEND_STAT(rx_stat_etherstatsjabbers);
 759         UPDATE_EXTEND_STAT(rx_stat_maccontrolframesreceived);
 760         UPDATE_EXTEND_STAT(rx_stat_xoffstateentered);
 761         UPDATE_EXTEND_STAT(rx_stat_xonpauseframesreceived);
 762         UPDATE_EXTEND_STAT(rx_stat_xoffpauseframesreceived);
 763         UPDATE_EXTEND_STAT(tx_stat_outxonsent);
 764         UPDATE_EXTEND_STAT(tx_stat_outxoffsent);
 765         UPDATE_EXTEND_STAT(tx_stat_flowcontroldone);
 766         UPDATE_EXTEND_STAT(tx_stat_etherstatscollisions);
 767         UPDATE_EXTEND_STAT(tx_stat_dot3statssinglecollisionframes);
 768         UPDATE_EXTEND_STAT(tx_stat_dot3statsmultiplecollisionframes);
 769         UPDATE_EXTEND_STAT(tx_stat_dot3statsdeferredtransmissions);
 770         UPDATE_EXTEND_STAT(tx_stat_dot3statsexcessivecollisions);
 771         UPDATE_EXTEND_STAT(tx_stat_dot3statslatecollisions);
 772         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts64octets);
 773         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts65octetsto127octets);
 774         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts128octetsto255octets);
 775         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts256octetsto511octets);
 776         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts512octetsto1023octets);
 777         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts1024octetsto1522octets);
 778         UPDATE_EXTEND_STAT(tx_stat_etherstatspktsover1522octets);
 779         UPDATE_EXTEND_STAT(tx_stat_dot3statsinternalmactransmiterrors);
 780
 781         estats->pause_frames_received_hi =
 782                         pstats->mac_stx[1].rx_stat_xonpauseframesreceived_hi;
 783         estats->pause_frames_received_lo =
 784                         pstats->mac_stx[1].rx_stat_xonpauseframesreceived_lo;
 785         ADD_64(estats->pause_frames_received_hi,
 786                pstats->mac_stx[1].rx_stat_xoffpauseframesreceived_hi,
 787                estats->pause_frames_received_lo,
 788                pstats->mac_stx[1].rx_stat_xoffpauseframesreceived_lo);
 789
 790         estats->pause_frames_sent_hi =
 791                         pstats->mac_stx[1].tx_stat_outxonsent_hi;
 792         estats->pause_frames_sent_lo =
 793                         pstats->mac_stx[1].tx_stat_outxonsent_lo;
 794         ADD_64(estats->pause_frames_sent_hi,
 795                pstats->mac_stx[1].tx_stat_outxoffsent_hi,
 796                estats->pause_frames_sent_lo,
 797                pstats->mac_stx[1].tx_stat_outxoffsent_lo);
 798 }
 799
 800 static int bnx2x_hw_stats_update(struct bnx2x *bp)
 801 {
 802         struct nig_stats *new = bnx2x_sp(bp, nig_stats);
 803         struct nig_stats *old = &(bp->port.old_nig_stats);
 804         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
 805         struct bnx2x_eth_stats *estats = &bp->eth_stats;
 806         struct {
 807                 u32 lo;
 808                 u32 hi;
 809         } diff;
 810
 811         switch (bp->link_vars.mac_type) {
 812         case MAC_TYPE_BMAC:
 813                 bnx2x_bmac_stats_update(bp);
 814                 break;
 815
 816         case MAC_TYPE_EMAC:
 817                 bnx2x_emac_stats_update(bp);
 818                 break;
 819
 820         case MAC_TYPE_UMAC:
 821         case MAC_TYPE_XMAC:
 822                 bnx2x_mstat_stats_update(bp);
 823                 break;
 824
 825         case MAC_TYPE_NONE: /* unreached */
 826                 DP(BNX2X_MSG_STATS,
 827                    "stats updated by DMAE but no MAC active\n");
 828                 return -1;
 829
 830         default: /* unreached */
 831                 BNX2X_ERR("Unknown MAC type\n");
 832         }
 833
 834         ADD_EXTEND_64(pstats->brb_drop_hi, pstats->brb_drop_lo,
 835                       new->brb_discard - old->brb_discard);
 836         ADD_EXTEND_64(estats->brb_truncate_hi, estats->brb_truncate_lo,
 837                       new->brb_truncate - old->brb_truncate);
 838
 839         if (!CHIP_IS_E3(bp)) {
 840                 UPDATE_STAT64_NIG(egress_mac_pkt0,
 841                                         etherstatspkts1024octetsto1522octets);
 842                 UPDATE_STAT64_NIG(egress_mac_pkt1,
 843                                         etherstatspktsover1522octets);
 844         }
 845
 846         memcpy(old, new, sizeof(struct nig_stats));
 847
 848         memcpy(&(estats->rx_stat_ifhcinbadoctets_hi), &(pstats->mac_stx[1]),
 849                sizeof(struct mac_stx));
 850         estats->brb_drop_hi = pstats->brb_drop_hi;
 851         estats->brb_drop_lo = pstats->brb_drop_lo;
 852
 853         pstats->host_port_stats_counter++;
 854
 855         if (CHIP_IS_E3(bp)) {
 856                 u32 lpi_reg = BP_PORT(bp) ? MISC_REG_CPMU_LP_SM_ENT_CNT_P1
 857                                           : MISC_REG_CPMU_LP_SM_ENT_CNT_P0;
 858                 estats->eee_tx_lpi += REG_RD(bp, lpi_reg);
 859         }
 860
 861         if (!BP_NOMCP(bp)) {
 862                 u32 nig_timer_max =
 863                         SHMEM_RD(bp, port_mb[BP_PORT(bp)].stat_nig_timer);
 864                 if (nig_timer_max != estats->nig_timer_max) {
 865                         estats->nig_timer_max = nig_timer_max;
 866                         BNX2X_ERR("NIG timer max (%u)\n",
 867                                   estats->nig_timer_max);
 868                 }
 869         }
 870
 871         return 0;
 872 }
 873
 874 static int bnx2x_storm_stats_validate_counters(struct bnx2x *bp)
 875 {
 876         struct stats_counter *counters = &bp->fw_stats_data->storm_counters;
 877         u16 cur_stats_counter;
 878         /* Make sure we use the value of the counter
 879          * used for sending the last stats ramrod.
 880          */
 881         cur_stats_counter = bp->stats_counter - 1;
 882
 883         /* are storm stats valid? */
 884         if (le16_to_cpu(counters->xstats_counter) != cur_stats_counter) {
 885                 DP(BNX2X_MSG_STATS,
 886                    "stats not updated by xstorm  xstorm counter (0x%x) != stats_counter (0x%x)\n",
 887                    le16_to_cpu(counters->xstats_counter), bp->stats_counter);
 888                 return -EAGAIN;
 889         }
 890
 891         if (le16_to_cpu(counters->ustats_counter) != cur_stats_counter) {
 892                 DP(BNX2X_MSG_STATS,
 893                    "stats not updated by ustorm  ustorm counter (0x%x) != stats_counter (0x%x)\n",
 894                    le16_to_cpu(counters->ustats_counter), bp->stats_counter);
 895                 return -EAGAIN;
 896         }
 897
 898         if (le16_to_cpu(counters->cstats_counter) != cur_stats_counter) {
 899                 DP(BNX2X_MSG_STATS,
 900                    "stats not updated by cstorm  cstorm counter (0x%x) != stats_counter (0x%x)\n",
 901                    le16_to_cpu(counters->cstats_counter), bp->stats_counter);
 902                 return -EAGAIN;
 903         }
 904
 905         if (le16_to_cpu(counters->tstats_counter) != cur_stats_counter) {
 906                 DP(BNX2X_MSG_STATS,
 907                    "stats not updated by tstorm  tstorm counter (0x%x) != stats_counter (0x%x)\n",
 908                    le16_to_cpu(counters->tstats_counter), bp->stats_counter);
 909                 return -EAGAIN;
 910         }
 911         return 0;
 912 }
 913
 914 static int bnx2x_storm_stats_update(struct bnx2x *bp)
 915 {
 916         struct tstorm_per_port_stats *tport =
 917                                 &bp->fw_stats_data->port.tstorm_port_statistics;
 918         struct tstorm_per_pf_stats *tfunc =
 919                                 &bp->fw_stats_data->pf.tstorm_pf_statistics;
 920         struct host_func_stats *fstats = &bp->func_stats;
 921         struct bnx2x_eth_stats *estats = &bp->eth_stats;
 922         struct bnx2x_eth_stats_old *estats_old = &bp->eth_stats_old;
 923         int i;
 924
 925         /* vfs stat counter is managed by pf */
 926         if (IS_PF(bp) && bnx2x_storm_stats_validate_counters(bp))
 927                 return -EAGAIN;
 928
 929         estats->error_bytes_received_hi = 0;
 930         estats->error_bytes_received_lo = 0;
 931
 932         for_each_eth_queue(bp, i) {
 933                 struct bnx2x_fastpath *fp = &bp->fp[i];
 934                 struct tstorm_per_queue_stats *tclient =
 935                         &bp->fw_stats_data->queue_stats[i].
 936                         tstorm_queue_statistics;
 937                 struct tstorm_per_queue_stats *old_tclient =
 938                         &bnx2x_fp_stats(bp, fp)->old_tclient;
 939                 struct ustorm_per_queue_stats *uclient =
 940                         &bp->fw_stats_data->queue_stats[i].
 941                         ustorm_queue_statistics;
 942                 struct ustorm_per_queue_stats *old_uclient =
 943                         &bnx2x_fp_stats(bp, fp)->old_uclient;
 944                 struct xstorm_per_queue_stats *xclient =
 945                         &bp->fw_stats_data->queue_stats[i].
 946                         xstorm_queue_statistics;
 947                 struct xstorm_per_queue_stats *old_xclient =
 948                         &bnx2x_fp_stats(bp, fp)->old_xclient;
 949                 struct bnx2x_eth_q_stats *qstats =
 950                         &bnx2x_fp_stats(bp, fp)->eth_q_stats;
 951                 struct bnx2x_eth_q_stats_old *qstats_old =
 952                         &bnx2x_fp_stats(bp, fp)->eth_q_stats_old;
 953
 954                 u32 diff;
 955
 956                 DP(BNX2X_MSG_STATS, "queue[%d]: ucast_sent 0x%x, bcast_sent 0x%x mcast_sent 0x%x\n",
 957                    i, xclient->ucast_pkts_sent,
 958                    xclient->bcast_pkts_sent, xclient->mcast_pkts_sent);
 959
 960                 DP(BNX2X_MSG_STATS, "---------------\n");
 961
 962                 UPDATE_QSTAT(tclient->rcv_bcast_bytes,
 963                              total_broadcast_bytes_received);
 964                 UPDATE_QSTAT(tclient->rcv_mcast_bytes,
 965                              total_multicast_bytes_received);
 966                 UPDATE_QSTAT(tclient->rcv_ucast_bytes,
 967                              total_unicast_bytes_received);
 968
 969                 /*
 970                  * sum to total_bytes_received all
 971                  * unicast/multicast/broadcast
 972                  */
 973                 qstats->total_bytes_received_hi =
 974                         qstats->total_broadcast_bytes_received_hi;
 975                 qstats->total_bytes_received_lo =
 976                         qstats->total_broadcast_bytes_received_lo;
 977
 978                 ADD_64(qstats->total_bytes_received_hi,
 979                        qstats->total_multicast_bytes_received_hi,
 980                        qstats->total_bytes_received_lo,
 981                        qstats->total_multicast_bytes_received_lo);
 982
 983                 ADD_64(qstats->total_bytes_received_hi,
 984                        qstats->total_unicast_bytes_received_hi,
 985                        qstats->total_bytes_received_lo,
 986                        qstats->total_unicast_bytes_received_lo);
 987
 988                 qstats->valid_bytes_received_hi =
 989                                         qstats->total_bytes_received_hi;
 990                 qstats->valid_bytes_received_lo =
 991                                         qstats->total_bytes_received_lo;
 992
 993                 UPDATE_EXTEND_TSTAT(rcv_ucast_pkts,
 994                                         total_unicast_packets_received);
 995                 UPDATE_EXTEND_TSTAT(rcv_mcast_pkts,
 996                                         total_multicast_packets_received);
 997                 UPDATE_EXTEND_TSTAT(rcv_bcast_pkts,
 998                                         total_broadcast_packets_received);
 999                 UPDATE_EXTEND_E_TSTAT(pkts_too_big_discard,
1000                                       etherstatsoverrsizepkts, 32);
1001                 UPDATE_EXTEND_E_TSTAT(no_buff_discard, no_buff_discard, 16);
1002
1003                 SUB_EXTEND_USTAT(ucast_no_buff_pkts,
1004                                         total_unicast_packets_received);
1005                 SUB_EXTEND_USTAT(mcast_no_buff_pkts,
1006                                         total_multicast_packets_received);
1007                 SUB_EXTEND_USTAT(bcast_no_buff_pkts,
1008                                         total_broadcast_packets_received);
1009                 UPDATE_EXTEND_E_USTAT(ucast_no_buff_pkts, no_buff_discard);
1010                 UPDATE_EXTEND_E_USTAT(mcast_no_buff_pkts, no_buff_discard);
1011                 UPDATE_EXTEND_E_USTAT(bcast_no_buff_pkts, no_buff_discard);
1012
1013                 UPDATE_QSTAT(xclient->bcast_bytes_sent,
1014                              total_broadcast_bytes_transmitted);
1015                 UPDATE_QSTAT(xclient->mcast_bytes_sent,
1016                              total_multicast_bytes_transmitted);
1017                 UPDATE_QSTAT(xclient->ucast_bytes_sent,
1018                              total_unicast_bytes_transmitted);
1019
1020                 /*
1021                  * sum to total_bytes_transmitted all
1022                  * unicast/multicast/broadcast
1023                  */
1024                 qstats->total_bytes_transmitted_hi =
1025                                 qstats->total_unicast_bytes_transmitted_hi;
1026                 qstats->total_bytes_transmitted_lo =
1027                                 qstats->total_unicast_bytes_transmitted_lo;
1028
1029                 ADD_64(qstats->total_bytes_transmitted_hi,
1030                        qstats->total_broadcast_bytes_transmitted_hi,
1031                        qstats->total_bytes_transmitted_lo,
1032                        qstats->total_broadcast_bytes_transmitted_lo);
1033
1034                 ADD_64(qstats->total_bytes_transmitted_hi,
1035                        qstats->total_multicast_bytes_transmitted_hi,
1036                        qstats->total_bytes_transmitted_lo,
1037                        qstats->total_multicast_bytes_transmitted_lo);
1038
1039                 UPDATE_EXTEND_XSTAT(ucast_pkts_sent,
1040                                         total_unicast_packets_transmitted);
1041                 UPDATE_EXTEND_XSTAT(mcast_pkts_sent,
1042                                         total_multicast_packets_transmitted);
1043                 UPDATE_EXTEND_XSTAT(bcast_pkts_sent,
1044                                         total_broadcast_packets_transmitted);
1045
1046                 UPDATE_EXTEND_TSTAT(checksum_discard,
1047                                     total_packets_received_checksum_discarded);
1048                 UPDATE_EXTEND_TSTAT(ttl0_discard,
1049                                     total_packets_received_ttl0_discarded);
1050
1051                 UPDATE_EXTEND_XSTAT(error_drop_pkts,
1052                                     total_transmitted_dropped_packets_error);
1053
1054                 /* TPA aggregations completed */
1055                 UPDATE_EXTEND_E_USTAT(coalesced_events, total_tpa_aggregations);
1056                 /* Number of network frames aggregated by TPA */
1057                 UPDATE_EXTEND_E_USTAT(coalesced_pkts,
1058                                       total_tpa_aggregated_frames);
1059                 /* Total number of bytes in completed TPA aggregations */
1060                 UPDATE_QSTAT(uclient->coalesced_bytes, total_tpa_bytes);
1061
1062                 UPDATE_ESTAT_QSTAT_64(total_tpa_bytes);
1063
1064                 UPDATE_FSTAT_QSTAT(total_bytes_received);
1065                 UPDATE_FSTAT_QSTAT(total_bytes_transmitted);
1066                 UPDATE_FSTAT_QSTAT(total_unicast_packets_received);
1067                 UPDATE_FSTAT_QSTAT(total_multicast_packets_received);
1068                 UPDATE_FSTAT_QSTAT(total_broadcast_packets_received);
1069                 UPDATE_FSTAT_QSTAT(total_unicast_packets_transmitted);
1070                 UPDATE_FSTAT_QSTAT(total_multicast_packets_transmitted);
1071                 UPDATE_FSTAT_QSTAT(total_broadcast_packets_transmitted);
1072                 UPDATE_FSTAT_QSTAT(valid_bytes_received);
1073         }
1074
1075         ADD_64(estats->total_bytes_received_hi,
1076                estats->rx_stat_ifhcinbadoctets_hi,
1077                estats->total_bytes_received_lo,
1078                estats->rx_stat_ifhcinbadoctets_lo);
1079
1080         ADD_64_LE(estats->total_bytes_received_hi,
1081                   tfunc->rcv_error_bytes.hi,
1082                   estats->total_bytes_received_lo,
1083                   tfunc->rcv_error_bytes.lo);
1084
1085         ADD_64_LE(estats->error_bytes_received_hi,
1086                   tfunc->rcv_error_bytes.hi,
1087                   estats->error_bytes_received_lo,
1088                   tfunc->rcv_error_bytes.lo);
1089
1090         UPDATE_ESTAT(etherstatsoverrsizepkts, rx_stat_dot3statsframestoolong);
1091
1092         ADD_64(estats->error_bytes_received_hi,
1093                estats->rx_stat_ifhcinbadoctets_hi,
1094                estats->error_bytes_received_lo,
1095                estats->rx_stat_ifhcinbadoctets_lo);
1096
1097         if (bp->port.pmf) {
1098                 struct bnx2x_fw_port_stats_old *fwstats = &bp->fw_stats_old;
1099                 UPDATE_FW_STAT(mac_filter_discard);
1100                 UPDATE_FW_STAT(mf_tag_discard);
1101                 UPDATE_FW_STAT(brb_truncate_discard);
1102                 UPDATE_FW_STAT(mac_discard);
1103         }
1104
1105         fstats->host_func_stats_start = ++fstats->host_func_stats_end;
1106
1107         bp->stats_pending = 0;
1108
1109         return 0;
1110 }
1111
1112 static void bnx2x_net_stats_update(struct bnx2x *bp)
1113 {
1114         struct bnx2x_eth_stats *estats = &bp->eth_stats;
1115         struct net_device_stats *nstats = &bp->dev->stats;
1116         unsigned long tmp;
1117         int i;
1118
1119         nstats->rx_packets =
1120                 bnx2x_hilo(&estats->total_unicast_packets_received_hi) +
1121                 bnx2x_hilo(&estats->total_multicast_packets_received_hi) +
1122                 bnx2x_hilo(&estats->total_broadcast_packets_received_hi);
1123
1124         nstats->tx_packets =
1125                 bnx2x_hilo(&estats->total_unicast_packets_transmitted_hi) +
1126                 bnx2x_hilo(&estats->total_multicast_packets_transmitted_hi) +
1127                 bnx2x_hilo(&estats->total_broadcast_packets_transmitted_hi);
1128
1129         nstats->rx_bytes = bnx2x_hilo(&estats->total_bytes_received_hi);
1130
1131         nstats->tx_bytes = bnx2x_hilo(&estats->total_bytes_transmitted_hi);
1132
1133         tmp = estats->mac_discard;
1134         for_each_rx_queue(bp, i) {
1135                 struct tstorm_per_queue_stats *old_tclient =
1136                         &bp->fp_stats[i].old_tclient;
1137                 tmp += le32_to_cpu(old_tclient->checksum_discard);
1138         }
1139         nstats->rx_dropped = tmp + bp->net_stats_old.rx_dropped;
1140
1141         nstats->tx_dropped = 0;
1142
1143         nstats->multicast =
1144                 bnx2x_hilo(&estats->total_multicast_packets_received_hi);
1145
1146         nstats->collisions =
1147                 bnx2x_hilo(&estats->tx_stat_etherstatscollisions_hi);
1148
1149         nstats->rx_length_errors =
1150                 bnx2x_hilo(&estats->rx_stat_etherstatsundersizepkts_hi) +
1151                 bnx2x_hilo(&estats->etherstatsoverrsizepkts_hi);
1152         nstats->rx_over_errors = bnx2x_hilo(&estats->brb_drop_hi) +
1153                                  bnx2x_hilo(&estats->brb_truncate_hi);
1154         nstats->rx_crc_errors =
1155                 bnx2x_hilo(&estats->rx_stat_dot3statsfcserrors_hi);
1156         nstats->rx_frame_errors =
1157                 bnx2x_hilo(&estats->rx_stat_dot3statsalignmenterrors_hi);
1158         nstats->rx_fifo_errors = bnx2x_hilo(&estats->no_buff_discard_hi);
1159         nstats->rx_missed_errors = 0;
1160
1161         nstats->rx_errors = nstats->rx_length_errors +
1162                             nstats->rx_over_errors +
1163                             nstats->rx_crc_errors +
1164                             nstats->rx_frame_errors +
1165                             nstats->rx_fifo_errors +
1166                             nstats->rx_missed_errors;
1167
1168         nstats->tx_aborted_errors =
1169                 bnx2x_hilo(&estats->tx_stat_dot3statslatecollisions_hi) +
1170                 bnx2x_hilo(&estats->tx_stat_dot3statsexcessivecollisions_hi);
1171         nstats->tx_carrier_errors =
1172                 bnx2x_hilo(&estats->rx_stat_dot3statscarriersenseerrors_hi);
1173         nstats->tx_fifo_errors = 0;
1174         nstats->tx_heartbeat_errors = 0;
1175         nstats->tx_window_errors = 0;
1176
1177         nstats->tx_errors = nstats->tx_aborted_errors +
1178                             nstats->tx_carrier_errors +
1179             bnx2x_hilo(&estats->tx_stat_dot3statsinternalmactransmiterrors_hi);
1180 }
1181
1182 static void bnx2x_drv_stats_update(struct bnx2x *bp)
1183 {
1184         struct bnx2x_eth_stats *estats = &bp->eth_stats;
1185         int i;
1186
1187         for_each_queue(bp, i) {
1188                 struct bnx2x_eth_q_stats *qstats = &bp->fp_stats[i].eth_q_stats;
1189                 struct bnx2x_eth_q_stats_old *qstats_old =
1190                         &bp->fp_stats[i].eth_q_stats_old;
1191
1192                 UPDATE_ESTAT_QSTAT(driver_xoff);
1193                 UPDATE_ESTAT_QSTAT(rx_err_discard_pkt);
1194                 UPDATE_ESTAT_QSTAT(rx_skb_alloc_failed);
1195                 UPDATE_ESTAT_QSTAT(hw_csum_err);
1196                 UPDATE_ESTAT_QSTAT(driver_filtered_tx_pkt);
1197         }
1198 }
1199
1200 static bool bnx2x_edebug_stats_stopped(struct bnx2x *bp)
1201 {
1202         u32 val;
1203
1204         if (SHMEM2_HAS(bp, edebug_driver_if[1])) {
1205                 val = SHMEM2_RD(bp, edebug_driver_if[1]);
1206
1207                 if (val == EDEBUG_DRIVER_IF_OP_CODE_DISABLE_STAT)
1208                         return true;
1209         }
1210
1211         return false;
1212 }
1213
1214 static void bnx2x_stats_update(struct bnx2x *bp)
1215 {
1216         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
1217
1218         if (bnx2x_edebug_stats_stopped(bp))
1219                 return;
1220
1221         if (IS_PF(bp)) {
1222                 if (*stats_comp != DMAE_COMP_VAL)
1223                         return;
1224
1225                 if (bp->port.pmf)
1226                         bnx2x_hw_stats_update(bp);
1227
1228                 if (bnx2x_storm_stats_update(bp)) {
1229                         if (bp->stats_pending++ == 3) {
1230                                 BNX2X_ERR("storm stats were not updated for 3 times\n");
1231                                 bnx2x_panic();
1232                         }
1233                         return;
1234                 }
1235         } else {
1236                 /* vf doesn't collect HW statistics, and doesn't get completions
1237                  * perform only update
1238                  */
1239                 bnx2x_storm_stats_update(bp);
1240         }
1241
1242         bnx2x_net_stats_update(bp);
1243         bnx2x_drv_stats_update(bp);
1244
1245         /* vf is done */
1246         if (IS_VF(bp))
1247                 return;
1248
1249         if (netif_msg_timer(bp)) {
1250                 struct bnx2x_eth_stats *estats = &bp->eth_stats;
1251
1252                 netdev_dbg(bp->dev, "brb drops %u  brb truncate %u\n",
1253                        estats->brb_drop_lo, estats->brb_truncate_lo);
1254         }
1255
1256         bnx2x_hw_stats_post(bp);
1257         bnx2x_storm_stats_post(bp);
1258 }
1259
1260 static void bnx2x_port_stats_stop(struct bnx2x *bp)
1261 {
1262         struct dmae_command *dmae;
1263         u32 opcode;
1264         int loader_idx = PMF_DMAE_C(bp);
1265         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
1266
1267         bp->executer_idx = 0;
1268
1269         opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_PCI, DMAE_DST_GRC, false, 0);
1270
1271         if (bp->port.port_stx) {
1272
1273                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
1274                 if (bp->func_stx)
1275                         dmae->opcode = bnx2x_dmae_opcode_add_comp(
1276                                                 opcode, DMAE_COMP_GRC);
1277                 else
1278                         dmae->opcode = bnx2x_dmae_opcode_add_comp(
1279                                                 opcode, DMAE_COMP_PCI);
1280
1281                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
1282                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
1283                 dmae->dst_addr_lo = bp->port.port_stx >> 2;
1284                 dmae->dst_addr_hi = 0;
1285                 dmae->len = bnx2x_get_port_stats_dma_len(bp);
1286                 if (bp->func_stx) {
1287                         dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
1288                         dmae->comp_addr_hi = 0;
1289                         dmae->comp_val = 1;
1290                 } else {
1291                         dmae->comp_addr_lo =
1292                                 U64_LO(bnx2x_sp_mapping(bp, stats_comp));
1293                         dmae->comp_addr_hi =
1294                                 U64_HI(bnx2x_sp_mapping(bp, stats_comp));
1295                         dmae->comp_val = DMAE_COMP_VAL;
1296
1297                         *stats_comp = 0;
1298                 }
1299         }
1300
1301         if (bp->func_stx) {
1302
1303                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
1304                 dmae->opcode =
1305                         bnx2x_dmae_opcode_add_comp(opcode, DMAE_COMP_PCI);
1306                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
1307                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
1308                 dmae->dst_addr_lo = bp->func_stx >> 2;
1309                 dmae->dst_addr_hi = 0;
1310                 dmae->len = sizeof(struct host_func_stats) >> 2;
1311                 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
1312                 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
1313                 dmae->comp_val = DMAE_COMP_VAL;
1314
1315                 *stats_comp = 0;
1316         }
1317 }
1318
1319 static void bnx2x_stats_stop(struct bnx2x *bp)
1320 {
1321         bool update = false;
1322
1323         bnx2x_stats_comp(bp);
1324
1325         if (bp->port.pmf)
1326                 update = (bnx2x_hw_stats_update(bp) == 0);
1327
1328         update |= (bnx2x_storm_stats_update(bp) == 0);
1329
1330         if (update) {
1331                 bnx2x_net_stats_update(bp);
1332
1333                 if (bp->port.pmf)
1334                         bnx2x_port_stats_stop(bp);
1335
1336                 bnx2x_hw_stats_post(bp);
1337                 bnx2x_stats_comp(bp);
1338         }
1339 }
1340
1341 static void bnx2x_stats_do_nothing(struct bnx2x *bp)
1342 {
1343 }
1344
1345 static const struct {
1346         void (*action)(struct bnx2x *bp);
1347         enum bnx2x_stats_state next_state;
1348 } bnx2x_stats_stm[STATS_STATE_MAX][STATS_EVENT_MAX] = {
1349 /* state        event   */
1350 {
1351 /* DISABLED     PMF     */ {bnx2x_stats_pmf_update, STATS_STATE_DISABLED},
1352 /*              LINK_UP */ {bnx2x_stats_start,      STATS_STATE_ENABLED},
1353 /*              UPDATE  */ {bnx2x_stats_do_nothing, STATS_STATE_DISABLED},
1354 /*              STOP    */ {bnx2x_stats_do_nothing, STATS_STATE_DISABLED}
1355 },
1356 {
1357 /* ENABLED      PMF     */ {bnx2x_stats_pmf_start,  STATS_STATE_ENABLED},
1358 /*              LINK_UP */ {bnx2x_stats_restart,    STATS_STATE_ENABLED},
1359 /*              UPDATE  */ {bnx2x_stats_update,     STATS_STATE_ENABLED},
1360 /*              STOP    */ {bnx2x_stats_stop,       STATS_STATE_DISABLED}
1361 }
1362 };
1363
1364 void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event)
1365 {
1366         enum bnx2x_stats_state state = bp->stats_state;
1367
1368         if (unlikely(bp->panic))
1369                 return;
1370
1371         /* Statistics update run from timer context, and we don't want to stop
1372          * that context in case someone is in the middle of a transition.
1373          * For other events, wait a bit until lock is taken.
1374          */
1375         if (down_trylock(&bp->stats_lock)) {
1376                 if (event == STATS_EVENT_UPDATE)
1377                         return;
1378
1379                 DP(BNX2X_MSG_STATS,
1380                    "Unlikely stats' lock contention [event %d]\n", event);
1381                 if (unlikely(down_timeout(&bp->stats_lock, HZ / 10))) {
1382                         BNX2X_ERR("Failed to take stats lock [event %d]\n",
1383                                   event);
1384                         return;
1385                 }
1386         }
1387
1388         bnx2x_stats_stm[state][event].action(bp);
1389         bp->stats_state = bnx2x_stats_stm[state][event].next_state;
1390
1391         up(&bp->stats_lock);
1392
1393         if ((event != STATS_EVENT_UPDATE) || netif_msg_timer(bp))
1394                 DP(BNX2X_MSG_STATS, "state %d -> event %d -> state %d\n",
1395                    state, event, bp->stats_state);
1396 }
1397
1398 static void bnx2x_port_stats_base_init(struct bnx2x *bp)
1399 {
1400         struct dmae_command *dmae;
1401         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
1402
1403         /* sanity */
1404         if (!bp->port.pmf || !bp->port.port_stx) {
1405                 BNX2X_ERR("BUG!\n");
1406                 return;
1407         }
1408
1409         bp->executer_idx = 0;
1410
1411         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
1412         dmae->opcode = bnx2x_dmae_opcode(bp, DMAE_SRC_PCI, DMAE_DST_GRC,
1413                                          true, DMAE_COMP_PCI);
1414         dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
1415         dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
1416         dmae->dst_addr_lo = bp->port.port_stx >> 2;
1417         dmae->dst_addr_hi = 0;
1418         dmae->len = bnx2x_get_port_stats_dma_len(bp);
1419         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
1420         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
1421         dmae->comp_val = DMAE_COMP_VAL;
1422
1423         *stats_comp = 0;
1424         bnx2x_hw_stats_post(bp);
1425         bnx2x_stats_comp(bp);
1426 }
1427
1428 /* This function will prepare the statistics ramrod data the way
1429  * we will only have to increment the statistics counter and
1430  * send the ramrod each time we have to.
1431  */
1432 static void bnx2x_prep_fw_stats_req(struct bnx2x *bp)
1433 {
1434         int i;
1435         int first_queue_query_index;
1436         struct stats_query_header *stats_hdr = &bp->fw_stats_req->hdr;
1437
1438         dma_addr_t cur_data_offset;
1439         struct stats_query_entry *cur_query_entry;
1440
1441         stats_hdr->cmd_num = bp->fw_stats_num;
1442         stats_hdr->drv_stats_counter = 0;
1443
1444         /* storm_counters struct contains the counters of completed
1445          * statistics requests per storm which are incremented by FW
1446          * each time it completes hadning a statistics ramrod. We will
1447          * check these counters in the timer handler and discard a
1448          * (statistics) ramrod completion.
1449          */
1450         cur_data_offset = bp->fw_stats_data_mapping +
1451                 offsetof(struct bnx2x_fw_stats_data, storm_counters);
1452
1453         stats_hdr->stats_counters_addrs.hi =
1454                 cpu_to_le32(U64_HI(cur_data_offset));
1455         stats_hdr->stats_counters_addrs.lo =
1456                 cpu_to_le32(U64_LO(cur_data_offset));
1457
1458         /* prepare to the first stats ramrod (will be completed with
1459          * the counters equal to zero) - init counters to somethig different.
1460          */
1461         memset(&bp->fw_stats_data->storm_counters, 0xff,
1462                sizeof(struct stats_counter));
1463
1464         /**** Port FW statistics data ****/
1465         cur_data_offset = bp->fw_stats_data_mapping +
1466                 offsetof(struct bnx2x_fw_stats_data, port);
1467
1468         cur_query_entry = &bp->fw_stats_req->query[BNX2X_PORT_QUERY_IDX];
1469
1470         cur_query_entry->kind = STATS_TYPE_PORT;
1471         /* For port query index is a DONT CARE */
1472         cur_query_entry->index = BP_PORT(bp);
1473         /* For port query funcID is a DONT CARE */
1474         cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
1475         cur_query_entry->address.hi = cpu_to_le32(U64_HI(cur_data_offset));
1476         cur_query_entry->address.lo = cpu_to_le32(U64_LO(cur_data_offset));
1477
1478         /**** PF FW statistics data ****/
1479         cur_data_offset = bp->fw_stats_data_mapping +
1480                 offsetof(struct bnx2x_fw_stats_data, pf);
1481
1482         cur_query_entry = &bp->fw_stats_req->query[BNX2X_PF_QUERY_IDX];
1483
1484         cur_query_entry->kind = STATS_TYPE_PF;
1485         /* For PF query index is a DONT CARE */
1486         cur_query_entry->index = BP_PORT(bp);
1487         cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
1488         cur_query_entry->address.hi = cpu_to_le32(U64_HI(cur_data_offset));
1489         cur_query_entry->address.lo = cpu_to_le32(U64_LO(cur_data_offset));
1490
1491         /**** FCoE FW statistics data ****/
1492         if (!NO_FCOE(bp)) {
1493                 cur_data_offset = bp->fw_stats_data_mapping +
1494                         offsetof(struct bnx2x_fw_stats_data, fcoe);
1495
1496                 cur_query_entry =
1497                         &bp->fw_stats_req->query[BNX2X_FCOE_QUERY_IDX];
1498
1499                 cur_query_entry->kind = STATS_TYPE_FCOE;
1500                 /* For FCoE query index is a DONT CARE */
1501                 cur_query_entry->index = BP_PORT(bp);
1502                 cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
1503                 cur_query_entry->address.hi =
1504                         cpu_to_le32(U64_HI(cur_data_offset));
1505                 cur_query_entry->address.lo =
1506                         cpu_to_le32(U64_LO(cur_data_offset));
1507         }
1508
1509         /**** Clients' queries ****/
1510         cur_data_offset = bp->fw_stats_data_mapping +
1511                 offsetof(struct bnx2x_fw_stats_data, queue_stats);
1512
1513         /* first queue query index depends whether FCoE offloaded request will
1514          * be included in the ramrod
1515          */
1516         if (!NO_FCOE(bp))
1517                 first_queue_query_index = BNX2X_FIRST_QUEUE_QUERY_IDX;
1518         else
1519                 first_queue_query_index = BNX2X_FIRST_QUEUE_QUERY_IDX - 1;
1520
1521         for_each_eth_queue(bp, i) {
1522                 cur_query_entry =
1523                         &bp->fw_stats_req->
1524                                         query[first_queue_query_index + i];
1525
1526                 cur_query_entry->kind = STATS_TYPE_QUEUE;
1527                 cur_query_entry->index = bnx2x_stats_id(&bp->fp[i]);
1528                 cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
1529                 cur_query_entry->address.hi =
1530                         cpu_to_le32(U64_HI(cur_data_offset));
1531                 cur_query_entry->address.lo =
1532                         cpu_to_le32(U64_LO(cur_data_offset));
1533
1534                 cur_data_offset += sizeof(struct per_queue_stats);
1535         }
1536
1537         /* add FCoE queue query if needed */
1538         if (!NO_FCOE(bp)) {
1539                 cur_query_entry =
1540                         &bp->fw_stats_req->
1541                                         query[first_queue_query_index + i];
1542
1543                 cur_query_entry->kind = STATS_TYPE_QUEUE;
1544                 cur_query_entry->index = bnx2x_stats_id(&bp->fp[FCOE_IDX(bp)]);
1545                 cur_query_entry->funcID = cpu_to_le16(BP_FUNC(bp));
1546                 cur_query_entry->address.hi =
1547                         cpu_to_le32(U64_HI(cur_data_offset));
1548                 cur_query_entry->address.lo =
1549                         cpu_to_le32(U64_LO(cur_data_offset));
1550         }
1551 }
1552
1553 void bnx2x_memset_stats(struct bnx2x *bp)
1554 {
1555         int i;
1556
1557         /* function stats */
1558         for_each_queue(bp, i) {
1559                 struct bnx2x_fp_stats *fp_stats = &bp->fp_stats[i];
1560
1561                 memset(&fp_stats->old_tclient, 0,
1562                        sizeof(fp_stats->old_tclient));
1563                 memset(&fp_stats->old_uclient, 0,
1564                        sizeof(fp_stats->old_uclient));
1565                 memset(&fp_stats->old_xclient, 0,
1566                        sizeof(fp_stats->old_xclient));
1567                 if (bp->stats_init) {
1568                         memset(&fp_stats->eth_q_stats, 0,
1569                                sizeof(fp_stats->eth_q_stats));
1570                         memset(&fp_stats->eth_q_stats_old, 0,
1571                                sizeof(fp_stats->eth_q_stats_old));
1572                 }
1573         }
1574
1575         memset(&bp->dev->stats, 0, sizeof(bp->dev->stats));
1576
1577         if (bp->stats_init) {
1578                 memset(&bp->net_stats_old, 0, sizeof(bp->net_stats_old));
1579                 memset(&bp->fw_stats_old, 0, sizeof(bp->fw_stats_old));
1580                 memset(&bp->eth_stats_old, 0, sizeof(bp->eth_stats_old));
1581                 memset(&bp->eth_stats, 0, sizeof(bp->eth_stats));
1582                 memset(&bp->func_stats, 0, sizeof(bp->func_stats));
1583         }
1584
1585         bp->stats_state = STATS_STATE_DISABLED;
1586
1587         if (bp->port.pmf && bp->port.port_stx)
1588                 bnx2x_port_stats_base_init(bp);
1589
1590         /* mark the end of statistics initialization */
1591         bp->stats_init = false;
1592 }
1593
1594 void bnx2x_stats_init(struct bnx2x *bp)
1595 {
1596         int /*abs*/port = BP_PORT(bp);
1597         int mb_idx = BP_FW_MB_IDX(bp);
1598
1599         if (IS_VF(bp)) {
1600                 bnx2x_memset_stats(bp);
1601                 return;
1602         }
1603
1604         bp->stats_pending = 0;
1605         bp->executer_idx = 0;
1606         bp->stats_counter = 0;
1607
1608         /* port and func stats for management */
1609         if (!BP_NOMCP(bp)) {
1610                 bp->port.port_stx = SHMEM_RD(bp, port_mb[port].port_stx);
1611                 bp->func_stx = SHMEM_RD(bp, func_mb[mb_idx].fw_mb_param);
1612
1613         } else {
1614                 bp->port.port_stx = 0;
1615                 bp->func_stx = 0;
1616         }
1617         DP(BNX2X_MSG_STATS, "port_stx 0x%x  func_stx 0x%x\n",
1618            bp->port.port_stx, bp->func_stx);
1619
1620         /* pmf should retrieve port statistics from SP on a non-init*/
1621         if (!bp->stats_init && bp->port.pmf && bp->port.port_stx)
1622                 bnx2x_stats_handle(bp, STATS_EVENT_PMF);
1623
1624         port = BP_PORT(bp);
1625         /* port stats */
1626         memset(&(bp->port.old_nig_stats), 0, sizeof(struct nig_stats));
1627         bp->port.old_nig_stats.brb_discard =
1628                         REG_RD(bp, NIG_REG_STAT0_BRB_DISCARD + port*0x38);
1629         bp->port.old_nig_stats.brb_truncate =
1630                         REG_RD(bp, NIG_REG_STAT0_BRB_TRUNCATE + port*0x38);
1631         if (!CHIP_IS_E3(bp)) {
1632                 REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT0 + port*0x50,
1633                             &(bp->port.old_nig_stats.egress_mac_pkt0_lo), 2);
1634                 REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT1 + port*0x50,
1635                             &(bp->port.old_nig_stats.egress_mac_pkt1_lo), 2);
1636         }
1637
1638         /* Prepare statistics ramrod data */
1639         bnx2x_prep_fw_stats_req(bp);
1640
1641         /* Clean SP from previous statistics */
1642         if (bp->stats_init) {
1643                 if (bp->func_stx) {
1644                         memset(bnx2x_sp(bp, func_stats), 0,
1645                                sizeof(struct host_func_stats));
1646                         bnx2x_func_stats_init(bp);
1647                         bnx2x_hw_stats_post(bp);
1648                         bnx2x_stats_comp(bp);
1649                 }
1650         }
1651
1652         bnx2x_memset_stats(bp);
1653 }
1654
1655 void bnx2x_save_statistics(struct bnx2x *bp)
1656 {
1657         int i;
1658         struct net_device_stats *nstats = &bp->dev->stats;
1659
1660         /* save queue statistics */
1661         for_each_eth_queue(bp, i) {
1662                 struct bnx2x_fastpath *fp = &bp->fp[i];
1663                 struct bnx2x_eth_q_stats *qstats =
1664                         &bnx2x_fp_stats(bp, fp)->eth_q_stats;
1665                 struct bnx2x_eth_q_stats_old *qstats_old =
1666                         &bnx2x_fp_stats(bp, fp)->eth_q_stats_old;
1667
1668                 UPDATE_QSTAT_OLD(total_unicast_bytes_received_hi);
1669                 UPDATE_QSTAT_OLD(total_unicast_bytes_received_lo);
1670                 UPDATE_QSTAT_OLD(total_broadcast_bytes_received_hi);
1671                 UPDATE_QSTAT_OLD(total_broadcast_bytes_received_lo);
1672                 UPDATE_QSTAT_OLD(total_multicast_bytes_received_hi);
1673                 UPDATE_QSTAT_OLD(total_multicast_bytes_received_lo);
1674                 UPDATE_QSTAT_OLD(total_unicast_bytes_transmitted_hi);
1675                 UPDATE_QSTAT_OLD(total_unicast_bytes_transmitted_lo);
1676                 UPDATE_QSTAT_OLD(total_broadcast_bytes_transmitted_hi);
1677                 UPDATE_QSTAT_OLD(total_broadcast_bytes_transmitted_lo);
1678                 UPDATE_QSTAT_OLD(total_multicast_bytes_transmitted_hi);
1679                 UPDATE_QSTAT_OLD(total_multicast_bytes_transmitted_lo);
1680                 UPDATE_QSTAT_OLD(total_tpa_bytes_hi);
1681                 UPDATE_QSTAT_OLD(total_tpa_bytes_lo);
1682         }
1683
1684         /* save net_device_stats statistics */
1685         bp->net_stats_old.rx_dropped = nstats->rx_dropped;
1686
1687         /* store port firmware statistics */
1688         if (bp->port.pmf && IS_MF(bp)) {
1689                 struct bnx2x_eth_stats *estats = &bp->eth_stats;
1690                 struct bnx2x_fw_port_stats_old *fwstats = &bp->fw_stats_old;
1691                 UPDATE_FW_STAT_OLD(mac_filter_discard);
1692                 UPDATE_FW_STAT_OLD(mf_tag_discard);
1693                 UPDATE_FW_STAT_OLD(brb_truncate_discard);
1694                 UPDATE_FW_STAT_OLD(mac_discard);
1695         }
1696 }
1697
1698 void bnx2x_afex_collect_stats(struct bnx2x *bp, void *void_afex_stats,
1699                               u32 stats_type)
1700 {
1701         int i;
1702         struct afex_stats *afex_stats = (struct afex_stats *)void_afex_stats;
1703         struct bnx2x_eth_stats *estats = &bp->eth_stats;
1704         struct per_queue_stats *fcoe_q_stats =
1705                 &bp->fw_stats_data->queue_stats[FCOE_IDX(bp)];
1706
1707         struct tstorm_per_queue_stats *fcoe_q_tstorm_stats =
1708                 &fcoe_q_stats->tstorm_queue_statistics;
1709
1710         struct ustorm_per_queue_stats *fcoe_q_ustorm_stats =
1711                 &fcoe_q_stats->ustorm_queue_statistics;
1712
1713         struct xstorm_per_queue_stats *fcoe_q_xstorm_stats =
1714                 &fcoe_q_stats->xstorm_queue_statistics;
1715
1716         struct fcoe_statistics_params *fw_fcoe_stat =
1717                 &bp->fw_stats_data->fcoe;
1718
1719         memset(afex_stats, 0, sizeof(struct afex_stats));
1720
1721         for_each_eth_queue(bp, i) {
1722                 struct bnx2x_eth_q_stats *qstats = &bp->fp_stats[i].eth_q_stats;
1723
1724                 ADD_64(afex_stats->rx_unicast_bytes_hi,
1725                        qstats->total_unicast_bytes_received_hi,
1726                        afex_stats->rx_unicast_bytes_lo,
1727                        qstats->total_unicast_bytes_received_lo);
1728
1729                 ADD_64(afex_stats->rx_broadcast_bytes_hi,
1730                        qstats->total_broadcast_bytes_received_hi,
1731                        afex_stats->rx_broadcast_bytes_lo,
1732                        qstats->total_broadcast_bytes_received_lo);
1733
1734                 ADD_64(afex_stats->rx_multicast_bytes_hi,
1735                        qstats->total_multicast_bytes_received_hi,
1736                        afex_stats->rx_multicast_bytes_lo,
1737                        qstats->total_multicast_bytes_received_lo);
1738
1739                 ADD_64(afex_stats->rx_unicast_frames_hi,
1740                        qstats->total_unicast_packets_received_hi,
1741                        afex_stats->rx_unicast_frames_lo,
1742                        qstats->total_unicast_packets_received_lo);
1743
1744                 ADD_64(afex_stats->rx_broadcast_frames_hi,
1745                        qstats->total_broadcast_packets_received_hi,
1746                        afex_stats->rx_broadcast_frames_lo,
1747                        qstats->total_broadcast_packets_received_lo);
1748
1749                 ADD_64(afex_stats->rx_multicast_frames_hi,
1750                        qstats->total_multicast_packets_received_hi,
1751                        afex_stats->rx_multicast_frames_lo,
1752                        qstats->total_multicast_packets_received_lo);
1753
1754                 /* sum to rx_frames_discarded all discraded
1755                  * packets due to size, ttl0 and checksum
1756                  */
1757                 ADD_64(afex_stats->rx_frames_discarded_hi,
1758                        qstats->total_packets_received_checksum_discarded_hi,
1759                        afex_stats->rx_frames_discarded_lo,
1760                        qstats->total_packets_received_checksum_discarded_lo);
1761
1762                 ADD_64(afex_stats->rx_frames_discarded_hi,
1763                        qstats->total_packets_received_ttl0_discarded_hi,
1764                        afex_stats->rx_frames_discarded_lo,
1765                        qstats->total_packets_received_ttl0_discarded_lo);
1766
1767                 ADD_64(afex_stats->rx_frames_discarded_hi,
1768                        qstats->etherstatsoverrsizepkts_hi,
1769                        afex_stats->rx_frames_discarded_lo,
1770                        qstats->etherstatsoverrsizepkts_lo);
1771
1772                 ADD_64(afex_stats->rx_frames_dropped_hi,
1773                        qstats->no_buff_discard_hi,
1774                        afex_stats->rx_frames_dropped_lo,
1775                        qstats->no_buff_discard_lo);
1776
1777                 ADD_64(afex_stats->tx_unicast_bytes_hi,
1778                        qstats->total_unicast_bytes_transmitted_hi,
1779                        afex_stats->tx_unicast_bytes_lo,
1780                        qstats->total_unicast_bytes_transmitted_lo);
1781
1782                 ADD_64(afex_stats->tx_broadcast_bytes_hi,
1783                        qstats->total_broadcast_bytes_transmitted_hi,
1784                        afex_stats->tx_broadcast_bytes_lo,
1785                        qstats->total_broadcast_bytes_transmitted_lo);
1786
1787                 ADD_64(afex_stats->tx_multicast_bytes_hi,
1788                        qstats->total_multicast_bytes_transmitted_hi,
1789                        afex_stats->tx_multicast_bytes_lo,
1790                        qstats->total_multicast_bytes_transmitted_lo);
1791
1792                 ADD_64(afex_stats->tx_unicast_frames_hi,
1793                        qstats->total_unicast_packets_transmitted_hi,
1794                        afex_stats->tx_unicast_frames_lo,
1795                        qstats->total_unicast_packets_transmitted_lo);
1796
1797                 ADD_64(afex_stats->tx_broadcast_frames_hi,
1798                        qstats->total_broadcast_packets_transmitted_hi,
1799                        afex_stats->tx_broadcast_frames_lo,
1800                        qstats->total_broadcast_packets_transmitted_lo);
1801
1802                 ADD_64(afex_stats->tx_multicast_frames_hi,
1803                        qstats->total_multicast_packets_transmitted_hi,
1804                        afex_stats->tx_multicast_frames_lo,
1805                        qstats->total_multicast_packets_transmitted_lo);
1806
1807                 ADD_64(afex_stats->tx_frames_dropped_hi,
1808                        qstats->total_transmitted_dropped_packets_error_hi,
1809                        afex_stats->tx_frames_dropped_lo,
1810                        qstats->total_transmitted_dropped_packets_error_lo);
1811         }
1812
1813         /* now add FCoE statistics which are collected separately
1814          * (both offloaded and non offloaded)
1815          */
1816         if (!NO_FCOE(bp)) {
1817                 ADD_64_LE(afex_stats->rx_unicast_bytes_hi,
1818                           LE32_0,
1819                           afex_stats->rx_unicast_bytes_lo,
1820                           fw_fcoe_stat->rx_stat0.fcoe_rx_byte_cnt);
1821
1822                 ADD_64_LE(afex_stats->rx_unicast_bytes_hi,
1823                           fcoe_q_tstorm_stats->rcv_ucast_bytes.hi,
1824                           afex_stats->rx_unicast_bytes_lo,
1825                           fcoe_q_tstorm_stats->rcv_ucast_bytes.lo);
1826
1827                 ADD_64_LE(afex_stats->rx_broadcast_bytes_hi,
1828                           fcoe_q_tstorm_stats->rcv_bcast_bytes.hi,
1829                           afex_stats->rx_broadcast_bytes_lo,
1830                           fcoe_q_tstorm_stats->rcv_bcast_bytes.lo);
1831
1832                 ADD_64_LE(afex_stats->rx_multicast_bytes_hi,
1833                           fcoe_q_tstorm_stats->rcv_mcast_bytes.hi,
1834                           afex_stats->rx_multicast_bytes_lo,
1835                           fcoe_q_tstorm_stats->rcv_mcast_bytes.lo);
1836
1837                 ADD_64_LE(afex_stats->rx_unicast_frames_hi,
1838                           LE32_0,
1839                           afex_stats->rx_unicast_frames_lo,
1840                           fw_fcoe_stat->rx_stat0.fcoe_rx_pkt_cnt);
1841
1842                 ADD_64_LE(afex_stats->rx_unicast_frames_hi,
1843                           LE32_0,
1844                           afex_stats->rx_unicast_frames_lo,
1845                           fcoe_q_tstorm_stats->rcv_ucast_pkts);
1846
1847                 ADD_64_LE(afex_stats->rx_broadcast_frames_hi,
1848                           LE32_0,
1849                           afex_stats->rx_broadcast_frames_lo,
1850                           fcoe_q_tstorm_stats->rcv_bcast_pkts);
1851
1852                 ADD_64_LE(afex_stats->rx_multicast_frames_hi,
1853                           LE32_0,
1854                           afex_stats->rx_multicast_frames_lo,
1855                           fcoe_q_tstorm_stats->rcv_ucast_pkts);
1856
1857                 ADD_64_LE(afex_stats->rx_frames_discarded_hi,
1858                           LE32_0,
1859                           afex_stats->rx_frames_discarded_lo,
1860                           fcoe_q_tstorm_stats->checksum_discard);
1861
1862                 ADD_64_LE(afex_stats->rx_frames_discarded_hi,
1863                           LE32_0,
1864                           afex_stats->rx_frames_discarded_lo,
1865                           fcoe_q_tstorm_stats->pkts_too_big_discard);
1866
1867                 ADD_64_LE(afex_stats->rx_frames_discarded_hi,
1868                           LE32_0,
1869                           afex_stats->rx_frames_discarded_lo,
1870                           fcoe_q_tstorm_stats->ttl0_discard);
1871
1872                 ADD_64_LE16(afex_stats->rx_frames_dropped_hi,
1873                             LE16_0,
1874                             afex_stats->rx_frames_dropped_lo,
1875                             fcoe_q_tstorm_stats->no_buff_discard);
1876
1877                 ADD_64_LE(afex_stats->rx_frames_dropped_hi,
1878                           LE32_0,
1879                           afex_stats->rx_frames_dropped_lo,
1880                           fcoe_q_ustorm_stats->ucast_no_buff_pkts);
1881
1882                 ADD_64_LE(afex_stats->rx_frames_dropped_hi,
1883                           LE32_0,
1884                           afex_stats->rx_frames_dropped_lo,
1885                           fcoe_q_ustorm_stats->mcast_no_buff_pkts);
1886
1887                 ADD_64_LE(afex_stats->rx_frames_dropped_hi,
1888                           LE32_0,
1889                           afex_stats->rx_frames_dropped_lo,
1890                           fcoe_q_ustorm_stats->bcast_no_buff_pkts);
1891
1892                 ADD_64_LE(afex_stats->rx_frames_dropped_hi,
1893                           LE32_0,
1894                           afex_stats->rx_frames_dropped_lo,
1895                           fw_fcoe_stat->rx_stat1.fcoe_rx_drop_pkt_cnt);
1896
1897                 ADD_64_LE(afex_stats->rx_frames_dropped_hi,
1898                           LE32_0,
1899                           afex_stats->rx_frames_dropped_lo,
1900                           fw_fcoe_stat->rx_stat2.fcoe_rx_drop_pkt_cnt);
1901
1902                 ADD_64_LE(afex_stats->tx_unicast_bytes_hi,
1903                           LE32_0,
1904                           afex_stats->tx_unicast_bytes_lo,
1905                           fw_fcoe_stat->tx_stat.fcoe_tx_byte_cnt);
1906
1907                 ADD_64_LE(afex_stats->tx_unicast_bytes_hi,
1908                           fcoe_q_xstorm_stats->ucast_bytes_sent.hi,
1909                           afex_stats->tx_unicast_bytes_lo,
1910                           fcoe_q_xstorm_stats->ucast_bytes_sent.lo);
1911
1912                 ADD_64_LE(afex_stats->tx_broadcast_bytes_hi,
1913                           fcoe_q_xstorm_stats->bcast_bytes_sent.hi,
1914                           afex_stats->tx_broadcast_bytes_lo,
1915                           fcoe_q_xstorm_stats->bcast_bytes_sent.lo);
1916
1917                 ADD_64_LE(afex_stats->tx_multicast_bytes_hi,
1918                           fcoe_q_xstorm_stats->mcast_bytes_sent.hi,
1919                           afex_stats->tx_multicast_bytes_lo,
1920                           fcoe_q_xstorm_stats->mcast_bytes_sent.lo);
1921
1922                 ADD_64_LE(afex_stats->tx_unicast_frames_hi,
1923                           LE32_0,
1924                           afex_stats->tx_unicast_frames_lo,
1925                           fw_fcoe_stat->tx_stat.fcoe_tx_pkt_cnt);
1926
1927                 ADD_64_LE(afex_stats->tx_unicast_frames_hi,
1928                           LE32_0,
1929                           afex_stats->tx_unicast_frames_lo,
1930                           fcoe_q_xstorm_stats->ucast_pkts_sent);
1931
1932                 ADD_64_LE(afex_stats->tx_broadcast_frames_hi,
1933                           LE32_0,
1934                           afex_stats->tx_broadcast_frames_lo,
1935                           fcoe_q_xstorm_stats->bcast_pkts_sent);
1936
1937                 ADD_64_LE(afex_stats->tx_multicast_frames_hi,
1938                           LE32_0,
1939                           afex_stats->tx_multicast_frames_lo,
1940                           fcoe_q_xstorm_stats->mcast_pkts_sent);
1941
1942                 ADD_64_LE(afex_stats->tx_frames_dropped_hi,
1943                           LE32_0,
1944                           afex_stats->tx_frames_dropped_lo,
1945                           fcoe_q_xstorm_stats->error_drop_pkts);
1946         }
1947
1948         /* if port stats are requested, add them to the PMF
1949          * stats, as anyway they will be accumulated by the
1950          * MCP before sent to the switch
1951          */
1952         if ((bp->port.pmf) && (stats_type == VICSTATST_UIF_INDEX)) {
1953                 ADD_64(afex_stats->rx_frames_dropped_hi,
1954                        0,
1955                        afex_stats->rx_frames_dropped_lo,
1956                        estats->mac_filter_discard);
1957                 ADD_64(afex_stats->rx_frames_dropped_hi,
1958                        0,
1959                        afex_stats->rx_frames_dropped_lo,
1960                        estats->brb_truncate_discard);
1961                 ADD_64(afex_stats->rx_frames_discarded_hi,
1962                        0,
1963                        afex_stats->rx_frames_discarded_lo,
1964                        estats->mac_discard);
1965         }
1966 }
1967
1968 int bnx2x_stats_safe_exec(struct bnx2x *bp,
1969                           void (func_to_exec)(void *cookie),
1970                           void *cookie)
1971 {
1972         int cnt = 10, rc = 0;
1973
1974         /* Wait for statistics to end [while blocking further requests],
1975          * then run supplied function 'safely'.
1976          */
1977         rc = down_timeout(&bp->stats_lock, HZ / 10);
1978         if (unlikely(rc)) {
1979                 BNX2X_ERR("Failed to take statistics lock for safe execution\n");
1980                 goto out_no_lock;
1981         }
1982
1983         bnx2x_stats_comp(bp);
1984         while (bp->stats_pending && cnt--)
1985                 if (bnx2x_storm_stats_update(bp))
1986                         usleep_range(1000, 2000);
1987         if (bp->stats_pending) {
1988                 BNX2X_ERR("Failed to wait for stats pending to clear [possibly FW is stuck]\n");
1989                 rc = -EBUSY;
1990                 goto out;
1991         }
1992
1993         func_to_exec(cookie);
1994
1995 out:
1996         /* No need to restart statistics - if they're enabled, the timer
1997          * will restart the statistics.
1998          */
1999         up(&bp->stats_lock);
2000 out_no_lock:
2001         return rc;
2002 }