drivers/net/bnx2x_main.c

   1 /* bnx2x_main.c: Broadcom Everest network driver.
   2  *
   3  * Copyright (c) 2007-2009 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: Eilon Greenstein <eilong@broadcom.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 rework by Vladislav Zolotarov
  14  * Statistics and Link management by Yitchak Gertner
  15  *
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/moduleparam.h>
  20 #include <linux/kernel.h>
  21 #include <linux/device.h>  /* for dev_info() */
  22 #include <linux/timer.h>
  23 #include <linux/errno.h>
  24 #include <linux/ioport.h>
  25 #include <linux/slab.h>
  26 #include <linux/vmalloc.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/pci.h>
  29 #include <linux/init.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/etherdevice.h>
  32 #include <linux/skbuff.h>
  33 #include <linux/dma-mapping.h>
  34 #include <linux/bitops.h>
  35 #include <linux/irq.h>
  36 #include <linux/delay.h>
  37 #include <asm/byteorder.h>
  38 #include <linux/time.h>
  39 #include <linux/ethtool.h>
  40 #include <linux/mii.h>
  41 #include <linux/if_vlan.h>
  42 #include <net/ip.h>
  43 #include <net/tcp.h>
  44 #include <net/checksum.h>
  45 #include <net/ip6_checksum.h>
  46 #include <linux/workqueue.h>
  47 #include <linux/crc32.h>
  48 #include <linux/crc32c.h>
  49 #include <linux/prefetch.h>
  50 #include <linux/zlib.h>
  51 #include <linux/io.h>
  52
  53
  54 #include "bnx2x.h"
  55 #include "bnx2x_init.h"
  56 #include "bnx2x_dump.h"
  57
  58 #define DRV_MODULE_VERSION      "1.48.105"
  59 #define DRV_MODULE_RELDATE      "2009/03/02"
  60 #define BNX2X_BC_VER            0x040200
  61
  62 /* Time in jiffies before concluding the transmitter is hung */
  63 #define TX_TIMEOUT              (5*HZ)
  64
  65 static char version[] __devinitdata =
  66         "Broadcom NetXtreme II 5771x 10Gigabit Ethernet Driver "
  67         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  68
  69 MODULE_AUTHOR("Eliezer Tamir");
  70 MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710/57711/57711E Driver");
  71 MODULE_LICENSE("GPL");
  72 MODULE_VERSION(DRV_MODULE_VERSION);
  73
  74 static int multi_mode = 1;
  75 module_param(multi_mode, int, 0);
  76 MODULE_PARM_DESC(multi_mode, " Use per-CPU queues");
  77
  78 static int disable_tpa;
  79 module_param(disable_tpa, int, 0);
  80 MODULE_PARM_DESC(disable_tpa, " Disable the TPA (LRO) feature");
  81
  82 static int int_mode;
  83 module_param(int_mode, int, 0);
  84 MODULE_PARM_DESC(int_mode, " Force interrupt mode (1 INT#x; 2 MSI)");
  85
  86 static int poll;
  87 module_param(poll, int, 0);
  88 MODULE_PARM_DESC(poll, " Use polling (for debug)");
  89
  90 static int mrrs = -1;
  91 module_param(mrrs, int, 0);
  92 MODULE_PARM_DESC(mrrs, " Force Max Read Req Size (0..3) (for debug)");
  93
  94 static int debug;
  95 module_param(debug, int, 0);
  96 MODULE_PARM_DESC(debug, " Default debug msglevel");
  97
  98 static int load_count[3]; /* 0-common, 1-port0, 2-port1 */
  99
 100 static struct workqueue_struct *bnx2x_wq;
 101
 102 enum bnx2x_board_type {
 103         BCM57710 = 0,
 104         BCM57711 = 1,
 105         BCM57711E = 2,
 106 };
 107
 108 /* indexed by board_type, above */
 109 static struct {
 110         char *name;
 111 } board_info[] __devinitdata = {
 112         { "Broadcom NetXtreme II BCM57710 XGb" },
 113         { "Broadcom NetXtreme II BCM57711 XGb" },
 114         { "Broadcom NetXtreme II BCM57711E XGb" }
 115 };
 116
 117
 118 static const struct pci_device_id bnx2x_pci_tbl[] = {
 119         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57710,
 120                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57710 },
 121         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57711,
 122                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57711 },
 123         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_57711E,
 124                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM57711E },
 125         { 0 }
 126 };
 127
 128 MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
 129
 130 /****************************************************************************
 131 * General service functions
 132 ****************************************************************************/
 133
 134 /* used only at init
 135  * locking is done by mcp
 136  */
 137 static void bnx2x_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
 138 {
 139         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
 140         pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
 141         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
 142                                PCICFG_VENDOR_ID_OFFSET);
 143 }
 144
 145 static u32 bnx2x_reg_rd_ind(struct bnx2x *bp, u32 addr)
 146 {
 147         u32 val;
 148
 149         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
 150         pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
 151         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
 152                                PCICFG_VENDOR_ID_OFFSET);
 153
 154         return val;
 155 }
 156
 157 static const u32 dmae_reg_go_c[] = {
 158         DMAE_REG_GO_C0, DMAE_REG_GO_C1, DMAE_REG_GO_C2, DMAE_REG_GO_C3,
 159         DMAE_REG_GO_C4, DMAE_REG_GO_C5, DMAE_REG_GO_C6, DMAE_REG_GO_C7,
 160         DMAE_REG_GO_C8, DMAE_REG_GO_C9, DMAE_REG_GO_C10, DMAE_REG_GO_C11,
 161         DMAE_REG_GO_C12, DMAE_REG_GO_C13, DMAE_REG_GO_C14, DMAE_REG_GO_C15
 162 };
 163
 164 /* copy command into DMAE command memory and set DMAE command go */
 165 static void bnx2x_post_dmae(struct bnx2x *bp, struct dmae_command *dmae,
 166                             int idx)
 167 {
 168         u32 cmd_offset;
 169         int i;
 170
 171         cmd_offset = (DMAE_REG_CMD_MEM + sizeof(struct dmae_command) * idx);
 172         for (i = 0; i < (sizeof(struct dmae_command)/4); i++) {
 173                 REG_WR(bp, cmd_offset + i*4, *(((u32 *)dmae) + i));
 174
 175                 DP(BNX2X_MSG_OFF, "DMAE cmd[%d].%d (0x%08x) : 0x%08x\n",
 176                    idx, i, cmd_offset + i*4, *(((u32 *)dmae) + i));
 177         }
 178         REG_WR(bp, dmae_reg_go_c[idx], 1);
 179 }
 180
 181 void bnx2x_write_dmae(struct bnx2x *bp, dma_addr_t dma_addr, u32 dst_addr,
 182                       u32 len32)
 183 {
 184         struct dmae_command *dmae = &bp->init_dmae;
 185         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
 186         int cnt = 200;
 187
 188         if (!bp->dmae_ready) {
 189                 u32 *data = bnx2x_sp(bp, wb_data[0]);
 190
 191                 DP(BNX2X_MSG_OFF, "DMAE is not ready (dst_addr %08x  len32 %d)"
 192                    "  using indirect\n", dst_addr, len32);
 193                 bnx2x_init_ind_wr(bp, dst_addr, data, len32);
 194                 return;
 195         }
 196
 197         mutex_lock(&bp->dmae_mutex);
 198
 199         memset(dmae, 0, sizeof(struct dmae_command));
 200
 201         dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
 202                         DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
 203                         DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
 204 #ifdef __BIG_ENDIAN
 205                         DMAE_CMD_ENDIANITY_B_DW_SWAP |
 206 #else
 207                         DMAE_CMD_ENDIANITY_DW_SWAP |
 208 #endif
 209                         (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
 210                         (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
 211         dmae->src_addr_lo = U64_LO(dma_addr);
 212         dmae->src_addr_hi = U64_HI(dma_addr);
 213         dmae->dst_addr_lo = dst_addr >> 2;
 214         dmae->dst_addr_hi = 0;
 215         dmae->len = len32;
 216         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
 217         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
 218         dmae->comp_val = DMAE_COMP_VAL;
 219
 220         DP(BNX2X_MSG_OFF, "DMAE: opcode 0x%08x\n"
 221            DP_LEVEL "src_addr  [%x:%08x]  len [%d *4]  "
 222                     "dst_addr [%x:%08x (%08x)]\n"
 223            DP_LEVEL "comp_addr [%x:%08x]  comp_val 0x%08x\n",
 224            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
 225            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo, dst_addr,
 226            dmae->comp_addr_hi, dmae->comp_addr_lo, dmae->comp_val);
 227         DP(BNX2X_MSG_OFF, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
 228            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
 229            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
 230
 231         *wb_comp = 0;
 232
 233         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
 234
 235         udelay(5);
 236
 237         while (*wb_comp != DMAE_COMP_VAL) {
 238                 DP(BNX2X_MSG_OFF, "wb_comp 0x%08x\n", *wb_comp);
 239
 240                 if (!cnt) {
 241                         BNX2X_ERR("DMAE timeout!\n");
 242                         break;
 243                 }
 244                 cnt--;
 245                 /* adjust delay for emulation/FPGA */
 246                 if (CHIP_REV_IS_SLOW(bp))
 247                         msleep(100);
 248                 else
 249                         udelay(5);
 250         }
 251
 252         mutex_unlock(&bp->dmae_mutex);
 253 }
 254
 255 void bnx2x_read_dmae(struct bnx2x *bp, u32 src_addr, u32 len32)
 256 {
 257         struct dmae_command *dmae = &bp->init_dmae;
 258         u32 *wb_comp = bnx2x_sp(bp, wb_comp);
 259         int cnt = 200;
 260
 261         if (!bp->dmae_ready) {
 262                 u32 *data = bnx2x_sp(bp, wb_data[0]);
 263                 int i;
 264
 265                 DP(BNX2X_MSG_OFF, "DMAE is not ready (src_addr %08x  len32 %d)"
 266                    "  using indirect\n", src_addr, len32);
 267                 for (i = 0; i < len32; i++)
 268                         data[i] = bnx2x_reg_rd_ind(bp, src_addr + i*4);
 269                 return;
 270         }
 271
 272         mutex_lock(&bp->dmae_mutex);
 273
 274         memset(bnx2x_sp(bp, wb_data[0]), 0, sizeof(u32) * 4);
 275         memset(dmae, 0, sizeof(struct dmae_command));
 276
 277         dmae->opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
 278                         DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
 279                         DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
 280 #ifdef __BIG_ENDIAN
 281                         DMAE_CMD_ENDIANITY_B_DW_SWAP |
 282 #else
 283                         DMAE_CMD_ENDIANITY_DW_SWAP |
 284 #endif
 285                         (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
 286                         (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
 287         dmae->src_addr_lo = src_addr >> 2;
 288         dmae->src_addr_hi = 0;
 289         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_data));
 290         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_data));
 291         dmae->len = len32;
 292         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, wb_comp));
 293         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, wb_comp));
 294         dmae->comp_val = DMAE_COMP_VAL;
 295
 296         DP(BNX2X_MSG_OFF, "DMAE: opcode 0x%08x\n"
 297            DP_LEVEL "src_addr  [%x:%08x]  len [%d *4]  "
 298                     "dst_addr [%x:%08x (%08x)]\n"
 299            DP_LEVEL "comp_addr [%x:%08x]  comp_val 0x%08x\n",
 300            dmae->opcode, dmae->src_addr_hi, dmae->src_addr_lo,
 301            dmae->len, dmae->dst_addr_hi, dmae->dst_addr_lo, src_addr,
 302            dmae->comp_addr_hi, dmae->comp_addr_lo, dmae->comp_val);
 303
 304         *wb_comp = 0;
 305
 306         bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
 307
 308         udelay(5);
 309
 310         while (*wb_comp != DMAE_COMP_VAL) {
 311
 312                 if (!cnt) {
 313                         BNX2X_ERR("DMAE timeout!\n");
 314                         break;
 315                 }
 316                 cnt--;
 317                 /* adjust delay for emulation/FPGA */
 318                 if (CHIP_REV_IS_SLOW(bp))
 319                         msleep(100);
 320                 else
 321                         udelay(5);
 322         }
 323         DP(BNX2X_MSG_OFF, "data [0x%08x 0x%08x 0x%08x 0x%08x]\n",
 324            bp->slowpath->wb_data[0], bp->slowpath->wb_data[1],
 325            bp->slowpath->wb_data[2], bp->slowpath->wb_data[3]);
 326
 327         mutex_unlock(&bp->dmae_mutex);
 328 }
 329
 330 /* used only for slowpath so not inlined */
 331 static void bnx2x_wb_wr(struct bnx2x *bp, int reg, u32 val_hi, u32 val_lo)
 332 {
 333         u32 wb_write[2];
 334
 335         wb_write[0] = val_hi;
 336         wb_write[1] = val_lo;
 337         REG_WR_DMAE(bp, reg, wb_write, 2);
 338 }
 339
 340 #ifdef USE_WB_RD
 341 static u64 bnx2x_wb_rd(struct bnx2x *bp, int reg)
 342 {
 343         u32 wb_data[2];
 344
 345         REG_RD_DMAE(bp, reg, wb_data, 2);
 346
 347         return HILO_U64(wb_data[0], wb_data[1]);
 348 }
 349 #endif
 350
 351 static int bnx2x_mc_assert(struct bnx2x *bp)
 352 {
 353         char last_idx;
 354         int i, rc = 0;
 355         u32 row0, row1, row2, row3;
 356
 357         /* XSTORM */
 358         last_idx = REG_RD8(bp, BAR_XSTRORM_INTMEM +
 359                            XSTORM_ASSERT_LIST_INDEX_OFFSET);
 360         if (last_idx)
 361                 BNX2X_ERR("XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 362
 363         /* print the asserts */
 364         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 365
 366                 row0 = REG_RD(bp, BAR_XSTRORM_INTMEM +
 367                               XSTORM_ASSERT_LIST_OFFSET(i));
 368                 row1 = REG_RD(bp, BAR_XSTRORM_INTMEM +
 369                               XSTORM_ASSERT_LIST_OFFSET(i) + 4);
 370                 row2 = REG_RD(bp, BAR_XSTRORM_INTMEM +
 371                               XSTORM_ASSERT_LIST_OFFSET(i) + 8);
 372                 row3 = REG_RD(bp, BAR_XSTRORM_INTMEM +
 373                               XSTORM_ASSERT_LIST_OFFSET(i) + 12);
 374
 375                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
 376                         BNX2X_ERR("XSTORM_ASSERT_INDEX 0x%x = 0x%08x"
 377                                   " 0x%08x 0x%08x 0x%08x\n",
 378                                   i, row3, row2, row1, row0);
 379                         rc++;
 380                 } else {
 381                         break;
 382                 }
 383         }
 384
 385         /* TSTORM */
 386         last_idx = REG_RD8(bp, BAR_TSTRORM_INTMEM +
 387                            TSTORM_ASSERT_LIST_INDEX_OFFSET);
 388         if (last_idx)
 389                 BNX2X_ERR("TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 390
 391         /* print the asserts */
 392         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 393
 394                 row0 = REG_RD(bp, BAR_TSTRORM_INTMEM +
 395                               TSTORM_ASSERT_LIST_OFFSET(i));
 396                 row1 = REG_RD(bp, BAR_TSTRORM_INTMEM +
 397                               TSTORM_ASSERT_LIST_OFFSET(i) + 4);
 398                 row2 = REG_RD(bp, BAR_TSTRORM_INTMEM +
 399                               TSTORM_ASSERT_LIST_OFFSET(i) + 8);
 400                 row3 = REG_RD(bp, BAR_TSTRORM_INTMEM +
 401                               TSTORM_ASSERT_LIST_OFFSET(i) + 12);
 402
 403                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
 404                         BNX2X_ERR("TSTORM_ASSERT_INDEX 0x%x = 0x%08x"
 405                                   " 0x%08x 0x%08x 0x%08x\n",
 406                                   i, row3, row2, row1, row0);
 407                         rc++;
 408                 } else {
 409                         break;
 410                 }
 411         }
 412
 413         /* CSTORM */
 414         last_idx = REG_RD8(bp, BAR_CSTRORM_INTMEM +
 415                            CSTORM_ASSERT_LIST_INDEX_OFFSET);
 416         if (last_idx)
 417                 BNX2X_ERR("CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 418
 419         /* print the asserts */
 420         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 421
 422                 row0 = REG_RD(bp, BAR_CSTRORM_INTMEM +
 423                               CSTORM_ASSERT_LIST_OFFSET(i));
 424                 row1 = REG_RD(bp, BAR_CSTRORM_INTMEM +
 425                               CSTORM_ASSERT_LIST_OFFSET(i) + 4);
 426                 row2 = REG_RD(bp, BAR_CSTRORM_INTMEM +
 427                               CSTORM_ASSERT_LIST_OFFSET(i) + 8);
 428                 row3 = REG_RD(bp, BAR_CSTRORM_INTMEM +
 429                               CSTORM_ASSERT_LIST_OFFSET(i) + 12);
 430
 431                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
 432                         BNX2X_ERR("CSTORM_ASSERT_INDEX 0x%x = 0x%08x"
 433                                   " 0x%08x 0x%08x 0x%08x\n",
 434                                   i, row3, row2, row1, row0);
 435                         rc++;
 436                 } else {
 437                         break;
 438                 }
 439         }
 440
 441         /* USTORM */
 442         last_idx = REG_RD8(bp, BAR_USTRORM_INTMEM +
 443                            USTORM_ASSERT_LIST_INDEX_OFFSET);
 444         if (last_idx)
 445                 BNX2X_ERR("USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
 446
 447         /* print the asserts */
 448         for (i = 0; i < STROM_ASSERT_ARRAY_SIZE; i++) {
 449
 450                 row0 = REG_RD(bp, BAR_USTRORM_INTMEM +
 451                               USTORM_ASSERT_LIST_OFFSET(i));
 452                 row1 = REG_RD(bp, BAR_USTRORM_INTMEM +
 453                               USTORM_ASSERT_LIST_OFFSET(i) + 4);
 454                 row2 = REG_RD(bp, BAR_USTRORM_INTMEM +
 455                               USTORM_ASSERT_LIST_OFFSET(i) + 8);
 456                 row3 = REG_RD(bp, BAR_USTRORM_INTMEM +
 457                               USTORM_ASSERT_LIST_OFFSET(i) + 12);
 458
 459                 if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
 460                         BNX2X_ERR("USTORM_ASSERT_INDEX 0x%x = 0x%08x"
 461                                   " 0x%08x 0x%08x 0x%08x\n",
 462                                   i, row3, row2, row1, row0);
 463                         rc++;
 464                 } else {
 465                         break;
 466                 }
 467         }
 468
 469         return rc;
 470 }
 471
 472 static void bnx2x_fw_dump(struct bnx2x *bp)
 473 {
 474         u32 mark, offset;
 475         __be32 data[9];
 476         int word;
 477
 478         mark = REG_RD(bp, MCP_REG_MCPR_SCRATCH + 0xf104);
 479         mark = ((mark + 0x3) & ~0x3);
 480         printk(KERN_ERR PFX "begin fw dump (mark 0x%x)\n" KERN_ERR, mark);
 481
 482         for (offset = mark - 0x08000000; offset <= 0xF900; offset += 0x8*4) {
 483                 for (word = 0; word < 8; word++)
 484                         data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
 485                                                   offset + 4*word));
 486                 data[8] = 0x0;
 487                 printk(KERN_CONT "%s", (char *)data);
 488         }
 489         for (offset = 0xF108; offset <= mark - 0x08000000; offset += 0x8*4) {
 490                 for (word = 0; word < 8; word++)
 491                         data[word] = htonl(REG_RD(bp, MCP_REG_MCPR_SCRATCH +
 492                                                   offset + 4*word));
 493                 data[8] = 0x0;
 494                 printk(KERN_CONT "%s", (char *)data);
 495         }
 496         printk("\n" KERN_ERR PFX "end of fw dump\n");
 497 }
 498
 499 static void bnx2x_panic_dump(struct bnx2x *bp)
 500 {
 501         int i;
 502         u16 j, start, end;
 503
 504         bp->stats_state = STATS_STATE_DISABLED;
 505         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
 506
 507         BNX2X_ERR("begin crash dump -----------------\n");
 508
 509         /* Indices */
 510         /* Common */
 511         BNX2X_ERR("def_c_idx(%u)  def_u_idx(%u)  def_x_idx(%u)"
 512                   "  def_t_idx(%u)  def_att_idx(%u)  attn_state(%u)"
 513                   "  spq_prod_idx(%u)\n",
 514                   bp->def_c_idx, bp->def_u_idx, bp->def_x_idx, bp->def_t_idx,
 515                   bp->def_att_idx, bp->attn_state, bp->spq_prod_idx);
 516
 517         /* Rx */
 518         for_each_rx_queue(bp, i) {
 519                 struct bnx2x_fastpath *fp = &bp->fp[i];
 520
 521                 BNX2X_ERR("fp%d: rx_bd_prod(%x)  rx_bd_cons(%x)"
 522                           "  *rx_bd_cons_sb(%x)  rx_comp_prod(%x)"
 523                           "  rx_comp_cons(%x)  *rx_cons_sb(%x)\n",
 524                           i, fp->rx_bd_prod, fp->rx_bd_cons,
 525                           le16_to_cpu(*fp->rx_bd_cons_sb), fp->rx_comp_prod,
 526                           fp->rx_comp_cons, le16_to_cpu(*fp->rx_cons_sb));
 527                 BNX2X_ERR("      rx_sge_prod(%x)  last_max_sge(%x)"
 528                           "  fp_u_idx(%x) *sb_u_idx(%x)\n",
 529                           fp->rx_sge_prod, fp->last_max_sge,
 530                           le16_to_cpu(fp->fp_u_idx),
 531                           fp->status_blk->u_status_block.status_block_index);
 532         }
 533
 534         /* Tx */
 535         for_each_tx_queue(bp, i) {
 536                 struct bnx2x_fastpath *fp = &bp->fp[i];
 537                 struct eth_tx_db_data *hw_prods = fp->hw_tx_prods;
 538
 539                 BNX2X_ERR("fp%d: tx_pkt_prod(%x)  tx_pkt_cons(%x)"
 540                           "  tx_bd_prod(%x)  tx_bd_cons(%x)  *tx_cons_sb(%x)\n",
 541                           i, fp->tx_pkt_prod, fp->tx_pkt_cons, fp->tx_bd_prod,
 542                           fp->tx_bd_cons, le16_to_cpu(*fp->tx_cons_sb));
 543                 BNX2X_ERR("      fp_c_idx(%x)  *sb_c_idx(%x)"
 544                           "  bd data(%x,%x)\n", le16_to_cpu(fp->fp_c_idx),
 545                           fp->status_blk->c_status_block.status_block_index,
 546                           hw_prods->packets_prod, hw_prods->bds_prod);
 547         }
 548
 549         /* Rings */
 550         /* Rx */
 551         for_each_rx_queue(bp, i) {
 552                 struct bnx2x_fastpath *fp = &bp->fp[i];
 553
 554                 start = RX_BD(le16_to_cpu(*fp->rx_cons_sb) - 10);
 555                 end = RX_BD(le16_to_cpu(*fp->rx_cons_sb) + 503);
 556                 for (j = start; j != end; j = RX_BD(j + 1)) {
 557                         u32 *rx_bd = (u32 *)&fp->rx_desc_ring[j];
 558                         struct sw_rx_bd *sw_bd = &fp->rx_buf_ring[j];
 559
 560                         BNX2X_ERR("fp%d: rx_bd[%x]=[%x:%x]  sw_bd=[%p]\n",
 561                                   i, j, rx_bd[1], rx_bd[0], sw_bd->skb);
 562                 }
 563
 564                 start = RX_SGE(fp->rx_sge_prod);
 565                 end = RX_SGE(fp->last_max_sge);
 566                 for (j = start; j != end; j = RX_SGE(j + 1)) {
 567                         u32 *rx_sge = (u32 *)&fp->rx_sge_ring[j];
 568                         struct sw_rx_page *sw_page = &fp->rx_page_ring[j];
 569
 570                         BNX2X_ERR("fp%d: rx_sge[%x]=[%x:%x]  sw_page=[%p]\n",
 571                                   i, j, rx_sge[1], rx_sge[0], sw_page->page);
 572                 }
 573
 574                 start = RCQ_BD(fp->rx_comp_cons - 10);
 575                 end = RCQ_BD(fp->rx_comp_cons + 503);
 576                 for (j = start; j != end; j = RCQ_BD(j + 1)) {
 577                         u32 *cqe = (u32 *)&fp->rx_comp_ring[j];
 578
 579                         BNX2X_ERR("fp%d: cqe[%x]=[%x:%x:%x:%x]\n",
 580                                   i, j, cqe[0], cqe[1], cqe[2], cqe[3]);
 581                 }
 582         }
 583
 584         /* Tx */
 585         for_each_tx_queue(bp, i) {
 586                 struct bnx2x_fastpath *fp = &bp->fp[i];
 587
 588                 start = TX_BD(le16_to_cpu(*fp->tx_cons_sb) - 10);
 589                 end = TX_BD(le16_to_cpu(*fp->tx_cons_sb) + 245);
 590                 for (j = start; j != end; j = TX_BD(j + 1)) {
 591                         struct sw_tx_bd *sw_bd = &fp->tx_buf_ring[j];
 592
 593                         BNX2X_ERR("fp%d: packet[%x]=[%p,%x]\n",
 594                                   i, j, sw_bd->skb, sw_bd->first_bd);
 595                 }
 596
 597                 start = TX_BD(fp->tx_bd_cons - 10);
 598                 end = TX_BD(fp->tx_bd_cons + 254);
 599                 for (j = start; j != end; j = TX_BD(j + 1)) {
 600                         u32 *tx_bd = (u32 *)&fp->tx_desc_ring[j];
 601
 602                         BNX2X_ERR("fp%d: tx_bd[%x]=[%x:%x:%x:%x]\n",
 603                                   i, j, tx_bd[0], tx_bd[1], tx_bd[2], tx_bd[3]);
 604                 }
 605         }
 606
 607         bnx2x_fw_dump(bp);
 608         bnx2x_mc_assert(bp);
 609         BNX2X_ERR("end crash dump -----------------\n");
 610 }
 611
 612 static void bnx2x_int_enable(struct bnx2x *bp)
 613 {
 614         int port = BP_PORT(bp);
 615         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
 616         u32 val = REG_RD(bp, addr);
 617         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
 618         int msi = (bp->flags & USING_MSI_FLAG) ? 1 : 0;
 619
 620         if (msix) {
 621                 val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
 622                          HC_CONFIG_0_REG_INT_LINE_EN_0);
 623                 val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
 624                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
 625         } else if (msi) {
 626                 val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
 627                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
 628                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
 629                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
 630         } else {
 631                 val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
 632                         HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
 633                         HC_CONFIG_0_REG_INT_LINE_EN_0 |
 634                         HC_CONFIG_0_REG_ATTN_BIT_EN_0);
 635
 636                 DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
 637                    val, port, addr);
 638
 639                 REG_WR(bp, addr, val);
 640
 641                 val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
 642         }
 643
 644         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)  mode %s\n",
 645            val, port, addr, (msix ? "MSI-X" : (msi ? "MSI" : "INTx")));
 646
 647         REG_WR(bp, addr, val);
 648
 649         if (CHIP_IS_E1H(bp)) {
 650                 /* init leading/trailing edge */
 651                 if (IS_E1HMF(bp)) {
 652                         val = (0xee0f | (1 << (BP_E1HVN(bp) + 4)));
 653                         if (bp->port.pmf)
 654                                 /* enable nig and gpio3 attention */
 655                                 val |= 0x1100;
 656                 } else
 657                         val = 0xffff;
 658
 659                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
 660                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
 661         }
 662 }
 663
 664 static void bnx2x_int_disable(struct bnx2x *bp)
 665 {
 666         int port = BP_PORT(bp);
 667         u32 addr = port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
 668         u32 val = REG_RD(bp, addr);
 669
 670         val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
 671                  HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
 672                  HC_CONFIG_0_REG_INT_LINE_EN_0 |
 673                  HC_CONFIG_0_REG_ATTN_BIT_EN_0);
 674
 675         DP(NETIF_MSG_INTR, "write %x to HC %d (addr 0x%x)\n",
 676            val, port, addr);
 677
 678         /* flush all outstanding writes */
 679         mmiowb();
 680
 681         REG_WR(bp, addr, val);
 682         if (REG_RD(bp, addr) != val)
 683                 BNX2X_ERR("BUG! proper val not read from IGU!\n");
 684
 685 }
 686
 687 static void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
 688 {
 689         int msix = (bp->flags & USING_MSIX_FLAG) ? 1 : 0;
 690         int i, offset;
 691
 692         /* disable interrupt handling */
 693         atomic_inc(&bp->intr_sem);
 694         if (disable_hw)
 695                 /* prevent the HW from sending interrupts */
 696                 bnx2x_int_disable(bp);
 697
 698         /* make sure all ISRs are done */
 699         if (msix) {
 700                 synchronize_irq(bp->msix_table[0].vector);
 701                 offset = 1;
 702                 for_each_queue(bp, i)
 703                         synchronize_irq(bp->msix_table[i + offset].vector);
 704         } else
 705                 synchronize_irq(bp->pdev->irq);
 706
 707         /* make sure sp_task is not running */
 708         cancel_delayed_work(&bp->sp_task);
 709         flush_workqueue(bnx2x_wq);
 710 }
 711
 712 /* fast path */
 713
 714 /*
 715  * General service functions
 716  */
 717
 718 static inline void bnx2x_ack_sb(struct bnx2x *bp, u8 sb_id,
 719                                 u8 storm, u16 index, u8 op, u8 update)
 720 {
 721         u32 hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
 722                        COMMAND_REG_INT_ACK);
 723         struct igu_ack_register igu_ack;
 724
 725         igu_ack.status_block_index = index;
 726         igu_ack.sb_id_and_flags =
 727                         ((sb_id << IGU_ACK_REGISTER_STATUS_BLOCK_ID_SHIFT) |
 728                          (storm << IGU_ACK_REGISTER_STORM_ID_SHIFT) |
 729                          (update << IGU_ACK_REGISTER_UPDATE_INDEX_SHIFT) |
 730                          (op << IGU_ACK_REGISTER_INTERRUPT_MODE_SHIFT));
 731
 732         DP(BNX2X_MSG_OFF, "write 0x%08x to HC addr 0x%x\n",
 733            (*(u32 *)&igu_ack), hc_addr);
 734         REG_WR(bp, hc_addr, (*(u32 *)&igu_ack));
 735 }
 736
 737 static inline u16 bnx2x_update_fpsb_idx(struct bnx2x_fastpath *fp)
 738 {
 739         struct host_status_block *fpsb = fp->status_blk;
 740         u16 rc = 0;
 741
 742         barrier(); /* status block is written to by the chip */
 743         if (fp->fp_c_idx != fpsb->c_status_block.status_block_index) {
 744                 fp->fp_c_idx = fpsb->c_status_block.status_block_index;
 745                 rc |= 1;
 746         }
 747         if (fp->fp_u_idx != fpsb->u_status_block.status_block_index) {
 748                 fp->fp_u_idx = fpsb->u_status_block.status_block_index;
 749                 rc |= 2;
 750         }
 751         return rc;
 752 }
 753
 754 static u16 bnx2x_ack_int(struct bnx2x *bp)
 755 {
 756         u32 hc_addr = (HC_REG_COMMAND_REG + BP_PORT(bp)*32 +
 757                        COMMAND_REG_SIMD_MASK);
 758         u32 result = REG_RD(bp, hc_addr);
 759
 760         DP(BNX2X_MSG_OFF, "read 0x%08x from HC addr 0x%x\n",
 761            result, hc_addr);
 762
 763         return result;
 764 }
 765
 766
 767 /*
 768  * fast path service functions
 769  */
 770
 771 static inline int bnx2x_has_tx_work(struct bnx2x_fastpath *fp)
 772 {
 773         u16 tx_cons_sb;
 774
 775         /* Tell compiler that status block fields can change */
 776         barrier();
 777         tx_cons_sb = le16_to_cpu(*fp->tx_cons_sb);
 778         return (fp->tx_pkt_cons != tx_cons_sb);
 779 }
 780
 781 static inline int bnx2x_has_tx_work_unload(struct bnx2x_fastpath *fp)
 782 {
 783         /* Tell compiler that consumer and producer can change */
 784         barrier();
 785         return (fp->tx_pkt_prod != fp->tx_pkt_cons);
 786 }
 787
 788 /* free skb in the packet ring at pos idx
 789  * return idx of last bd freed
 790  */
 791 static u16 bnx2x_free_tx_pkt(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 792                              u16 idx)
 793 {
 794         struct sw_tx_bd *tx_buf = &fp->tx_buf_ring[idx];
 795         struct eth_tx_bd *tx_bd;
 796         struct sk_buff *skb = tx_buf->skb;
 797         u16 bd_idx = TX_BD(tx_buf->first_bd), new_cons;
 798         int nbd;
 799
 800         DP(BNX2X_MSG_OFF, "pkt_idx %d  buff @(%p)->skb %p\n",
 801            idx, tx_buf, skb);
 802
 803         /* unmap first bd */
 804         DP(BNX2X_MSG_OFF, "free bd_idx %d\n", bd_idx);
 805         tx_bd = &fp->tx_desc_ring[bd_idx];
 806         pci_unmap_single(bp->pdev, BD_UNMAP_ADDR(tx_bd),
 807                          BD_UNMAP_LEN(tx_bd), PCI_DMA_TODEVICE);
 808
 809         nbd = le16_to_cpu(tx_bd->nbd) - 1;
 810         new_cons = nbd + tx_buf->first_bd;
 811 #ifdef BNX2X_STOP_ON_ERROR
 812         if (nbd > (MAX_SKB_FRAGS + 2)) {
 813                 BNX2X_ERR("BAD nbd!\n");
 814                 bnx2x_panic();
 815         }
 816 #endif
 817
 818         /* Skip a parse bd and the TSO split header bd
 819            since they have no mapping */
 820         if (nbd)
 821                 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
 822
 823         if (tx_bd->bd_flags.as_bitfield & (ETH_TX_BD_FLAGS_IP_CSUM |
 824                                            ETH_TX_BD_FLAGS_TCP_CSUM |
 825                                            ETH_TX_BD_FLAGS_SW_LSO)) {
 826                 if (--nbd)
 827                         bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
 828                 tx_bd = &fp->tx_desc_ring[bd_idx];
 829                 /* is this a TSO split header bd? */
 830                 if (tx_bd->bd_flags.as_bitfield & ETH_TX_BD_FLAGS_SW_LSO) {
 831                         if (--nbd)
 832                                 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
 833                 }
 834         }
 835
 836         /* now free frags */
 837         while (nbd > 0) {
 838
 839                 DP(BNX2X_MSG_OFF, "free frag bd_idx %d\n", bd_idx);
 840                 tx_bd = &fp->tx_desc_ring[bd_idx];
 841                 pci_unmap_page(bp->pdev, BD_UNMAP_ADDR(tx_bd),
 842                                BD_UNMAP_LEN(tx_bd), PCI_DMA_TODEVICE);
 843                 if (--nbd)
 844                         bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
 845         }
 846
 847         /* release skb */
 848         WARN_ON(!skb);
 849         dev_kfree_skb(skb);
 850         tx_buf->first_bd = 0;
 851         tx_buf->skb = NULL;
 852
 853         return new_cons;
 854 }
 855
 856 static inline u16 bnx2x_tx_avail(struct bnx2x_fastpath *fp)
 857 {
 858         s16 used;
 859         u16 prod;
 860         u16 cons;
 861
 862         barrier(); /* Tell compiler that prod and cons can change */
 863         prod = fp->tx_bd_prod;
 864         cons = fp->tx_bd_cons;
 865
 866         /* NUM_TX_RINGS = number of "next-page" entries
 867            It will be used as a threshold */
 868         used = SUB_S16(prod, cons) + (s16)NUM_TX_RINGS;
 869
 870 #ifdef BNX2X_STOP_ON_ERROR
 871         WARN_ON(used < 0);
 872         WARN_ON(used > fp->bp->tx_ring_size);
 873         WARN_ON((fp->bp->tx_ring_size - used) > MAX_TX_AVAIL);
 874 #endif
 875
 876         return (s16)(fp->bp->tx_ring_size) - used;
 877 }
 878
 879 static void bnx2x_tx_int(struct bnx2x_fastpath *fp)
 880 {
 881         struct bnx2x *bp = fp->bp;
 882         struct netdev_queue *txq;
 883         u16 hw_cons, sw_cons, bd_cons = fp->tx_bd_cons;
 884         int done = 0;
 885
 886 #ifdef BNX2X_STOP_ON_ERROR
 887         if (unlikely(bp->panic))
 888                 return;
 889 #endif
 890
 891         txq = netdev_get_tx_queue(bp->dev, fp->index);
 892         hw_cons = le16_to_cpu(*fp->tx_cons_sb);
 893         sw_cons = fp->tx_pkt_cons;
 894
 895         while (sw_cons != hw_cons) {
 896                 u16 pkt_cons;
 897
 898                 pkt_cons = TX_BD(sw_cons);
 899
 900                 /* prefetch(bp->tx_buf_ring[pkt_cons].skb); */
 901
 902                 DP(NETIF_MSG_TX_DONE, "hw_cons %u  sw_cons %u  pkt_cons %u\n",
 903                    hw_cons, sw_cons, pkt_cons);
 904
 905 /*              if (NEXT_TX_IDX(sw_cons) != hw_cons) {
 906                         rmb();
 907                         prefetch(fp->tx_buf_ring[NEXT_TX_IDX(sw_cons)].skb);
 908                 }
 909 */
 910                 bd_cons = bnx2x_free_tx_pkt(bp, fp, pkt_cons);
 911                 sw_cons++;
 912                 done++;
 913         }
 914
 915         fp->tx_pkt_cons = sw_cons;
 916         fp->tx_bd_cons = bd_cons;
 917
 918         /* TBD need a thresh? */
 919         if (unlikely(netif_tx_queue_stopped(txq))) {
 920
 921                 __netif_tx_lock(txq, smp_processor_id());
 922
 923                 /* Need to make the tx_bd_cons update visible to start_xmit()
 924                  * before checking for netif_tx_queue_stopped().  Without the
 925                  * memory barrier, there is a small possibility that
 926                  * start_xmit() will miss it and cause the queue to be stopped
 927                  * forever.
 928                  */
 929                 smp_mb();
 930
 931                 if ((netif_tx_queue_stopped(txq)) &&
 932                     (bp->state == BNX2X_STATE_OPEN) &&
 933                     (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3))
 934                         netif_tx_wake_queue(txq);
 935
 936                 __netif_tx_unlock(txq);
 937         }
 938 }
 939
 940
 941 static void bnx2x_sp_event(struct bnx2x_fastpath *fp,
 942                            union eth_rx_cqe *rr_cqe)
 943 {
 944         struct bnx2x *bp = fp->bp;
 945         int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
 946         int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
 947
 948         DP(BNX2X_MSG_SP,
 949            "fp %d  cid %d  got ramrod #%d  state is %x  type is %d\n",
 950            fp->index, cid, command, bp->state,
 951            rr_cqe->ramrod_cqe.ramrod_type);
 952
 953         bp->spq_left++;
 954
 955         if (fp->index) {
 956                 switch (command | fp->state) {
 957                 case (RAMROD_CMD_ID_ETH_CLIENT_SETUP |
 958                                                 BNX2X_FP_STATE_OPENING):
 959                         DP(NETIF_MSG_IFUP, "got MULTI[%d] setup ramrod\n",
 960                            cid);
 961                         fp->state = BNX2X_FP_STATE_OPEN;
 962                         break;
 963
 964                 case (RAMROD_CMD_ID_ETH_HALT | BNX2X_FP_STATE_HALTING):
 965                         DP(NETIF_MSG_IFDOWN, "got MULTI[%d] halt ramrod\n",
 966                            cid);
 967                         fp->state = BNX2X_FP_STATE_HALTED;
 968                         break;
 969
 970                 default:
 971                         BNX2X_ERR("unexpected MC reply (%d)  "
 972                                   "fp->state is %x\n", command, fp->state);
 973                         break;
 974                 }
 975                 mb(); /* force bnx2x_wait_ramrod() to see the change */
 976                 return;
 977         }
 978
 979         switch (command | bp->state) {
 980         case (RAMROD_CMD_ID_ETH_PORT_SETUP | BNX2X_STATE_OPENING_WAIT4_PORT):
 981                 DP(NETIF_MSG_IFUP, "got setup ramrod\n");
 982                 bp->state = BNX2X_STATE_OPEN;
 983                 break;
 984
 985         case (RAMROD_CMD_ID_ETH_HALT | BNX2X_STATE_CLOSING_WAIT4_HALT):
 986                 DP(NETIF_MSG_IFDOWN, "got halt ramrod\n");
 987                 bp->state = BNX2X_STATE_CLOSING_WAIT4_DELETE;
 988                 fp->state = BNX2X_FP_STATE_HALTED;
 989                 break;
 990
 991         case (RAMROD_CMD_ID_ETH_CFC_DEL | BNX2X_STATE_CLOSING_WAIT4_HALT):
 992                 DP(NETIF_MSG_IFDOWN, "got delete ramrod for MULTI[%d]\n", cid);
 993                 bnx2x_fp(bp, cid, state) = BNX2X_FP_STATE_CLOSED;
 994                 break;
 995
 996
 997         case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_OPEN):
 998         case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_DIAG):
 999                 DP(NETIF_MSG_IFUP, "got set mac ramrod\n");
1000                 bp->set_mac_pending = 0;
1001                 break;
1002
1003         case (RAMROD_CMD_ID_ETH_SET_MAC | BNX2X_STATE_CLOSING_WAIT4_HALT):
1004                 DP(NETIF_MSG_IFDOWN, "got (un)set mac ramrod\n");
1005                 break;
1006
1007         default:
1008                 BNX2X_ERR("unexpected MC reply (%d)  bp->state is %x\n",
1009                           command, bp->state);
1010                 break;
1011         }
1012         mb(); /* force bnx2x_wait_ramrod() to see the change */
1013 }
1014
1015 static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
1016                                      struct bnx2x_fastpath *fp, u16 index)
1017 {
1018         struct sw_rx_page *sw_buf = &fp->rx_page_ring[index];
1019         struct page *page = sw_buf->page;
1020         struct eth_rx_sge *sge = &fp->rx_sge_ring[index];
1021
1022         /* Skip "next page" elements */
1023         if (!page)
1024                 return;
1025
1026         pci_unmap_page(bp->pdev, pci_unmap_addr(sw_buf, mapping),
1027                        SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
1028         __free_pages(page, PAGES_PER_SGE_SHIFT);
1029
1030         sw_buf->page = NULL;
1031         sge->addr_hi = 0;
1032         sge->addr_lo = 0;
1033 }
1034
1035 static inline void bnx2x_free_rx_sge_range(struct bnx2x *bp,
1036                                            struct bnx2x_fastpath *fp, int last)
1037 {
1038         int i;
1039
1040         for (i = 0; i < last; i++)
1041                 bnx2x_free_rx_sge(bp, fp, i);
1042 }
1043
1044 static inline int bnx2x_alloc_rx_sge(struct bnx2x *bp,
1045                                      struct bnx2x_fastpath *fp, u16 index)
1046 {
1047         struct page *page = alloc_pages(GFP_ATOMIC, PAGES_PER_SGE_SHIFT);
1048         struct sw_rx_page *sw_buf = &fp->rx_page_ring[index];
1049         struct eth_rx_sge *sge = &fp->rx_sge_ring[index];
1050         dma_addr_t mapping;
1051
1052         if (unlikely(page == NULL))
1053                 return -ENOMEM;
1054
1055         mapping = pci_map_page(bp->pdev, page, 0, SGE_PAGE_SIZE*PAGES_PER_SGE,
1056                                PCI_DMA_FROMDEVICE);
1057         if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
1058                 __free_pages(page, PAGES_PER_SGE_SHIFT);
1059                 return -ENOMEM;
1060         }
1061
1062         sw_buf->page = page;
1063         pci_unmap_addr_set(sw_buf, mapping, mapping);
1064
1065         sge->addr_hi = cpu_to_le32(U64_HI(mapping));
1066         sge->addr_lo = cpu_to_le32(U64_LO(mapping));
1067
1068         return 0;
1069 }
1070
1071 static inline int bnx2x_alloc_rx_skb(struct bnx2x *bp,
1072                                      struct bnx2x_fastpath *fp, u16 index)
1073 {
1074         struct sk_buff *skb;
1075         struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[index];
1076         struct eth_rx_bd *rx_bd = &fp->rx_desc_ring[index];
1077         dma_addr_t mapping;
1078
1079         skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
1080         if (unlikely(skb == NULL))
1081                 return -ENOMEM;
1082
1083         mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_size,
1084                                  PCI_DMA_FROMDEVICE);
1085         if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
1086                 dev_kfree_skb(skb);
1087                 return -ENOMEM;
1088         }
1089
1090         rx_buf->skb = skb;
1091         pci_unmap_addr_set(rx_buf, mapping, mapping);
1092
1093         rx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
1094         rx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
1095
1096         return 0;
1097 }
1098
1099 /* note that we are not allocating a new skb,
1100  * we are just moving one from cons to prod
1101  * we are not creating a new mapping,
1102  * so there is no need to check for dma_mapping_error().
1103  */
1104 static void bnx2x_reuse_rx_skb(struct bnx2x_fastpath *fp,
1105                                struct sk_buff *skb, u16 cons, u16 prod)
1106 {
1107         struct bnx2x *bp = fp->bp;
1108         struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
1109         struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
1110         struct eth_rx_bd *cons_bd = &fp->rx_desc_ring[cons];
1111         struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
1112
1113         pci_dma_sync_single_for_device(bp->pdev,
1114                                        pci_unmap_addr(cons_rx_buf, mapping),
1115                                        RX_COPY_THRESH, PCI_DMA_FROMDEVICE);
1116
1117         prod_rx_buf->skb = cons_rx_buf->skb;
1118         pci_unmap_addr_set(prod_rx_buf, mapping,
1119                            pci_unmap_addr(cons_rx_buf, mapping));
1120         *prod_bd = *cons_bd;
1121 }
1122
1123 static inline void bnx2x_update_last_max_sge(struct bnx2x_fastpath *fp,
1124                                              u16 idx)
1125 {
1126         u16 last_max = fp->last_max_sge;
1127
1128         if (SUB_S16(idx, last_max) > 0)
1129                 fp->last_max_sge = idx;
1130 }
1131
1132 static void bnx2x_clear_sge_mask_next_elems(struct bnx2x_fastpath *fp)
1133 {
1134         int i, j;
1135
1136         for (i = 1; i <= NUM_RX_SGE_PAGES; i++) {
1137                 int idx = RX_SGE_CNT * i - 1;
1138
1139                 for (j = 0; j < 2; j++) {
1140                         SGE_MASK_CLEAR_BIT(fp, idx);
1141                         idx--;
1142                 }
1143         }
1144 }
1145
1146 static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
1147                                   struct eth_fast_path_rx_cqe *fp_cqe)
1148 {
1149         struct bnx2x *bp = fp->bp;
1150         u16 sge_len = SGE_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
1151                                      le16_to_cpu(fp_cqe->len_on_bd)) >>
1152                       SGE_PAGE_SHIFT;
1153         u16 last_max, last_elem, first_elem;
1154         u16 delta = 0;
1155         u16 i;
1156
1157         if (!sge_len)
1158                 return;
1159
1160         /* First mark all used pages */
1161         for (i = 0; i < sge_len; i++)
1162                 SGE_MASK_CLEAR_BIT(fp, RX_SGE(le16_to_cpu(fp_cqe->sgl[i])));
1163
1164         DP(NETIF_MSG_RX_STATUS, "fp_cqe->sgl[%d] = %d\n",
1165            sge_len - 1, le16_to_cpu(fp_cqe->sgl[sge_len - 1]));
1166
1167         /* Here we assume that the last SGE index is the biggest */
1168         prefetch((void *)(fp->sge_mask));
1169         bnx2x_update_last_max_sge(fp, le16_to_cpu(fp_cqe->sgl[sge_len - 1]));
1170
1171         last_max = RX_SGE(fp->last_max_sge);
1172         last_elem = last_max >> RX_SGE_MASK_ELEM_SHIFT;
1173         first_elem = RX_SGE(fp->rx_sge_prod) >> RX_SGE_MASK_ELEM_SHIFT;
1174
1175         /* If ring is not full */
1176         if (last_elem + 1 != first_elem)
1177                 last_elem++;
1178
1179         /* Now update the prod */
1180         for (i = first_elem; i != last_elem; i = NEXT_SGE_MASK_ELEM(i)) {
1181                 if (likely(fp->sge_mask[i]))
1182                         break;
1183
1184                 fp->sge_mask[i] = RX_SGE_MASK_ELEM_ONE_MASK;
1185                 delta += RX_SGE_MASK_ELEM_SZ;
1186         }
1187
1188         if (delta > 0) {
1189                 fp->rx_sge_prod += delta;
1190                 /* clear page-end entries */
1191                 bnx2x_clear_sge_mask_next_elems(fp);
1192         }
1193
1194         DP(NETIF_MSG_RX_STATUS,
1195            "fp->last_max_sge = %d  fp->rx_sge_prod = %d\n",
1196            fp->last_max_sge, fp->rx_sge_prod);
1197 }
1198
1199 static inline void bnx2x_init_sge_ring_bit_mask(struct bnx2x_fastpath *fp)
1200 {
1201         /* Set the mask to all 1-s: it's faster to compare to 0 than to 0xf-s */
1202         memset(fp->sge_mask, 0xff,
1203                (NUM_RX_SGE >> RX_SGE_MASK_ELEM_SHIFT)*sizeof(u64));
1204
1205         /* Clear the two last indices in the page to 1:
1206            these are the indices that correspond to the "next" element,
1207            hence will never be indicated and should be removed from
1208            the calculations. */
1209         bnx2x_clear_sge_mask_next_elems(fp);
1210 }
1211
1212 static void bnx2x_tpa_start(struct bnx2x_fastpath *fp, u16 queue,
1213                             struct sk_buff *skb, u16 cons, u16 prod)
1214 {
1215         struct bnx2x *bp = fp->bp;
1216         struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
1217         struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
1218         struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
1219         dma_addr_t mapping;
1220
1221         /* move empty skb from pool to prod and map it */
1222         prod_rx_buf->skb = fp->tpa_pool[queue].skb;
1223         mapping = pci_map_single(bp->pdev, fp->tpa_pool[queue].skb->data,
1224                                  bp->rx_buf_size, PCI_DMA_FROMDEVICE);
1225         pci_unmap_addr_set(prod_rx_buf, mapping, mapping);
1226
1227         /* move partial skb from cons to pool (don't unmap yet) */
1228         fp->tpa_pool[queue] = *cons_rx_buf;
1229
1230         /* mark bin state as start - print error if current state != stop */
1231         if (fp->tpa_state[queue] != BNX2X_TPA_STOP)
1232                 BNX2X_ERR("start of bin not in stop [%d]\n", queue);
1233
1234         fp->tpa_state[queue] = BNX2X_TPA_START;
1235
1236         /* point prod_bd to new skb */
1237         prod_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
1238         prod_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
1239
1240 #ifdef BNX2X_STOP_ON_ERROR
1241         fp->tpa_queue_used |= (1 << queue);
1242 #ifdef __powerpc64__
1243         DP(NETIF_MSG_RX_STATUS, "fp->tpa_queue_used = 0x%lx\n",
1244 #else
1245         DP(NETIF_MSG_RX_STATUS, "fp->tpa_queue_used = 0x%llx\n",
1246 #endif
1247            fp->tpa_queue_used);
1248 #endif
1249 }
1250
1251 static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
1252                                struct sk_buff *skb,
1253                                struct eth_fast_path_rx_cqe *fp_cqe,
1254                                u16 cqe_idx)
1255 {
1256         struct sw_rx_page *rx_pg, old_rx_pg;
1257         u16 len_on_bd = le16_to_cpu(fp_cqe->len_on_bd);
1258         u32 i, frag_len, frag_size, pages;
1259         int err;
1260         int j;
1261
1262         frag_size = le16_to_cpu(fp_cqe->pkt_len) - len_on_bd;
1263         pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
1264
1265         /* This is needed in order to enable forwarding support */
1266         if (frag_size)
1267                 skb_shinfo(skb)->gso_size = min((u32)SGE_PAGE_SIZE,
1268                                                max(frag_size, (u32)len_on_bd));
1269
1270 #ifdef BNX2X_STOP_ON_ERROR
1271         if (pages >
1272             min((u32)8, (u32)MAX_SKB_FRAGS) * SGE_PAGE_SIZE * PAGES_PER_SGE) {
1273                 BNX2X_ERR("SGL length is too long: %d. CQE index is %d\n",
1274                           pages, cqe_idx);
1275                 BNX2X_ERR("fp_cqe->pkt_len = %d  fp_cqe->len_on_bd = %d\n",
1276                           fp_cqe->pkt_len, len_on_bd);
1277                 bnx2x_panic();
1278                 return -EINVAL;
1279         }
1280 #endif
1281
1282         /* Run through the SGL and compose the fragmented skb */
1283         for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
1284                 u16 sge_idx = RX_SGE(le16_to_cpu(fp_cqe->sgl[j]));
1285
1286                 /* FW gives the indices of the SGE as if the ring is an array
1287                    (meaning that "next" element will consume 2 indices) */
1288                 frag_len = min(frag_size, (u32)(SGE_PAGE_SIZE*PAGES_PER_SGE));
1289                 rx_pg = &fp->rx_page_ring[sge_idx];
1290                 old_rx_pg = *rx_pg;
1291
1292                 /* If we fail to allocate a substitute page, we simply stop
1293                    where we are and drop the whole packet */
1294                 err = bnx2x_alloc_rx_sge(bp, fp, sge_idx);
1295                 if (unlikely(err)) {
1296                         fp->eth_q_stats.rx_skb_alloc_failed++;
1297                         return err;
1298                 }
1299
1300                 /* Unmap the page as we r going to pass it to the stack */
1301                 pci_unmap_page(bp->pdev, pci_unmap_addr(&old_rx_pg, mapping),
1302                               SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
1303
1304                 /* Add one frag and update the appropriate fields in the skb */
1305                 skb_fill_page_desc(skb, j, old_rx_pg.page, 0, frag_len);
1306
1307                 skb->data_len += frag_len;
1308                 skb->truesize += frag_len;
1309                 skb->len += frag_len;
1310
1311                 frag_size -= frag_len;
1312         }
1313
1314         return 0;
1315 }
1316
1317 static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
1318                            u16 queue, int pad, int len, union eth_rx_cqe *cqe,
1319                            u16 cqe_idx)
1320 {
1321         struct sw_rx_bd *rx_buf = &fp->tpa_pool[queue];
1322         struct sk_buff *skb = rx_buf->skb;
1323         /* alloc new skb */
1324         struct sk_buff *new_skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
1325
1326         /* Unmap skb in the pool anyway, as we are going to change
1327            pool entry status to BNX2X_TPA_STOP even if new skb allocation
1328            fails. */
1329         pci_unmap_single(bp->pdev, pci_unmap_addr(rx_buf, mapping),
1330                          bp->rx_buf_size, PCI_DMA_FROMDEVICE);
1331
1332         if (likely(new_skb)) {
1333                 /* fix ip xsum and give it to the stack */
1334                 /* (no need to map the new skb) */
1335 #ifdef BCM_VLAN
1336                 int is_vlan_cqe =
1337                         (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
1338                          PARSING_FLAGS_VLAN);
1339                 int is_not_hwaccel_vlan_cqe =
1340                         (is_vlan_cqe && (!(bp->flags & HW_VLAN_RX_FLAG)));
1341 #endif
1342
1343                 prefetch(skb);
1344                 prefetch(((char *)(skb)) + 128);
1345
1346 #ifdef BNX2X_STOP_ON_ERROR
1347                 if (pad + len > bp->rx_buf_size) {
1348                         BNX2X_ERR("skb_put is about to fail...  "
1349                                   "pad %d  len %d  rx_buf_size %d\n",
1350                                   pad, len, bp->rx_buf_size);
1351                         bnx2x_panic();
1352                         return;
1353                 }
1354 #endif
1355
1356                 skb_reserve(skb, pad);
1357                 skb_put(skb, len);
1358
1359                 skb->protocol = eth_type_trans(skb, bp->dev);
1360                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1361
1362                 {
1363                         struct iphdr *iph;
1364
1365                         iph = (struct iphdr *)skb->data;
1366 #ifdef BCM_VLAN
1367                         /* If there is no Rx VLAN offloading -
1368                            take VLAN tag into an account */
1369                         if (unlikely(is_not_hwaccel_vlan_cqe))
1370                                 iph = (struct iphdr *)((u8 *)iph + VLAN_HLEN);
1371 #endif
1372                         iph->check = 0;
1373                         iph->check = ip_fast_csum((u8 *)iph, iph->ihl);
1374                 }
1375
1376                 if (!bnx2x_fill_frag_skb(bp, fp, skb,
1377                                          &cqe->fast_path_cqe, cqe_idx)) {
1378 #ifdef BCM_VLAN
1379                         if ((bp->vlgrp != NULL) && is_vlan_cqe &&
1380                             (!is_not_hwaccel_vlan_cqe))
1381                                 vlan_hwaccel_receive_skb(skb, bp->vlgrp,
1382                                                 le16_to_cpu(cqe->fast_path_cqe.
1383                                                             vlan_tag));
1384                         else
1385 #endif
1386                                 netif_receive_skb(skb);
1387                 } else {
1388                         DP(NETIF_MSG_RX_STATUS, "Failed to allocate new pages"
1389                            " - dropping packet!\n");
1390                         dev_kfree_skb(skb);
1391                 }
1392
1393
1394                 /* put new skb in bin */
1395                 fp->tpa_pool[queue].skb = new_skb;
1396
1397         } else {
1398                 /* else drop the packet and keep the buffer in the bin */
1399                 DP(NETIF_MSG_RX_STATUS,
1400                    "Failed to allocate new skb - dropping packet!\n");
1401                 fp->eth_q_stats.rx_skb_alloc_failed++;
1402         }
1403
1404         fp->tpa_state[queue] = BNX2X_TPA_STOP;
1405 }
1406
1407 static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
1408                                         struct bnx2x_fastpath *fp,
1409                                         u16 bd_prod, u16 rx_comp_prod,
1410                                         u16 rx_sge_prod)
1411 {
1412         struct ustorm_eth_rx_producers rx_prods = {0};
1413         int i;
1414
1415         /* Update producers */
1416         rx_prods.bd_prod = bd_prod;
1417         rx_prods.cqe_prod = rx_comp_prod;
1418         rx_prods.sge_prod = rx_sge_prod;
1419
1420         /*
1421          * Make sure that the BD and SGE data is updated before updating the
1422          * producers since FW might read the BD/SGE right after the producer
1423          * is updated.
1424          * This is only applicable for weak-ordered memory model archs such
1425          * as IA-64. The following barrier is also mandatory since FW will
1426          * assumes BDs must have buffers.
1427          */
1428         wmb();
1429
1430         for (i = 0; i < sizeof(struct ustorm_eth_rx_producers)/4; i++)
1431                 REG_WR(bp, BAR_USTRORM_INTMEM +
1432                        USTORM_RX_PRODS_OFFSET(BP_PORT(bp), fp->cl_id) + i*4,
1433                        ((u32 *)&rx_prods)[i]);
1434
1435         mmiowb(); /* keep prod updates ordered */
1436
1437         DP(NETIF_MSG_RX_STATUS,
1438            "queue[%d]:  wrote  bd_prod %u  cqe_prod %u  sge_prod %u\n",
1439            fp->index, bd_prod, rx_comp_prod, rx_sge_prod);
1440 }
1441
1442 static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
1443 {
1444         struct bnx2x *bp = fp->bp;
1445         u16 bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
1446         u16 hw_comp_cons, sw_comp_cons, sw_comp_prod;
1447         int rx_pkt = 0;
1448
1449 #ifdef BNX2X_STOP_ON_ERROR
1450         if (unlikely(bp->panic))
1451                 return 0;
1452 #endif
1453
1454         /* CQ "next element" is of the size of the regular element,
1455            that's why it's ok here */
1456         hw_comp_cons = le16_to_cpu(*fp->rx_cons_sb);
1457         if ((hw_comp_cons & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
1458                 hw_comp_cons++;
1459
1460         bd_cons = fp->rx_bd_cons;
1461         bd_prod = fp->rx_bd_prod;
1462         bd_prod_fw = bd_prod;
1463         sw_comp_cons = fp->rx_comp_cons;
1464         sw_comp_prod = fp->rx_comp_prod;
1465
1466         /* Memory barrier necessary as speculative reads of the rx
1467          * buffer can be ahead of the index in the status block
1468          */
1469         rmb();
1470
1471         DP(NETIF_MSG_RX_STATUS,
1472            "queue[%d]:  hw_comp_cons %u  sw_comp_cons %u\n",
1473            fp->index, hw_comp_cons, sw_comp_cons);
1474
1475         while (sw_comp_cons != hw_comp_cons) {
1476                 struct sw_rx_bd *rx_buf = NULL;
1477                 struct sk_buff *skb;
1478                 union eth_rx_cqe *cqe;
1479                 u8 cqe_fp_flags;
1480                 u16 len, pad;
1481
1482                 comp_ring_cons = RCQ_BD(sw_comp_cons);
1483                 bd_prod = RX_BD(bd_prod);
1484                 bd_cons = RX_BD(bd_cons);
1485
1486                 cqe = &fp->rx_comp_ring[comp_ring_cons];
1487                 cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
1488
1489                 DP(NETIF_MSG_RX_STATUS, "CQE type %x  err %x  status %x"
1490                    "  queue %x  vlan %x  len %u\n", CQE_TYPE(cqe_fp_flags),
1491                    cqe_fp_flags, cqe->fast_path_cqe.status_flags,
1492                    le32_to_cpu(cqe->fast_path_cqe.rss_hash_result),
1493                    le16_to_cpu(cqe->fast_path_cqe.vlan_tag),
1494                    le16_to_cpu(cqe->fast_path_cqe.pkt_len));
1495
1496                 /* is this a slowpath msg? */
1497                 if (unlikely(CQE_TYPE(cqe_fp_flags))) {
1498                         bnx2x_sp_event(fp, cqe);
1499                         goto next_cqe;
1500
1501                 /* this is an rx packet */
1502                 } else {
1503                         rx_buf = &fp->rx_buf_ring[bd_cons];
1504                         skb = rx_buf->skb;
1505                         len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
1506                         pad = cqe->fast_path_cqe.placement_offset;
1507
1508                         /* If CQE is marked both TPA_START and TPA_END
1509                            it is a non-TPA CQE */
1510                         if ((!fp->disable_tpa) &&
1511                             (TPA_TYPE(cqe_fp_flags) !=
1512                                         (TPA_TYPE_START | TPA_TYPE_END))) {
1513                                 u16 queue = cqe->fast_path_cqe.queue_index;
1514
1515                                 if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_START) {
1516                                         DP(NETIF_MSG_RX_STATUS,
1517                                            "calling tpa_start on queue %d\n",
1518                                            queue);
1519
1520                                         bnx2x_tpa_start(fp, queue, skb,
1521                                                         bd_cons, bd_prod);
1522                                         goto next_rx;
1523                                 }
1524
1525                                 if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_END) {
1526                                         DP(NETIF_MSG_RX_STATUS,
1527                                            "calling tpa_stop on queue %d\n",
1528                                            queue);
1529
1530                                         if (!BNX2X_RX_SUM_FIX(cqe))
1531                                                 BNX2X_ERR("STOP on none TCP "
1532                                                           "data\n");
1533
1534                                         /* This is a size of the linear data
1535                                            on this skb */
1536                                         len = le16_to_cpu(cqe->fast_path_cqe.
1537                                                                 len_on_bd);
1538                                         bnx2x_tpa_stop(bp, fp, queue, pad,
1539                                                     len, cqe, comp_ring_cons);
1540 #ifdef BNX2X_STOP_ON_ERROR
1541                                         if (bp->panic)
1542                                                 return -EINVAL;
1543 #endif
1544
1545                                         bnx2x_update_sge_prod(fp,
1546                                                         &cqe->fast_path_cqe);
1547                                         goto next_cqe;
1548                                 }
1549                         }
1550
1551                         pci_dma_sync_single_for_device(bp->pdev,
1552                                         pci_unmap_addr(rx_buf, mapping),
1553                                                        pad + RX_COPY_THRESH,
1554                                                        PCI_DMA_FROMDEVICE);
1555                         prefetch(skb);
1556                         prefetch(((char *)(skb)) + 128);
1557
1558                         /* is this an error packet? */
1559                         if (unlikely(cqe_fp_flags & ETH_RX_ERROR_FALGS)) {
1560                                 DP(NETIF_MSG_RX_ERR,
1561                                    "ERROR  flags %x  rx packet %u\n",
1562                                    cqe_fp_flags, sw_comp_cons);
1563                                 fp->eth_q_stats.rx_err_discard_pkt++;
1564                                 goto reuse_rx;
1565                         }
1566
1567                         /* Since we don't have a jumbo ring
1568                          * copy small packets if mtu > 1500
1569                          */
1570                         if ((bp->dev->mtu > ETH_MAX_PACKET_SIZE) &&
1571                             (len <= RX_COPY_THRESH)) {
1572                                 struct sk_buff *new_skb;
1573
1574                                 new_skb = netdev_alloc_skb(bp->dev,
1575                                                            len + pad);
1576                                 if (new_skb == NULL) {
1577                                         DP(NETIF_MSG_RX_ERR,
1578                                            "ERROR  packet dropped "
1579                                            "because of alloc failure\n");
1580                                         fp->eth_q_stats.rx_skb_alloc_failed++;
1581                                         goto reuse_rx;
1582                                 }
1583
1584                                 /* aligned copy */
1585                                 skb_copy_from_linear_data_offset(skb, pad,
1586                                                     new_skb->data + pad, len);
1587                                 skb_reserve(new_skb, pad);
1588                                 skb_put(new_skb, len);
1589
1590                                 bnx2x_reuse_rx_skb(fp, skb, bd_cons, bd_prod);
1591
1592                                 skb = new_skb;
1593
1594                         } else if (bnx2x_alloc_rx_skb(bp, fp, bd_prod) == 0) {
1595                                 pci_unmap_single(bp->pdev,
1596                                         pci_unmap_addr(rx_buf, mapping),
1597                                                  bp->rx_buf_size,
1598                                                  PCI_DMA_FROMDEVICE);
1599                                 skb_reserve(skb, pad);
1600                                 skb_put(skb, len);
1601
1602                         } else {
1603                                 DP(NETIF_MSG_RX_ERR,
1604                                    "ERROR  packet dropped because "
1605                                    "of alloc failure\n");
1606                                 fp->eth_q_stats.rx_skb_alloc_failed++;
1607 reuse_rx:
1608                                 bnx2x_reuse_rx_skb(fp, skb, bd_cons, bd_prod);
1609                                 goto next_rx;
1610                         }
1611
1612                         skb->protocol = eth_type_trans(skb, bp->dev);
1613
1614                         skb->ip_summed = CHECKSUM_NONE;
1615                         if (bp->rx_csum) {
1616                                 if (likely(BNX2X_RX_CSUM_OK(cqe)))
1617                                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1618                                 else
1619                                         fp->eth_q_stats.hw_csum_err++;
1620                         }
1621                 }
1622
1623                 skb_record_rx_queue(skb, fp->index);
1624 #ifdef BCM_VLAN
1625                 if ((bp->vlgrp != NULL) && (bp->flags & HW_VLAN_RX_FLAG) &&
1626                     (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
1627                      PARSING_FLAGS_VLAN))
1628                         vlan_hwaccel_receive_skb(skb, bp->vlgrp,
1629                                 le16_to_cpu(cqe->fast_path_cqe.vlan_tag));
1630                 else
1631 #endif
1632                         netif_receive_skb(skb);
1633
1634
1635 next_rx:
1636                 rx_buf->skb = NULL;
1637
1638                 bd_cons = NEXT_RX_IDX(bd_cons);
1639                 bd_prod = NEXT_RX_IDX(bd_prod);
1640                 bd_prod_fw = NEXT_RX_IDX(bd_prod_fw);
1641                 rx_pkt++;
1642 next_cqe:
1643                 sw_comp_prod = NEXT_RCQ_IDX(sw_comp_prod);
1644                 sw_comp_cons = NEXT_RCQ_IDX(sw_comp_cons);
1645
1646                 if (rx_pkt == budget)
1647                         break;
1648         } /* while */
1649
1650         fp->rx_bd_cons = bd_cons;
1651         fp->rx_bd_prod = bd_prod_fw;
1652         fp->rx_comp_cons = sw_comp_cons;
1653         fp->rx_comp_prod = sw_comp_prod;
1654
1655         /* Update producers */
1656         bnx2x_update_rx_prod(bp, fp, bd_prod_fw, sw_comp_prod,
1657                              fp->rx_sge_prod);
1658
1659         fp->rx_pkt += rx_pkt;
1660         fp->rx_calls++;
1661
1662         return rx_pkt;
1663 }
1664
1665 static irqreturn_t bnx2x_msix_fp_int(int irq, void *fp_cookie)
1666 {
1667         struct bnx2x_fastpath *fp = fp_cookie;
1668         struct bnx2x *bp = fp->bp;
1669         int index = fp->index;
1670
1671         /* Return here if interrupt is disabled */
1672         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1673                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1674                 return IRQ_HANDLED;
1675         }
1676
1677         DP(BNX2X_MSG_FP, "got an MSI-X interrupt on IDX:SB [%d:%d]\n",
1678            index, fp->sb_id);
1679         bnx2x_ack_sb(bp, fp->sb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
1680
1681 #ifdef BNX2X_STOP_ON_ERROR
1682         if (unlikely(bp->panic))
1683                 return IRQ_HANDLED;
1684 #endif
1685
1686         prefetch(fp->rx_cons_sb);
1687         prefetch(fp->tx_cons_sb);
1688         prefetch(&fp->status_blk->c_status_block.status_block_index);
1689         prefetch(&fp->status_blk->u_status_block.status_block_index);
1690
1691         napi_schedule(&bnx2x_fp(bp, index, napi));
1692
1693         return IRQ_HANDLED;
1694 }
1695
1696 static irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
1697 {
1698         struct bnx2x *bp = netdev_priv(dev_instance);
1699         u16 status = bnx2x_ack_int(bp);
1700         u16 mask;
1701
1702         /* Return here if interrupt is shared and it's not for us */
1703         if (unlikely(status == 0)) {
1704                 DP(NETIF_MSG_INTR, "not our interrupt!\n");
1705                 return IRQ_NONE;
1706         }
1707         DP(NETIF_MSG_INTR, "got an interrupt  status 0x%x\n", status);
1708
1709         /* Return here if interrupt is disabled */
1710         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
1711                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
1712                 return IRQ_HANDLED;
1713         }
1714
1715 #ifdef BNX2X_STOP_ON_ERROR
1716         if (unlikely(bp->panic))
1717                 return IRQ_HANDLED;
1718 #endif
1719
1720         mask = 0x2 << bp->fp[0].sb_id;
1721         if (status & mask) {
1722                 struct bnx2x_fastpath *fp = &bp->fp[0];
1723
1724                 prefetch(fp->rx_cons_sb);
1725                 prefetch(fp->tx_cons_sb);
1726                 prefetch(&fp->status_blk->c_status_block.status_block_index);
1727                 prefetch(&fp->status_blk->u_status_block.status_block_index);
1728
1729                 napi_schedule(&bnx2x_fp(bp, 0, napi));
1730
1731                 status &= ~mask;
1732         }
1733
1734
1735         if (unlikely(status & 0x1)) {
1736                 queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
1737
1738                 status &= ~0x1;
1739                 if (!status)
1740                         return IRQ_HANDLED;
1741         }
1742
1743         if (status)
1744                 DP(NETIF_MSG_INTR, "got an unknown interrupt! (status %u)\n",
1745                    status);
1746
1747         return IRQ_HANDLED;
1748 }
1749
1750 /* end of fast path */
1751
1752 static void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event);
1753
1754 /* Link */
1755
1756 /*
1757  * General service functions
1758  */
1759
1760 static int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource)
1761 {
1762         u32 lock_status;
1763         u32 resource_bit = (1 << resource);
1764         int func = BP_FUNC(bp);
1765         u32 hw_lock_control_reg;
1766         int cnt;
1767
1768         /* Validating that the resource is within range */
1769         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1770                 DP(NETIF_MSG_HW,
1771                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1772                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1773                 return -EINVAL;
1774         }
1775
1776         if (func <= 5) {
1777                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1778         } else {
1779                 hw_lock_control_reg =
1780                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1781         }
1782
1783         /* Validating that the resource is not already taken */
1784         lock_status = REG_RD(bp, hw_lock_control_reg);
1785         if (lock_status & resource_bit) {
1786                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1787                    lock_status, resource_bit);
1788                 return -EEXIST;
1789         }
1790
1791         /* Try for 5 second every 5ms */
1792         for (cnt = 0; cnt < 1000; cnt++) {
1793                 /* Try to acquire the lock */
1794                 REG_WR(bp, hw_lock_control_reg + 4, resource_bit);
1795                 lock_status = REG_RD(bp, hw_lock_control_reg);
1796                 if (lock_status & resource_bit)
1797                         return 0;
1798
1799                 msleep(5);
1800         }
1801         DP(NETIF_MSG_HW, "Timeout\n");
1802         return -EAGAIN;
1803 }
1804
1805 static int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource)
1806 {
1807         u32 lock_status;
1808         u32 resource_bit = (1 << resource);
1809         int func = BP_FUNC(bp);
1810         u32 hw_lock_control_reg;
1811
1812         /* Validating that the resource is within range */
1813         if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1814                 DP(NETIF_MSG_HW,
1815                    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
1816                    resource, HW_LOCK_MAX_RESOURCE_VALUE);
1817                 return -EINVAL;
1818         }
1819
1820         if (func <= 5) {
1821                 hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
1822         } else {
1823                 hw_lock_control_reg =
1824                                 (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
1825         }
1826
1827         /* Validating that the resource is currently taken */
1828         lock_status = REG_RD(bp, hw_lock_control_reg);
1829         if (!(lock_status & resource_bit)) {
1830                 DP(NETIF_MSG_HW, "lock_status 0x%x  resource_bit 0x%x\n",
1831                    lock_status, resource_bit);
1832                 return -EFAULT;
1833         }
1834
1835         REG_WR(bp, hw_lock_control_reg, resource_bit);
1836         return 0;
1837 }
1838
1839 /* HW Lock for shared dual port PHYs */
1840 static void bnx2x_acquire_phy_lock(struct bnx2x *bp)
1841 {
1842         mutex_lock(&bp->port.phy_mutex);
1843
1844         if (bp->port.need_hw_lock)
1845                 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_MDIO);
1846 }
1847
1848 static void bnx2x_release_phy_lock(struct bnx2x *bp)
1849 {
1850         if (bp->port.need_hw_lock)
1851                 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_MDIO);
1852
1853         mutex_unlock(&bp->port.phy_mutex);
1854 }
1855
1856 int bnx2x_get_gpio(struct bnx2x *bp, int gpio_num, u8 port)
1857 {
1858         /* The GPIO should be swapped if swap register is set and active */
1859         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1860                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1861         int gpio_shift = gpio_num +
1862                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1863         u32 gpio_mask = (1 << gpio_shift);
1864         u32 gpio_reg;
1865         int value;
1866
1867         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1868                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1869                 return -EINVAL;
1870         }
1871
1872         /* read GPIO value */
1873         gpio_reg = REG_RD(bp, MISC_REG_GPIO);
1874
1875         /* get the requested pin value */
1876         if ((gpio_reg & gpio_mask) == gpio_mask)
1877                 value = 1;
1878         else
1879                 value = 0;
1880
1881         DP(NETIF_MSG_LINK, "pin %d  value 0x%x\n", gpio_num, value);
1882
1883         return value;
1884 }
1885
1886 int bnx2x_set_gpio(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1887 {
1888         /* The GPIO should be swapped if swap register is set and active */
1889         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1890                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1891         int gpio_shift = gpio_num +
1892                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1893         u32 gpio_mask = (1 << gpio_shift);
1894         u32 gpio_reg;
1895
1896         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1897                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1898                 return -EINVAL;
1899         }
1900
1901         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1902         /* read GPIO and mask except the float bits */
1903         gpio_reg = (REG_RD(bp, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1904
1905         switch (mode) {
1906         case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1907                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output low\n",
1908                    gpio_num, gpio_shift);
1909                 /* clear FLOAT and set CLR */
1910                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1911                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1912                 break;
1913
1914         case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1915                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> output high\n",
1916                    gpio_num, gpio_shift);
1917                 /* clear FLOAT and set SET */
1918                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1919                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1920                 break;
1921
1922         case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1923                 DP(NETIF_MSG_LINK, "Set GPIO %d (shift %d) -> input\n",
1924                    gpio_num, gpio_shift);
1925                 /* set FLOAT */
1926                 gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1927                 break;
1928
1929         default:
1930                 break;
1931         }
1932
1933         REG_WR(bp, MISC_REG_GPIO, gpio_reg);
1934         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1935
1936         return 0;
1937 }
1938
1939 int bnx2x_set_gpio_int(struct bnx2x *bp, int gpio_num, u32 mode, u8 port)
1940 {
1941         /* The GPIO should be swapped if swap register is set and active */
1942         int gpio_port = (REG_RD(bp, NIG_REG_PORT_SWAP) &&
1943                          REG_RD(bp, NIG_REG_STRAP_OVERRIDE)) ^ port;
1944         int gpio_shift = gpio_num +
1945                         (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0);
1946         u32 gpio_mask = (1 << gpio_shift);
1947         u32 gpio_reg;
1948
1949         if (gpio_num > MISC_REGISTERS_GPIO_3) {
1950                 BNX2X_ERR("Invalid GPIO %d\n", gpio_num);
1951                 return -EINVAL;
1952         }
1953
1954         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1955         /* read GPIO int */
1956         gpio_reg = REG_RD(bp, MISC_REG_GPIO_INT);
1957
1958         switch (mode) {
1959         case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
1960                 DP(NETIF_MSG_LINK, "Clear GPIO INT %d (shift %d) -> "
1961                                    "output low\n", gpio_num, gpio_shift);
1962                 /* clear SET and set CLR */
1963                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1964                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1965                 break;
1966
1967         case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
1968                 DP(NETIF_MSG_LINK, "Set GPIO INT %d (shift %d) -> "
1969                                    "output high\n", gpio_num, gpio_shift);
1970                 /* clear CLR and set SET */
1971                 gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
1972                 gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
1973                 break;
1974
1975         default:
1976                 break;
1977         }
1978
1979         REG_WR(bp, MISC_REG_GPIO_INT, gpio_reg);
1980         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_GPIO);
1981
1982         return 0;
1983 }
1984
1985 static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
1986 {
1987         u32 spio_mask = (1 << spio_num);
1988         u32 spio_reg;
1989
1990         if ((spio_num < MISC_REGISTERS_SPIO_4) ||
1991             (spio_num > MISC_REGISTERS_SPIO_7)) {
1992                 BNX2X_ERR("Invalid SPIO %d\n", spio_num);
1993                 return -EINVAL;
1994         }
1995
1996         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
1997         /* read SPIO and mask except the float bits */
1998         spio_reg = (REG_RD(bp, MISC_REG_SPIO) & MISC_REGISTERS_SPIO_FLOAT);
1999
2000         switch (mode) {
2001         case MISC_REGISTERS_SPIO_OUTPUT_LOW:
2002                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output low\n", spio_num);
2003                 /* clear FLOAT and set CLR */
2004                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
2005                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_CLR_POS);
2006                 break;
2007
2008         case MISC_REGISTERS_SPIO_OUTPUT_HIGH:
2009                 DP(NETIF_MSG_LINK, "Set SPIO %d -> output high\n", spio_num);
2010                 /* clear FLOAT and set SET */
2011                 spio_reg &= ~(spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
2012                 spio_reg |=  (spio_mask << MISC_REGISTERS_SPIO_SET_POS);
2013                 break;
2014
2015         case MISC_REGISTERS_SPIO_INPUT_HI_Z:
2016                 DP(NETIF_MSG_LINK, "Set SPIO %d -> input\n", spio_num);
2017                 /* set FLOAT */
2018                 spio_reg |= (spio_mask << MISC_REGISTERS_SPIO_FLOAT_POS);
2019                 break;
2020
2021         default:
2022                 break;
2023         }
2024
2025         REG_WR(bp, MISC_REG_SPIO, spio_reg);
2026         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_SPIO);
2027
2028         return 0;
2029 }
2030
2031 static void bnx2x_calc_fc_adv(struct bnx2x *bp)
2032 {
2033         switch (bp->link_vars.ieee_fc &
2034                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
2035         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
2036                 bp->port.advertising &= ~(ADVERTISED_Asym_Pause |
2037                                           ADVERTISED_Pause);
2038                 break;
2039
2040         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
2041                 bp->port.advertising |= (ADVERTISED_Asym_Pause |
2042                                          ADVERTISED_Pause);
2043                 break;
2044
2045         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
2046                 bp->port.advertising |= ADVERTISED_Asym_Pause;
2047                 break;
2048
2049         default:
2050                 bp->port.advertising &= ~(ADVERTISED_Asym_Pause |
2051                                           ADVERTISED_Pause);
2052                 break;
2053         }
2054 }
2055
2056 static void bnx2x_link_report(struct bnx2x *bp)
2057 {
2058         if (bp->link_vars.link_up) {
2059                 if (bp->state == BNX2X_STATE_OPEN)
2060                         netif_carrier_on(bp->dev);
2061                 printk(KERN_INFO PFX "%s NIC Link is Up, ", bp->dev->name);
2062
2063                 printk("%d Mbps ", bp->link_vars.line_speed);
2064
2065                 if (bp->link_vars.duplex == DUPLEX_FULL)
2066                         printk("full duplex");
2067                 else
2068                         printk("half duplex");
2069
2070                 if (bp->link_vars.flow_ctrl != BNX2X_FLOW_CTRL_NONE) {
2071                         if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_RX) {
2072                                 printk(", receive ");
2073                                 if (bp->link_vars.flow_ctrl &
2074                                     BNX2X_FLOW_CTRL_TX)
2075                                         printk("& transmit ");
2076                         } else {
2077                                 printk(", transmit ");
2078                         }
2079                         printk("flow control ON");
2080                 }
2081                 printk("\n");
2082
2083         } else { /* link_down */
2084                 netif_carrier_off(bp->dev);
2085                 printk(KERN_ERR PFX "%s NIC Link is Down\n", bp->dev->name);
2086         }
2087 }
2088
2089 static u8 bnx2x_initial_phy_init(struct bnx2x *bp, int load_mode)
2090 {
2091         if (!BP_NOMCP(bp)) {
2092                 u8 rc;
2093
2094                 /* Initialize link parameters structure variables */
2095                 /* It is recommended to turn off RX FC for jumbo frames
2096                    for better performance */
2097                 if (IS_E1HMF(bp))
2098                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
2099                 else if (bp->dev->mtu > 5000)
2100                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_TX;
2101                 else
2102                         bp->link_params.req_fc_auto_adv = BNX2X_FLOW_CTRL_BOTH;
2103
2104                 bnx2x_acquire_phy_lock(bp);
2105
2106                 if (load_mode == LOAD_DIAG)
2107                         bp->link_params.loopback_mode = LOOPBACK_XGXS_10;
2108
2109                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2110
2111                 bnx2x_release_phy_lock(bp);
2112
2113                 bnx2x_calc_fc_adv(bp);
2114
2115                 if (CHIP_REV_IS_SLOW(bp) && bp->link_vars.link_up) {
2116                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2117                         bnx2x_link_report(bp);
2118                 }
2119
2120                 return rc;
2121         }
2122         BNX2X_ERR("Bootcode is missing - can not initialize link\n");
2123         return -EINVAL;
2124 }
2125
2126 static void bnx2x_link_set(struct bnx2x *bp)
2127 {
2128         if (!BP_NOMCP(bp)) {
2129                 bnx2x_acquire_phy_lock(bp);
2130                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
2131                 bnx2x_release_phy_lock(bp);
2132
2133                 bnx2x_calc_fc_adv(bp);
2134         } else
2135                 BNX2X_ERR("Bootcode is missing - can not set link\n");
2136 }
2137
2138 static void bnx2x__link_reset(struct bnx2x *bp)
2139 {
2140         if (!BP_NOMCP(bp)) {
2141                 bnx2x_acquire_phy_lock(bp);
2142                 bnx2x_link_reset(&bp->link_params, &bp->link_vars, 1);
2143                 bnx2x_release_phy_lock(bp);
2144         } else
2145                 BNX2X_ERR("Bootcode is missing - can not reset link\n");
2146 }
2147
2148 static u8 bnx2x_link_test(struct bnx2x *bp)
2149 {
2150         u8 rc;
2151
2152         bnx2x_acquire_phy_lock(bp);
2153         rc = bnx2x_test_link(&bp->link_params, &bp->link_vars);
2154         bnx2x_release_phy_lock(bp);
2155
2156         return rc;
2157 }
2158
2159 static void bnx2x_init_port_minmax(struct bnx2x *bp)
2160 {
2161         u32 r_param = bp->link_vars.line_speed / 8;
2162         u32 fair_periodic_timeout_usec;
2163         u32 t_fair;
2164
2165         memset(&(bp->cmng.rs_vars), 0,
2166                sizeof(struct rate_shaping_vars_per_port));
2167         memset(&(bp->cmng.fair_vars), 0, sizeof(struct fairness_vars_per_port));
2168
2169         /* 100 usec in SDM ticks = 25 since each tick is 4 usec */
2170         bp->cmng.rs_vars.rs_periodic_timeout = RS_PERIODIC_TIMEOUT_USEC / 4;
2171
2172         /* this is the threshold below which no timer arming will occur
2173            1.25 coefficient is for the threshold to be a little bigger
2174            than the real time, to compensate for timer in-accuracy */
2175         bp->cmng.rs_vars.rs_threshold =
2176                                 (RS_PERIODIC_TIMEOUT_USEC * r_param * 5) / 4;
2177
2178         /* resolution of fairness timer */
2179         fair_periodic_timeout_usec = QM_ARB_BYTES / r_param;
2180         /* for 10G it is 1000usec. for 1G it is 10000usec. */
2181         t_fair = T_FAIR_COEF / bp->link_vars.line_speed;
2182
2183         /* this is the threshold below which we won't arm the timer anymore */
2184         bp->cmng.fair_vars.fair_threshold = QM_ARB_BYTES;
2185
2186         /* we multiply by 1e3/8 to get bytes/msec.
2187            We don't want the credits to pass a credit
2188            of the t_fair*FAIR_MEM (algorithm resolution) */
2189         bp->cmng.fair_vars.upper_bound = r_param * t_fair * FAIR_MEM;
2190         /* since each tick is 4 usec */
2191         bp->cmng.fair_vars.fairness_timeout = fair_periodic_timeout_usec / 4;
2192 }
2193
2194 static void bnx2x_init_vn_minmax(struct bnx2x *bp, int func)
2195 {
2196         struct rate_shaping_vars_per_vn m_rs_vn;
2197         struct fairness_vars_per_vn m_fair_vn;
2198         u32 vn_cfg = SHMEM_RD(bp, mf_cfg.func_mf_config[func].config);
2199         u16 vn_min_rate, vn_max_rate;
2200         int i;
2201
2202         /* If function is hidden - set min and max to zeroes */
2203         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
2204                 vn_min_rate = 0;
2205                 vn_max_rate = 0;
2206
2207         } else {
2208                 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
2209                                 FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
2210                 /* If fairness is enabled (not all min rates are zeroes) and
2211                    if current min rate is zero - set it to 1.
2212                    This is a requirement of the algorithm. */
2213                 if (bp->vn_weight_sum && (vn_min_rate == 0))
2214                         vn_min_rate = DEF_MIN_RATE;
2215                 vn_max_rate = ((vn_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
2216                                 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
2217         }
2218
2219         DP(NETIF_MSG_IFUP,
2220            "func %d: vn_min_rate=%d  vn_max_rate=%d  vn_weight_sum=%d\n",
2221            func, vn_min_rate, vn_max_rate, bp->vn_weight_sum);
2222
2223         memset(&m_rs_vn, 0, sizeof(struct rate_shaping_vars_per_vn));
2224         memset(&m_fair_vn, 0, sizeof(struct fairness_vars_per_vn));
2225
2226         /* global vn counter - maximal Mbps for this vn */
2227         m_rs_vn.vn_counter.rate = vn_max_rate;
2228
2229         /* quota - number of bytes transmitted in this period */
2230         m_rs_vn.vn_counter.quota =
2231                                 (vn_max_rate * RS_PERIODIC_TIMEOUT_USEC) / 8;
2232
2233         if (bp->vn_weight_sum) {
2234                 /* credit for each period of the fairness algorithm:
2235                    number of bytes in T_FAIR (the vn share the port rate).
2236                    vn_weight_sum should not be larger than 10000, thus
2237                    T_FAIR_COEF / (8 * vn_weight_sum) will always be greater
2238                    than zero */
2239                 m_fair_vn.vn_credit_delta =
2240                         max((u32)(vn_min_rate * (T_FAIR_COEF /
2241                                                  (8 * bp->vn_weight_sum))),
2242                             (u32)(bp->cmng.fair_vars.fair_threshold * 2));
2243                 DP(NETIF_MSG_IFUP, "m_fair_vn.vn_credit_delta=%d\n",
2244                    m_fair_vn.vn_credit_delta);
2245         }
2246
2247         /* Store it to internal memory */
2248         for (i = 0; i < sizeof(struct rate_shaping_vars_per_vn)/4; i++)
2249                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2250                        XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func) + i * 4,
2251                        ((u32 *)(&m_rs_vn))[i]);
2252
2253         for (i = 0; i < sizeof(struct fairness_vars_per_vn)/4; i++)
2254                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2255                        XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func) + i * 4,
2256                        ((u32 *)(&m_fair_vn))[i]);
2257 }
2258
2259
2260 /* This function is called upon link interrupt */
2261 static void bnx2x_link_attn(struct bnx2x *bp)
2262 {
2263         /* Make sure that we are synced with the current statistics */
2264         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2265
2266         bnx2x_link_update(&bp->link_params, &bp->link_vars);
2267
2268         if (bp->link_vars.link_up) {
2269
2270                 /* dropless flow control */
2271                 if (CHIP_IS_E1H(bp)) {
2272                         int port = BP_PORT(bp);
2273                         u32 pause_enabled = 0;
2274
2275                         if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX)
2276                                 pause_enabled = 1;
2277
2278                         REG_WR(bp, BAR_USTRORM_INTMEM +
2279                                USTORM_PAUSE_ENABLED_OFFSET(port),
2280                                pause_enabled);
2281                 }
2282
2283                 if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
2284                         struct host_port_stats *pstats;
2285
2286                         pstats = bnx2x_sp(bp, port_stats);
2287                         /* reset old bmac stats */
2288                         memset(&(pstats->mac_stx[0]), 0,
2289                                sizeof(struct mac_stx));
2290                 }
2291                 if ((bp->state == BNX2X_STATE_OPEN) ||
2292                     (bp->state == BNX2X_STATE_DISABLED))
2293                         bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2294         }
2295
2296         /* indicate link status */
2297         bnx2x_link_report(bp);
2298
2299         if (IS_E1HMF(bp)) {
2300                 int port = BP_PORT(bp);
2301                 int func;
2302                 int vn;
2303
2304                 for (vn = VN_0; vn < E1HVN_MAX; vn++) {
2305                         if (vn == BP_E1HVN(bp))
2306                                 continue;
2307
2308                         func = ((vn << 1) | port);
2309
2310                         /* Set the attention towards other drivers
2311                            on the same port */
2312                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_0 +
2313                                (LINK_SYNC_ATTENTION_BIT_FUNC_0 + func)*4, 1);
2314                 }
2315
2316                 if (bp->link_vars.link_up) {
2317                         int i;
2318
2319                         /* Init rate shaping and fairness contexts */
2320                         bnx2x_init_port_minmax(bp);
2321
2322                         for (vn = VN_0; vn < E1HVN_MAX; vn++)
2323                                 bnx2x_init_vn_minmax(bp, 2*vn + port);
2324
2325                         /* Store it to internal memory */
2326                         for (i = 0;
2327                              i < sizeof(struct cmng_struct_per_port) / 4; i++)
2328                                 REG_WR(bp, BAR_XSTRORM_INTMEM +
2329                                   XSTORM_CMNG_PER_PORT_VARS_OFFSET(port) + i*4,
2330                                        ((u32 *)(&bp->cmng))[i]);
2331                 }
2332         }
2333 }
2334
2335 static void bnx2x__link_status_update(struct bnx2x *bp)
2336 {
2337         if (bp->state != BNX2X_STATE_OPEN)
2338                 return;
2339
2340         bnx2x_link_status_update(&bp->link_params, &bp->link_vars);
2341
2342         if (bp->link_vars.link_up)
2343                 bnx2x_stats_handle(bp, STATS_EVENT_LINK_UP);
2344         else
2345                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
2346
2347         /* indicate link status */
2348         bnx2x_link_report(bp);
2349 }
2350
2351 static void bnx2x_pmf_update(struct bnx2x *bp)
2352 {
2353         int port = BP_PORT(bp);
2354         u32 val;
2355
2356         bp->port.pmf = 1;
2357         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
2358
2359         /* enable nig attention */
2360         val = (0xff0f | (1 << (BP_E1HVN(bp) + 4)));
2361         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, val);
2362         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, val);
2363
2364         bnx2x_stats_handle(bp, STATS_EVENT_PMF);
2365 }
2366
2367 /* end of Link */
2368
2369 /* slow path */
2370
2371 /*
2372  * General service functions
2373  */
2374
2375 /* the slow path queue is odd since completions arrive on the fastpath ring */
2376 static int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
2377                          u32 data_hi, u32 data_lo, int common)
2378 {
2379         int func = BP_FUNC(bp);
2380
2381         DP(BNX2X_MSG_SP/*NETIF_MSG_TIMER*/,
2382            "SPQE (%x:%x)  command %d  hw_cid %x  data (%x:%x)  left %x\n",
2383            (u32)U64_HI(bp->spq_mapping), (u32)(U64_LO(bp->spq_mapping) +
2384            (void *)bp->spq_prod_bd - (void *)bp->spq), command,
2385            HW_CID(bp, cid), data_hi, data_lo, bp->spq_left);
2386
2387 #ifdef BNX2X_STOP_ON_ERROR
2388         if (unlikely(bp->panic))
2389                 return -EIO;
2390 #endif
2391
2392         spin_lock_bh(&bp->spq_lock);
2393
2394         if (!bp->spq_left) {
2395                 BNX2X_ERR("BUG! SPQ ring full!\n");
2396                 spin_unlock_bh(&bp->spq_lock);
2397                 bnx2x_panic();
2398                 return -EBUSY;
2399         }
2400
2401         /* CID needs port number to be encoded int it */
2402         bp->spq_prod_bd->hdr.conn_and_cmd_data =
2403                         cpu_to_le32(((command << SPE_HDR_CMD_ID_SHIFT) |
2404                                      HW_CID(bp, cid)));
2405         bp->spq_prod_bd->hdr.type = cpu_to_le16(ETH_CONNECTION_TYPE);
2406         if (common)
2407                 bp->spq_prod_bd->hdr.type |=
2408                         cpu_to_le16((1 << SPE_HDR_COMMON_RAMROD_SHIFT));
2409
2410         bp->spq_prod_bd->data.mac_config_addr.hi = cpu_to_le32(data_hi);
2411         bp->spq_prod_bd->data.mac_config_addr.lo = cpu_to_le32(data_lo);
2412
2413         bp->spq_left--;
2414
2415         if (bp->spq_prod_bd == bp->spq_last_bd) {
2416                 bp->spq_prod_bd = bp->spq;
2417                 bp->spq_prod_idx = 0;
2418                 DP(NETIF_MSG_TIMER, "end of spq\n");
2419
2420         } else {
2421                 bp->spq_prod_bd++;
2422                 bp->spq_prod_idx++;
2423         }
2424
2425         REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func),
2426                bp->spq_prod_idx);
2427
2428         spin_unlock_bh(&bp->spq_lock);
2429         return 0;
2430 }
2431
2432 /* acquire split MCP access lock register */
2433 static int bnx2x_acquire_alr(struct bnx2x *bp)
2434 {
2435         u32 i, j, val;
2436         int rc = 0;
2437
2438         might_sleep();
2439         i = 100;
2440         for (j = 0; j < i*10; j++) {
2441                 val = (1UL << 31);
2442                 REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2443                 val = REG_RD(bp, GRCBASE_MCP + 0x9c);
2444                 if (val & (1L << 31))
2445                         break;
2446
2447                 msleep(5);
2448         }
2449         if (!(val & (1L << 31))) {
2450                 BNX2X_ERR("Cannot acquire MCP access lock register\n");
2451                 rc = -EBUSY;
2452         }
2453
2454         return rc;
2455 }
2456
2457 /* release split MCP access lock register */
2458 static void bnx2x_release_alr(struct bnx2x *bp)
2459 {
2460         u32 val = 0;
2461
2462         REG_WR(bp, GRCBASE_MCP + 0x9c, val);
2463 }
2464
2465 static inline u16 bnx2x_update_dsb_idx(struct bnx2x *bp)
2466 {
2467         struct host_def_status_block *def_sb = bp->def_status_blk;
2468         u16 rc = 0;
2469
2470         barrier(); /* status block is written to by the chip */
2471         if (bp->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
2472                 bp->def_att_idx = def_sb->atten_status_block.attn_bits_index;
2473                 rc |= 1;
2474         }
2475         if (bp->def_c_idx != def_sb->c_def_status_block.status_block_index) {
2476                 bp->def_c_idx = def_sb->c_def_status_block.status_block_index;
2477                 rc |= 2;
2478         }
2479         if (bp->def_u_idx != def_sb->u_def_status_block.status_block_index) {
2480                 bp->def_u_idx = def_sb->u_def_status_block.status_block_index;
2481                 rc |= 4;
2482         }
2483         if (bp->def_x_idx != def_sb->x_def_status_block.status_block_index) {
2484                 bp->def_x_idx = def_sb->x_def_status_block.status_block_index;
2485                 rc |= 8;
2486         }
2487         if (bp->def_t_idx != def_sb->t_def_status_block.status_block_index) {
2488                 bp->def_t_idx = def_sb->t_def_status_block.status_block_index;
2489                 rc |= 16;
2490         }
2491         return rc;
2492 }
2493
2494 /*
2495  * slow path service functions
2496  */
2497
2498 static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
2499 {
2500         int port = BP_PORT(bp);
2501         u32 hc_addr = (HC_REG_COMMAND_REG + port*32 +
2502                        COMMAND_REG_ATTN_BITS_SET);
2503         u32 aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2504                               MISC_REG_AEU_MASK_ATTN_FUNC_0;
2505         u32 nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
2506                                        NIG_REG_MASK_INTERRUPT_PORT0;
2507         u32 aeu_mask;
2508         u32 nig_mask = 0;
2509
2510         if (bp->attn_state & asserted)
2511                 BNX2X_ERR("IGU ERROR\n");
2512
2513         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2514         aeu_mask = REG_RD(bp, aeu_addr);
2515
2516         DP(NETIF_MSG_HW, "aeu_mask %x  newly asserted %x\n",
2517            aeu_mask, asserted);
2518         aeu_mask &= ~(asserted & 0xff);
2519         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2520
2521         REG_WR(bp, aeu_addr, aeu_mask);
2522         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2523
2524         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2525         bp->attn_state |= asserted;
2526         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2527
2528         if (asserted & ATTN_HARD_WIRED_MASK) {
2529                 if (asserted & ATTN_NIG_FOR_FUNC) {
2530
2531                         bnx2x_acquire_phy_lock(bp);
2532
2533                         /* save nig interrupt mask */
2534                         nig_mask = REG_RD(bp, nig_int_mask_addr);
2535                         REG_WR(bp, nig_int_mask_addr, 0);
2536
2537                         bnx2x_link_attn(bp);
2538
2539                         /* handle unicore attn? */
2540                 }
2541                 if (asserted & ATTN_SW_TIMER_4_FUNC)
2542                         DP(NETIF_MSG_HW, "ATTN_SW_TIMER_4_FUNC!\n");
2543
2544                 if (asserted & GPIO_2_FUNC)
2545                         DP(NETIF_MSG_HW, "GPIO_2_FUNC!\n");
2546
2547                 if (asserted & GPIO_3_FUNC)
2548                         DP(NETIF_MSG_HW, "GPIO_3_FUNC!\n");
2549
2550                 if (asserted & GPIO_4_FUNC)
2551                         DP(NETIF_MSG_HW, "GPIO_4_FUNC!\n");
2552
2553                 if (port == 0) {
2554                         if (asserted & ATTN_GENERAL_ATTN_1) {
2555                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_1!\n");
2556                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
2557                         }
2558                         if (asserted & ATTN_GENERAL_ATTN_2) {
2559                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_2!\n");
2560                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
2561                         }
2562                         if (asserted & ATTN_GENERAL_ATTN_3) {
2563                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_3!\n");
2564                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
2565                         }
2566                 } else {
2567                         if (asserted & ATTN_GENERAL_ATTN_4) {
2568                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_4!\n");
2569                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
2570                         }
2571                         if (asserted & ATTN_GENERAL_ATTN_5) {
2572                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_5!\n");
2573                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
2574                         }
2575                         if (asserted & ATTN_GENERAL_ATTN_6) {
2576                                 DP(NETIF_MSG_HW, "ATTN_GENERAL_ATTN_6!\n");
2577                                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
2578                         }
2579                 }
2580
2581         } /* if hardwired */
2582
2583         DP(NETIF_MSG_HW, "about to mask 0x%08x at HC addr 0x%x\n",
2584            asserted, hc_addr);
2585         REG_WR(bp, hc_addr, asserted);
2586
2587         /* now set back the mask */
2588         if (asserted & ATTN_NIG_FOR_FUNC) {
2589                 REG_WR(bp, nig_int_mask_addr, nig_mask);
2590                 bnx2x_release_phy_lock(bp);
2591         }
2592 }
2593
2594 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
2595 {
2596         int port = BP_PORT(bp);
2597         int reg_offset;
2598         u32 val;
2599
2600         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
2601                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
2602
2603         if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
2604
2605                 val = REG_RD(bp, reg_offset);
2606                 val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
2607                 REG_WR(bp, reg_offset, val);
2608
2609                 BNX2X_ERR("SPIO5 hw attention\n");
2610
2611                 switch (XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config)) {
2612                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
2613                         /* Fan failure attention */
2614
2615                         /* The PHY reset is controlled by GPIO 1 */
2616                         bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_1,
2617                                        MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
2618                         /* Low power mode is controlled by GPIO 2 */
2619                         bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
2620                                        MISC_REGISTERS_GPIO_OUTPUT_LOW, port);
2621                         /* mark the failure */
2622                         bp->link_params.ext_phy_config &=
2623                                         ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
2624                         bp->link_params.ext_phy_config |=
2625                                         PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
2626                         SHMEM_WR(bp,
2627                                  dev_info.port_hw_config[port].
2628                                                         external_phy_config,
2629                                  bp->link_params.ext_phy_config);
2630                         /* log the failure */
2631                         printk(KERN_ERR PFX "Fan Failure on Network"
2632                                " Controller %s has caused the driver to"
2633                                " shutdown the card to prevent permanent"
2634                                " damage.  Please contact Dell Support for"
2635                                " assistance\n", bp->dev->name);
2636                         break;
2637
2638                 default:
2639                         break;
2640                 }
2641         }
2642
2643         if (attn & (AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 |
2644                     AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1)) {
2645                 bnx2x_acquire_phy_lock(bp);
2646                 bnx2x_handle_module_detect_int(&bp->link_params);
2647                 bnx2x_release_phy_lock(bp);
2648         }
2649
2650         if (attn & HW_INTERRUT_ASSERT_SET_0) {
2651
2652                 val = REG_RD(bp, reg_offset);
2653                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
2654                 REG_WR(bp, reg_offset, val);
2655
2656                 BNX2X_ERR("FATAL HW block attention set0 0x%x\n",
2657                           (attn & HW_INTERRUT_ASSERT_SET_0));
2658                 bnx2x_panic();
2659         }
2660 }
2661
2662 static inline void bnx2x_attn_int_deasserted1(struct bnx2x *bp, u32 attn)
2663 {
2664         u32 val;
2665
2666         if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
2667
2668                 val = REG_RD(bp, DORQ_REG_DORQ_INT_STS_CLR);
2669                 BNX2X_ERR("DB hw attention 0x%x\n", val);
2670                 /* DORQ discard attention */
2671                 if (val & 0x2)
2672                         BNX2X_ERR("FATAL error from DORQ\n");
2673         }
2674
2675         if (attn & HW_INTERRUT_ASSERT_SET_1) {
2676
2677                 int port = BP_PORT(bp);
2678                 int reg_offset;
2679
2680                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
2681                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
2682
2683                 val = REG_RD(bp, reg_offset);
2684                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
2685                 REG_WR(bp, reg_offset, val);
2686
2687                 BNX2X_ERR("FATAL HW block attention set1 0x%x\n",
2688                           (attn & HW_INTERRUT_ASSERT_SET_1));
2689                 bnx2x_panic();
2690         }
2691 }
2692
2693 static inline void bnx2x_attn_int_deasserted2(struct bnx2x *bp, u32 attn)
2694 {
2695         u32 val;
2696
2697         if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
2698
2699                 val = REG_RD(bp, CFC_REG_CFC_INT_STS_CLR);
2700                 BNX2X_ERR("CFC hw attention 0x%x\n", val);
2701                 /* CFC error attention */
2702                 if (val & 0x2)
2703                         BNX2X_ERR("FATAL error from CFC\n");
2704         }
2705
2706         if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
2707
2708                 val = REG_RD(bp, PXP_REG_PXP_INT_STS_CLR_0);
2709                 BNX2X_ERR("PXP hw attention 0x%x\n", val);
2710                 /* RQ_USDMDP_FIFO_OVERFLOW */
2711                 if (val & 0x18000)
2712                         BNX2X_ERR("FATAL error from PXP\n");
2713         }
2714
2715         if (attn & HW_INTERRUT_ASSERT_SET_2) {
2716
2717                 int port = BP_PORT(bp);
2718                 int reg_offset;
2719
2720                 reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
2721                                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
2722
2723                 val = REG_RD(bp, reg_offset);
2724                 val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
2725                 REG_WR(bp, reg_offset, val);
2726
2727                 BNX2X_ERR("FATAL HW block attention set2 0x%x\n",
2728                           (attn & HW_INTERRUT_ASSERT_SET_2));
2729                 bnx2x_panic();
2730         }
2731 }
2732
2733 static inline void bnx2x_attn_int_deasserted3(struct bnx2x *bp, u32 attn)
2734 {
2735         u32 val;
2736
2737         if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
2738
2739                 if (attn & BNX2X_PMF_LINK_ASSERT) {
2740                         int func = BP_FUNC(bp);
2741
2742                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
2743                         bnx2x__link_status_update(bp);
2744                         if (SHMEM_RD(bp, func_mb[func].drv_status) &
2745                                                         DRV_STATUS_PMF)
2746                                 bnx2x_pmf_update(bp);
2747
2748                 } else if (attn & BNX2X_MC_ASSERT_BITS) {
2749
2750                         BNX2X_ERR("MC assert!\n");
2751                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_10, 0);
2752                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_9, 0);
2753                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_8, 0);
2754                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_7, 0);
2755                         bnx2x_panic();
2756
2757                 } else if (attn & BNX2X_MCP_ASSERT) {
2758
2759                         BNX2X_ERR("MCP assert!\n");
2760                         REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_11, 0);
2761                         bnx2x_fw_dump(bp);
2762
2763                 } else
2764                         BNX2X_ERR("Unknown HW assert! (attn 0x%x)\n", attn);
2765         }
2766
2767         if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
2768                 BNX2X_ERR("LATCHED attention 0x%08x (masked)\n", attn);
2769                 if (attn & BNX2X_GRC_TIMEOUT) {
2770                         val = CHIP_IS_E1H(bp) ?
2771                                 REG_RD(bp, MISC_REG_GRC_TIMEOUT_ATTN) : 0;
2772                         BNX2X_ERR("GRC time-out 0x%08x\n", val);
2773                 }
2774                 if (attn & BNX2X_GRC_RSV) {
2775                         val = CHIP_IS_E1H(bp) ?
2776                                 REG_RD(bp, MISC_REG_GRC_RSV_ATTN) : 0;
2777                         BNX2X_ERR("GRC reserved 0x%08x\n", val);
2778                 }
2779                 REG_WR(bp, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
2780         }
2781 }
2782
2783 static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
2784 {
2785         struct attn_route attn;
2786         struct attn_route group_mask;
2787         int port = BP_PORT(bp);
2788         int index;
2789         u32 reg_addr;
2790         u32 val;
2791         u32 aeu_mask;
2792
2793         /* need to take HW lock because MCP or other port might also
2794            try to handle this event */
2795         bnx2x_acquire_alr(bp);
2796
2797         attn.sig[0] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
2798         attn.sig[1] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
2799         attn.sig[2] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
2800         attn.sig[3] = REG_RD(bp, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
2801         DP(NETIF_MSG_HW, "attn: %08x %08x %08x %08x\n",
2802            attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3]);
2803
2804         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
2805                 if (deasserted & (1 << index)) {
2806                         group_mask = bp->attn_group[index];
2807
2808                         DP(NETIF_MSG_HW, "group[%d]: %08x %08x %08x %08x\n",
2809                            index, group_mask.sig[0], group_mask.sig[1],
2810                            group_mask.sig[2], group_mask.sig[3]);
2811
2812                         bnx2x_attn_int_deasserted3(bp,
2813                                         attn.sig[3] & group_mask.sig[3]);
2814                         bnx2x_attn_int_deasserted1(bp,
2815                                         attn.sig[1] & group_mask.sig[1]);
2816                         bnx2x_attn_int_deasserted2(bp,
2817                                         attn.sig[2] & group_mask.sig[2]);
2818                         bnx2x_attn_int_deasserted0(bp,
2819                                         attn.sig[0] & group_mask.sig[0]);
2820
2821                         if ((attn.sig[0] & group_mask.sig[0] &
2822                                                 HW_PRTY_ASSERT_SET_0) ||
2823                             (attn.sig[1] & group_mask.sig[1] &
2824                                                 HW_PRTY_ASSERT_SET_1) ||
2825                             (attn.sig[2] & group_mask.sig[2] &
2826                                                 HW_PRTY_ASSERT_SET_2))
2827                                 BNX2X_ERR("FATAL HW block parity attention\n");
2828                 }
2829         }
2830
2831         bnx2x_release_alr(bp);
2832
2833         reg_addr = (HC_REG_COMMAND_REG + port*32 + COMMAND_REG_ATTN_BITS_CLR);
2834
2835         val = ~deasserted;
2836         DP(NETIF_MSG_HW, "about to mask 0x%08x at HC addr 0x%x\n",
2837            val, reg_addr);
2838         REG_WR(bp, reg_addr, val);
2839
2840         if (~bp->attn_state & deasserted)
2841                 BNX2X_ERR("IGU ERROR\n");
2842
2843         reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
2844                           MISC_REG_AEU_MASK_ATTN_FUNC_0;
2845
2846         bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2847         aeu_mask = REG_RD(bp, reg_addr);
2848
2849         DP(NETIF_MSG_HW, "aeu_mask %x  newly deasserted %x\n",
2850            aeu_mask, deasserted);
2851         aeu_mask |= (deasserted & 0xff);
2852         DP(NETIF_MSG_HW, "new mask %x\n", aeu_mask);
2853
2854         REG_WR(bp, reg_addr, aeu_mask);
2855         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
2856
2857         DP(NETIF_MSG_HW, "attn_state %x\n", bp->attn_state);
2858         bp->attn_state &= ~deasserted;
2859         DP(NETIF_MSG_HW, "new state %x\n", bp->attn_state);
2860 }
2861
2862 static void bnx2x_attn_int(struct bnx2x *bp)
2863 {
2864         /* read local copy of bits */
2865         u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
2866                                                                 attn_bits);
2867         u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
2868                                                                 attn_bits_ack);
2869         u32 attn_state = bp->attn_state;
2870
2871         /* look for changed bits */
2872         u32 asserted   =  attn_bits & ~attn_ack & ~attn_state;
2873         u32 deasserted = ~attn_bits &  attn_ack &  attn_state;
2874
2875         DP(NETIF_MSG_HW,
2876            "attn_bits %x  attn_ack %x  asserted %x  deasserted %x\n",
2877            attn_bits, attn_ack, asserted, deasserted);
2878
2879         if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state))
2880                 BNX2X_ERR("BAD attention state\n");
2881
2882         /* handle bits that were raised */
2883         if (asserted)
2884                 bnx2x_attn_int_asserted(bp, asserted);
2885
2886         if (deasserted)
2887                 bnx2x_attn_int_deasserted(bp, deasserted);
2888 }
2889
2890 static void bnx2x_sp_task(struct work_struct *work)
2891 {
2892         struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
2893         u16 status;
2894
2895
2896         /* Return here if interrupt is disabled */
2897         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
2898                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
2899                 return;
2900         }
2901
2902         status = bnx2x_update_dsb_idx(bp);
2903 /*      if (status == 0)                                     */
2904 /*              BNX2X_ERR("spurious slowpath interrupt!\n"); */
2905
2906         DP(NETIF_MSG_INTR, "got a slowpath interrupt (updated %x)\n", status);
2907
2908         /* HW attentions */
2909         if (status & 0x1)
2910                 bnx2x_attn_int(bp);
2911
2912         bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, le16_to_cpu(bp->def_att_idx),
2913                      IGU_INT_NOP, 1);
2914         bnx2x_ack_sb(bp, DEF_SB_ID, USTORM_ID, le16_to_cpu(bp->def_u_idx),
2915                      IGU_INT_NOP, 1);
2916         bnx2x_ack_sb(bp, DEF_SB_ID, CSTORM_ID, le16_to_cpu(bp->def_c_idx),
2917                      IGU_INT_NOP, 1);
2918         bnx2x_ack_sb(bp, DEF_SB_ID, XSTORM_ID, le16_to_cpu(bp->def_x_idx),
2919                      IGU_INT_NOP, 1);
2920         bnx2x_ack_sb(bp, DEF_SB_ID, TSTORM_ID, le16_to_cpu(bp->def_t_idx),
2921                      IGU_INT_ENABLE, 1);
2922
2923 }
2924
2925 static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
2926 {
2927         struct net_device *dev = dev_instance;
2928         struct bnx2x *bp = netdev_priv(dev);
2929
2930         /* Return here if interrupt is disabled */
2931         if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
2932                 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
2933                 return IRQ_HANDLED;
2934         }
2935
2936         bnx2x_ack_sb(bp, DEF_SB_ID, TSTORM_ID, 0, IGU_INT_DISABLE, 0);
2937
2938 #ifdef BNX2X_STOP_ON_ERROR
2939         if (unlikely(bp->panic))
2940                 return IRQ_HANDLED;
2941 #endif
2942
2943         queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
2944
2945         return IRQ_HANDLED;
2946 }
2947
2948 /* end of slow path */
2949
2950 /* Statistics */
2951
2952 /****************************************************************************
2953 * Macros
2954 ****************************************************************************/
2955
2956 /* sum[hi:lo] += add[hi:lo] */
2957 #define ADD_64(s_hi, a_hi, s_lo, a_lo) \
2958         do { \
2959                 s_lo += a_lo; \
2960                 s_hi += a_hi + ((s_lo < a_lo) ? 1 : 0); \
2961         } while (0)
2962
2963 /* difference = minuend - subtrahend */
2964 #define DIFF_64(d_hi, m_hi, s_hi, d_lo, m_lo, s_lo) \
2965         do { \
2966                 if (m_lo < s_lo) { \
2967                         /* underflow */ \
2968                         d_hi = m_hi - s_hi; \
2969                         if (d_hi > 0) { \
2970                                 /* we can 'loan' 1 */ \
2971                                 d_hi--; \
2972                                 d_lo = m_lo + (UINT_MAX - s_lo) + 1; \
2973                         } else { \
2974                                 /* m_hi <= s_hi */ \
2975                                 d_hi = 0; \
2976                                 d_lo = 0; \
2977                         } \
2978                 } else { \
2979                         /* m_lo >= s_lo */ \
2980                         if (m_hi < s_hi) { \
2981                                 d_hi = 0; \
2982                                 d_lo = 0; \
2983                         } else { \
2984                                 /* m_hi >= s_hi */ \
2985                                 d_hi = m_hi - s_hi; \
2986                                 d_lo = m_lo - s_lo; \
2987                         } \
2988                 } \
2989         } while (0)
2990
2991 #define UPDATE_STAT64(s, t) \
2992         do { \
2993                 DIFF_64(diff.hi, new->s##_hi, pstats->mac_stx[0].t##_hi, \
2994                         diff.lo, new->s##_lo, pstats->mac_stx[0].t##_lo); \
2995                 pstats->mac_stx[0].t##_hi = new->s##_hi; \
2996                 pstats->mac_stx[0].t##_lo = new->s##_lo; \
2997                 ADD_64(pstats->mac_stx[1].t##_hi, diff.hi, \
2998                        pstats->mac_stx[1].t##_lo, diff.lo); \
2999         } while (0)
3000
3001 #define UPDATE_STAT64_NIG(s, t) \
3002         do { \
3003                 DIFF_64(diff.hi, new->s##_hi, old->s##_hi, \
3004                         diff.lo, new->s##_lo, old->s##_lo); \
3005                 ADD_64(estats->t##_hi, diff.hi, \
3006                        estats->t##_lo, diff.lo); \
3007         } while (0)
3008
3009 /* sum[hi:lo] += add */
3010 #define ADD_EXTEND_64(s_hi, s_lo, a) \
3011         do { \
3012                 s_lo += a; \
3013                 s_hi += (s_lo < a) ? 1 : 0; \
3014         } while (0)
3015
3016 #define UPDATE_EXTEND_STAT(s) \
3017         do { \
3018                 ADD_EXTEND_64(pstats->mac_stx[1].s##_hi, \
3019                               pstats->mac_stx[1].s##_lo, \
3020                               new->s); \
3021         } while (0)
3022
3023 #define UPDATE_EXTEND_TSTAT(s, t) \
3024         do { \
3025                 diff = le32_to_cpu(tclient->s) - le32_to_cpu(old_tclient->s); \
3026                 old_tclient->s = tclient->s; \
3027                 ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
3028         } while (0)
3029
3030 #define UPDATE_EXTEND_USTAT(s, t) \
3031         do { \
3032                 diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \
3033                 old_uclient->s = uclient->s; \
3034                 ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
3035         } while (0)
3036
3037 #define UPDATE_EXTEND_XSTAT(s, t) \
3038         do { \
3039                 diff = le32_to_cpu(xclient->s) - le32_to_cpu(old_xclient->s); \
3040                 old_xclient->s = xclient->s; \
3041                 ADD_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
3042         } while (0)
3043
3044 /* minuend -= subtrahend */
3045 #define SUB_64(m_hi, s_hi, m_lo, s_lo) \
3046         do { \
3047                 DIFF_64(m_hi, m_hi, s_hi, m_lo, m_lo, s_lo); \
3048         } while (0)
3049
3050 /* minuend[hi:lo] -= subtrahend */
3051 #define SUB_EXTEND_64(m_hi, m_lo, s) \
3052         do { \
3053                 SUB_64(m_hi, 0, m_lo, s); \
3054         } while (0)
3055
3056 #define SUB_EXTEND_USTAT(s, t) \
3057         do { \
3058                 diff = le32_to_cpu(uclient->s) - le32_to_cpu(old_uclient->s); \
3059                 SUB_EXTEND_64(qstats->t##_hi, qstats->t##_lo, diff); \
3060         } while (0)
3061
3062 /*
3063  * General service functions
3064  */
3065
3066 static inline long bnx2x_hilo(u32 *hiref)
3067 {
3068         u32 lo = *(hiref + 1);
3069 #if (BITS_PER_LONG == 64)
3070         u32 hi = *hiref;
3071
3072         return HILO_U64(hi, lo);
3073 #else
3074         return lo;
3075 #endif
3076 }
3077
3078 /*
3079  * Init service functions
3080  */
3081
3082 static void bnx2x_storm_stats_post(struct bnx2x *bp)
3083 {
3084         if (!bp->stats_pending) {
3085                 struct eth_query_ramrod_data ramrod_data = {0};
3086                 int i, rc;
3087
3088                 ramrod_data.drv_counter = bp->stats_counter++;
3089                 ramrod_data.collect_port = bp->port.pmf ? 1 : 0;
3090                 for_each_queue(bp, i)
3091                         ramrod_data.ctr_id_vector |= (1 << bp->fp[i].cl_id);
3092
3093                 rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_STAT_QUERY, 0,
3094                                    ((u32 *)&ramrod_data)[1],
3095                                    ((u32 *)&ramrod_data)[0], 0);
3096                 if (rc == 0) {
3097                         /* stats ramrod has it's own slot on the spq */
3098                         bp->spq_left++;
3099                         bp->stats_pending = 1;
3100                 }
3101         }
3102 }
3103
3104 static void bnx2x_stats_init(struct bnx2x *bp)
3105 {
3106         int port = BP_PORT(bp);
3107         int i;
3108
3109         bp->stats_pending = 0;
3110         bp->executer_idx = 0;
3111         bp->stats_counter = 0;
3112
3113         /* port stats */
3114         if (!BP_NOMCP(bp))
3115                 bp->port.port_stx = SHMEM_RD(bp, port_mb[port].port_stx);
3116         else
3117                 bp->port.port_stx = 0;
3118         DP(BNX2X_MSG_STATS, "port_stx 0x%x\n", bp->port.port_stx);
3119
3120         memset(&(bp->port.old_nig_stats), 0, sizeof(struct nig_stats));
3121         bp->port.old_nig_stats.brb_discard =
3122                         REG_RD(bp, NIG_REG_STAT0_BRB_DISCARD + port*0x38);
3123         bp->port.old_nig_stats.brb_truncate =
3124                         REG_RD(bp, NIG_REG_STAT0_BRB_TRUNCATE + port*0x38);
3125         REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT0 + port*0x50,
3126                     &(bp->port.old_nig_stats.egress_mac_pkt0_lo), 2);
3127         REG_RD_DMAE(bp, NIG_REG_STAT0_EGRESS_MAC_PKT1 + port*0x50,
3128                     &(bp->port.old_nig_stats.egress_mac_pkt1_lo), 2);
3129
3130         /* function stats */
3131         for_each_queue(bp, i) {
3132                 struct bnx2x_fastpath *fp = &bp->fp[i];
3133
3134                 memset(&fp->old_tclient, 0,
3135                        sizeof(struct tstorm_per_client_stats));
3136                 memset(&fp->old_uclient, 0,
3137                        sizeof(struct ustorm_per_client_stats));
3138                 memset(&fp->old_xclient, 0,
3139                        sizeof(struct xstorm_per_client_stats));
3140                 memset(&fp->eth_q_stats, 0, sizeof(struct bnx2x_eth_q_stats));
3141         }
3142
3143         memset(&bp->dev->stats, 0, sizeof(struct net_device_stats));
3144         memset(&bp->eth_stats, 0, sizeof(struct bnx2x_eth_stats));
3145
3146         bp->stats_state = STATS_STATE_DISABLED;
3147         if (IS_E1HMF(bp) && bp->port.pmf && bp->port.port_stx)
3148                 bnx2x_stats_handle(bp, STATS_EVENT_PMF);
3149 }
3150
3151 static void bnx2x_hw_stats_post(struct bnx2x *bp)
3152 {
3153         struct dmae_command *dmae = &bp->stats_dmae;
3154         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3155
3156         *stats_comp = DMAE_COMP_VAL;
3157         if (CHIP_REV_IS_SLOW(bp))
3158                 return;
3159
3160         /* loader */
3161         if (bp->executer_idx) {
3162                 int loader_idx = PMF_DMAE_C(bp);
3163
3164                 memset(dmae, 0, sizeof(struct dmae_command));
3165
3166                 dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3167                                 DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3168                                 DMAE_CMD_DST_RESET |
3169 #ifdef __BIG_ENDIAN
3170                                 DMAE_CMD_ENDIANITY_B_DW_SWAP |
3171 #else
3172                                 DMAE_CMD_ENDIANITY_DW_SWAP |
3173 #endif
3174                                 (BP_PORT(bp) ? DMAE_CMD_PORT_1 :
3175                                                DMAE_CMD_PORT_0) |
3176                                 (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3177                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, dmae[0]));
3178                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, dmae[0]));
3179                 dmae->dst_addr_lo = (DMAE_REG_CMD_MEM +
3180                                      sizeof(struct dmae_command) *
3181                                      (loader_idx + 1)) >> 2;
3182                 dmae->dst_addr_hi = 0;
3183                 dmae->len = sizeof(struct dmae_command) >> 2;
3184                 if (CHIP_IS_E1(bp))
3185                         dmae->len--;
3186                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx + 1] >> 2;
3187                 dmae->comp_addr_hi = 0;
3188                 dmae->comp_val = 1;
3189
3190                 *stats_comp = 0;
3191                 bnx2x_post_dmae(bp, dmae, loader_idx);
3192
3193         } else if (bp->func_stx) {
3194                 *stats_comp = 0;
3195                 bnx2x_post_dmae(bp, dmae, INIT_DMAE_C(bp));
3196         }
3197 }
3198
3199 static int bnx2x_stats_comp(struct bnx2x *bp)
3200 {
3201         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3202         int cnt = 10;
3203
3204         might_sleep();
3205         while (*stats_comp != DMAE_COMP_VAL) {
3206                 if (!cnt) {
3207                         BNX2X_ERR("timeout waiting for stats finished\n");
3208                         break;
3209                 }
3210                 cnt--;
3211                 msleep(1);
3212         }
3213         return 1;
3214 }
3215
3216 /*
3217  * Statistics service functions
3218  */
3219
3220 static void bnx2x_stats_pmf_update(struct bnx2x *bp)
3221 {
3222         struct dmae_command *dmae;
3223         u32 opcode;
3224         int loader_idx = PMF_DMAE_C(bp);
3225         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3226
3227         /* sanity */
3228         if (!IS_E1HMF(bp) || !bp->port.pmf || !bp->port.port_stx) {
3229                 BNX2X_ERR("BUG!\n");
3230                 return;
3231         }
3232
3233         bp->executer_idx = 0;
3234
3235         opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3236                   DMAE_CMD_C_ENABLE |
3237                   DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3238 #ifdef __BIG_ENDIAN
3239                   DMAE_CMD_ENDIANITY_B_DW_SWAP |
3240 #else
3241                   DMAE_CMD_ENDIANITY_DW_SWAP |
3242 #endif
3243                   (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3244                   (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3245
3246         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3247         dmae->opcode = (opcode | DMAE_CMD_C_DST_GRC);
3248         dmae->src_addr_lo = bp->port.port_stx >> 2;
3249         dmae->src_addr_hi = 0;
3250         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
3251         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
3252         dmae->len = DMAE_LEN32_RD_MAX;
3253         dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3254         dmae->comp_addr_hi = 0;
3255         dmae->comp_val = 1;
3256
3257         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3258         dmae->opcode = (opcode | DMAE_CMD_C_DST_PCI);
3259         dmae->src_addr_lo = (bp->port.port_stx >> 2) + DMAE_LEN32_RD_MAX;
3260         dmae->src_addr_hi = 0;
3261         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats) +
3262                                    DMAE_LEN32_RD_MAX * 4);
3263         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats) +
3264                                    DMAE_LEN32_RD_MAX * 4);
3265         dmae->len = (sizeof(struct host_port_stats) >> 2) - DMAE_LEN32_RD_MAX;
3266         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3267         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3268         dmae->comp_val = DMAE_COMP_VAL;
3269
3270         *stats_comp = 0;
3271         bnx2x_hw_stats_post(bp);
3272         bnx2x_stats_comp(bp);
3273 }
3274
3275 static void bnx2x_port_stats_init(struct bnx2x *bp)
3276 {
3277         struct dmae_command *dmae;
3278         int port = BP_PORT(bp);
3279         int vn = BP_E1HVN(bp);
3280         u32 opcode;
3281         int loader_idx = PMF_DMAE_C(bp);
3282         u32 mac_addr;
3283         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3284
3285         /* sanity */
3286         if (!bp->link_vars.link_up || !bp->port.pmf) {
3287                 BNX2X_ERR("BUG!\n");
3288                 return;
3289         }
3290
3291         bp->executer_idx = 0;
3292
3293         /* MCP */
3294         opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3295                   DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3296                   DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3297 #ifdef __BIG_ENDIAN
3298                   DMAE_CMD_ENDIANITY_B_DW_SWAP |
3299 #else
3300                   DMAE_CMD_ENDIANITY_DW_SWAP |
3301 #endif
3302                   (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3303                   (vn << DMAE_CMD_E1HVN_SHIFT));
3304
3305         if (bp->port.port_stx) {
3306
3307                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3308                 dmae->opcode = opcode;
3309                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
3310                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
3311                 dmae->dst_addr_lo = bp->port.port_stx >> 2;
3312                 dmae->dst_addr_hi = 0;
3313                 dmae->len = sizeof(struct host_port_stats) >> 2;
3314                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3315                 dmae->comp_addr_hi = 0;
3316                 dmae->comp_val = 1;
3317         }
3318
3319         if (bp->func_stx) {
3320
3321                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3322                 dmae->opcode = opcode;
3323                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
3324                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
3325                 dmae->dst_addr_lo = bp->func_stx >> 2;
3326                 dmae->dst_addr_hi = 0;
3327                 dmae->len = sizeof(struct host_func_stats) >> 2;
3328                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3329                 dmae->comp_addr_hi = 0;
3330                 dmae->comp_val = 1;
3331         }
3332
3333         /* MAC */
3334         opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3335                   DMAE_CMD_C_DST_GRC | DMAE_CMD_C_ENABLE |
3336                   DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3337 #ifdef __BIG_ENDIAN
3338                   DMAE_CMD_ENDIANITY_B_DW_SWAP |
3339 #else
3340                   DMAE_CMD_ENDIANITY_DW_SWAP |
3341 #endif
3342                   (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3343                   (vn << DMAE_CMD_E1HVN_SHIFT));
3344
3345         if (bp->link_vars.mac_type == MAC_TYPE_BMAC) {
3346
3347                 mac_addr = (port ? NIG_REG_INGRESS_BMAC1_MEM :
3348                                    NIG_REG_INGRESS_BMAC0_MEM);
3349
3350                 /* BIGMAC_REGISTER_TX_STAT_GTPKT ..
3351                    BIGMAC_REGISTER_TX_STAT_GTBYT */
3352                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3353                 dmae->opcode = opcode;
3354                 dmae->src_addr_lo = (mac_addr +
3355                                      BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
3356                 dmae->src_addr_hi = 0;
3357                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
3358                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
3359                 dmae->len = (8 + BIGMAC_REGISTER_TX_STAT_GTBYT -
3360                              BIGMAC_REGISTER_TX_STAT_GTPKT) >> 2;
3361                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3362                 dmae->comp_addr_hi = 0;
3363                 dmae->comp_val = 1;
3364
3365                 /* BIGMAC_REGISTER_RX_STAT_GR64 ..
3366                    BIGMAC_REGISTER_RX_STAT_GRIPJ */
3367                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3368                 dmae->opcode = opcode;
3369                 dmae->src_addr_lo = (mac_addr +
3370                                      BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
3371                 dmae->src_addr_hi = 0;
3372                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3373                                 offsetof(struct bmac_stats, rx_stat_gr64_lo));
3374                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3375                                 offsetof(struct bmac_stats, rx_stat_gr64_lo));
3376                 dmae->len = (8 + BIGMAC_REGISTER_RX_STAT_GRIPJ -
3377                              BIGMAC_REGISTER_RX_STAT_GR64) >> 2;
3378                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3379                 dmae->comp_addr_hi = 0;
3380                 dmae->comp_val = 1;
3381
3382         } else if (bp->link_vars.mac_type == MAC_TYPE_EMAC) {
3383
3384                 mac_addr = (port ? GRCBASE_EMAC1 : GRCBASE_EMAC0);
3385
3386                 /* EMAC_REG_EMAC_RX_STAT_AC (EMAC_REG_EMAC_RX_STAT_AC_COUNT)*/
3387                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3388                 dmae->opcode = opcode;
3389                 dmae->src_addr_lo = (mac_addr +
3390                                      EMAC_REG_EMAC_RX_STAT_AC) >> 2;
3391                 dmae->src_addr_hi = 0;
3392                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats));
3393                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats));
3394                 dmae->len = EMAC_REG_EMAC_RX_STAT_AC_COUNT;
3395                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3396                 dmae->comp_addr_hi = 0;
3397                 dmae->comp_val = 1;
3398
3399                 /* EMAC_REG_EMAC_RX_STAT_AC_28 */
3400                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3401                 dmae->opcode = opcode;
3402                 dmae->src_addr_lo = (mac_addr +
3403                                      EMAC_REG_EMAC_RX_STAT_AC_28) >> 2;
3404                 dmae->src_addr_hi = 0;
3405                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3406                      offsetof(struct emac_stats, rx_stat_falsecarriererrors));
3407                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3408                      offsetof(struct emac_stats, rx_stat_falsecarriererrors));
3409                 dmae->len = 1;
3410                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3411                 dmae->comp_addr_hi = 0;
3412                 dmae->comp_val = 1;
3413
3414                 /* EMAC_REG_EMAC_TX_STAT_AC (EMAC_REG_EMAC_TX_STAT_AC_COUNT)*/
3415                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3416                 dmae->opcode = opcode;
3417                 dmae->src_addr_lo = (mac_addr +
3418                                      EMAC_REG_EMAC_TX_STAT_AC) >> 2;
3419                 dmae->src_addr_hi = 0;
3420                 dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, mac_stats) +
3421                         offsetof(struct emac_stats, tx_stat_ifhcoutoctets));
3422                 dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, mac_stats) +
3423                         offsetof(struct emac_stats, tx_stat_ifhcoutoctets));
3424                 dmae->len = EMAC_REG_EMAC_TX_STAT_AC_COUNT;
3425                 dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3426                 dmae->comp_addr_hi = 0;
3427                 dmae->comp_val = 1;
3428         }
3429
3430         /* NIG */
3431         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3432         dmae->opcode = opcode;
3433         dmae->src_addr_lo = (port ? NIG_REG_STAT1_BRB_DISCARD :
3434                                     NIG_REG_STAT0_BRB_DISCARD) >> 2;
3435         dmae->src_addr_hi = 0;
3436         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats));
3437         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats));
3438         dmae->len = (sizeof(struct nig_stats) - 4*sizeof(u32)) >> 2;
3439         dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3440         dmae->comp_addr_hi = 0;
3441         dmae->comp_val = 1;
3442
3443         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3444         dmae->opcode = opcode;
3445         dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT0 :
3446                                     NIG_REG_STAT0_EGRESS_MAC_PKT0) >> 2;
3447         dmae->src_addr_hi = 0;
3448         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
3449                         offsetof(struct nig_stats, egress_mac_pkt0_lo));
3450         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
3451                         offsetof(struct nig_stats, egress_mac_pkt0_lo));
3452         dmae->len = (2*sizeof(u32)) >> 2;
3453         dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
3454         dmae->comp_addr_hi = 0;
3455         dmae->comp_val = 1;
3456
3457         dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
3458         dmae->opcode = (DMAE_CMD_SRC_GRC | DMAE_CMD_DST_PCI |
3459                         DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
3460                         DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3461 #ifdef __BIG_ENDIAN
3462                         DMAE_CMD_ENDIANITY_B_DW_SWAP |
3463 #else
3464                         DMAE_CMD_ENDIANITY_DW_SWAP |
3465 #endif
3466                         (port ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3467                         (vn << DMAE_CMD_E1HVN_SHIFT));
3468         dmae->src_addr_lo = (port ? NIG_REG_STAT1_EGRESS_MAC_PKT1 :
3469                                     NIG_REG_STAT0_EGRESS_MAC_PKT1) >> 2;
3470         dmae->src_addr_hi = 0;
3471         dmae->dst_addr_lo = U64_LO(bnx2x_sp_mapping(bp, nig_stats) +
3472                         offsetof(struct nig_stats, egress_mac_pkt1_lo));
3473         dmae->dst_addr_hi = U64_HI(bnx2x_sp_mapping(bp, nig_stats) +
3474                         offsetof(struct nig_stats, egress_mac_pkt1_lo));
3475         dmae->len = (2*sizeof(u32)) >> 2;
3476         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3477         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3478         dmae->comp_val = DMAE_COMP_VAL;
3479
3480         *stats_comp = 0;
3481 }
3482
3483 static void bnx2x_func_stats_init(struct bnx2x *bp)
3484 {
3485         struct dmae_command *dmae = &bp->stats_dmae;
3486         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3487
3488         /* sanity */
3489         if (!bp->func_stx) {
3490                 BNX2X_ERR("BUG!\n");
3491                 return;
3492         }
3493
3494         bp->executer_idx = 0;
3495         memset(dmae, 0, sizeof(struct dmae_command));
3496
3497         dmae->opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
3498                         DMAE_CMD_C_DST_PCI | DMAE_CMD_C_ENABLE |
3499                         DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
3500 #ifdef __BIG_ENDIAN
3501                         DMAE_CMD_ENDIANITY_B_DW_SWAP |
3502 #else
3503                         DMAE_CMD_ENDIANITY_DW_SWAP |
3504 #endif
3505                         (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
3506                         (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
3507         dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
3508         dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
3509         dmae->dst_addr_lo = bp->func_stx >> 2;
3510         dmae->dst_addr_hi = 0;
3511         dmae->len = sizeof(struct host_func_stats) >> 2;
3512         dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
3513         dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
3514         dmae->comp_val = DMAE_COMP_VAL;
3515
3516         *stats_comp = 0;
3517 }
3518
3519 static void bnx2x_stats_start(struct bnx2x *bp)
3520 {
3521         if (bp->port.pmf)
3522                 bnx2x_port_stats_init(bp);
3523
3524         else if (bp->func_stx)
3525                 bnx2x_func_stats_init(bp);
3526
3527         bnx2x_hw_stats_post(bp);
3528         bnx2x_storm_stats_post(bp);
3529 }
3530
3531 static void bnx2x_stats_pmf_start(struct bnx2x *bp)
3532 {
3533         bnx2x_stats_comp(bp);
3534         bnx2x_stats_pmf_update(bp);
3535         bnx2x_stats_start(bp);
3536 }
3537
3538 static void bnx2x_stats_restart(struct bnx2x *bp)
3539 {
3540         bnx2x_stats_comp(bp);
3541         bnx2x_stats_start(bp);
3542 }
3543
3544 static void bnx2x_bmac_stats_update(struct bnx2x *bp)
3545 {
3546         struct bmac_stats *new = bnx2x_sp(bp, mac_stats.bmac_stats);
3547         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
3548         struct bnx2x_eth_stats *estats = &bp->eth_stats;
3549         struct {
3550                 u32 lo;
3551                 u32 hi;
3552         } diff;
3553
3554         UPDATE_STAT64(rx_stat_grerb, rx_stat_ifhcinbadoctets);
3555         UPDATE_STAT64(rx_stat_grfcs, rx_stat_dot3statsfcserrors);
3556         UPDATE_STAT64(rx_stat_grund, rx_stat_etherstatsundersizepkts);
3557         UPDATE_STAT64(rx_stat_grovr, rx_stat_dot3statsframestoolong);
3558         UPDATE_STAT64(rx_stat_grfrg, rx_stat_etherstatsfragments);
3559         UPDATE_STAT64(rx_stat_grjbr, rx_stat_etherstatsjabbers);
3560         UPDATE_STAT64(rx_stat_grxcf, rx_stat_maccontrolframesreceived);
3561         UPDATE_STAT64(rx_stat_grxpf, rx_stat_xoffstateentered);
3562         UPDATE_STAT64(rx_stat_grxpf, rx_stat_bmac_xpf);
3563         UPDATE_STAT64(tx_stat_gtxpf, tx_stat_outxoffsent);
3564         UPDATE_STAT64(tx_stat_gtxpf, tx_stat_flowcontroldone);
3565         UPDATE_STAT64(tx_stat_gt64, tx_stat_etherstatspkts64octets);
3566         UPDATE_STAT64(tx_stat_gt127,
3567                                 tx_stat_etherstatspkts65octetsto127octets);
3568         UPDATE_STAT64(tx_stat_gt255,
3569                                 tx_stat_etherstatspkts128octetsto255octets);
3570         UPDATE_STAT64(tx_stat_gt511,
3571                                 tx_stat_etherstatspkts256octetsto511octets);
3572         UPDATE_STAT64(tx_stat_gt1023,
3573                                 tx_stat_etherstatspkts512octetsto1023octets);
3574         UPDATE_STAT64(tx_stat_gt1518,
3575                                 tx_stat_etherstatspkts1024octetsto1522octets);
3576         UPDATE_STAT64(tx_stat_gt2047, tx_stat_bmac_2047);
3577         UPDATE_STAT64(tx_stat_gt4095, tx_stat_bmac_4095);
3578         UPDATE_STAT64(tx_stat_gt9216, tx_stat_bmac_9216);
3579         UPDATE_STAT64(tx_stat_gt16383, tx_stat_bmac_16383);
3580         UPDATE_STAT64(tx_stat_gterr,
3581                                 tx_stat_dot3statsinternalmactransmiterrors);
3582         UPDATE_STAT64(tx_stat_gtufl, tx_stat_bmac_ufl);
3583
3584         estats->pause_frames_received_hi =
3585                                 pstats->mac_stx[1].rx_stat_bmac_xpf_hi;
3586         estats->pause_frames_received_lo =
3587                                 pstats->mac_stx[1].rx_stat_bmac_xpf_lo;
3588
3589         estats->pause_frames_sent_hi =
3590                                 pstats->mac_stx[1].tx_stat_outxoffsent_hi;
3591         estats->pause_frames_sent_lo =
3592                                 pstats->mac_stx[1].tx_stat_outxoffsent_lo;
3593 }
3594
3595 static void bnx2x_emac_stats_update(struct bnx2x *bp)
3596 {
3597         struct emac_stats *new = bnx2x_sp(bp, mac_stats.emac_stats);
3598         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
3599         struct bnx2x_eth_stats *estats = &bp->eth_stats;
3600
3601         UPDATE_EXTEND_STAT(rx_stat_ifhcinbadoctets);
3602         UPDATE_EXTEND_STAT(tx_stat_ifhcoutbadoctets);
3603         UPDATE_EXTEND_STAT(rx_stat_dot3statsfcserrors);
3604         UPDATE_EXTEND_STAT(rx_stat_dot3statsalignmenterrors);
3605         UPDATE_EXTEND_STAT(rx_stat_dot3statscarriersenseerrors);
3606         UPDATE_EXTEND_STAT(rx_stat_falsecarriererrors);
3607         UPDATE_EXTEND_STAT(rx_stat_etherstatsundersizepkts);
3608         UPDATE_EXTEND_STAT(rx_stat_dot3statsframestoolong);
3609         UPDATE_EXTEND_STAT(rx_stat_etherstatsfragments);
3610         UPDATE_EXTEND_STAT(rx_stat_etherstatsjabbers);
3611         UPDATE_EXTEND_STAT(rx_stat_maccontrolframesreceived);
3612         UPDATE_EXTEND_STAT(rx_stat_xoffstateentered);
3613         UPDATE_EXTEND_STAT(rx_stat_xonpauseframesreceived);
3614         UPDATE_EXTEND_STAT(rx_stat_xoffpauseframesreceived);
3615         UPDATE_EXTEND_STAT(tx_stat_outxonsent);
3616         UPDATE_EXTEND_STAT(tx_stat_outxoffsent);
3617         UPDATE_EXTEND_STAT(tx_stat_flowcontroldone);
3618         UPDATE_EXTEND_STAT(tx_stat_etherstatscollisions);
3619         UPDATE_EXTEND_STAT(tx_stat_dot3statssinglecollisionframes);
3620         UPDATE_EXTEND_STAT(tx_stat_dot3statsmultiplecollisionframes);
3621         UPDATE_EXTEND_STAT(tx_stat_dot3statsdeferredtransmissions);
3622         UPDATE_EXTEND_STAT(tx_stat_dot3statsexcessivecollisions);
3623         UPDATE_EXTEND_STAT(tx_stat_dot3statslatecollisions);
3624         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts64octets);
3625         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts65octetsto127octets);
3626         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts128octetsto255octets);
3627         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts256octetsto511octets);
3628         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts512octetsto1023octets);
3629         UPDATE_EXTEND_STAT(tx_stat_etherstatspkts1024octetsto1522octets);
3630         UPDATE_EXTEND_STAT(tx_stat_etherstatspktsover1522octets);
3631         UPDATE_EXTEND_STAT(tx_stat_dot3statsinternalmactransmiterrors);
3632
3633         estats->pause_frames_received_hi =
3634                         pstats->mac_stx[1].rx_stat_xonpauseframesreceived_hi;
3635         estats->pause_frames_received_lo =
3636                         pstats->mac_stx[1].rx_stat_xonpauseframesreceived_lo;
3637         ADD_64(estats->pause_frames_received_hi,
3638                pstats->mac_stx[1].rx_stat_xoffpauseframesreceived_hi,
3639                estats->pause_frames_received_lo,
3640                pstats->mac_stx[1].rx_stat_xoffpauseframesreceived_lo);
3641
3642         estats->pause_frames_sent_hi =
3643                         pstats->mac_stx[1].tx_stat_outxonsent_hi;
3644         estats->pause_frames_sent_lo =
3645                         pstats->mac_stx[1].tx_stat_outxonsent_lo;
3646         ADD_64(estats->pause_frames_sent_hi,
3647                pstats->mac_stx[1].tx_stat_outxoffsent_hi,
3648                estats->pause_frames_sent_lo,
3649                pstats->mac_stx[1].tx_stat_outxoffsent_lo);
3650 }
3651
3652 static int bnx2x_hw_stats_update(struct bnx2x *bp)
3653 {
3654         struct nig_stats *new = bnx2x_sp(bp, nig_stats);
3655         struct nig_stats *old = &(bp->port.old_nig_stats);
3656         struct host_port_stats *pstats = bnx2x_sp(bp, port_stats);
3657         struct bnx2x_eth_stats *estats = &bp->eth_stats;
3658         struct {
3659                 u32 lo;
3660                 u32 hi;
3661         } diff;
3662         u32 nig_timer_max;
3663
3664         if (bp->link_vars.mac_type == MAC_TYPE_BMAC)
3665                 bnx2x_bmac_stats_update(bp);
3666
3667         else if (bp->link_vars.mac_type == MAC_TYPE_EMAC)
3668                 bnx2x_emac_stats_update(bp);
3669
3670         else { /* unreached */
3671                 BNX2X_ERR("stats updated by DMAE but no MAC active\n");
3672                 return -1;
3673         }
3674
3675         ADD_EXTEND_64(pstats->brb_drop_hi, pstats->brb_drop_lo,
3676                       new->brb_discard - old->brb_discard);
3677         ADD_EXTEND_64(estats->brb_truncate_hi, estats->brb_truncate_lo,
3678                       new->brb_truncate - old->brb_truncate);
3679
3680         UPDATE_STAT64_NIG(egress_mac_pkt0,
3681                                         etherstatspkts1024octetsto1522octets);
3682         UPDATE_STAT64_NIG(egress_mac_pkt1, etherstatspktsover1522octets);
3683
3684         memcpy(old, new, sizeof(struct nig_stats));
3685
3686         memcpy(&(estats->rx_stat_ifhcinbadoctets_hi), &(pstats->mac_stx[1]),
3687                sizeof(struct mac_stx));
3688         estats->brb_drop_hi = pstats->brb_drop_hi;
3689         estats->brb_drop_lo = pstats->brb_drop_lo;
3690
3691         pstats->host_port_stats_start = ++pstats->host_port_stats_end;
3692
3693         nig_timer_max = SHMEM_RD(bp, port_mb[BP_PORT(bp)].stat_nig_timer);
3694         if (nig_timer_max != estats->nig_timer_max) {
3695                 estats->nig_timer_max = nig_timer_max;
3696                 BNX2X_ERR("NIG timer max (%u)\n", estats->nig_timer_max);
3697         }
3698
3699         return 0;
3700 }
3701
3702 static int bnx2x_storm_stats_update(struct bnx2x *bp)
3703 {
3704         struct eth_stats_query *stats = bnx2x_sp(bp, fw_stats);
3705         struct tstorm_per_port_stats *tport =
3706                                         &stats->tstorm_common.port_statistics;
3707         struct host_func_stats *fstats = bnx2x_sp(bp, func_stats);
3708         struct bnx2x_eth_stats *estats = &bp->eth_stats;
3709         int i;
3710
3711         memset(&(fstats->total_bytes_received_hi), 0,
3712                sizeof(struct host_func_stats) - 2*sizeof(u32));
3713         estats->error_bytes_received_hi = 0;
3714         estats->error_bytes_received_lo = 0;
3715         estats->etherstatsoverrsizepkts_hi = 0;
3716         estats->etherstatsoverrsizepkts_lo = 0;
3717         estats->no_buff_discard_hi = 0;
3718         estats->no_buff_discard_lo = 0;
3719
3720         for_each_queue(bp, i) {
3721                 struct bnx2x_fastpath *fp = &bp->fp[i];
3722                 int cl_id = fp->cl_id;
3723                 struct tstorm_per_client_stats *tclient =
3724                                 &stats->tstorm_common.client_statistics[cl_id];
3725                 struct tstorm_per_client_stats *old_tclient = &fp->old_tclient;
3726                 struct ustorm_per_client_stats *uclient =
3727                                 &stats->ustorm_common.client_statistics[cl_id];
3728                 struct ustorm_per_client_stats *old_uclient = &fp->old_uclient;
3729                 struct xstorm_per_client_stats *xclient =
3730                                 &stats->xstorm_common.client_statistics[cl_id];
3731                 struct xstorm_per_client_stats *old_xclient = &fp->old_xclient;
3732                 struct bnx2x_eth_q_stats *qstats = &fp->eth_q_stats;
3733                 u32 diff;
3734
3735                 /* are storm stats valid? */
3736                 if ((u16)(le16_to_cpu(xclient->stats_counter) + 1) !=
3737                                                         bp->stats_counter) {
3738                         DP(BNX2X_MSG_STATS, "[%d] stats not updated by xstorm"
3739                            "  xstorm counter (%d) != stats_counter (%d)\n",
3740                            i, xclient->stats_counter, bp->stats_counter);
3741                         return -1;
3742                 }
3743                 if ((u16)(le16_to_cpu(tclient->stats_counter) + 1) !=
3744                                                         bp->stats_counter) {
3745                         DP(BNX2X_MSG_STATS, "[%d] stats not updated by tstorm"
3746                            "  tstorm counter (%d) != stats_counter (%d)\n",
3747                            i, tclient->stats_counter, bp->stats_counter);
3748                         return -2;
3749                 }
3750                 if ((u16)(le16_to_cpu(uclient->stats_counter) + 1) !=
3751                                                         bp->stats_counter) {
3752                         DP(BNX2X_MSG_STATS, "[%d] stats not updated by ustorm"
3753                            "  ustorm counter (%d) != stats_counter (%d)\n",
3754                            i, uclient->stats_counter, bp->stats_counter);
3755                         return -4;
3756                 }
3757
3758                 qstats->total_bytes_received_hi =
3759                 qstats->valid_bytes_received_hi =
3760                                 le32_to_cpu(tclient->total_rcv_bytes.hi);
3761                 qstats->total_bytes_received_lo =
3762                 qstats->valid_bytes_received_lo =
3763                                 le32_to_cpu(tclient->total_rcv_bytes.lo);
3764
3765                 qstats->error_bytes_received_hi =
3766                                 le32_to_cpu(tclient->rcv_error_bytes.hi);
3767                 qstats->error_bytes_received_lo =
3768                                 le32_to_cpu(tclient->rcv_error_bytes.lo);
3769
3770                 ADD_64(qstats->total_bytes_received_hi,
3771                        qstats->error_bytes_received_hi,
3772                        qstats->total_bytes_received_lo,
3773                        qstats->error_bytes_received_lo);
3774
3775                 UPDATE_EXTEND_TSTAT(rcv_unicast_pkts,
3776                                         total_unicast_packets_received);
3777                 UPDATE_EXTEND_TSTAT(rcv_multicast_pkts,
3778                                         total_multicast_packets_received);
3779                 UPDATE_EXTEND_TSTAT(rcv_broadcast_pkts,
3780                                         total_broadcast_packets_received);
3781                 UPDATE_EXTEND_TSTAT(packets_too_big_discard,
3782                                         etherstatsoverrsizepkts);
3783                 UPDATE_EXTEND_TSTAT(no_buff_discard, no_buff_discard);
3784
3785                 SUB_EXTEND_USTAT(ucast_no_buff_pkts,
3786                                         total_unicast_packets_received);
3787                 SUB_EXTEND_USTAT(mcast_no_buff_pkts,
3788                                         total_multicast_packets_received);
3789                 SUB_EXTEND_USTAT(bcast_no_buff_pkts,
3790                                         total_broadcast_packets_received);
3791                 UPDATE_EXTEND_USTAT(ucast_no_buff_pkts, no_buff_discard);
3792                 UPDATE_EXTEND_USTAT(mcast_no_buff_pkts, no_buff_discard);
3793                 UPDATE_EXTEND_USTAT(bcast_no_buff_pkts, no_buff_discard);
3794
3795                 qstats->total_bytes_transmitted_hi =
3796                                 le32_to_cpu(xclient->total_sent_bytes.hi);
3797                 qstats->total_bytes_transmitted_lo =
3798                                 le32_to_cpu(xclient->total_sent_bytes.lo);
3799
3800                 UPDATE_EXTEND_XSTAT(unicast_pkts_sent,
3801                                         total_unicast_packets_transmitted);
3802                 UPDATE_EXTEND_XSTAT(multicast_pkts_sent,
3803                                         total_multicast_packets_transmitted);
3804                 UPDATE_EXTEND_XSTAT(broadcast_pkts_sent,
3805                                         total_broadcast_packets_transmitted);
3806
3807                 old_tclient->checksum_discard = tclient->checksum_discard;
3808                 old_tclient->ttl0_discard = tclient->ttl0_discard;
3809
3810                 ADD_64(fstats->total_bytes_received_hi,
3811                        qstats->total_bytes_received_hi,
3812                        fstats->total_bytes_received_lo,
3813                        qstats->total_bytes_received_lo);
3814                 ADD_64(fstats->total_bytes_transmitted_hi,
3815                        qstats->total_bytes_transmitted_hi,
3816                        fstats->total_bytes_transmitted_lo,
3817                        qstats->total_bytes_transmitted_lo);
3818                 ADD_64(fstats->total_unicast_packets_received_hi,
3819                        qstats->total_unicast_packets_received_hi,
3820                        fstats->total_unicast_packets_received_lo,
3821                        qstats->total_unicast_packets_received_lo);
3822                 ADD_64(fstats->total_multicast_packets_received_hi,
3823                        qstats->total_multicast_packets_received_hi,
3824                        fstats->total_multicast_packets_received_lo,
3825                        qstats->total_multicast_packets_received_lo);
3826                 ADD_64(fstats->total_broadcast_packets_received_hi,
3827                        qstats->total_broadcast_packets_received_hi,
3828                        fstats->total_broadcast_packets_received_lo,
3829                        qstats->total_broadcast_packets_received_lo);
3830                 ADD_64(fstats->total_unicast_packets_transmitted_hi,
3831                        qstats->total_unicast_packets_transmitted_hi,
3832                        fstats->total_unicast_packets_transmitted_lo,
3833                        qstats->total_unicast_packets_transmitted_lo);
3834                 ADD_64(fstats->total_multicast_packets_transmitted_hi,
3835                        qstats->total_multicast_packets_transmitted_hi,
3836                        fstats->total_multicast_packets_transmitted_lo,
3837                        qstats->total_multicast_packets_transmitted_lo);
3838                 ADD_64(fstats->total_broadcast_packets_transmitted_hi,
3839                        qstats->total_broadcast_packets_transmitted_hi,
3840                        fstats->total_broadcast_packets_transmitted_lo,
3841                        qstats->total_broadcast_packets_transmitted_lo);
3842                 ADD_64(fstats->valid_bytes_received_hi,
3843                        qstats->valid_bytes_received_hi,
3844                        fstats->valid_bytes_received_lo,
3845                        qstats->valid_bytes_received_lo);
3846
3847                 ADD_64(estats->error_bytes_received_hi,
3848                        qstats->error_bytes_received_hi,
3849                        estats->error_bytes_received_lo,
3850                        qstats->error_bytes_received_lo);
3851                 ADD_64(estats->etherstatsoverrsizepkts_hi,
3852                        qstats->etherstatsoverrsizepkts_hi,
3853                        estats->etherstatsoverrsizepkts_lo,
3854                        qstats->etherstatsoverrsizepkts_lo);
3855                 ADD_64(estats->no_buff_discard_hi, qstats->no_buff_discard_hi,
3856                        estats->no_buff_discard_lo, qstats->no_buff_discard_lo);
3857         }
3858
3859         ADD_64(fstats->total_bytes_received_hi,
3860                estats->rx_stat_ifhcinbadoctets_hi,
3861                fstats->total_bytes_received_lo,
3862                estats->rx_stat_ifhcinbadoctets_lo);
3863
3864         memcpy(estats, &(fstats->total_bytes_received_hi),
3865                sizeof(struct host_func_stats) - 2*sizeof(u32));
3866
3867         ADD_64(estats->etherstatsoverrsizepkts_hi,
3868                estats->rx_stat_dot3statsframestoolong_hi,
3869                estats->etherstatsoverrsizepkts_lo,
3870                estats->rx_stat_dot3statsframestoolong_lo);
3871         ADD_64(estats->error_bytes_received_hi,
3872                estats->rx_stat_ifhcinbadoctets_hi,
3873                estats->error_bytes_received_lo,
3874                estats->rx_stat_ifhcinbadoctets_lo);
3875
3876         if (bp->port.pmf) {
3877                 estats->mac_filter_discard =
3878                                 le32_to_cpu(tport->mac_filter_discard);
3879                 estats->xxoverflow_discard =
3880                                 le32_to_cpu(tport->xxoverflow_discard);
3881                 estats->brb_truncate_discard =
3882                                 le32_to_cpu(tport->brb_truncate_discard);
3883                 estats->mac_discard = le32_to_cpu(tport->mac_discard);
3884         }
3885
3886         fstats->host_func_stats_start = ++fstats->host_func_stats_end;
3887
3888         bp->stats_pending = 0;
3889
3890         return 0;
3891 }
3892
3893 static void bnx2x_net_stats_update(struct bnx2x *bp)
3894 {
3895         struct bnx2x_eth_stats *estats = &bp->eth_stats;
3896         struct net_device_stats *nstats = &bp->dev->stats;
3897         int i;
3898
3899         nstats->rx_packets =
3900                 bnx2x_hilo(&estats->total_unicast_packets_received_hi) +
3901                 bnx2x_hilo(&estats->total_multicast_packets_received_hi) +
3902                 bnx2x_hilo(&estats->total_broadcast_packets_received_hi);
3903
3904         nstats->tx_packets =
3905                 bnx2x_hilo(&estats->total_unicast_packets_transmitted_hi) +
3906                 bnx2x_hilo(&estats->total_multicast_packets_transmitted_hi) +
3907                 bnx2x_hilo(&estats->total_broadcast_packets_transmitted_hi);
3908
3909         nstats->rx_bytes = bnx2x_hilo(&estats->total_bytes_received_hi);
3910
3911         nstats->tx_bytes = bnx2x_hilo(&estats->total_bytes_transmitted_hi);
3912
3913         nstats->rx_dropped = estats->mac_discard;
3914         for_each_queue(bp, i)
3915                 nstats->rx_dropped +=
3916                         le32_to_cpu(bp->fp[i].old_tclient.checksum_discard);
3917
3918         nstats->tx_dropped = 0;
3919
3920         nstats->multicast =
3921                 bnx2x_hilo(&estats->total_multicast_packets_received_hi);
3922
3923         nstats->collisions =
3924                 bnx2x_hilo(&estats->tx_stat_etherstatscollisions_hi);
3925
3926         nstats->rx_length_errors =
3927                 bnx2x_hilo(&estats->rx_stat_etherstatsundersizepkts_hi) +
3928                 bnx2x_hilo(&estats->etherstatsoverrsizepkts_hi);
3929         nstats->rx_over_errors = bnx2x_hilo(&estats->brb_drop_hi) +
3930                                  bnx2x_hilo(&estats->brb_truncate_hi);
3931         nstats->rx_crc_errors =
3932                 bnx2x_hilo(&estats->rx_stat_dot3statsfcserrors_hi);
3933         nstats->rx_frame_errors =
3934                 bnx2x_hilo(&estats->rx_stat_dot3statsalignmenterrors_hi);
3935         nstats->rx_fifo_errors = bnx2x_hilo(&estats->no_buff_discard_hi);
3936         nstats->rx_missed_errors = estats->xxoverflow_discard;
3937
3938         nstats->rx_errors = nstats->rx_length_errors +
3939                             nstats->rx_over_errors +
3940                             nstats->rx_crc_errors +
3941                             nstats->rx_frame_errors +
3942                             nstats->rx_fifo_errors +
3943                             nstats->rx_missed_errors;
3944
3945         nstats->tx_aborted_errors =
3946                 bnx2x_hilo(&estats->tx_stat_dot3statslatecollisions_hi) +
3947                 bnx2x_hilo(&estats->tx_stat_dot3statsexcessivecollisions_hi);
3948         nstats->tx_carrier_errors =
3949                 bnx2x_hilo(&estats->rx_stat_dot3statscarriersenseerrors_hi);
3950         nstats->tx_fifo_errors = 0;
3951         nstats->tx_heartbeat_errors = 0;
3952         nstats->tx_window_errors = 0;
3953
3954         nstats->tx_errors = nstats->tx_aborted_errors +
3955                             nstats->tx_carrier_errors +
3956             bnx2x_hilo(&estats->tx_stat_dot3statsinternalmactransmiterrors_hi);
3957 }
3958
3959 static void bnx2x_drv_stats_update(struct bnx2x *bp)
3960 {
3961         struct bnx2x_eth_stats *estats = &bp->eth_stats;
3962         int i;
3963
3964         estats->driver_xoff = 0;
3965         estats->rx_err_discard_pkt = 0;
3966         estats->rx_skb_alloc_failed = 0;
3967         estats->hw_csum_err = 0;
3968         for_each_queue(bp, i) {
3969                 struct bnx2x_eth_q_stats *qstats = &bp->fp[i].eth_q_stats;
3970
3971                 estats->driver_xoff += qstats->driver_xoff;
3972                 estats->rx_err_discard_pkt += qstats->rx_err_discard_pkt;
3973                 estats->rx_skb_alloc_failed += qstats->rx_skb_alloc_failed;
3974                 estats->hw_csum_err += qstats->hw_csum_err;
3975         }
3976 }
3977
3978 static void bnx2x_stats_update(struct bnx2x *bp)
3979 {
3980         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
3981
3982         if (*stats_comp != DMAE_COMP_VAL)
3983                 return;
3984
3985         if (bp->port.pmf)
3986                 bnx2x_hw_stats_update(bp);
3987
3988         if (bnx2x_storm_stats_update(bp) && (bp->stats_pending++ == 3)) {
3989                 BNX2X_ERR("storm stats were not updated for 3 times\n");
3990                 bnx2x_panic();
3991                 return;
3992         }
3993
3994         bnx2x_net_stats_update(bp);
3995         bnx2x_drv_stats_update(bp);
3996
3997         if (bp->msglevel & NETIF_MSG_TIMER) {
3998                 struct tstorm_per_client_stats *old_tclient =
3999                                                         &bp->fp->old_tclient;
4000                 struct bnx2x_eth_q_stats *qstats = &bp->fp->eth_q_stats;
4001                 struct bnx2x_eth_stats *estats = &bp->eth_stats;
4002                 struct net_device_stats *nstats = &bp->dev->stats;
4003                 int i;
4004
4005                 printk(KERN_DEBUG "%s:\n", bp->dev->name);
4006                 printk(KERN_DEBUG "  tx avail (%4x)  tx hc idx (%x)"
4007                                   "  tx pkt (%lx)\n",
4008                        bnx2x_tx_avail(bp->fp),
4009                        le16_to_cpu(*bp->fp->tx_cons_sb), nstats->tx_packets);
4010                 printk(KERN_DEBUG "  rx usage (%4x)  rx hc idx (%x)"
4011                                   "  rx pkt (%lx)\n",
4012                        (u16)(le16_to_cpu(*bp->fp->rx_cons_sb) -
4013                              bp->fp->rx_comp_cons),
4014                        le16_to_cpu(*bp->fp->rx_cons_sb), nstats->rx_packets);
4015                 printk(KERN_DEBUG "  %s (Xoff events %u)  brb drops %u  "
4016                                   "brb truncate %u\n",
4017                        (netif_queue_stopped(bp->dev) ? "Xoff" : "Xon"),
4018                        qstats->driver_xoff,
4019                        estats->brb_drop_lo, estats->brb_truncate_lo);
4020                 printk(KERN_DEBUG "tstats: checksum_discard %u  "
4021                         "packets_too_big_discard %lu  no_buff_discard %lu  "
4022                         "mac_discard %u  mac_filter_discard %u  "
4023                         "xxovrflow_discard %u  brb_truncate_discard %u  "
4024                         "ttl0_discard %u\n",
4025                        le32_to_cpu(old_tclient->checksum_discard),
4026                        bnx2x_hilo(&qstats->etherstatsoverrsizepkts_hi),
4027                        bnx2x_hilo(&qstats->no_buff_discard_hi),
4028                        estats->mac_discard, estats->mac_filter_discard,
4029                        estats->xxoverflow_discard, estats->brb_truncate_discard,
4030                        le32_to_cpu(old_tclient->ttl0_discard));
4031
4032                 for_each_queue(bp, i) {
4033                         printk(KERN_DEBUG "[%d]: %lu\t%lu\t%lu\n", i,
4034                                bnx2x_fp(bp, i, tx_pkt),
4035                                bnx2x_fp(bp, i, rx_pkt),
4036                                bnx2x_fp(bp, i, rx_calls));
4037                 }
4038         }
4039
4040         bnx2x_hw_stats_post(bp);
4041         bnx2x_storm_stats_post(bp);
4042 }
4043
4044 static void bnx2x_port_stats_stop(struct bnx2x *bp)
4045 {
4046         struct dmae_command *dmae;
4047         u32 opcode;
4048         int loader_idx = PMF_DMAE_C(bp);
4049         u32 *stats_comp = bnx2x_sp(bp, stats_comp);
4050
4051         bp->executer_idx = 0;
4052
4053         opcode = (DMAE_CMD_SRC_PCI | DMAE_CMD_DST_GRC |
4054                   DMAE_CMD_C_ENABLE |
4055                   DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET |
4056 #ifdef __BIG_ENDIAN
4057                   DMAE_CMD_ENDIANITY_B_DW_SWAP |
4058 #else
4059                   DMAE_CMD_ENDIANITY_DW_SWAP |
4060 #endif
4061                   (BP_PORT(bp) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0) |
4062                   (BP_E1HVN(bp) << DMAE_CMD_E1HVN_SHIFT));
4063
4064         if (bp->port.port_stx) {
4065
4066                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
4067                 if (bp->func_stx)
4068                         dmae->opcode = (opcode | DMAE_CMD_C_DST_GRC);
4069                 else
4070                         dmae->opcode = (opcode | DMAE_CMD_C_DST_PCI);
4071                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, port_stats));
4072                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, port_stats));
4073                 dmae->dst_addr_lo = bp->port.port_stx >> 2;
4074                 dmae->dst_addr_hi = 0;
4075                 dmae->len = sizeof(struct host_port_stats) >> 2;
4076                 if (bp->func_stx) {
4077                         dmae->comp_addr_lo = dmae_reg_go_c[loader_idx] >> 2;
4078                         dmae->comp_addr_hi = 0;
4079                         dmae->comp_val = 1;
4080                 } else {
4081                         dmae->comp_addr_lo =
4082                                 U64_LO(bnx2x_sp_mapping(bp, stats_comp));
4083                         dmae->comp_addr_hi =
4084                                 U64_HI(bnx2x_sp_mapping(bp, stats_comp));
4085                         dmae->comp_val = DMAE_COMP_VAL;
4086
4087                         *stats_comp = 0;
4088                 }
4089         }
4090
4091         if (bp->func_stx) {
4092
4093                 dmae = bnx2x_sp(bp, dmae[bp->executer_idx++]);
4094                 dmae->opcode = (opcode | DMAE_CMD_C_DST_PCI);
4095                 dmae->src_addr_lo = U64_LO(bnx2x_sp_mapping(bp, func_stats));
4096                 dmae->src_addr_hi = U64_HI(bnx2x_sp_mapping(bp, func_stats));
4097                 dmae->dst_addr_lo = bp->func_stx >> 2;
4098                 dmae->dst_addr_hi = 0;
4099                 dmae->len = sizeof(struct host_func_stats) >> 2;
4100                 dmae->comp_addr_lo = U64_LO(bnx2x_sp_mapping(bp, stats_comp));
4101                 dmae->comp_addr_hi = U64_HI(bnx2x_sp_mapping(bp, stats_comp));
4102                 dmae->comp_val = DMAE_COMP_VAL;
4103
4104                 *stats_comp = 0;
4105         }
4106 }
4107
4108 static void bnx2x_stats_stop(struct bnx2x *bp)
4109 {
4110         int update = 0;
4111
4112         bnx2x_stats_comp(bp);
4113
4114         if (bp->port.pmf)
4115                 update = (bnx2x_hw_stats_update(bp) == 0);
4116
4117         update |= (bnx2x_storm_stats_update(bp) == 0);
4118
4119         if (update) {
4120                 bnx2x_net_stats_update(bp);
4121
4122                 if (bp->port.pmf)
4123                         bnx2x_port_stats_stop(bp);
4124
4125                 bnx2x_hw_stats_post(bp);
4126                 bnx2x_stats_comp(bp);
4127         }
4128 }
4129
4130 static void bnx2x_stats_do_nothing(struct bnx2x *bp)
4131 {
4132 }
4133
4134 static const struct {
4135         void (*action)(struct bnx2x *bp);
4136         enum bnx2x_stats_state next_state;
4137 } bnx2x_stats_stm[STATS_STATE_MAX][STATS_EVENT_MAX] = {
4138 /* state        event   */
4139 {
4140 /* DISABLED     PMF     */ {bnx2x_stats_pmf_update, STATS_STATE_DISABLED},
4141 /*              LINK_UP */ {bnx2x_stats_start,      STATS_STATE_ENABLED},
4142 /*              UPDATE  */ {bnx2x_stats_do_nothing, STATS_STATE_DISABLED},
4143 /*              STOP    */ {bnx2x_stats_do_nothing, STATS_STATE_DISABLED}
4144 },
4145 {
4146 /* ENABLED      PMF     */ {bnx2x_stats_pmf_start,  STATS_STATE_ENABLED},
4147 /*              LINK_UP */ {bnx2x_stats_restart,    STATS_STATE_ENABLED},
4148 /*              UPDATE  */ {bnx2x_stats_update,     STATS_STATE_ENABLED},
4149 /*              STOP    */ {bnx2x_stats_stop,       STATS_STATE_DISABLED}
4150 }
4151 };
4152
4153 static void bnx2x_stats_handle(struct bnx2x *bp, enum bnx2x_stats_event event)
4154 {
4155         enum bnx2x_stats_state state = bp->stats_state;
4156
4157         bnx2x_stats_stm[state][event].action(bp);
4158         bp->stats_state = bnx2x_stats_stm[state][event].next_state;
4159
4160         if ((event != STATS_EVENT_UPDATE) || (bp->msglevel & NETIF_MSG_TIMER))
4161                 DP(BNX2X_MSG_STATS, "state %d -> event %d -> state %d\n",
4162                    state, event, bp->stats_state);
4163 }
4164
4165 static void bnx2x_timer(unsigned long data)
4166 {
4167         struct bnx2x *bp = (struct bnx2x *) data;
4168
4169         if (!netif_running(bp->dev))
4170                 return;
4171
4172         if (atomic_read(&bp->intr_sem) != 0)
4173                 goto timer_restart;
4174
4175         if (poll) {
4176                 struct bnx2x_fastpath *fp = &bp->fp[0];
4177                 int rc;
4178
4179                 bnx2x_tx_int(fp);
4180                 rc = bnx2x_rx_int(fp, 1000);
4181         }
4182
4183         if (!BP_NOMCP(bp)) {
4184                 int func = BP_FUNC(bp);
4185                 u32 drv_pulse;
4186                 u32 mcp_pulse;
4187
4188                 ++bp->fw_drv_pulse_wr_seq;
4189                 bp->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
4190                 /* TBD - add SYSTEM_TIME */
4191                 drv_pulse = bp->fw_drv_pulse_wr_seq;
4192                 SHMEM_WR(bp, func_mb[func].drv_pulse_mb, drv_pulse);
4193
4194                 mcp_pulse = (SHMEM_RD(bp, func_mb[func].mcp_pulse_mb) &
4195                              MCP_PULSE_SEQ_MASK);
4196                 /* The delta between driver pulse and mcp response
4197                  * should be 1 (before mcp response) or 0 (after mcp response)
4198                  */
4199                 if ((drv_pulse != mcp_pulse) &&
4200                     (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
4201                         /* someone lost a heartbeat... */
4202                         BNX2X_ERR("drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
4203                                   drv_pulse, mcp_pulse);
4204                 }
4205         }
4206
4207         if ((bp->state == BNX2X_STATE_OPEN) ||
4208             (bp->state == BNX2X_STATE_DISABLED))
4209                 bnx2x_stats_handle(bp, STATS_EVENT_UPDATE);
4210
4211 timer_restart:
4212         mod_timer(&bp->timer, jiffies + bp->current_interval);
4213 }
4214
4215 /* end of Statistics */
4216
4217 /* nic init */
4218
4219 /*
4220  * nic init service functions
4221  */
4222
4223 static void bnx2x_zero_sb(struct bnx2x *bp, int sb_id)
4224 {
4225         int port = BP_PORT(bp);
4226
4227         bnx2x_init_fill(bp, USTORM_INTMEM_ADDR +
4228                         USTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), 0,
4229                         sizeof(struct ustorm_status_block)/4);
4230         bnx2x_init_fill(bp, CSTORM_INTMEM_ADDR +
4231                         CSTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), 0,
4232                         sizeof(struct cstorm_status_block)/4);
4233 }
4234
4235 static void bnx2x_init_sb(struct bnx2x *bp, struct host_status_block *sb,
4236                           dma_addr_t mapping, int sb_id)
4237 {
4238         int port = BP_PORT(bp);
4239         int func = BP_FUNC(bp);
4240         int index;
4241         u64 section;
4242
4243         /* USTORM */
4244         section = ((u64)mapping) + offsetof(struct host_status_block,
4245                                             u_status_block);
4246         sb->u_status_block.status_block_id = sb_id;
4247
4248         REG_WR(bp, BAR_USTRORM_INTMEM +
4249                USTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id), U64_LO(section));
4250         REG_WR(bp, BAR_USTRORM_INTMEM +
4251                ((USTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id)) + 4),
4252                U64_HI(section));
4253         REG_WR8(bp, BAR_USTRORM_INTMEM + FP_USB_FUNC_OFF +
4254                 USTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), func);
4255
4256         for (index = 0; index < HC_USTORM_SB_NUM_INDICES; index++)
4257                 REG_WR16(bp, BAR_USTRORM_INTMEM +
4258                          USTORM_SB_HC_DISABLE_OFFSET(port, sb_id, index), 1);
4259
4260         /* CSTORM */
4261         section = ((u64)mapping) + offsetof(struct host_status_block,
4262                                             c_status_block);
4263         sb->c_status_block.status_block_id = sb_id;
4264
4265         REG_WR(bp, BAR_CSTRORM_INTMEM +
4266                CSTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id), U64_LO(section));
4267         REG_WR(bp, BAR_CSTRORM_INTMEM +
4268                ((CSTORM_SB_HOST_SB_ADDR_OFFSET(port, sb_id)) + 4),
4269                U64_HI(section));
4270         REG_WR8(bp, BAR_CSTRORM_INTMEM + FP_CSB_FUNC_OFF +
4271                 CSTORM_SB_HOST_STATUS_BLOCK_OFFSET(port, sb_id), func);
4272
4273         for (index = 0; index < HC_CSTORM_SB_NUM_INDICES; index++)
4274                 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4275                          CSTORM_SB_HC_DISABLE_OFFSET(port, sb_id, index), 1);
4276
4277         bnx2x_ack_sb(bp, sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
4278 }
4279
4280 static void bnx2x_zero_def_sb(struct bnx2x *bp)
4281 {
4282         int func = BP_FUNC(bp);
4283
4284         bnx2x_init_fill(bp, TSTORM_INTMEM_ADDR +
4285                         TSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4286                         sizeof(struct tstorm_def_status_block)/4);
4287         bnx2x_init_fill(bp, USTORM_INTMEM_ADDR +
4288                         USTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4289                         sizeof(struct ustorm_def_status_block)/4);
4290         bnx2x_init_fill(bp, CSTORM_INTMEM_ADDR +
4291                         CSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4292                         sizeof(struct cstorm_def_status_block)/4);
4293         bnx2x_init_fill(bp, XSTORM_INTMEM_ADDR +
4294                         XSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), 0,
4295                         sizeof(struct xstorm_def_status_block)/4);
4296 }
4297
4298 static void bnx2x_init_def_sb(struct bnx2x *bp,
4299                               struct host_def_status_block *def_sb,
4300                               dma_addr_t mapping, int sb_id)
4301 {
4302         int port = BP_PORT(bp);
4303         int func = BP_FUNC(bp);
4304         int index, val, reg_offset;
4305         u64 section;
4306
4307         /* ATTN */
4308         section = ((u64)mapping) + offsetof(struct host_def_status_block,
4309                                             atten_status_block);
4310         def_sb->atten_status_block.status_block_id = sb_id;
4311
4312         bp->attn_state = 0;
4313
4314         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
4315                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
4316
4317         for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
4318                 bp->attn_group[index].sig[0] = REG_RD(bp,
4319                                                      reg_offset + 0x10*index);
4320                 bp->attn_group[index].sig[1] = REG_RD(bp,
4321                                                reg_offset + 0x4 + 0x10*index);
4322                 bp->attn_group[index].sig[2] = REG_RD(bp,
4323                                                reg_offset + 0x8 + 0x10*index);
4324                 bp->attn_group[index].sig[3] = REG_RD(bp,
4325                                                reg_offset + 0xc + 0x10*index);
4326         }
4327
4328         reg_offset = (port ? HC_REG_ATTN_MSG1_ADDR_L :
4329                              HC_REG_ATTN_MSG0_ADDR_L);
4330
4331         REG_WR(bp, reg_offset, U64_LO(section));
4332         REG_WR(bp, reg_offset + 4, U64_HI(section));
4333
4334         reg_offset = (port ? HC_REG_ATTN_NUM_P1 : HC_REG_ATTN_NUM_P0);
4335
4336         val = REG_RD(bp, reg_offset);
4337         val |= sb_id;
4338         REG_WR(bp, reg_offset, val);
4339
4340         /* USTORM */
4341         section = ((u64)mapping) + offsetof(struct host_def_status_block,
4342                                             u_def_status_block);
4343         def_sb->u_def_status_block.status_block_id = sb_id;
4344
4345         REG_WR(bp, BAR_USTRORM_INTMEM +
4346                USTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4347         REG_WR(bp, BAR_USTRORM_INTMEM +
4348                ((USTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4349                U64_HI(section));
4350         REG_WR8(bp, BAR_USTRORM_INTMEM + DEF_USB_FUNC_OFF +
4351                 USTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4352
4353         for (index = 0; index < HC_USTORM_DEF_SB_NUM_INDICES; index++)
4354                 REG_WR16(bp, BAR_USTRORM_INTMEM +
4355                          USTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4356
4357         /* CSTORM */
4358         section = ((u64)mapping) + offsetof(struct host_def_status_block,
4359                                             c_def_status_block);
4360         def_sb->c_def_status_block.status_block_id = sb_id;
4361
4362         REG_WR(bp, BAR_CSTRORM_INTMEM +
4363                CSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4364         REG_WR(bp, BAR_CSTRORM_INTMEM +
4365                ((CSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4366                U64_HI(section));
4367         REG_WR8(bp, BAR_CSTRORM_INTMEM + DEF_CSB_FUNC_OFF +
4368                 CSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4369
4370         for (index = 0; index < HC_CSTORM_DEF_SB_NUM_INDICES; index++)
4371                 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4372                          CSTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4373
4374         /* TSTORM */
4375         section = ((u64)mapping) + offsetof(struct host_def_status_block,
4376                                             t_def_status_block);
4377         def_sb->t_def_status_block.status_block_id = sb_id;
4378
4379         REG_WR(bp, BAR_TSTRORM_INTMEM +
4380                TSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4381         REG_WR(bp, BAR_TSTRORM_INTMEM +
4382                ((TSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4383                U64_HI(section));
4384         REG_WR8(bp, BAR_TSTRORM_INTMEM + DEF_TSB_FUNC_OFF +
4385                 TSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4386
4387         for (index = 0; index < HC_TSTORM_DEF_SB_NUM_INDICES; index++)
4388                 REG_WR16(bp, BAR_TSTRORM_INTMEM +
4389                          TSTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4390
4391         /* XSTORM */
4392         section = ((u64)mapping) + offsetof(struct host_def_status_block,
4393                                             x_def_status_block);
4394         def_sb->x_def_status_block.status_block_id = sb_id;
4395
4396         REG_WR(bp, BAR_XSTRORM_INTMEM +
4397                XSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func), U64_LO(section));
4398         REG_WR(bp, BAR_XSTRORM_INTMEM +
4399                ((XSTORM_DEF_SB_HOST_SB_ADDR_OFFSET(func)) + 4),
4400                U64_HI(section));
4401         REG_WR8(bp, BAR_XSTRORM_INTMEM + DEF_XSB_FUNC_OFF +
4402                 XSTORM_DEF_SB_HOST_STATUS_BLOCK_OFFSET(func), func);
4403
4404         for (index = 0; index < HC_XSTORM_DEF_SB_NUM_INDICES; index++)
4405                 REG_WR16(bp, BAR_XSTRORM_INTMEM +
4406                          XSTORM_DEF_SB_HC_DISABLE_OFFSET(func, index), 1);
4407
4408         bp->stats_pending = 0;
4409         bp->set_mac_pending = 0;
4410
4411         bnx2x_ack_sb(bp, sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
4412 }
4413
4414 static void bnx2x_update_coalesce(struct bnx2x *bp)
4415 {
4416         int port = BP_PORT(bp);
4417         int i;
4418
4419         for_each_queue(bp, i) {
4420                 int sb_id = bp->fp[i].sb_id;
4421
4422                 /* HC_INDEX_U_ETH_RX_CQ_CONS */
4423                 REG_WR8(bp, BAR_USTRORM_INTMEM +
4424                         USTORM_SB_HC_TIMEOUT_OFFSET(port, sb_id,
4425                                                     U_SB_ETH_RX_CQ_INDEX),
4426                         bp->rx_ticks/12);
4427                 REG_WR16(bp, BAR_USTRORM_INTMEM +
4428                          USTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
4429                                                      U_SB_ETH_RX_CQ_INDEX),
4430                          bp->rx_ticks ? 0 : 1);
4431
4432                 /* HC_INDEX_C_ETH_TX_CQ_CONS */
4433                 REG_WR8(bp, BAR_CSTRORM_INTMEM +
4434                         CSTORM_SB_HC_TIMEOUT_OFFSET(port, sb_id,
4435                                                     C_SB_ETH_TX_CQ_INDEX),
4436                         bp->tx_ticks/12);
4437                 REG_WR16(bp, BAR_CSTRORM_INTMEM +
4438                          CSTORM_SB_HC_DISABLE_OFFSET(port, sb_id,
4439                                                      C_SB_ETH_TX_CQ_INDEX),
4440                          bp->tx_ticks ? 0 : 1);
4441         }
4442 }
4443
4444 static inline void bnx2x_free_tpa_pool(struct bnx2x *bp,
4445                                        struct bnx2x_fastpath *fp, int last)
4446 {
4447         int i;
4448
4449         for (i = 0; i < last; i++) {
4450                 struct sw_rx_bd *rx_buf = &(fp->tpa_pool[i]);
4451                 struct sk_buff *skb = rx_buf->skb;
4452
4453                 if (skb == NULL) {
4454                         DP(NETIF_MSG_IFDOWN, "tpa bin %d empty on free\n", i);
4455                         continue;
4456                 }
4457
4458                 if (fp->tpa_state[i] == BNX2X_TPA_START)
4459                         pci_unmap_single(bp->pdev,
4460                                          pci_unmap_addr(rx_buf, mapping),
4461                                          bp->rx_buf_size, PCI_DMA_FROMDEVICE);
4462
4463                 dev_kfree_skb(skb);
4464                 rx_buf->skb = NULL;
4465         }
4466 }
4467
4468 static void bnx2x_init_rx_rings(struct bnx2x *bp)
4469 {
4470         int func = BP_FUNC(bp);
4471         int max_agg_queues = CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
4472                                               ETH_MAX_AGGREGATION_QUEUES_E1H;
4473         u16 ring_prod, cqe_ring_prod;
4474         int i, j;
4475
4476         bp->rx_buf_size = bp->dev->mtu + ETH_OVREHEAD + BNX2X_RX_ALIGN;
4477         DP(NETIF_MSG_IFUP,
4478            "mtu %d  rx_buf_size %d\n", bp->dev->mtu, bp->rx_buf_size);
4479
4480         if (bp->flags & TPA_ENABLE_FLAG) {
4481
4482                 for_each_rx_queue(bp, j) {
4483                         struct bnx2x_fastpath *fp = &bp->fp[j];
4484
4485                         for (i = 0; i < max_agg_queues; i++) {
4486                                 fp->tpa_pool[i].skb =
4487                                    netdev_alloc_skb(bp->dev, bp->rx_buf_size);
4488                                 if (!fp->tpa_pool[i].skb) {
4489                                         BNX2X_ERR("Failed to allocate TPA "
4490                                                   "skb pool for queue[%d] - "
4491                                                   "disabling TPA on this "
4492                                                   "queue!\n", j);
4493                                         bnx2x_free_tpa_pool(bp, fp, i);
4494                                         fp->disable_tpa = 1;
4495                                         break;
4496                                 }
4497                                 pci_unmap_addr_set((struct sw_rx_bd *)
4498                                                         &bp->fp->tpa_pool[i],
4499                                                    mapping, 0);
4500                                 fp->tpa_state[i] = BNX2X_TPA_STOP;
4501                         }
4502                 }
4503         }
4504
4505         for_each_rx_queue(bp, j) {
4506                 struct bnx2x_fastpath *fp = &bp->fp[j];
4507
4508                 fp->rx_bd_cons = 0;
4509                 fp->rx_cons_sb = BNX2X_RX_SB_INDEX;
4510                 fp->rx_bd_cons_sb = BNX2X_RX_SB_BD_INDEX;
4511
4512                 /* "next page" elements initialization */
4513                 /* SGE ring */
4514                 for (i = 1; i <= NUM_RX_SGE_PAGES; i++) {
4515                         struct eth_rx_sge *sge;
4516
4517                         sge = &fp->rx_sge_ring[RX_SGE_CNT * i - 2];
4518                         sge->addr_hi =
4519                                 cpu_to_le32(U64_HI(fp->rx_sge_mapping +
4520                                         BCM_PAGE_SIZE*(i % NUM_RX_SGE_PAGES)));
4521                         sge->addr_lo =
4522                                 cpu_to_le32(U64_LO(fp->rx_sge_mapping +
4523                                         BCM_PAGE_SIZE*(i % NUM_RX_SGE_PAGES)));
4524                 }
4525
4526                 bnx2x_init_sge_ring_bit_mask(fp);
4527
4528                 /* RX BD ring */
4529                 for (i = 1; i <= NUM_RX_RINGS; i++) {
4530                         struct eth_rx_bd *rx_bd;
4531
4532                         rx_bd = &fp->rx_desc_ring[RX_DESC_CNT * i - 2];
4533                         rx_bd->addr_hi =
4534                                 cpu_to_le32(U64_HI(fp->rx_desc_mapping +
4535                                             BCM_PAGE_SIZE*(i % NUM_RX_RINGS)));
4536                         rx_bd->addr_lo =
4537                                 cpu_to_le32(U64_LO(fp->rx_desc_mapping +
4538                                             BCM_PAGE_SIZE*(i % NUM_RX_RINGS)));
4539                 }
4540
4541                 /* CQ ring */
4542                 for (i = 1; i <= NUM_RCQ_RINGS; i++) {
4543                         struct eth_rx_cqe_next_page *nextpg;
4544
4545                         nextpg = (struct eth_rx_cqe_next_page *)
4546                                 &fp->rx_comp_ring[RCQ_DESC_CNT * i - 1];
4547                         nextpg->addr_hi =
4548                                 cpu_to_le32(U64_HI(fp->rx_comp_mapping +
4549                                            BCM_PAGE_SIZE*(i % NUM_RCQ_RINGS)));
4550                         nextpg->addr_lo =
4551                                 cpu_to_le32(U64_LO(fp->rx_comp_mapping +
4552                                            BCM_PAGE_SIZE*(i % NUM_RCQ_RINGS)));
4553                 }
4554
4555                 /* Allocate SGEs and initialize the ring elements */
4556                 for (i = 0, ring_prod = 0;
4557                      i < MAX_RX_SGE_CNT*NUM_RX_SGE_PAGES; i++) {
4558
4559                         if (bnx2x_alloc_rx_sge(bp, fp, ring_prod) < 0) {
4560                                 BNX2X_ERR("was only able to allocate "
4561                                           "%d rx sges\n", i);
4562                                 BNX2X_ERR("disabling TPA for queue[%d]\n", j);
4563                                 /* Cleanup already allocated elements */
4564                                 bnx2x_free_rx_sge_range(bp, fp, ring_prod);
4565                                 bnx2x_free_tpa_pool(bp, fp, max_agg_queues);
4566                                 fp->disable_tpa = 1;
4567                                 ring_prod = 0;
4568                                 break;
4569                         }
4570                         ring_prod = NEXT_SGE_IDX(ring_prod);
4571                 }
4572                 fp->rx_sge_prod = ring_prod;
4573
4574                 /* Allocate BDs and initialize BD ring */
4575                 fp->rx_comp_cons = 0;
4576                 cqe_ring_prod = ring_prod = 0;
4577                 for (i = 0; i < bp->rx_ring_size; i++) {
4578                         if (bnx2x_alloc_rx_skb(bp, fp, ring_prod) < 0) {
4579                                 BNX2X_ERR("was only able to allocate "
4580                                           "%d rx skbs on queue[%d]\n", i, j);
4581                                 fp->eth_q_stats.rx_skb_alloc_failed++;
4582                                 break;
4583                         }
4584                         ring_prod = NEXT_RX_IDX(ring_prod);
4585                         cqe_ring_prod = NEXT_RCQ_IDX(cqe_ring_prod);
4586                         WARN_ON(ring_prod <= i);
4587                 }
4588
4589                 fp->rx_bd_prod = ring_prod;
4590                 /* must not have more available CQEs than BDs */
4591                 fp->rx_comp_prod = min((u16)(NUM_RCQ_RINGS*RCQ_DESC_CNT),
4592                                        cqe_ring_prod);
4593                 fp->rx_pkt = fp->rx_calls = 0;
4594
4595                 /* Warning!
4596                  * this will generate an interrupt (to the TSTORM)
4597                  * must only be done after chip is initialized
4598                  */
4599                 bnx2x_update_rx_prod(bp, fp, ring_prod, fp->rx_comp_prod,
4600                                      fp->rx_sge_prod);
4601                 if (j != 0)
4602                         continue;
4603
4604                 REG_WR(bp, BAR_USTRORM_INTMEM +
4605                        USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func),
4606                        U64_LO(fp->rx_comp_mapping));
4607                 REG_WR(bp, BAR_USTRORM_INTMEM +
4608                        USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func) + 4,
4609                        U64_HI(fp->rx_comp_mapping));
4610         }
4611 }
4612
4613 static void bnx2x_init_tx_ring(struct bnx2x *bp)
4614 {
4615         int i, j;
4616
4617         for_each_tx_queue(bp, j) {
4618                 struct bnx2x_fastpath *fp = &bp->fp[j];
4619
4620                 for (i = 1; i <= NUM_TX_RINGS; i++) {
4621                         struct eth_tx_bd *tx_bd =
4622                                 &fp->tx_desc_ring[TX_DESC_CNT * i - 1];
4623
4624                         tx_bd->addr_hi =
4625                                 cpu_to_le32(U64_HI(fp->tx_desc_mapping +
4626                                             BCM_PAGE_SIZE*(i % NUM_TX_RINGS)));
4627                         tx_bd->addr_lo =
4628                                 cpu_to_le32(U64_LO(fp->tx_desc_mapping +
4629                                             BCM_PAGE_SIZE*(i % NUM_TX_RINGS)));
4630                 }
4631
4632                 fp->tx_pkt_prod = 0;
4633                 fp->tx_pkt_cons = 0;
4634                 fp->tx_bd_prod = 0;
4635                 fp->tx_bd_cons = 0;
4636                 fp->tx_cons_sb = BNX2X_TX_SB_INDEX;
4637                 fp->tx_pkt = 0;
4638         }
4639 }
4640
4641 static void bnx2x_init_sp_ring(struct bnx2x *bp)
4642 {
4643         int func = BP_FUNC(bp);
4644
4645         spin_lock_init(&bp->spq_lock);
4646
4647         bp->spq_left = MAX_SPQ_PENDING;
4648         bp->spq_prod_idx = 0;
4649         bp->dsb_sp_prod = BNX2X_SP_DSB_INDEX;
4650         bp->spq_prod_bd = bp->spq;
4651         bp->spq_last_bd = bp->spq_prod_bd + MAX_SP_DESC_CNT;
4652
4653         REG_WR(bp, XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PAGE_BASE_OFFSET(func),
4654                U64_LO(bp->spq_mapping));
4655         REG_WR(bp,
4656                XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PAGE_BASE_OFFSET(func) + 4,
4657                U64_HI(bp->spq_mapping));
4658
4659         REG_WR(bp, XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PROD_OFFSET(func),
4660                bp->spq_prod_idx);
4661 }
4662
4663 static void bnx2x_init_context(struct bnx2x *bp)
4664 {
4665         int i;
4666
4667         for_each_queue(bp, i) {
4668                 struct eth_context *context = bnx2x_sp(bp, context[i].eth);
4669                 struct bnx2x_fastpath *fp = &bp->fp[i];
4670                 u8 cl_id = fp->cl_id;
4671                 u8 sb_id = fp->sb_id;
4672
4673                 context->ustorm_st_context.common.sb_index_numbers =
4674                                                 BNX2X_RX_SB_INDEX_NUM;
4675                 context->ustorm_st_context.common.clientId = cl_id;
4676                 context->ustorm_st_context.common.status_block_id = sb_id;
4677                 context->ustorm_st_context.common.flags =
4678                         (USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_MC_ALIGNMENT |
4679                          USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_STATISTICS);
4680                 context->ustorm_st_context.common.statistics_counter_id =
4681                                                 cl_id;
4682                 context->ustorm_st_context.common.mc_alignment_log_size =
4683                                                 BNX2X_RX_ALIGN_SHIFT;
4684                 context->ustorm_st_context.common.bd_buff_size =
4685                                                 bp->rx_buf_size;
4686                 context->ustorm_st_context.common.bd_page_base_hi =
4687                                                 U64_HI(fp->rx_desc_mapping);
4688                 context->ustorm_st_context.common.bd_page_base_lo =
4689                                                 U64_LO(fp->rx_desc_mapping);
4690                 if (!fp->disable_tpa) {
4691                         context->ustorm_st_context.common.flags |=
4692                                 (USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_TPA |
4693                                  USTORM_ETH_ST_CONTEXT_CONFIG_ENABLE_SGE_RING);
4694                         context->ustorm_st_context.common.sge_buff_size =
4695                                 (u16)min((u32)SGE_PAGE_SIZE*PAGES_PER_SGE,
4696                                          (u32)0xffff);
4697                         context->ustorm_st_context.common.sge_page_base_hi =
4698                                                 U64_HI(fp->rx_sge_mapping);
4699                         context->ustorm_st_context.common.sge_page_base_lo =
4700                                                 U64_LO(fp->rx_sge_mapping);
4701                 }
4702
4703                 context->ustorm_ag_context.cdu_usage =
4704                         CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, i),
4705                                                CDU_REGION_NUMBER_UCM_AG,
4706                                                ETH_CONNECTION_TYPE);
4707
4708                 context->xstorm_st_context.tx_bd_page_base_hi =
4709                                                 U64_HI(fp->tx_desc_mapping);
4710                 context->xstorm_st_context.tx_bd_page_base_lo =
4711                                                 U64_LO(fp->tx_desc_mapping);
4712                 context->xstorm_st_context.db_data_addr_hi =
4713                                                 U64_HI(fp->tx_prods_mapping);
4714                 context->xstorm_st_context.db_data_addr_lo =
4715                                                 U64_LO(fp->tx_prods_mapping);
4716                 context->xstorm_st_context.statistics_data = (cl_id |
4717                                 XSTORM_ETH_ST_CONTEXT_STATISTICS_ENABLE);
4718                 context->cstorm_st_context.sb_index_number =
4719                                                 C_SB_ETH_TX_CQ_INDEX;
4720                 context->cstorm_st_context.status_block_id = sb_id;
4721
4722                 context->xstorm_ag_context.cdu_reserved =
4723                         CDU_RSRVD_VALUE_TYPE_A(HW_CID(bp, i),
4724                                                CDU_REGION_NUMBER_XCM_AG,
4725                                                ETH_CONNECTION_TYPE);
4726         }
4727 }
4728
4729 static void bnx2x_init_ind_table(struct bnx2x *bp)
4730 {
4731         int func = BP_FUNC(bp);
4732         int i;
4733
4734         if (bp->multi_mode == ETH_RSS_MODE_DISABLED)
4735                 return;
4736
4737         DP(NETIF_MSG_IFUP,
4738            "Initializing indirection table  multi_mode %d\n", bp->multi_mode);
4739         for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
4740                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
4741                         TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
4742                         bp->fp->cl_id + (i % bp->num_rx_queues));
4743 }
4744
4745 static void bnx2x_set_client_config(struct bnx2x *bp)
4746 {
4747         struct tstorm_eth_client_config tstorm_client = {0};
4748         int port = BP_PORT(bp);
4749         int i;
4750
4751         tstorm_client.mtu = bp->dev->mtu;
4752         tstorm_client.config_flags =
4753                                 (TSTORM_ETH_CLIENT_CONFIG_STATSITICS_ENABLE |
4754                                  TSTORM_ETH_CLIENT_CONFIG_E1HOV_REM_ENABLE);
4755 #ifdef BCM_VLAN
4756         if (bp->rx_mode && bp->vlgrp && (bp->flags & HW_VLAN_RX_FLAG)) {
4757                 tstorm_client.config_flags |=
4758                                 TSTORM_ETH_CLIENT_CONFIG_VLAN_REM_ENABLE;
4759                 DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
4760         }
4761 #endif
4762
4763         if (bp->flags & TPA_ENABLE_FLAG) {
4764                 tstorm_client.max_sges_for_packet =
4765                         SGE_PAGE_ALIGN(tstorm_client.mtu) >> SGE_PAGE_SHIFT;
4766                 tstorm_client.max_sges_for_packet =
4767                         ((tstorm_client.max_sges_for_packet +
4768                           PAGES_PER_SGE - 1) & (~(PAGES_PER_SGE - 1))) >>
4769                         PAGES_PER_SGE_SHIFT;
4770
4771                 tstorm_client.config_flags |=
4772                                 TSTORM_ETH_CLIENT_CONFIG_ENABLE_SGE_RING;
4773         }
4774
4775         for_each_queue(bp, i) {
4776                 tstorm_client.statistics_counter_id = bp->fp[i].cl_id;
4777
4778                 REG_WR(bp, BAR_TSTRORM_INTMEM +
4779                        TSTORM_CLIENT_CONFIG_OFFSET(port, bp->fp[i].cl_id),
4780                        ((u32 *)&tstorm_client)[0]);
4781                 REG_WR(bp, BAR_TSTRORM_INTMEM +
4782                        TSTORM_CLIENT_CONFIG_OFFSET(port, bp->fp[i].cl_id) + 4,
4783                        ((u32 *)&tstorm_client)[1]);
4784         }
4785
4786         DP(BNX2X_MSG_OFF, "tstorm_client: 0x%08x 0x%08x\n",
4787            ((u32 *)&tstorm_client)[0], ((u32 *)&tstorm_client)[1]);
4788 }
4789
4790 static void bnx2x_set_storm_rx_mode(struct bnx2x *bp)
4791 {
4792         struct tstorm_eth_mac_filter_config tstorm_mac_filter = {0};
4793         int mode = bp->rx_mode;
4794         int mask = (1 << BP_L_ID(bp));
4795         int func = BP_FUNC(bp);
4796         int i;
4797
4798         DP(NETIF_MSG_IFUP, "rx mode %d  mask 0x%x\n", mode, mask);
4799
4800         switch (mode) {
4801         case BNX2X_RX_MODE_NONE: /* no Rx */
4802                 tstorm_mac_filter.ucast_drop_all = mask;
4803                 tstorm_mac_filter.mcast_drop_all = mask;
4804                 tstorm_mac_filter.bcast_drop_all = mask;
4805                 break;
4806
4807         case BNX2X_RX_MODE_NORMAL:
4808                 tstorm_mac_filter.bcast_accept_all = mask;
4809                 break;
4810
4811         case BNX2X_RX_MODE_ALLMULTI:
4812                 tstorm_mac_filter.mcast_accept_all = mask;
4813                 tstorm_mac_filter.bcast_accept_all = mask;
4814                 break;
4815
4816         case BNX2X_RX_MODE_PROMISC:
4817                 tstorm_mac_filter.ucast_accept_all = mask;
4818                 tstorm_mac_filter.mcast_accept_all = mask;
4819                 tstorm_mac_filter.bcast_accept_all = mask;
4820                 break;
4821
4822         default:
4823                 BNX2X_ERR("BAD rx mode (%d)\n", mode);
4824                 break;
4825         }
4826
4827         for (i = 0; i < sizeof(struct tstorm_eth_mac_filter_config)/4; i++) {
4828                 REG_WR(bp, BAR_TSTRORM_INTMEM +
4829                        TSTORM_MAC_FILTER_CONFIG_OFFSET(func) + i * 4,
4830                        ((u32 *)&tstorm_mac_filter)[i]);
4831
4832 /*              DP(NETIF_MSG_IFUP, "tstorm_mac_filter[%d]: 0x%08x\n", i,
4833                    ((u32 *)&tstorm_mac_filter)[i]); */
4834         }
4835
4836         if (mode != BNX2X_RX_MODE_NONE)
4837                 bnx2x_set_client_config(bp);
4838 }
4839
4840 static void bnx2x_init_internal_common(struct bnx2x *bp)
4841 {
4842         int i;
4843
4844         if (bp->flags & TPA_ENABLE_FLAG) {
4845                 struct tstorm_eth_tpa_exist tpa = {0};
4846
4847                 tpa.tpa_exist = 1;
4848
4849                 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET,
4850                        ((u32 *)&tpa)[0]);
4851                 REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_TPA_EXIST_OFFSET + 4,
4852                        ((u32 *)&tpa)[1]);
4853         }
4854
4855         /* Zero this manually as its initialization is
4856            currently missing in the initTool */
4857         for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++)
4858                 REG_WR(bp, BAR_USTRORM_INTMEM +
4859                        USTORM_AGG_DATA_OFFSET + i * 4, 0);
4860 }
4861
4862 static void bnx2x_init_internal_port(struct bnx2x *bp)
4863 {
4864         int port = BP_PORT(bp);
4865
4866         REG_WR(bp, BAR_USTRORM_INTMEM + USTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4867         REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4868         REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4869         REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_HC_BTR_OFFSET(port), BNX2X_BTR);
4870 }
4871
4872 /* Calculates the sum of vn_min_rates.
4873    It's needed for further normalizing of the min_rates.
4874    Returns:
4875      sum of vn_min_rates.
4876        or
4877      0 - if all the min_rates are 0.
4878      In the later case fainess algorithm should be deactivated.
4879      If not all min_rates are zero then those that are zeroes will be set to 1.
4880  */
4881 static void bnx2x_calc_vn_weight_sum(struct bnx2x *bp)
4882 {
4883         int all_zero = 1;
4884         int port = BP_PORT(bp);
4885         int vn;
4886
4887         bp->vn_weight_sum = 0;
4888         for (vn = VN_0; vn < E1HVN_MAX; vn++) {
4889                 int func = 2*vn + port;
4890                 u32 vn_cfg =
4891                         SHMEM_RD(bp, mf_cfg.func_mf_config[func].config);
4892                 u32 vn_min_rate = ((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
4893                                    FUNC_MF_CFG_MIN_BW_SHIFT) * 100;
4894
4895                 /* Skip hidden vns */
4896                 if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE)
4897                         continue;
4898
4899                 /* If min rate is zero - set it to 1 */
4900                 if (!vn_min_rate)
4901                         vn_min_rate = DEF_MIN_RATE;
4902                 else
4903                         all_zero = 0;
4904
4905                 bp->vn_weight_sum += vn_min_rate;
4906         }
4907
4908         /* ... only if all min rates are zeros - disable fairness */
4909         if (all_zero)
4910                 bp->vn_weight_sum = 0;
4911 }
4912
4913 static void bnx2x_init_internal_func(struct bnx2x *bp)
4914 {
4915         struct tstorm_eth_function_common_config tstorm_config = {0};
4916         struct stats_indication_flags stats_flags = {0};
4917         int port = BP_PORT(bp);
4918         int func = BP_FUNC(bp);
4919         int i, j;
4920         u32 offset;
4921         u16 max_agg_size;
4922
4923         if (is_multi(bp)) {
4924                 tstorm_config.config_flags = MULTI_FLAGS(bp);
4925                 tstorm_config.rss_result_mask = MULTI_MASK;
4926         }
4927         if (IS_E1HMF(bp))
4928                 tstorm_config.config_flags |=
4929                                 TSTORM_ETH_FUNCTION_COMMON_CONFIG_E1HOV_IN_CAM;
4930
4931         tstorm_config.leading_client_id = BP_L_ID(bp);
4932
4933         REG_WR(bp, BAR_TSTRORM_INTMEM +
4934                TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(func),
4935                (*(u32 *)&tstorm_config));
4936
4937         bp->rx_mode = BNX2X_RX_MODE_NONE; /* no rx until link is up */
4938         bnx2x_set_storm_rx_mode(bp);
4939
4940         for_each_queue(bp, i) {
4941                 u8 cl_id = bp->fp[i].cl_id;
4942
4943                 /* reset xstorm per client statistics */
4944                 offset = BAR_XSTRORM_INTMEM +
4945                          XSTORM_PER_COUNTER_ID_STATS_OFFSET(port, cl_id);
4946                 for (j = 0;
4947                      j < sizeof(struct xstorm_per_client_stats) / 4; j++)
4948                         REG_WR(bp, offset + j*4, 0);
4949
4950                 /* reset tstorm per client statistics */
4951                 offset = BAR_TSTRORM_INTMEM +
4952                          TSTORM_PER_COUNTER_ID_STATS_OFFSET(port, cl_id);
4953                 for (j = 0;
4954                      j < sizeof(struct tstorm_per_client_stats) / 4; j++)
4955                         REG_WR(bp, offset + j*4, 0);
4956
4957                 /* reset ustorm per client statistics */
4958                 offset = BAR_USTRORM_INTMEM +
4959                          USTORM_PER_COUNTER_ID_STATS_OFFSET(port, cl_id);
4960                 for (j = 0;
4961                      j < sizeof(struct ustorm_per_client_stats) / 4; j++)
4962                         REG_WR(bp, offset + j*4, 0);
4963         }
4964
4965         /* Init statistics related context */
4966         stats_flags.collect_eth = 1;
4967
4968         REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(func),
4969                ((u32 *)&stats_flags)[0]);
4970         REG_WR(bp, BAR_XSTRORM_INTMEM + XSTORM_STATS_FLAGS_OFFSET(func) + 4,
4971                ((u32 *)&stats_flags)[1]);
4972
4973         REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(func),
4974                ((u32 *)&stats_flags)[0]);
4975         REG_WR(bp, BAR_TSTRORM_INTMEM + TSTORM_STATS_FLAGS_OFFSET(func) + 4,
4976                ((u32 *)&stats_flags)[1]);
4977
4978         REG_WR(bp, BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(func),
4979                ((u32 *)&stats_flags)[0]);
4980         REG_WR(bp, BAR_USTRORM_INTMEM + USTORM_STATS_FLAGS_OFFSET(func) + 4,
4981                ((u32 *)&stats_flags)[1]);
4982
4983         REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(func),
4984                ((u32 *)&stats_flags)[0]);
4985         REG_WR(bp, BAR_CSTRORM_INTMEM + CSTORM_STATS_FLAGS_OFFSET(func) + 4,
4986                ((u32 *)&stats_flags)[1]);
4987
4988         REG_WR(bp, BAR_XSTRORM_INTMEM +
4989                XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func),
4990                U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
4991         REG_WR(bp, BAR_XSTRORM_INTMEM +
4992                XSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func) + 4,
4993                U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
4994
4995         REG_WR(bp, BAR_TSTRORM_INTMEM +
4996                TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func),
4997                U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
4998         REG_WR(bp, BAR_TSTRORM_INTMEM +
4999                TSTORM_ETH_STATS_QUERY_ADDR_OFFSET(func) + 4,
5000                U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
5001
5002         REG_WR(bp, BAR_USTRORM_INTMEM +
5003                USTORM_ETH_STATS_QUERY_ADDR_OFFSET(func),
5004                U64_LO(bnx2x_sp_mapping(bp, fw_stats)));
5005         REG_WR(bp, BAR_USTRORM_INTMEM +
5006                USTORM_ETH_STATS_QUERY_ADDR_OFFSET(func) + 4,
5007                U64_HI(bnx2x_sp_mapping(bp, fw_stats)));
5008
5009         if (CHIP_IS_E1H(bp)) {
5010                 REG_WR8(bp, BAR_XSTRORM_INTMEM + XSTORM_FUNCTION_MODE_OFFSET,
5011                         IS_E1HMF(bp));
5012                 REG_WR8(bp, BAR_TSTRORM_INTMEM + TSTORM_FUNCTION_MODE_OFFSET,
5013                         IS_E1HMF(bp));
5014                 REG_WR8(bp, BAR_CSTRORM_INTMEM + CSTORM_FUNCTION_MODE_OFFSET,
5015                         IS_E1HMF(bp));
5016                 REG_WR8(bp, BAR_USTRORM_INTMEM + USTORM_FUNCTION_MODE_OFFSET,
5017                         IS_E1HMF(bp));
5018
5019                 REG_WR16(bp, BAR_XSTRORM_INTMEM + XSTORM_E1HOV_OFFSET(func),
5020                          bp->e1hov);
5021         }
5022
5023         /* Init CQ ring mapping and aggregation size, the FW limit is 8 frags */
5024         max_agg_size =
5025                 min((u32)(min((u32)8, (u32)MAX_SKB_FRAGS) *
5026                           SGE_PAGE_SIZE * PAGES_PER_SGE),
5027                     (u32)0xffff);
5028         for_each_rx_queue(bp, i) {
5029                 struct bnx2x_fastpath *fp = &bp->fp[i];
5030
5031                 REG_WR(bp, BAR_USTRORM_INTMEM +
5032                        USTORM_CQE_PAGE_BASE_OFFSET(port, fp->cl_id),
5033                        U64_LO(fp->rx_comp_mapping));
5034                 REG_WR(bp, BAR_USTRORM_INTMEM +
5035                        USTORM_CQE_PAGE_BASE_OFFSET(port, fp->cl_id) + 4,
5036                        U64_HI(fp->rx_comp_mapping));
5037
5038                 REG_WR16(bp, BAR_USTRORM_INTMEM +
5039                          USTORM_MAX_AGG_SIZE_OFFSET(port, fp->cl_id),
5040                          max_agg_size);
5041         }
5042
5043         /* dropless flow control */
5044         if (CHIP_IS_E1H(bp)) {
5045                 struct ustorm_eth_rx_pause_data_e1h rx_pause = {0};
5046
5047                 rx_pause.bd_thr_low = 250;
5048                 rx_pause.cqe_thr_low = 250;
5049                 rx_pause.cos = 1;
5050                 rx_pause.sge_thr_low = 0;
5051                 rx_pause.bd_thr_high = 350;
5052                 rx_pause.cqe_thr_high = 350;
5053                 rx_pause.sge_thr_high = 0;
5054
5055                 for_each_rx_queue(bp, i) {
5056                         struct bnx2x_fastpath *fp = &bp->fp[i];
5057
5058                         if (!fp->disable_tpa) {
5059                                 rx_pause.sge_thr_low = 150;
5060                                 rx_pause.sge_thr_high = 250;
5061                         }
5062
5063
5064                         offset = BAR_USTRORM_INTMEM +
5065                                  USTORM_ETH_RING_PAUSE_DATA_OFFSET(port,
5066                                                                    fp->cl_id);
5067                         for (j = 0;
5068                              j < sizeof(struct ustorm_eth_rx_pause_data_e1h)/4;
5069                              j++)
5070                                 REG_WR(bp, offset + j*4,
5071                                        ((u32 *)&rx_pause)[j]);
5072                 }
5073         }
5074
5075         memset(&(bp->cmng), 0, sizeof(struct cmng_struct_per_port));
5076
5077         /* Init rate shaping and fairness contexts */
5078         if (IS_E1HMF(bp)) {
5079                 int vn;
5080
5081                 /* During init there is no active link
5082                    Until link is up, set link rate to 10Gbps */
5083                 bp->link_vars.line_speed = SPEED_10000;
5084                 bnx2x_init_port_minmax(bp);
5085
5086                 bnx2x_calc_vn_weight_sum(bp);
5087
5088                 for (vn = VN_0; vn < E1HVN_MAX; vn++)
5089                         bnx2x_init_vn_minmax(bp, 2*vn + port);
5090
5091                 /* Enable rate shaping and fairness */
5092                 bp->cmng.flags.cmng_enables =
5093                                         CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
5094                 if (bp->vn_weight_sum)
5095                         bp->cmng.flags.cmng_enables |=
5096                                         CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
5097                 else
5098                         DP(NETIF_MSG_IFUP, "All MIN values are zeroes"
5099                            "  fairness will be disabled\n");
5100         } else {
5101                 /* rate shaping and fairness are disabled */
5102                 DP(NETIF_MSG_IFUP,
5103                    "single function mode  minmax will be disabled\n");
5104         }
5105
5106
5107         /* Store it to internal memory */
5108         if (bp->port.pmf)
5109                 for (i = 0; i < sizeof(struct cmng_struct_per_port) / 4; i++)
5110                         REG_WR(bp, BAR_XSTRORM_INTMEM +
5111                                XSTORM_CMNG_PER_PORT_VARS_OFFSET(port) + i * 4,
5112                                ((u32 *)(&bp->cmng))[i]);
5113 }
5114
5115 static void bnx2x_init_internal(struct bnx2x *bp, u32 load_code)
5116 {
5117         switch (load_code) {
5118         case FW_MSG_CODE_DRV_LOAD_COMMON:
5119                 bnx2x_init_internal_common(bp);
5120                 /* no break */
5121
5122         case FW_MSG_CODE_DRV_LOAD_PORT:
5123                 bnx2x_init_internal_port(bp);
5124                 /* no break */
5125
5126         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
5127                 bnx2x_init_internal_func(bp);
5128                 break;
5129
5130         default:
5131                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
5132                 break;
5133         }
5134 }
5135
5136 static void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
5137 {
5138         int i;
5139
5140         for_each_queue(bp, i) {
5141                 struct bnx2x_fastpath *fp = &bp->fp[i];
5142
5143                 fp->bp = bp;
5144                 fp->state = BNX2X_FP_STATE_CLOSED;
5145                 fp->index = i;
5146                 fp->cl_id = BP_L_ID(bp) + i;
5147                 fp->sb_id = fp->cl_id;
5148                 DP(NETIF_MSG_IFUP,
5149                    "queue[%d]:  bnx2x_init_sb(%p,%p)  cl_id %d  sb %d\n",
5150                    i, bp, fp->status_blk, fp->cl_id, fp->sb_id);
5151                 bnx2x_init_sb(bp, fp->status_blk, fp->status_blk_mapping,
5152                               fp->sb_id);
5153                 bnx2x_update_fpsb_idx(fp);
5154         }
5155
5156         /* ensure status block indices were read */
5157         rmb();
5158
5159
5160         bnx2x_init_def_sb(bp, bp->def_status_blk, bp->def_status_blk_mapping,
5161                           DEF_SB_ID);
5162         bnx2x_update_dsb_idx(bp);
5163         bnx2x_update_coalesce(bp);
5164         bnx2x_init_rx_rings(bp);
5165         bnx2x_init_tx_ring(bp);
5166         bnx2x_init_sp_ring(bp);
5167         bnx2x_init_context(bp);
5168         bnx2x_init_internal(bp, load_code);
5169         bnx2x_init_ind_table(bp);
5170         bnx2x_stats_init(bp);
5171
5172         /* At this point, we are ready for interrupts */
5173         atomic_set(&bp->intr_sem, 0);
5174
5175         /* flush all before enabling interrupts */
5176         mb();
5177         mmiowb();
5178
5179         bnx2x_int_enable(bp);
5180 }
5181
5182 /* end of nic init */
5183
5184 /*
5185  * gzip service functions
5186  */
5187
5188 static int bnx2x_gunzip_init(struct bnx2x *bp)
5189 {
5190         bp->gunzip_buf = pci_alloc_consistent(bp->pdev, FW_BUF_SIZE,
5191                                               &bp->gunzip_mapping);
5192         if (bp->gunzip_buf  == NULL)
5193                 goto gunzip_nomem1;
5194
5195         bp->strm = kmalloc(sizeof(*bp->strm), GFP_KERNEL);
5196         if (bp->strm  == NULL)
5197                 goto gunzip_nomem2;
5198
5199         bp->strm->workspace = kmalloc(zlib_inflate_workspacesize(),
5200                                       GFP_KERNEL);
5201         if (bp->strm->workspace == NULL)
5202                 goto gunzip_nomem3;
5203
5204         return 0;
5205
5206 gunzip_nomem3:
5207         kfree(bp->strm);
5208         bp->strm = NULL;
5209
5210 gunzip_nomem2:
5211         pci_free_consistent(bp->pdev, FW_BUF_SIZE, bp->gunzip_buf,
5212                             bp->gunzip_mapping);
5213         bp->gunzip_buf = NULL;
5214
5215 gunzip_nomem1:
5216         printk(KERN_ERR PFX "%s: Cannot allocate firmware buffer for"
5217                " un-compression\n", bp->dev->name);
5218         return -ENOMEM;
5219 }
5220
5221 static void bnx2x_gunzip_end(struct bnx2x *bp)
5222 {
5223         kfree(bp->strm->workspace);
5224
5225         kfree(bp->strm);
5226         bp->strm = NULL;
5227
5228         if (bp->gunzip_buf) {
5229                 pci_free_consistent(bp->pdev, FW_BUF_SIZE, bp->gunzip_buf,
5230                                     bp->gunzip_mapping);
5231                 bp->gunzip_buf = NULL;
5232         }
5233 }
5234
5235 static int bnx2x_gunzip(struct bnx2x *bp, u8 *zbuf, int len)
5236 {
5237         int n, rc;
5238
5239         /* check gzip header */
5240         if ((zbuf[0] != 0x1f) || (zbuf[1] != 0x8b) || (zbuf[2] != Z_DEFLATED))
5241                 return -EINVAL;
5242
5243         n = 10;
5244
5245 #define FNAME                           0x8
5246
5247         if (zbuf[3] & FNAME)
5248                 while ((zbuf[n++] != 0) && (n < len));
5249
5250         bp->strm->next_in = zbuf + n;
5251         bp->strm->avail_in = len - n;
5252         bp->strm->next_out = bp->gunzip_buf;
5253         bp->strm->avail_out = FW_BUF_SIZE;
5254
5255         rc = zlib_inflateInit2(bp->strm, -MAX_WBITS);
5256         if (rc != Z_OK)
5257                 return rc;
5258
5259         rc = zlib_inflate(bp->strm, Z_FINISH);
5260         if ((rc != Z_OK) && (rc != Z_STREAM_END))
5261                 printk(KERN_ERR PFX "%s: Firmware decompression error: %s\n",
5262                        bp->dev->name, bp->strm->msg);
5263
5264         bp->gunzip_outlen = (FW_BUF_SIZE - bp->strm->avail_out);
5265         if (bp->gunzip_outlen & 0x3)
5266                 printk(KERN_ERR PFX "%s: Firmware decompression error:"
5267                                     " gunzip_outlen (%d) not aligned\n",
5268                        bp->dev->name, bp->gunzip_outlen);
5269         bp->gunzip_outlen >>= 2;
5270
5271         zlib_inflateEnd(bp->strm);
5272
5273         if (rc == Z_STREAM_END)
5274                 return 0;
5275
5276         return rc;
5277 }
5278
5279 /* nic load/unload */
5280
5281 /*
5282  * General service functions
5283  */
5284
5285 /* send a NIG loopback debug packet */
5286 static void bnx2x_lb_pckt(struct bnx2x *bp)
5287 {
5288         u32 wb_write[3];
5289
5290         /* Ethernet source and destination addresses */
5291         wb_write[0] = 0x55555555;
5292         wb_write[1] = 0x55555555;
5293         wb_write[2] = 0x20;             /* SOP */
5294         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
5295
5296         /* NON-IP protocol */
5297         wb_write[0] = 0x09000000;
5298         wb_write[1] = 0x55555555;
5299         wb_write[2] = 0x10;             /* EOP, eop_bvalid = 0 */
5300         REG_WR_DMAE(bp, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
5301 }
5302
5303 /* some of the internal memories
5304  * are not directly readable from the driver
5305  * to test them we send debug packets
5306  */
5307 static int bnx2x_int_mem_test(struct bnx2x *bp)
5308 {
5309         int factor;
5310         int count, i;
5311         u32 val = 0;
5312
5313         if (CHIP_REV_IS_FPGA(bp))
5314                 factor = 120;
5315         else if (CHIP_REV_IS_EMUL(bp))
5316                 factor = 200;
5317         else
5318                 factor = 1;
5319
5320         DP(NETIF_MSG_HW, "start part1\n");
5321
5322         /* Disable inputs of parser neighbor blocks */
5323         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
5324         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
5325         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
5326         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
5327
5328         /*  Write 0 to parser credits for CFC search request */
5329         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
5330
5331         /* send Ethernet packet */
5332         bnx2x_lb_pckt(bp);
5333
5334         /* TODO do i reset NIG statistic? */
5335         /* Wait until NIG register shows 1 packet of size 0x10 */
5336         count = 1000 * factor;
5337         while (count) {
5338
5339                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5340                 val = *bnx2x_sp(bp, wb_data[0]);
5341                 if (val == 0x10)
5342                         break;
5343
5344                 msleep(10);
5345                 count--;
5346         }
5347         if (val != 0x10) {
5348                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
5349                 return -1;
5350         }
5351
5352         /* Wait until PRS register shows 1 packet */
5353         count = 1000 * factor;
5354         while (count) {
5355                 val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5356                 if (val == 1)
5357                         break;
5358
5359                 msleep(10);
5360                 count--;
5361         }
5362         if (val != 0x1) {
5363                 BNX2X_ERR("PRS timeout val = 0x%x\n", val);
5364                 return -2;
5365         }
5366
5367         /* Reset and init BRB, PRS */
5368         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
5369         msleep(50);
5370         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
5371         msleep(50);
5372         bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5373         bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5374
5375         DP(NETIF_MSG_HW, "part2\n");
5376
5377         /* Disable inputs of parser neighbor blocks */
5378         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x0);
5379         REG_WR(bp, TCM_REG_PRS_IFEN, 0x0);
5380         REG_WR(bp, CFC_REG_DEBUG0, 0x1);
5381         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x0);
5382
5383         /* Write 0 to parser credits for CFC search request */
5384         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
5385
5386         /* send 10 Ethernet packets */
5387         for (i = 0; i < 10; i++)
5388                 bnx2x_lb_pckt(bp);
5389
5390         /* Wait until NIG register shows 10 + 1
5391            packets of size 11*0x10 = 0xb0 */
5392         count = 1000 * factor;
5393         while (count) {
5394
5395                 bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5396                 val = *bnx2x_sp(bp, wb_data[0]);
5397                 if (val == 0xb0)
5398                         break;
5399
5400                 msleep(10);
5401                 count--;
5402         }
5403         if (val != 0xb0) {
5404                 BNX2X_ERR("NIG timeout  val = 0x%x\n", val);
5405                 return -3;
5406         }
5407
5408         /* Wait until PRS register shows 2 packets */
5409         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5410         if (val != 2)
5411                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
5412
5413         /* Write 1 to parser credits for CFC search request */
5414         REG_WR(bp, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
5415
5416         /* Wait until PRS register shows 3 packets */
5417         msleep(10 * factor);
5418         /* Wait until NIG register shows 1 packet of size 0x10 */
5419         val = REG_RD(bp, PRS_REG_NUM_OF_PACKETS);
5420         if (val != 3)
5421                 BNX2X_ERR("PRS timeout  val = 0x%x\n", val);
5422
5423         /* clear NIG EOP FIFO */
5424         for (i = 0; i < 11; i++)
5425                 REG_RD(bp, NIG_REG_INGRESS_EOP_LB_FIFO);
5426         val = REG_RD(bp, NIG_REG_INGRESS_EOP_LB_EMPTY);
5427         if (val != 1) {
5428                 BNX2X_ERR("clear of NIG failed\n");
5429                 return -4;
5430         }
5431
5432         /* Reset and init BRB, PRS, NIG */
5433         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
5434         msleep(50);
5435         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
5436         msleep(50);
5437         bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5438         bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5439 #ifndef BCM_ISCSI
5440         /* set NIC mode */
5441         REG_WR(bp, PRS_REG_NIC_MODE, 1);
5442 #endif
5443
5444         /* Enable inputs of parser neighbor blocks */
5445         REG_WR(bp, TSDM_REG_ENABLE_IN1, 0x7fffffff);
5446         REG_WR(bp, TCM_REG_PRS_IFEN, 0x1);
5447         REG_WR(bp, CFC_REG_DEBUG0, 0x0);
5448         REG_WR(bp, NIG_REG_PRS_REQ_IN_EN, 0x1);
5449
5450         DP(NETIF_MSG_HW, "done\n");
5451
5452         return 0; /* OK */
5453 }
5454
5455 static void enable_blocks_attention(struct bnx2x *bp)
5456 {
5457         REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5458         REG_WR(bp, PXP_REG_PXP_INT_MASK_1, 0);
5459         REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5460         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5461         REG_WR(bp, QM_REG_QM_INT_MASK, 0);
5462         REG_WR(bp, TM_REG_TM_INT_MASK, 0);
5463         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_0, 0);
5464         REG_WR(bp, XSDM_REG_XSDM_INT_MASK_1, 0);
5465         REG_WR(bp, XCM_REG_XCM_INT_MASK, 0);
5466 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_0, 0); */
5467 /*      REG_WR(bp, XSEM_REG_XSEM_INT_MASK_1, 0); */
5468         REG_WR(bp, USDM_REG_USDM_INT_MASK_0, 0);
5469         REG_WR(bp, USDM_REG_USDM_INT_MASK_1, 0);
5470         REG_WR(bp, UCM_REG_UCM_INT_MASK, 0);
5471 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_0, 0); */
5472 /*      REG_WR(bp, USEM_REG_USEM_INT_MASK_1, 0); */
5473         REG_WR(bp, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
5474         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_0, 0);
5475         REG_WR(bp, CSDM_REG_CSDM_INT_MASK_1, 0);
5476         REG_WR(bp, CCM_REG_CCM_INT_MASK, 0);
5477 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_0, 0); */
5478 /*      REG_WR(bp, CSEM_REG_CSEM_INT_MASK_1, 0); */
5479         if (CHIP_REV_IS_FPGA(bp))
5480                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x580000);
5481         else
5482                 REG_WR(bp, PXP2_REG_PXP2_INT_MASK_0, 0x480000);
5483         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_0, 0);
5484         REG_WR(bp, TSDM_REG_TSDM_INT_MASK_1, 0);
5485         REG_WR(bp, TCM_REG_TCM_INT_MASK, 0);
5486 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_0, 0); */
5487 /*      REG_WR(bp, TSEM_REG_TSEM_INT_MASK_1, 0); */
5488         REG_WR(bp, CDU_REG_CDU_INT_MASK, 0);
5489         REG_WR(bp, DMAE_REG_DMAE_INT_MASK, 0);
5490 /*      REG_WR(bp, MISC_REG_MISC_INT_MASK, 0); */
5491         REG_WR(bp, PBF_REG_PBF_INT_MASK, 0X18);         /* bit 3,4 masked */
5492 }
5493
5494
5495 static void bnx2x_reset_common(struct bnx2x *bp)
5496 {
5497         /* reset_common */
5498         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5499                0xd3ffff7f);
5500         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
5501 }
5502
5503 static int bnx2x_init_common(struct bnx2x *bp)
5504 {
5505         u32 val, i;
5506
5507         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_FUNC(bp));
5508
5509         bnx2x_reset_common(bp);
5510         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
5511         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
5512
5513         bnx2x_init_block(bp, MISC_COMMON_START, MISC_COMMON_END);
5514         if (CHIP_IS_E1H(bp))
5515                 REG_WR(bp, MISC_REG_E1HMF_MODE, IS_E1HMF(bp));
5516
5517         REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x100);
5518         msleep(30);
5519         REG_WR(bp, MISC_REG_LCPLL_CTRL_REG_2, 0x0);
5520
5521         bnx2x_init_block(bp, PXP_COMMON_START, PXP_COMMON_END);
5522         if (CHIP_IS_E1(bp)) {
5523                 /* enable HW interrupt from PXP on USDM overflow
5524                    bit 16 on INT_MASK_0 */
5525                 REG_WR(bp, PXP_REG_PXP_INT_MASK_0, 0);
5526         }
5527
5528         bnx2x_init_block(bp, PXP2_COMMON_START, PXP2_COMMON_END);
5529         bnx2x_init_pxp(bp);
5530
5531 #ifdef __BIG_ENDIAN
5532         REG_WR(bp, PXP2_REG_RQ_QM_ENDIAN_M, 1);
5533         REG_WR(bp, PXP2_REG_RQ_TM_ENDIAN_M, 1);
5534         REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
5535         REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
5536         REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
5537         /* make sure this value is 0 */
5538         REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 0);
5539
5540 /*      REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
5541         REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
5542         REG_WR(bp, PXP2_REG_RD_TM_SWAP_MODE, 1);
5543         REG_WR(bp, PXP2_REG_RD_SRC_SWAP_MODE, 1);
5544         REG_WR(bp, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
5545 #endif
5546
5547         REG_WR(bp, PXP2_REG_RQ_CDU_P_SIZE, 2);
5548 #ifdef BCM_ISCSI
5549         REG_WR(bp, PXP2_REG_RQ_TM_P_SIZE, 5);
5550         REG_WR(bp, PXP2_REG_RQ_QM_P_SIZE, 5);
5551         REG_WR(bp, PXP2_REG_RQ_SRC_P_SIZE, 5);
5552 #endif
5553
5554         if (CHIP_REV_IS_FPGA(bp) && CHIP_IS_E1H(bp))
5555                 REG_WR(bp, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
5556
5557         /* let the HW do it's magic ... */
5558         msleep(100);
5559         /* finish PXP init */
5560         val = REG_RD(bp, PXP2_REG_RQ_CFG_DONE);
5561         if (val != 1) {
5562                 BNX2X_ERR("PXP2 CFG failed\n");
5563                 return -EBUSY;
5564         }
5565         val = REG_RD(bp, PXP2_REG_RD_INIT_DONE);
5566         if (val != 1) {
5567                 BNX2X_ERR("PXP2 RD_INIT failed\n");
5568                 return -EBUSY;
5569         }
5570
5571         REG_WR(bp, PXP2_REG_RQ_DISABLE_INPUTS, 0);
5572         REG_WR(bp, PXP2_REG_RD_DISABLE_INPUTS, 0);
5573
5574         bnx2x_init_block(bp, DMAE_COMMON_START, DMAE_COMMON_END);
5575
5576         /* clean the DMAE memory */
5577         bp->dmae_ready = 1;
5578         bnx2x_init_fill(bp, TSEM_REG_PRAM, 0, 8);
5579
5580         bnx2x_init_block(bp, TCM_COMMON_START, TCM_COMMON_END);
5581         bnx2x_init_block(bp, UCM_COMMON_START, UCM_COMMON_END);
5582         bnx2x_init_block(bp, CCM_COMMON_START, CCM_COMMON_END);
5583         bnx2x_init_block(bp, XCM_COMMON_START, XCM_COMMON_END);
5584
5585         bnx2x_read_dmae(bp, XSEM_REG_PASSIVE_BUFFER, 3);
5586         bnx2x_read_dmae(bp, CSEM_REG_PASSIVE_BUFFER, 3);
5587         bnx2x_read_dmae(bp, TSEM_REG_PASSIVE_BUFFER, 3);
5588         bnx2x_read_dmae(bp, USEM_REG_PASSIVE_BUFFER, 3);
5589
5590         bnx2x_init_block(bp, QM_COMMON_START, QM_COMMON_END);
5591         /* soft reset pulse */
5592         REG_WR(bp, QM_REG_SOFT_RESET, 1);
5593         REG_WR(bp, QM_REG_SOFT_RESET, 0);
5594
5595 #ifdef BCM_ISCSI
5596         bnx2x_init_block(bp, TIMERS_COMMON_START, TIMERS_COMMON_END);
5597 #endif
5598
5599         bnx2x_init_block(bp, DQ_COMMON_START, DQ_COMMON_END);
5600         REG_WR(bp, DORQ_REG_DPM_CID_OFST, BCM_PAGE_SHIFT);
5601         if (!CHIP_REV_IS_SLOW(bp)) {
5602                 /* enable hw interrupt from doorbell Q */
5603                 REG_WR(bp, DORQ_REG_DORQ_INT_MASK, 0);
5604         }
5605
5606         bnx2x_init_block(bp, BRB1_COMMON_START, BRB1_COMMON_END);
5607         bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
5608         REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
5609         /* set NIC mode */
5610         REG_WR(bp, PRS_REG_NIC_MODE, 1);
5611         if (CHIP_IS_E1H(bp))
5612                 REG_WR(bp, PRS_REG_E1HOV_MODE, IS_E1HMF(bp));
5613
5614         bnx2x_init_block(bp, TSDM_COMMON_START, TSDM_COMMON_END);
5615         bnx2x_init_block(bp, CSDM_COMMON_START, CSDM_COMMON_END);
5616         bnx2x_init_block(bp, USDM_COMMON_START, USDM_COMMON_END);
5617         bnx2x_init_block(bp, XSDM_COMMON_START, XSDM_COMMON_END);
5618
5619         bnx2x_init_fill(bp, TSTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE(bp));
5620         bnx2x_init_fill(bp, USTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE(bp));
5621         bnx2x_init_fill(bp, CSTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE(bp));
5622         bnx2x_init_fill(bp, XSTORM_INTMEM_ADDR, 0, STORM_INTMEM_SIZE(bp));
5623
5624         bnx2x_init_block(bp, TSEM_COMMON_START, TSEM_COMMON_END);
5625         bnx2x_init_block(bp, USEM_COMMON_START, USEM_COMMON_END);
5626         bnx2x_init_block(bp, CSEM_COMMON_START, CSEM_COMMON_END);
5627         bnx2x_init_block(bp, XSEM_COMMON_START, XSEM_COMMON_END);
5628
5629         /* sync semi rtc */
5630         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
5631                0x80000000);
5632         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
5633                0x80000000);
5634
5635         bnx2x_init_block(bp, UPB_COMMON_START, UPB_COMMON_END);
5636         bnx2x_init_block(bp, XPB_COMMON_START, XPB_COMMON_END);
5637         bnx2x_init_block(bp, PBF_COMMON_START, PBF_COMMON_END);
5638
5639         REG_WR(bp, SRC_REG_SOFT_RST, 1);
5640         for (i = SRC_REG_KEYRSS0_0; i <= SRC_REG_KEYRSS1_9; i += 4) {
5641                 REG_WR(bp, i, 0xc0cac01a);
5642                 /* TODO: replace with something meaningful */
5643         }
5644         bnx2x_init_block(bp, SRCH_COMMON_START, SRCH_COMMON_END);
5645         REG_WR(bp, SRC_REG_SOFT_RST, 0);
5646
5647         if (sizeof(union cdu_context) != 1024)
5648                 /* we currently assume that a context is 1024 bytes */
5649                 printk(KERN_ALERT PFX "please adjust the size of"
5650                        " cdu_context(%ld)\n", (long)sizeof(union cdu_context));
5651
5652         bnx2x_init_block(bp, CDU_COMMON_START, CDU_COMMON_END);
5653         val = (4 << 24) + (0 << 12) + 1024;
5654         REG_WR(bp, CDU_REG_CDU_GLOBAL_PARAMS, val);
5655         if (CHIP_IS_E1(bp)) {
5656                 /* !!! fix pxp client crdit until excel update */
5657                 REG_WR(bp, CDU_REG_CDU_DEBUG, 0x264);
5658                 REG_WR(bp, CDU_REG_CDU_DEBUG, 0);
5659         }
5660
5661         bnx2x_init_block(bp, CFC_COMMON_START, CFC_COMMON_END);
5662         REG_WR(bp, CFC_REG_INIT_REG, 0x7FF);
5663         /* enable context validation interrupt from CFC */
5664         REG_WR(bp, CFC_REG_CFC_INT_MASK, 0);
5665
5666         /* set the thresholds to prevent CFC/CDU race */
5667         REG_WR(bp, CFC_REG_DEBUG0, 0x20020000);
5668
5669         bnx2x_init_block(bp, HC_COMMON_START, HC_COMMON_END);
5670         bnx2x_init_block(bp, MISC_AEU_COMMON_START, MISC_AEU_COMMON_END);
5671
5672         /* PXPCS COMMON comes here */
5673         /* Reset PCIE errors for debug */
5674         REG_WR(bp, 0x2814, 0xffffffff);
5675         REG_WR(bp, 0x3820, 0xffffffff);
5676
5677         /* EMAC0 COMMON comes here */
5678         /* EMAC1 COMMON comes here */
5679         /* DBU COMMON comes here */
5680         /* DBG COMMON comes here */
5681
5682         bnx2x_init_block(bp, NIG_COMMON_START, NIG_COMMON_END);
5683         if (CHIP_IS_E1H(bp)) {
5684                 REG_WR(bp, NIG_REG_LLH_MF_MODE, IS_E1HMF(bp));
5685                 REG_WR(bp, NIG_REG_LLH_E1HOV_MODE, IS_E1HMF(bp));
5686         }
5687
5688         if (CHIP_REV_IS_SLOW(bp))
5689                 msleep(200);
5690
5691         /* finish CFC init */
5692         val = reg_poll(bp, CFC_REG_LL_INIT_DONE, 1, 100, 10);
5693         if (val != 1) {
5694                 BNX2X_ERR("CFC LL_INIT failed\n");
5695                 return -EBUSY;
5696         }
5697         val = reg_poll(bp, CFC_REG_AC_INIT_DONE, 1, 100, 10);
5698         if (val != 1) {
5699                 BNX2X_ERR("CFC AC_INIT failed\n");
5700                 return -EBUSY;
5701         }
5702         val = reg_poll(bp, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
5703         if (val != 1) {
5704                 BNX2X_ERR("CFC CAM_INIT failed\n");
5705                 return -EBUSY;
5706         }
5707         REG_WR(bp, CFC_REG_DEBUG0, 0);
5708
5709         /* read NIG statistic
5710            to see if this is our first up since powerup */
5711         bnx2x_read_dmae(bp, NIG_REG_STAT2_BRB_OCTET, 2);
5712         val = *bnx2x_sp(bp, wb_data[0]);
5713
5714         /* do internal memory self test */
5715         if ((CHIP_IS_E1(bp)) && (val == 0) && bnx2x_int_mem_test(bp)) {
5716                 BNX2X_ERR("internal mem self test failed\n");
5717                 return -EBUSY;
5718         }
5719
5720         switch (XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config)) {
5721         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
5722         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
5723         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
5724                 bp->port.need_hw_lock = 1;
5725                 break;
5726
5727         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5728                 /* Fan failure is indicated by SPIO 5 */
5729                 bnx2x_set_spio(bp, MISC_REGISTERS_SPIO_5,
5730                                MISC_REGISTERS_SPIO_INPUT_HI_Z);
5731
5732                 /* set to active low mode */
5733                 val = REG_RD(bp, MISC_REG_SPIO_INT);
5734                 val |= ((1 << MISC_REGISTERS_SPIO_5) <<
5735                                         MISC_REGISTERS_SPIO_INT_OLD_SET_POS);
5736                 REG_WR(bp, MISC_REG_SPIO_INT, val);
5737
5738                 /* enable interrupt to signal the IGU */
5739                 val = REG_RD(bp, MISC_REG_SPIO_EVENT_EN);
5740                 val |= (1 << MISC_REGISTERS_SPIO_5);
5741                 REG_WR(bp, MISC_REG_SPIO_EVENT_EN, val);
5742                 break;
5743
5744         default:
5745                 break;
5746         }
5747
5748         /* clear PXP2 attentions */
5749         REG_RD(bp, PXP2_REG_PXP2_INT_STS_CLR_0);
5750
5751         enable_blocks_attention(bp);
5752
5753         if (!BP_NOMCP(bp)) {
5754                 bnx2x_acquire_phy_lock(bp);
5755                 bnx2x_common_init_phy(bp, bp->common.shmem_base);
5756                 bnx2x_release_phy_lock(bp);
5757         } else
5758                 BNX2X_ERR("Bootcode is missing - can not initialize link\n");
5759
5760         return 0;
5761 }
5762
5763 static int bnx2x_init_port(struct bnx2x *bp)
5764 {
5765         int port = BP_PORT(bp);
5766         u32 low, high;
5767         u32 val;
5768
5769         DP(BNX2X_MSG_MCP, "starting port init  port %x\n", port);
5770
5771         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
5772
5773         /* Port PXP comes here */
5774         /* Port PXP2 comes here */
5775 #ifdef BCM_ISCSI
5776         /* Port0  1
5777          * Port1  385 */
5778         i++;
5779         wb_write[0] = ONCHIP_ADDR1(bp->timers_mapping);
5780         wb_write[1] = ONCHIP_ADDR2(bp->timers_mapping);
5781         REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5782         REG_WR(bp, PXP2_REG_PSWRQ_TM0_L2P + func*4, PXP_ONE_ILT(i));
5783
5784         /* Port0  2
5785          * Port1  386 */
5786         i++;
5787         wb_write[0] = ONCHIP_ADDR1(bp->qm_mapping);
5788         wb_write[1] = ONCHIP_ADDR2(bp->qm_mapping);
5789         REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5790         REG_WR(bp, PXP2_REG_PSWRQ_QM0_L2P + func*4, PXP_ONE_ILT(i));
5791
5792         /* Port0  3
5793          * Port1  387 */
5794         i++;
5795         wb_write[0] = ONCHIP_ADDR1(bp->t1_mapping);
5796         wb_write[1] = ONCHIP_ADDR2(bp->t1_mapping);
5797         REG_WR_DMAE(bp, PXP2_REG_RQ_ONCHIP_AT + i*8, wb_write, 2);
5798         REG_WR(bp, PXP2_REG_PSWRQ_SRC0_L2P + func*4, PXP_ONE_ILT(i));
5799 #endif
5800         /* Port CMs come here */
5801         bnx2x_init_block(bp, (port ? XCM_PORT1_START : XCM_PORT0_START),
5802                              (port ? XCM_PORT1_END : XCM_PORT0_END));
5803
5804         /* Port QM comes here */
5805 #ifdef BCM_ISCSI
5806         REG_WR(bp, TM_REG_LIN0_SCAN_TIME + func*4, 1024/64*20);
5807         REG_WR(bp, TM_REG_LIN0_MAX_ACTIVE_CID + func*4, 31);
5808
5809         bnx2x_init_block(bp, func ? TIMERS_PORT1_START : TIMERS_PORT0_START,
5810                              func ? TIMERS_PORT1_END : TIMERS_PORT0_END);
5811 #endif
5812         /* Port DQ comes here */
5813
5814         bnx2x_init_block(bp, (port ? BRB1_PORT1_START : BRB1_PORT0_START),
5815                              (port ? BRB1_PORT1_END : BRB1_PORT0_END));
5816         if (CHIP_REV_IS_SLOW(bp) && !CHIP_IS_E1H(bp)) {
5817                 /* no pause for emulation and FPGA */
5818                 low = 0;
5819                 high = 513;
5820         } else {
5821                 if (IS_E1HMF(bp))
5822                         low = ((bp->flags & ONE_PORT_FLAG) ? 160 : 246);
5823                 else if (bp->dev->mtu > 4096) {
5824                         if (bp->flags & ONE_PORT_FLAG)
5825                                 low = 160;
5826                         else {
5827                                 val = bp->dev->mtu;
5828                                 /* (24*1024 + val*4)/256 */
5829                                 low = 96 + (val/64) + ((val % 64) ? 1 : 0);
5830                         }
5831                 } else
5832                         low = ((bp->flags & ONE_PORT_FLAG) ? 80 : 160);
5833                 high = low + 56;        /* 14*1024/256 */
5834         }
5835         REG_WR(bp, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
5836         REG_WR(bp, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
5837
5838
5839         /* Port PRS comes here */
5840         /* Port TSDM comes here */
5841         /* Port CSDM comes here */
5842         /* Port USDM comes here */
5843         /* Port XSDM comes here */
5844
5845         bnx2x_init_block(bp, port ? TSEM_PORT1_START : TSEM_PORT0_START,
5846                              port ? TSEM_PORT1_END : TSEM_PORT0_END);
5847         bnx2x_init_block(bp, port ? USEM_PORT1_START : USEM_PORT0_START,
5848                              port ? USEM_PORT1_END : USEM_PORT0_END);
5849         bnx2x_init_block(bp, port ? CSEM_PORT1_START : CSEM_PORT0_START,
5850                              port ? CSEM_PORT1_END : CSEM_PORT0_END);
5851         bnx2x_init_block(bp, port ? XSEM_PORT1_START : XSEM_PORT0_START,
5852                              port ? XSEM_PORT1_END : XSEM_PORT0_END);
5853
5854         /* Port UPB comes here */
5855         /* Port XPB comes here */
5856
5857         bnx2x_init_block(bp, port ? PBF_PORT1_START : PBF_PORT0_START,
5858                              port ? PBF_PORT1_END : PBF_PORT0_END);
5859
5860         /* configure PBF to work without PAUSE mtu 9000 */
5861         REG_WR(bp, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
5862
5863         /* update threshold */
5864         REG_WR(bp, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
5865         /* update init credit */
5866         REG_WR(bp, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
5867
5868         /* probe changes */
5869         REG_WR(bp, PBF_REG_INIT_P0 + port*4, 1);
5870         msleep(5);
5871         REG_WR(bp, PBF_REG_INIT_P0 + port*4, 0);
5872
5873 #ifdef BCM_ISCSI
5874         /* tell the searcher where the T2 table is */
5875         REG_WR(bp, SRC_REG_COUNTFREE0 + func*4, 16*1024/64);
5876
5877         wb_write[0] = U64_LO(bp->t2_mapping);
5878         wb_write[1] = U64_HI(bp->t2_mapping);
5879         REG_WR_DMAE(bp, SRC_REG_FIRSTFREE0 + func*4, wb_write, 2);
5880         wb_write[0] = U64_LO((u64)bp->t2_mapping + 16*1024 - 64);
5881         wb_write[1] = U64_HI((u64)bp->t2_mapping + 16*1024 - 64);
5882         REG_WR_DMAE(bp, SRC_REG_LASTFREE0 + func*4, wb_write, 2);
5883
5884         REG_WR(bp, SRC_REG_NUMBER_HASH_BITS0 + func*4, 10);
5885         /* Port SRCH comes here */
5886 #endif
5887         /* Port CDU comes here */
5888         /* Port CFC comes here */
5889
5890         if (CHIP_IS_E1(bp)) {
5891                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
5892                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
5893         }
5894         bnx2x_init_block(bp, port ? HC_PORT1_START : HC_PORT0_START,
5895                              port ? HC_PORT1_END : HC_PORT0_END);
5896
5897         bnx2x_init_block(bp, port ? MISC_AEU_PORT1_START :
5898                                     MISC_AEU_PORT0_START,
5899                              port ? MISC_AEU_PORT1_END : MISC_AEU_PORT0_END);
5900         /* init aeu_mask_attn_func_0/1:
5901          *  - SF mode: bits 3-7 are masked. only bits 0-2 are in use
5902          *  - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
5903          *             bits 4-7 are used for "per vn group attention" */
5904         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4,
5905                (IS_E1HMF(bp) ? 0xF7 : 0x7));
5906
5907         /* Port PXPCS comes here */
5908         /* Port EMAC0 comes here */
5909         /* Port EMAC1 comes here */
5910         /* Port DBU comes here */
5911         /* Port DBG comes here */
5912
5913         bnx2x_init_block(bp, port ? NIG_PORT1_START : NIG_PORT0_START,
5914                              port ? NIG_PORT1_END : NIG_PORT0_END);
5915
5916         REG_WR(bp, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
5917
5918         if (CHIP_IS_E1H(bp)) {
5919                 /* 0x2 disable e1hov, 0x1 enable */
5920                 REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
5921                        (IS_E1HMF(bp) ? 0x1 : 0x2));
5922
5923                 /* support pause requests from USDM, TSDM and BRB */
5924                 REG_WR(bp, NIG_REG_LLFC_EGRESS_SRC_ENABLE_0 + port*4, 0x7);
5925
5926                 {
5927                         REG_WR(bp, NIG_REG_LLFC_ENABLE_0 + port*4, 0);
5928                         REG_WR(bp, NIG_REG_LLFC_OUT_EN_0 + port*4, 0);
5929                         REG_WR(bp, NIG_REG_PAUSE_ENABLE_0 + port*4, 1);
5930                 }
5931         }
5932
5933         /* Port MCP comes here */
5934         /* Port DMAE comes here */
5935
5936         switch (XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config)) {
5937         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
5938                 {
5939                 u32 swap_val, swap_override, aeu_gpio_mask, offset;
5940
5941                 bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_3,
5942                                MISC_REGISTERS_GPIO_INPUT_HI_Z, port);
5943
5944                 /* The GPIO should be swapped if the swap register is
5945                    set and active */
5946                 swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
5947                 swap_override = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
5948
5949                 /* Select function upon port-swap configuration */
5950                 if (port == 0) {
5951                         offset = MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0;
5952                         aeu_gpio_mask = (swap_val && swap_override) ?
5953                                 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1 :
5954                                 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0;
5955                 } else {
5956                         offset = MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0;
5957                         aeu_gpio_mask = (swap_val && swap_override) ?
5958                                 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_0 :
5959                                 AEU_INPUTS_ATTN_BITS_GPIO3_FUNCTION_1;
5960                 }
5961                 val = REG_RD(bp, offset);
5962                 /* add GPIO3 to group */
5963                 val |= aeu_gpio_mask;
5964                 REG_WR(bp, offset, val);
5965                 }
5966                 break;
5967
5968         case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
5969                 /* add SPIO 5 to group 0 */
5970                 val = REG_RD(bp, MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
5971                 val |= AEU_INPUTS_ATTN_BITS_SPIO5;
5972                 REG_WR(bp, MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0, val);
5973                 break;
5974
5975         default:
5976                 break;
5977         }
5978
5979         bnx2x__link_reset(bp);
5980
5981         return 0;
5982 }
5983
5984 #define ILT_PER_FUNC            (768/2)
5985 #define FUNC_ILT_BASE(func)     (func * ILT_PER_FUNC)
5986 /* the phys address is shifted right 12 bits and has an added
5987    1=valid bit added to the 53rd bit
5988    then since this is a wide register(TM)
5989    we split it into two 32 bit writes
5990  */
5991 #define ONCHIP_ADDR1(x)         ((u32)(((u64)x >> 12) & 0xFFFFFFFF))
5992 #define ONCHIP_ADDR2(x)         ((u32)((1 << 20) | ((u64)x >> 44)))
5993 #define PXP_ONE_ILT(x)          (((x) << 10) | x)
5994 #define PXP_ILT_RANGE(f, l)     (((l) << 10) | f)
5995
5996 #define CNIC_ILT_LINES          0
5997
5998 static void bnx2x_ilt_wr(struct bnx2x *bp, u32 index, dma_addr_t addr)
5999 {
6000         int reg;
6001
6002         if (CHIP_IS_E1H(bp))
6003                 reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
6004         else /* E1 */
6005                 reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
6006
6007         bnx2x_wb_wr(bp, reg, ONCHIP_ADDR1(addr), ONCHIP_ADDR2(addr));
6008 }
6009
6010 static int bnx2x_init_func(struct bnx2x *bp)
6011 {
6012         int port = BP_PORT(bp);
6013         int func = BP_FUNC(bp);
6014         u32 addr, val;
6015         int i;
6016
6017         DP(BNX2X_MSG_MCP, "starting func init  func %x\n", func);
6018
6019         /* set MSI reconfigure capability */
6020         addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
6021         val = REG_RD(bp, addr);
6022         val |= HC_CONFIG_0_REG_MSI_ATTN_EN_0;
6023         REG_WR(bp, addr, val);
6024
6025         i = FUNC_ILT_BASE(func);
6026
6027         bnx2x_ilt_wr(bp, i, bnx2x_sp_mapping(bp, context));
6028         if (CHIP_IS_E1H(bp)) {
6029                 REG_WR(bp, PXP2_REG_RQ_CDU_FIRST_ILT, i);
6030                 REG_WR(bp, PXP2_REG_RQ_CDU_LAST_ILT, i + CNIC_ILT_LINES);
6031         } else /* E1 */
6032                 REG_WR(bp, PXP2_REG_PSWRQ_CDU0_L2P + func*4,
6033                        PXP_ILT_RANGE(i, i + CNIC_ILT_LINES));
6034
6035
6036         if (CHIP_IS_E1H(bp)) {
6037                 for (i = 0; i < 9; i++)
6038                         bnx2x_init_block(bp,
6039                                          cm_start[func][i], cm_end[func][i]);
6040
6041                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 1);
6042                 REG_WR(bp, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, bp->e1hov);
6043         }
6044
6045         /* HC init per function */
6046         if (CHIP_IS_E1H(bp)) {
6047                 REG_WR(bp, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
6048
6049                 REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
6050                 REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
6051         }
6052         bnx2x_init_block(bp, hc_limits[func][0], hc_limits[func][1]);
6053
6054         /* Reset PCIE errors for debug */
6055         REG_WR(bp, 0x2114, 0xffffffff);
6056         REG_WR(bp, 0x2120, 0xffffffff);
6057
6058         return 0;
6059 }
6060
6061 static int bnx2x_init_hw(struct bnx2x *bp, u32 load_code)
6062 {
6063         int i, rc = 0;
6064
6065         DP(BNX2X_MSG_MCP, "function %d  load_code %x\n",
6066            BP_FUNC(bp), load_code);
6067
6068         bp->dmae_ready = 0;
6069         mutex_init(&bp->dmae_mutex);
6070         bnx2x_gunzip_init(bp);
6071
6072         switch (load_code) {
6073         case FW_MSG_CODE_DRV_LOAD_COMMON:
6074                 rc = bnx2x_init_common(bp);
6075                 if (rc)
6076                         goto init_hw_err;
6077                 /* no break */
6078
6079         case FW_MSG_CODE_DRV_LOAD_PORT:
6080                 bp->dmae_ready = 1;
6081                 rc = bnx2x_init_port(bp);
6082                 if (rc)
6083                         goto init_hw_err;
6084                 /* no break */
6085
6086         case FW_MSG_CODE_DRV_LOAD_FUNCTION:
6087                 bp->dmae_ready = 1;
6088                 rc = bnx2x_init_func(bp);
6089                 if (rc)
6090                         goto init_hw_err;
6091                 break;
6092
6093         default:
6094                 BNX2X_ERR("Unknown load_code (0x%x) from MCP\n", load_code);
6095                 break;
6096         }
6097
6098         if (!BP_NOMCP(bp)) {
6099                 int func = BP_FUNC(bp);
6100
6101                 bp->fw_drv_pulse_wr_seq =
6102                                 (SHMEM_RD(bp, func_mb[func].drv_pulse_mb) &
6103                                  DRV_PULSE_SEQ_MASK);
6104                 bp->func_stx = SHMEM_RD(bp, func_mb[func].fw_mb_param);
6105                 DP(BNX2X_MSG_MCP, "drv_pulse 0x%x  func_stx 0x%x\n",
6106                    bp->fw_drv_pulse_wr_seq, bp->func_stx);
6107         } else
6108                 bp->func_stx = 0;
6109
6110         /* this needs to be done before gunzip end */
6111         bnx2x_zero_def_sb(bp);
6112         for_each_queue(bp, i)
6113                 bnx2x_zero_sb(bp, BP_L_ID(bp) + i);
6114
6115 init_hw_err:
6116         bnx2x_gunzip_end(bp);
6117
6118         return rc;
6119 }
6120
6121 /* send the MCP a request, block until there is a reply */
6122 static u32 bnx2x_fw_command(struct bnx2x *bp, u32 command)
6123 {
6124         int func = BP_FUNC(bp);
6125         u32 seq = ++bp->fw_seq;
6126         u32 rc = 0;
6127         u32 cnt = 1;
6128         u8 delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
6129
6130         SHMEM_WR(bp, func_mb[func].drv_mb_header, (command | seq));
6131         DP(BNX2X_MSG_MCP, "wrote command (%x) to FW MB\n", (command | seq));
6132
6133         do {
6134                 /* let the FW do it's magic ... */
6135                 msleep(delay);
6136
6137                 rc = SHMEM_RD(bp, func_mb[func].fw_mb_header);
6138
6139                 /* Give the FW up to 2 second (200*10ms) */
6140         } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 200));
6141
6142         DP(BNX2X_MSG_MCP, "[after %d ms] read (%x) seq is (%x) from FW MB\n",
6143            cnt*delay, rc, seq);
6144
6145         /* is this a reply to our command? */
6146         if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK)) {
6147                 rc &= FW_MSG_CODE_MASK;
6148
6149         } else {
6150                 /* FW BUG! */
6151                 BNX2X_ERR("FW failed to respond!\n");
6152                 bnx2x_fw_dump(bp);
6153                 rc = 0;
6154         }
6155
6156         return rc;
6157 }
6158
6159 static void bnx2x_free_mem(struct bnx2x *bp)
6160 {
6161
6162 #define BNX2X_PCI_FREE(x, y, size) \
6163         do { \
6164                 if (x) { \
6165                         pci_free_consistent(bp->pdev, size, x, y); \
6166                         x = NULL; \
6167                         y = 0; \
6168                 } \
6169         } while (0)
6170
6171 #define BNX2X_FREE(x) \
6172         do { \
6173                 if (x) { \
6174                         vfree(x); \
6175                         x = NULL; \
6176                 } \
6177         } while (0)
6178
6179         int i;
6180
6181         /* fastpath */
6182         /* Common */
6183         for_each_queue(bp, i) {
6184
6185                 /* status blocks */
6186                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, status_blk),
6187                                bnx2x_fp(bp, i, status_blk_mapping),
6188                                sizeof(struct host_status_block) +
6189                                sizeof(struct eth_tx_db_data));
6190         }
6191         /* Rx */
6192         for_each_rx_queue(bp, i) {
6193
6194                 /* fastpath rx rings: rx_buf rx_desc rx_comp */
6195                 BNX2X_FREE(bnx2x_fp(bp, i, rx_buf_ring));
6196                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_desc_ring),
6197                                bnx2x_fp(bp, i, rx_desc_mapping),
6198                                sizeof(struct eth_rx_bd) * NUM_RX_BD);
6199
6200                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_comp_ring),
6201                                bnx2x_fp(bp, i, rx_comp_mapping),
6202                                sizeof(struct eth_fast_path_rx_cqe) *
6203                                NUM_RCQ_BD);
6204
6205                 /* SGE ring */
6206                 BNX2X_FREE(bnx2x_fp(bp, i, rx_page_ring));
6207                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, rx_sge_ring),
6208                                bnx2x_fp(bp, i, rx_sge_mapping),
6209                                BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
6210         }
6211         /* Tx */
6212         for_each_tx_queue(bp, i) {
6213
6214                 /* fastpath tx rings: tx_buf tx_desc */
6215                 BNX2X_FREE(bnx2x_fp(bp, i, tx_buf_ring));
6216                 BNX2X_PCI_FREE(bnx2x_fp(bp, i, tx_desc_ring),
6217                                bnx2x_fp(bp, i, tx_desc_mapping),
6218                                sizeof(struct eth_tx_bd) * NUM_TX_BD);
6219         }
6220         /* end of fastpath */
6221
6222         BNX2X_PCI_FREE(bp->def_status_blk, bp->def_status_blk_mapping,
6223                        sizeof(struct host_def_status_block));
6224
6225         BNX2X_PCI_FREE(bp->slowpath, bp->slowpath_mapping,
6226                        sizeof(struct bnx2x_slowpath));
6227
6228 #ifdef BCM_ISCSI
6229         BNX2X_PCI_FREE(bp->t1, bp->t1_mapping, 64*1024);
6230         BNX2X_PCI_FREE(bp->t2, bp->t2_mapping, 16*1024);
6231         BNX2X_PCI_FREE(bp->timers, bp->timers_mapping, 8*1024);
6232         BNX2X_PCI_FREE(bp->qm, bp->qm_mapping, 128*1024);
6233 #endif
6234         BNX2X_PCI_FREE(bp->spq, bp->spq_mapping, BCM_PAGE_SIZE);
6235
6236 #undef BNX2X_PCI_FREE
6237 #undef BNX2X_KFREE
6238 }
6239
6240 static int bnx2x_alloc_mem(struct bnx2x *bp)
6241 {
6242
6243 #define BNX2X_PCI_ALLOC(x, y, size) \
6244         do { \
6245                 x = pci_alloc_consistent(bp->pdev, size, y); \
6246                 if (x == NULL) \
6247                         goto alloc_mem_err; \
6248                 memset(x, 0, size); \
6249         } while (0)
6250
6251 #define BNX2X_ALLOC(x, size) \
6252         do { \
6253                 x = vmalloc(size); \
6254                 if (x == NULL) \
6255                         goto alloc_mem_err; \
6256                 memset(x, 0, size); \
6257         } while (0)
6258
6259         int i;
6260
6261         /* fastpath */
6262         /* Common */
6263         for_each_queue(bp, i) {
6264                 bnx2x_fp(bp, i, bp) = bp;
6265
6266                 /* status blocks */
6267                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, status_blk),
6268                                 &bnx2x_fp(bp, i, status_blk_mapping),
6269                                 sizeof(struct host_status_block) +
6270                                 sizeof(struct eth_tx_db_data));
6271         }
6272         /* Rx */
6273         for_each_rx_queue(bp, i) {
6274
6275                 /* fastpath rx rings: rx_buf rx_desc rx_comp */
6276                 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_buf_ring),
6277                                 sizeof(struct sw_rx_bd) * NUM_RX_BD);
6278                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_desc_ring),
6279                                 &bnx2x_fp(bp, i, rx_desc_mapping),
6280                                 sizeof(struct eth_rx_bd) * NUM_RX_BD);
6281
6282                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_comp_ring),
6283                                 &bnx2x_fp(bp, i, rx_comp_mapping),
6284                                 sizeof(struct eth_fast_path_rx_cqe) *
6285                                 NUM_RCQ_BD);
6286
6287                 /* SGE ring */
6288                 BNX2X_ALLOC(bnx2x_fp(bp, i, rx_page_ring),
6289                                 sizeof(struct sw_rx_page) * NUM_RX_SGE);
6290                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, rx_sge_ring),
6291                                 &bnx2x_fp(bp, i, rx_sge_mapping),
6292                                 BCM_PAGE_SIZE * NUM_RX_SGE_PAGES);
6293         }
6294         /* Tx */
6295         for_each_tx_queue(bp, i) {
6296
6297                 bnx2x_fp(bp, i, hw_tx_prods) =
6298                                 (void *)(bnx2x_fp(bp, i, status_blk) + 1);
6299
6300                 bnx2x_fp(bp, i, tx_prods_mapping) =
6301                                 bnx2x_fp(bp, i, status_blk_mapping) +
6302                                 sizeof(struct host_status_block);
6303
6304                 /* fastpath tx rings: tx_buf tx_desc */
6305                 BNX2X_ALLOC(bnx2x_fp(bp, i, tx_buf_ring),
6306                                 sizeof(struct sw_tx_bd) * NUM_TX_BD);
6307                 BNX2X_PCI_ALLOC(bnx2x_fp(bp, i, tx_desc_ring),
6308                                 &bnx2x_fp(bp, i, tx_desc_mapping),
6309                                 sizeof(struct eth_tx_bd) * NUM_TX_BD);
6310         }
6311         /* end of fastpath */
6312
6313         BNX2X_PCI_ALLOC(bp->def_status_blk, &bp->def_status_blk_mapping,
6314                         sizeof(struct host_def_status_block));
6315
6316         BNX2X_PCI_ALLOC(bp->slowpath, &bp->slowpath_mapping,
6317                         sizeof(struct bnx2x_slowpath));
6318
6319 #ifdef BCM_ISCSI
6320         BNX2X_PCI_ALLOC(bp->t1, &bp->t1_mapping, 64*1024);
6321
6322         /* Initialize T1 */
6323         for (i = 0; i < 64*1024; i += 64) {
6324                 *(u64 *)((char *)bp->t1 + i + 56) = 0x0UL;
6325                 *(u64 *)((char *)bp->t1 + i + 3) = 0x0UL;
6326         }
6327
6328         /* allocate searcher T2 table
6329            we allocate 1/4 of alloc num for T2
6330           (which is not entered into the ILT) */
6331         BNX2X_PCI_ALLOC(bp->t2, &bp->t2_mapping, 16*1024);
6332
6333         /* Initialize T2 */
6334         for (i = 0; i < 16*1024; i += 64)
6335                 * (u64 *)((char *)bp->t2 + i + 56) = bp->t2_mapping + i + 64;
6336
6337         /* now fixup the last line in the block to point to the next block */
6338         *(u64 *)((char *)bp->t2 + 1024*16-8) = bp->t2_mapping;
6339
6340         /* Timer block array (MAX_CONN*8) phys uncached for now 1024 conns */
6341         BNX2X_PCI_ALLOC(bp->timers, &bp->timers_mapping, 8*1024);
6342
6343         /* QM queues (128*MAX_CONN) */
6344         BNX2X_PCI_ALLOC(bp->qm, &bp->qm_mapping, 128*1024);
6345 #endif
6346
6347         /* Slow path ring */
6348         BNX2X_PCI_ALLOC(bp->spq, &bp->spq_mapping, BCM_PAGE_SIZE);
6349
6350         return 0;
6351
6352 alloc_mem_err:
6353         bnx2x_free_mem(bp);
6354         return -ENOMEM;
6355
6356 #undef BNX2X_PCI_ALLOC
6357 #undef BNX2X_ALLOC
6358 }
6359
6360 static void bnx2x_free_tx_skbs(struct bnx2x *bp)
6361 {
6362         int i;
6363
6364         for_each_tx_queue(bp, i) {
6365                 struct bnx2x_fastpath *fp = &bp->fp[i];
6366
6367                 u16 bd_cons = fp->tx_bd_cons;
6368                 u16 sw_prod = fp->tx_pkt_prod;
6369                 u16 sw_cons = fp->tx_pkt_cons;
6370
6371                 while (sw_cons != sw_prod) {
6372                         bd_cons = bnx2x_free_tx_pkt(bp, fp, TX_BD(sw_cons));
6373                         sw_cons++;
6374                 }
6375         }
6376 }
6377
6378 static void bnx2x_free_rx_skbs(struct bnx2x *bp)
6379 {
6380         int i, j;
6381
6382         for_each_rx_queue(bp, j) {
6383                 struct bnx2x_fastpath *fp = &bp->fp[j];
6384
6385                 for (i = 0; i < NUM_RX_BD; i++) {
6386                         struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[i];
6387                         struct sk_buff *skb = rx_buf->skb;
6388
6389                         if (skb == NULL)
6390                                 continue;
6391
6392                         pci_unmap_single(bp->pdev,
6393                                          pci_unmap_addr(rx_buf, mapping),
6394                                          bp->rx_buf_size, PCI_DMA_FROMDEVICE);
6395
6396                         rx_buf->skb = NULL;
6397                         dev_kfree_skb(skb);
6398                 }
6399                 if (!fp->disable_tpa)
6400                         bnx2x_free_tpa_pool(bp, fp, CHIP_IS_E1(bp) ?
6401                                             ETH_MAX_AGGREGATION_QUEUES_E1 :
6402                                             ETH_MAX_AGGREGATION_QUEUES_E1H);
6403         }
6404 }
6405
6406 static void bnx2x_free_skbs(struct bnx2x *bp)
6407 {
6408         bnx2x_free_tx_skbs(bp);
6409         bnx2x_free_rx_skbs(bp);
6410 }
6411
6412 static void bnx2x_free_msix_irqs(struct bnx2x *bp)
6413 {
6414         int i, offset = 1;
6415
6416         free_irq(bp->msix_table[0].vector, bp->dev);
6417         DP(NETIF_MSG_IFDOWN, "released sp irq (%d)\n",
6418            bp->msix_table[0].vector);
6419
6420         for_each_queue(bp, i) {
6421                 DP(NETIF_MSG_IFDOWN, "about to release fp #%d->%d irq  "
6422                    "state %x\n", i, bp->msix_table[i + offset].vector,
6423                    bnx2x_fp(bp, i, state));
6424
6425                 free_irq(bp->msix_table[i + offset].vector, &bp->fp[i]);
6426         }
6427 }
6428
6429 static void bnx2x_free_irq(struct bnx2x *bp)
6430 {
6431         if (bp->flags & USING_MSIX_FLAG) {
6432                 bnx2x_free_msix_irqs(bp);
6433                 pci_disable_msix(bp->pdev);
6434                 bp->flags &= ~USING_MSIX_FLAG;
6435
6436         } else if (bp->flags & USING_MSI_FLAG) {
6437                 free_irq(bp->pdev->irq, bp->dev);
6438                 pci_disable_msi(bp->pdev);
6439                 bp->flags &= ~USING_MSI_FLAG;
6440
6441         } else
6442                 free_irq(bp->pdev->irq, bp->dev);
6443 }
6444
6445 static int bnx2x_enable_msix(struct bnx2x *bp)
6446 {
6447         int i, rc, offset = 1;
6448         int igu_vec = 0;
6449
6450         bp->msix_table[0].entry = igu_vec;
6451         DP(NETIF_MSG_IFUP, "msix_table[0].entry = %d (slowpath)\n", igu_vec);
6452
6453         for_each_queue(bp, i) {
6454                 igu_vec = BP_L_ID(bp) + offset + i;
6455                 bp->msix_table[i + offset].entry = igu_vec;
6456                 DP(NETIF_MSG_IFUP, "msix_table[%d].entry = %d "
6457                    "(fastpath #%u)\n", i + offset, igu_vec, i);
6458         }
6459
6460         rc = pci_enable_msix(bp->pdev, &bp->msix_table[0],
6461                              BNX2X_NUM_QUEUES(bp) + offset);
6462         if (rc) {
6463                 DP(NETIF_MSG_IFUP, "MSI-X is not attainable  rc %d\n", rc);
6464                 return rc;
6465         }
6466
6467         bp->flags |= USING_MSIX_FLAG;
6468
6469         return 0;
6470 }
6471
6472 static int bnx2x_req_msix_irqs(struct bnx2x *bp)
6473 {
6474         int i, rc, offset = 1;
6475
6476         rc = request_irq(bp->msix_table[0].vector, bnx2x_msix_sp_int, 0,
6477                          bp->dev->name, bp->dev);
6478         if (rc) {
6479                 BNX2X_ERR("request sp irq failed\n");
6480                 return -EBUSY;
6481         }
6482
6483         for_each_queue(bp, i) {
6484                 struct bnx2x_fastpath *fp = &bp->fp[i];
6485
6486                 sprintf(fp->name, "%s.fp%d", bp->dev->name, i);
6487                 rc = request_irq(bp->msix_table[i + offset].vector,
6488                                  bnx2x_msix_fp_int, 0, fp->name, fp);
6489                 if (rc) {
6490                         BNX2X_ERR("request fp #%d irq failed  rc %d\n", i, rc);
6491                         bnx2x_free_msix_irqs(bp);
6492                         return -EBUSY;
6493                 }
6494
6495                 fp->state = BNX2X_FP_STATE_IRQ;
6496         }
6497
6498         i = BNX2X_NUM_QUEUES(bp);
6499         if (is_multi(bp))
6500                 printk(KERN_INFO PFX
6501                        "%s: using MSI-X  IRQs: sp %d  fp %d - %d\n",
6502                        bp->dev->name, bp->msix_table[0].vector,
6503                        bp->msix_table[offset].vector,
6504                        bp->msix_table[offset + i - 1].vector);
6505         else
6506                 printk(KERN_INFO PFX "%s: using MSI-X  IRQs: sp %d  fp %d\n",
6507                        bp->dev->name, bp->msix_table[0].vector,
6508                        bp->msix_table[offset + i - 1].vector);
6509
6510         return 0;
6511 }
6512
6513 static int bnx2x_enable_msi(struct bnx2x *bp)
6514 {
6515         int rc;
6516
6517         rc = pci_enable_msi(bp->pdev);
6518         if (rc) {
6519                 DP(NETIF_MSG_IFUP, "MSI is not attainable\n");
6520                 return -1;
6521         }
6522         bp->flags |= USING_MSI_FLAG;
6523
6524         return 0;
6525 }
6526
6527 static int bnx2x_req_irq(struct bnx2x *bp)
6528 {
6529         unsigned long flags;
6530         int rc;
6531
6532         if (bp->flags & USING_MSI_FLAG)
6533                 flags = 0;
6534         else
6535                 flags = IRQF_SHARED;
6536
6537         rc = request_irq(bp->pdev->irq, bnx2x_interrupt, flags,
6538                          bp->dev->name, bp->dev);
6539         if (!rc)
6540                 bnx2x_fp(bp, 0, state) = BNX2X_FP_STATE_IRQ;
6541
6542         return rc;
6543 }
6544
6545 static void bnx2x_napi_enable(struct bnx2x *bp)
6546 {
6547         int i;
6548
6549         for_each_rx_queue(bp, i)
6550                 napi_enable(&bnx2x_fp(bp, i, napi));
6551 }
6552
6553 static void bnx2x_napi_disable(struct bnx2x *bp)
6554 {
6555         int i;
6556
6557         for_each_rx_queue(bp, i)
6558                 napi_disable(&bnx2x_fp(bp, i, napi));
6559 }
6560
6561 static void bnx2x_netif_start(struct bnx2x *bp)
6562 {
6563         if (atomic_dec_and_test(&bp->intr_sem)) {
6564                 if (netif_running(bp->dev)) {
6565                         bnx2x_napi_enable(bp);
6566                         bnx2x_int_enable(bp);
6567                         if (bp->state == BNX2X_STATE_OPEN)
6568                                 netif_tx_wake_all_queues(bp->dev);
6569                 }
6570         }
6571 }
6572
6573 static void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
6574 {
6575         bnx2x_int_disable_sync(bp, disable_hw);
6576         bnx2x_napi_disable(bp);
6577         netif_tx_disable(bp->dev);
6578         bp->dev->trans_start = jiffies; /* prevent tx timeout */
6579 }
6580
6581 /*
6582  * Init service functions
6583  */
6584
6585 static void bnx2x_set_mac_addr_e1(struct bnx2x *bp, int set)
6586 {
6587         struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
6588         int port = BP_PORT(bp);
6589
6590         /* CAM allocation
6591          * unicasts 0-31:port0 32-63:port1
6592          * multicast 64-127:port0 128-191:port1
6593          */
6594         config->hdr.length = 2;
6595         config->hdr.offset = port ? 32 : 0;
6596         config->hdr.client_id = bp->fp->cl_id;
6597         config->hdr.reserved1 = 0;
6598
6599         /* primary MAC */
6600         config->config_table[0].cam_entry.msb_mac_addr =
6601                                         swab16(*(u16 *)&bp->dev->dev_addr[0]);
6602         config->config_table[0].cam_entry.middle_mac_addr =
6603                                         swab16(*(u16 *)&bp->dev->dev_addr[2]);
6604         config->config_table[0].cam_entry.lsb_mac_addr =
6605                                         swab16(*(u16 *)&bp->dev->dev_addr[4]);
6606         config->config_table[0].cam_entry.flags = cpu_to_le16(port);
6607         if (set)
6608                 config->config_table[0].target_table_entry.flags = 0;
6609         else
6610                 CAM_INVALIDATE(config->config_table[0]);
6611         config->config_table[0].target_table_entry.client_id = 0;
6612         config->config_table[0].target_table_entry.vlan_id = 0;
6613
6614         DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x)\n",
6615            (set ? "setting" : "clearing"),
6616            config->config_table[0].cam_entry.msb_mac_addr,
6617            config->config_table[0].cam_entry.middle_mac_addr,
6618            config->config_table[0].cam_entry.lsb_mac_addr);
6619
6620         /* broadcast */
6621         config->config_table[1].cam_entry.msb_mac_addr = cpu_to_le16(0xffff);
6622         config->config_table[1].cam_entry.middle_mac_addr = cpu_to_le16(0xffff);
6623         config->config_table[1].cam_entry.lsb_mac_addr = cpu_to_le16(0xffff);
6624         config->config_table[1].cam_entry.flags = cpu_to_le16(port);
6625         if (set)
6626                 config->config_table[1].target_table_entry.flags =
6627                                 TSTORM_CAM_TARGET_TABLE_ENTRY_BROADCAST;
6628         else
6629                 CAM_INVALIDATE(config->config_table[1]);
6630         config->config_table[1].target_table_entry.client_id = 0;
6631         config->config_table[1].target_table_entry.vlan_id = 0;
6632
6633         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
6634                       U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6635                       U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
6636 }
6637
6638 static void bnx2x_set_mac_addr_e1h(struct bnx2x *bp, int set)
6639 {
6640         struct mac_configuration_cmd_e1h *config =
6641                 (struct mac_configuration_cmd_e1h *)bnx2x_sp(bp, mac_config);
6642
6643         if (set && (bp->state != BNX2X_STATE_OPEN)) {
6644                 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
6645                 return;
6646         }
6647
6648         /* CAM allocation for E1H
6649          * unicasts: by func number
6650          * multicast: 20+FUNC*20, 20 each
6651          */
6652         config->hdr.length = 1;
6653         config->hdr.offset = BP_FUNC(bp);
6654         config->hdr.client_id = bp->fp->cl_id;
6655         config->hdr.reserved1 = 0;
6656
6657         /* primary MAC */
6658         config->config_table[0].msb_mac_addr =
6659                                         swab16(*(u16 *)&bp->dev->dev_addr[0]);
6660         config->config_table[0].middle_mac_addr =
6661                                         swab16(*(u16 *)&bp->dev->dev_addr[2]);
6662         config->config_table[0].lsb_mac_addr =
6663                                         swab16(*(u16 *)&bp->dev->dev_addr[4]);
6664         config->config_table[0].client_id = BP_L_ID(bp);
6665         config->config_table[0].vlan_id = 0;
6666         config->config_table[0].e1hov_id = cpu_to_le16(bp->e1hov);
6667         if (set)
6668                 config->config_table[0].flags = BP_PORT(bp);
6669         else
6670                 config->config_table[0].flags =
6671                                 MAC_CONFIGURATION_ENTRY_E1H_ACTION_TYPE;
6672
6673         DP(NETIF_MSG_IFUP, "%s MAC (%04x:%04x:%04x)  E1HOV %d  CLID %d\n",
6674            (set ? "setting" : "clearing"),
6675            config->config_table[0].msb_mac_addr,
6676            config->config_table[0].middle_mac_addr,
6677            config->config_table[0].lsb_mac_addr, bp->e1hov, BP_L_ID(bp));
6678
6679         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
6680                       U64_HI(bnx2x_sp_mapping(bp, mac_config)),
6681                       U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
6682 }
6683
6684 static int bnx2x_wait_ramrod(struct bnx2x *bp, int state, int idx,
6685                              int *state_p, int poll)
6686 {
6687         /* can take a while if any port is running */
6688         int cnt = 5000;
6689
6690         DP(NETIF_MSG_IFUP, "%s for state to become %x on IDX [%d]\n",
6691            poll ? "polling" : "waiting", state, idx);
6692
6693         might_sleep();
6694         while (cnt--) {
6695                 if (poll) {
6696                         bnx2x_rx_int(bp->fp, 10);
6697                         /* if index is different from 0
6698                          * the reply for some commands will
6699                          * be on the non default queue
6700                          */
6701                         if (idx)
6702                                 bnx2x_rx_int(&bp->fp[idx], 10);
6703                 }
6704
6705                 mb(); /* state is changed by bnx2x_sp_event() */
6706                 if (*state_p == state) {
6707 #ifdef BNX2X_STOP_ON_ERROR
6708                         DP(NETIF_MSG_IFUP, "exit  (cnt %d)\n", 5000 - cnt);
6709 #endif
6710                         return 0;
6711                 }
6712
6713                 msleep(1);
6714         }
6715
6716         /* timeout! */
6717         BNX2X_ERR("timeout %s for state %x on IDX [%d]\n",
6718                   poll ? "polling" : "waiting", state, idx);
6719 #ifdef BNX2X_STOP_ON_ERROR
6720         bnx2x_panic();
6721 #endif
6722
6723         return -EBUSY;
6724 }
6725
6726 static int bnx2x_setup_leading(struct bnx2x *bp)
6727 {
6728         int rc;
6729
6730         /* reset IGU state */
6731         bnx2x_ack_sb(bp, bp->fp[0].sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
6732
6733         /* SETUP ramrod */
6734         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_PORT_SETUP, 0, 0, 0, 0);
6735
6736         /* Wait for completion */
6737         rc = bnx2x_wait_ramrod(bp, BNX2X_STATE_OPEN, 0, &(bp->state), 0);
6738
6739         return rc;
6740 }
6741
6742 static int bnx2x_setup_multi(struct bnx2x *bp, int index)
6743 {
6744         struct bnx2x_fastpath *fp = &bp->fp[index];
6745
6746         /* reset IGU state */
6747         bnx2x_ack_sb(bp, fp->sb_id, CSTORM_ID, 0, IGU_INT_ENABLE, 0);
6748
6749         /* SETUP ramrod */
6750         fp->state = BNX2X_FP_STATE_OPENING;
6751         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CLIENT_SETUP, index, 0,
6752                       fp->cl_id, 0);
6753
6754         /* Wait for completion */
6755         return bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_OPEN, index,
6756                                  &(fp->state), 0);
6757 }
6758
6759 static int bnx2x_poll(struct napi_struct *napi, int budget);
6760
6761 static void bnx2x_set_int_mode(struct bnx2x *bp)
6762 {
6763         int num_queues;
6764
6765         switch (int_mode) {
6766         case INT_MODE_INTx:
6767         case INT_MODE_MSI:
6768                 num_queues = 1;
6769                 bp->num_rx_queues = num_queues;
6770                 bp->num_tx_queues = num_queues;
6771                 DP(NETIF_MSG_IFUP,
6772                    "set number of queues to %d\n", num_queues);
6773                 break;
6774
6775         case INT_MODE_MSIX:
6776         default:
6777                 if (bp->multi_mode == ETH_RSS_MODE_REGULAR)
6778                         num_queues = min_t(u32, num_online_cpus(),
6779                                            BNX2X_MAX_QUEUES(bp));
6780                 else
6781                         num_queues = 1;
6782                 bp->num_rx_queues = num_queues;
6783                 bp->num_tx_queues = num_queues;
6784                 DP(NETIF_MSG_IFUP, "set number of rx queues to %d"
6785                    "  number of tx queues to %d\n",
6786                    bp->num_rx_queues, bp->num_tx_queues);
6787                 /* if we can't use MSI-X we only need one fp,
6788                  * so try to enable MSI-X with the requested number of fp's
6789                  * and fallback to MSI or legacy INTx with one fp
6790                  */
6791                 if (bnx2x_enable_msix(bp)) {
6792                         /* failed to enable MSI-X */
6793                         num_queues = 1;
6794                         bp->num_rx_queues = num_queues;
6795                         bp->num_tx_queues = num_queues;
6796                         if (bp->multi_mode)
6797                                 BNX2X_ERR("Multi requested but failed to "
6798                                           "enable MSI-X  set number of "
6799                                           "queues to %d\n", num_queues);
6800                 }
6801                 break;
6802         }
6803         bp->dev->real_num_tx_queues = bp->num_tx_queues;
6804 }
6805
6806 static void bnx2x_set_rx_mode(struct net_device *dev);
6807
6808 /* must be called with rtnl_lock */
6809 static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
6810 {
6811         u32 load_code;
6812         int i, rc = 0;
6813 #ifdef BNX2X_STOP_ON_ERROR
6814         DP(NETIF_MSG_IFUP, "enter  load_mode %d\n", load_mode);
6815         if (unlikely(bp->panic))
6816                 return -EPERM;
6817 #endif
6818
6819         bp->state = BNX2X_STATE_OPENING_WAIT4_LOAD;
6820
6821         bnx2x_set_int_mode(bp);
6822
6823         if (bnx2x_alloc_mem(bp))
6824                 return -ENOMEM;
6825
6826         for_each_rx_queue(bp, i)
6827                 bnx2x_fp(bp, i, disable_tpa) =
6828                                         ((bp->flags & TPA_ENABLE_FLAG) == 0);
6829
6830         for_each_rx_queue(bp, i)
6831                 netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
6832                                bnx2x_poll, 128);
6833
6834 #ifdef BNX2X_STOP_ON_ERROR
6835         for_each_rx_queue(bp, i) {
6836                 struct bnx2x_fastpath *fp = &bp->fp[i];
6837
6838                 fp->poll_no_work = 0;
6839                 fp->poll_calls = 0;
6840                 fp->poll_max_calls = 0;
6841                 fp->poll_complete = 0;
6842                 fp->poll_exit = 0;
6843         }
6844 #endif
6845         bnx2x_napi_enable(bp);
6846
6847         if (bp->flags & USING_MSIX_FLAG) {
6848                 rc = bnx2x_req_msix_irqs(bp);
6849                 if (rc) {
6850                         pci_disable_msix(bp->pdev);
6851                         goto load_error1;
6852                 }
6853         } else {
6854                 if ((rc != -ENOMEM) && (int_mode != INT_MODE_INTx))
6855                         bnx2x_enable_msi(bp);
6856                 bnx2x_ack_int(bp);
6857                 rc = bnx2x_req_irq(bp);
6858                 if (rc) {
6859                         BNX2X_ERR("IRQ request failed  rc %d, aborting\n", rc);
6860                         if (bp->flags & USING_MSI_FLAG)
6861                                 pci_disable_msi(bp->pdev);
6862                         goto load_error1;
6863                 }
6864                 if (bp->flags & USING_MSI_FLAG) {
6865                         bp->dev->irq = bp->pdev->irq;
6866                         printk(KERN_INFO PFX "%s: using MSI  IRQ %d\n",
6867                                bp->dev->name, bp->pdev->irq);
6868                 }
6869         }
6870
6871         /* Send LOAD_REQUEST command to MCP
6872            Returns the type of LOAD command:
6873            if it is the first port to be initialized
6874            common blocks should be initialized, otherwise - not
6875         */
6876         if (!BP_NOMCP(bp)) {
6877                 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
6878                 if (!load_code) {
6879                         BNX2X_ERR("MCP response failure, aborting\n");
6880                         rc = -EBUSY;
6881                         goto load_error2;
6882                 }
6883                 if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED) {
6884                         rc = -EBUSY; /* other port in diagnostic mode */
6885                         goto load_error2;
6886                 }
6887
6888         } else {
6889                 int port = BP_PORT(bp);
6890
6891                 DP(NETIF_MSG_IFUP, "NO MCP - load counts      %d, %d, %d\n",
6892                    load_count[0], load_count[1], load_count[2]);
6893                 load_count[0]++;
6894                 load_count[1 + port]++;
6895                 DP(NETIF_MSG_IFUP, "NO MCP - new load counts  %d, %d, %d\n",
6896                    load_count[0], load_count[1], load_count[2]);
6897                 if (load_count[0] == 1)
6898                         load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
6899                 else if (load_count[1 + port] == 1)
6900                         load_code = FW_MSG_CODE_DRV_LOAD_PORT;
6901                 else
6902                         load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
6903         }
6904
6905         if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
6906             (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
6907                 bp->port.pmf = 1;
6908         else
6909                 bp->port.pmf = 0;
6910         DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
6911
6912         /* Initialize HW */
6913         rc = bnx2x_init_hw(bp, load_code);
6914         if (rc) {
6915                 BNX2X_ERR("HW init failed, aborting\n");
6916                 goto load_error2;
6917         }
6918
6919         /* Setup NIC internals and enable interrupts */
6920         bnx2x_nic_init(bp, load_code);
6921
6922         /* Send LOAD_DONE command to MCP */
6923         if (!BP_NOMCP(bp)) {
6924                 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE);
6925                 if (!load_code) {
6926                         BNX2X_ERR("MCP response failure, aborting\n");
6927                         rc = -EBUSY;
6928                         goto load_error3;
6929                 }
6930         }
6931
6932         bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
6933
6934         rc = bnx2x_setup_leading(bp);
6935         if (rc) {
6936                 BNX2X_ERR("Setup leading failed!\n");
6937                 goto load_error3;
6938         }
6939
6940         if (CHIP_IS_E1H(bp))
6941                 if (bp->mf_config & FUNC_MF_CFG_FUNC_DISABLED) {
6942                         DP(NETIF_MSG_IFUP, "mf_cfg function disabled\n");
6943                         bp->state = BNX2X_STATE_DISABLED;
6944                 }
6945
6946         if (bp->state == BNX2X_STATE_OPEN)
6947                 for_each_nondefault_queue(bp, i) {
6948                         rc = bnx2x_setup_multi(bp, i);
6949                         if (rc)
6950                                 goto load_error3;
6951                 }
6952
6953         if (CHIP_IS_E1(bp))
6954                 bnx2x_set_mac_addr_e1(bp, 1);
6955         else
6956                 bnx2x_set_mac_addr_e1h(bp, 1);
6957
6958         if (bp->port.pmf)
6959                 bnx2x_initial_phy_init(bp, load_mode);
6960
6961         /* Start fast path */
6962         switch (load_mode) {
6963         case LOAD_NORMAL:
6964                 /* Tx queue should be only reenabled */
6965                 netif_tx_wake_all_queues(bp->dev);
6966                 /* Initialize the receive filter. */
6967                 bnx2x_set_rx_mode(bp->dev);
6968                 break;
6969
6970         case LOAD_OPEN:
6971                 netif_tx_start_all_queues(bp->dev);
6972                 /* Initialize the receive filter. */
6973                 bnx2x_set_rx_mode(bp->dev);
6974                 break;
6975
6976         case LOAD_DIAG:
6977                 /* Initialize the receive filter. */
6978                 bnx2x_set_rx_mode(bp->dev);
6979                 bp->state = BNX2X_STATE_DIAG;
6980                 break;
6981
6982         default:
6983                 break;
6984         }
6985
6986         if (!bp->port.pmf)
6987                 bnx2x__link_status_update(bp);
6988
6989         /* start the timer */
6990         mod_timer(&bp->timer, jiffies + bp->current_interval);
6991
6992
6993         return 0;
6994
6995 load_error3:
6996         bnx2x_int_disable_sync(bp, 1);
6997         if (!BP_NOMCP(bp)) {
6998                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP);
6999                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
7000         }
7001         bp->port.pmf = 0;
7002         /* Free SKBs, SGEs, TPA pool and driver internals */
7003         bnx2x_free_skbs(bp);
7004         for_each_rx_queue(bp, i)
7005                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
7006 load_error2:
7007         /* Release IRQs */
7008         bnx2x_free_irq(bp);
7009 load_error1:
7010         bnx2x_napi_disable(bp);
7011         for_each_rx_queue(bp, i)
7012                 netif_napi_del(&bnx2x_fp(bp, i, napi));
7013         bnx2x_free_mem(bp);
7014
7015         return rc;
7016 }
7017
7018 static int bnx2x_stop_multi(struct bnx2x *bp, int index)
7019 {
7020         struct bnx2x_fastpath *fp = &bp->fp[index];
7021         int rc;
7022
7023         /* halt the connection */
7024         fp->state = BNX2X_FP_STATE_HALTING;
7025         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, index, 0, fp->cl_id, 0);
7026
7027         /* Wait for completion */
7028         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, index,
7029                                &(fp->state), 1);
7030         if (rc) /* timeout */
7031                 return rc;
7032
7033         /* delete cfc entry */
7034         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_CFC_DEL, index, 0, 0, 1);
7035
7036         /* Wait for completion */
7037         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_CLOSED, index,
7038                                &(fp->state), 1);
7039         return rc;
7040 }
7041
7042 static int bnx2x_stop_leading(struct bnx2x *bp)
7043 {
7044         __le16 dsb_sp_prod_idx;
7045         /* if the other port is handling traffic,
7046            this can take a lot of time */
7047         int cnt = 500;
7048         int rc;
7049
7050         might_sleep();
7051
7052         /* Send HALT ramrod */
7053         bp->fp[0].state = BNX2X_FP_STATE_HALTING;
7054         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_HALT, 0, 0, bp->fp->cl_id, 0);
7055
7056         /* Wait for completion */
7057         rc = bnx2x_wait_ramrod(bp, BNX2X_FP_STATE_HALTED, 0,
7058                                &(bp->fp[0].state), 1);
7059         if (rc) /* timeout */
7060                 return rc;
7061
7062         dsb_sp_prod_idx = *bp->dsb_sp_prod;
7063
7064         /* Send PORT_DELETE ramrod */
7065         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_PORT_DEL, 0, 0, 0, 1);
7066
7067         /* Wait for completion to arrive on default status block
7068            we are going to reset the chip anyway
7069            so there is not much to do if this times out
7070          */
7071         while (dsb_sp_prod_idx == *bp->dsb_sp_prod) {
7072                 if (!cnt) {
7073                         DP(NETIF_MSG_IFDOWN, "timeout waiting for port del "
7074                            "dsb_sp_prod 0x%x != dsb_sp_prod_idx 0x%x\n",
7075                            *bp->dsb_sp_prod, dsb_sp_prod_idx);
7076 #ifdef BNX2X_STOP_ON_ERROR
7077                         bnx2x_panic();
7078 #endif
7079                         rc = -EBUSY;
7080                         break;
7081                 }
7082                 cnt--;
7083                 msleep(1);
7084                 rmb(); /* Refresh the dsb_sp_prod */
7085         }
7086         bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
7087         bp->fp[0].state = BNX2X_FP_STATE_CLOSED;
7088
7089         return rc;
7090 }
7091
7092 static void bnx2x_reset_func(struct bnx2x *bp)
7093 {
7094         int port = BP_PORT(bp);
7095         int func = BP_FUNC(bp);
7096         int base, i;
7097
7098         /* Configure IGU */
7099         REG_WR(bp, HC_REG_LEADING_EDGE_0 + port*8, 0);
7100         REG_WR(bp, HC_REG_TRAILING_EDGE_0 + port*8, 0);
7101
7102         /* Clear ILT */
7103         base = FUNC_ILT_BASE(func);
7104         for (i = base; i < base + ILT_PER_FUNC; i++)
7105                 bnx2x_ilt_wr(bp, i, 0);
7106 }
7107
7108 static void bnx2x_reset_port(struct bnx2x *bp)
7109 {
7110         int port = BP_PORT(bp);
7111         u32 val;
7112
7113         REG_WR(bp, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
7114
7115         /* Do not rcv packets to BRB */
7116         REG_WR(bp, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
7117         /* Do not direct rcv packets that are not for MCP to the BRB */
7118         REG_WR(bp, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
7119                            NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
7120
7121         /* Configure AEU */
7122         REG_WR(bp, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
7123
7124         msleep(100);
7125         /* Check for BRB port occupancy */
7126         val = REG_RD(bp, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
7127         if (val)
7128                 DP(NETIF_MSG_IFDOWN,
7129                    "BRB1 is not empty  %d blocks are occupied\n", val);
7130
7131         /* TODO: Close Doorbell port? */
7132 }
7133
7134 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
7135 {
7136         DP(BNX2X_MSG_MCP, "function %d  reset_code %x\n",
7137            BP_FUNC(bp), reset_code);
7138
7139         switch (reset_code) {
7140         case FW_MSG_CODE_DRV_UNLOAD_COMMON:
7141                 bnx2x_reset_port(bp);
7142                 bnx2x_reset_func(bp);
7143                 bnx2x_reset_common(bp);
7144                 break;
7145
7146         case FW_MSG_CODE_DRV_UNLOAD_PORT:
7147                 bnx2x_reset_port(bp);
7148                 bnx2x_reset_func(bp);
7149                 break;
7150
7151         case FW_MSG_CODE_DRV_UNLOAD_FUNCTION:
7152                 bnx2x_reset_func(bp);
7153                 break;
7154
7155         default:
7156                 BNX2X_ERR("Unknown reset_code (0x%x) from MCP\n", reset_code);
7157                 break;
7158         }
7159 }
7160
7161 /* must be called with rtnl_lock */
7162 static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
7163 {
7164         int port = BP_PORT(bp);
7165         u32 reset_code = 0;
7166         int i, cnt, rc;
7167
7168         bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
7169
7170         bp->rx_mode = BNX2X_RX_MODE_NONE;
7171         bnx2x_set_storm_rx_mode(bp);
7172
7173         bnx2x_netif_stop(bp, 1);
7174
7175         del_timer_sync(&bp->timer);
7176         SHMEM_WR(bp, func_mb[BP_FUNC(bp)].drv_pulse_mb,
7177                  (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
7178         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
7179
7180         /* Release IRQs */
7181         bnx2x_free_irq(bp);
7182
7183         /* Wait until tx fastpath tasks complete */
7184         for_each_tx_queue(bp, i) {
7185                 struct bnx2x_fastpath *fp = &bp->fp[i];
7186
7187                 cnt = 1000;
7188                 while (bnx2x_has_tx_work_unload(fp)) {
7189
7190                         bnx2x_tx_int(fp);
7191                         if (!cnt) {
7192                                 BNX2X_ERR("timeout waiting for queue[%d]\n",
7193                                           i);
7194 #ifdef BNX2X_STOP_ON_ERROR
7195                                 bnx2x_panic();
7196                                 return -EBUSY;
7197 #else
7198                                 break;
7199 #endif
7200                         }
7201                         cnt--;
7202                         msleep(1);
7203                 }
7204         }
7205         /* Give HW time to discard old tx messages */
7206         msleep(1);
7207
7208         if (CHIP_IS_E1(bp)) {
7209                 struct mac_configuration_cmd *config =
7210                                                 bnx2x_sp(bp, mcast_config);
7211
7212                 bnx2x_set_mac_addr_e1(bp, 0);
7213
7214                 for (i = 0; i < config->hdr.length; i++)
7215                         CAM_INVALIDATE(config->config_table[i]);
7216
7217                 config->hdr.length = i;
7218                 if (CHIP_REV_IS_SLOW(bp))
7219                         config->hdr.offset = BNX2X_MAX_EMUL_MULTI*(1 + port);
7220                 else
7221                         config->hdr.offset = BNX2X_MAX_MULTICAST*(1 + port);
7222                 config->hdr.client_id = bp->fp->cl_id;
7223                 config->hdr.reserved1 = 0;
7224
7225                 bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
7226                               U64_HI(bnx2x_sp_mapping(bp, mcast_config)),
7227                               U64_LO(bnx2x_sp_mapping(bp, mcast_config)), 0);
7228
7229         } else { /* E1H */
7230                 REG_WR(bp, NIG_REG_LLH0_FUNC_EN + port*8, 0);
7231
7232                 bnx2x_set_mac_addr_e1h(bp, 0);
7233
7234                 for (i = 0; i < MC_HASH_SIZE; i++)
7235                         REG_WR(bp, MC_HASH_OFFSET(bp, i), 0);
7236         }
7237
7238         if (unload_mode == UNLOAD_NORMAL)
7239                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7240
7241         else if (bp->flags & NO_WOL_FLAG) {
7242                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP;
7243                 if (CHIP_IS_E1H(bp))
7244                         REG_WR(bp, MISC_REG_E1HMF_MODE, 0);
7245
7246         } else if (bp->wol) {
7247                 u32 emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
7248                 u8 *mac_addr = bp->dev->dev_addr;
7249                 u32 val;
7250                 /* The mac address is written to entries 1-4 to
7251                    preserve entry 0 which is used by the PMF */
7252                 u8 entry = (BP_E1HVN(bp) + 1)*8;
7253
7254                 val = (mac_addr[0] << 8) | mac_addr[1];
7255                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry, val);
7256
7257                 val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
7258                       (mac_addr[4] << 8) | mac_addr[5];
7259                 EMAC_WR(bp, EMAC_REG_EMAC_MAC_MATCH + entry + 4, val);
7260
7261                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_EN;
7262
7263         } else
7264                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7265
7266         /* Close multi and leading connections
7267            Completions for ramrods are collected in a synchronous way */
7268         for_each_nondefault_queue(bp, i)
7269                 if (bnx2x_stop_multi(bp, i))
7270                         goto unload_error;
7271
7272         rc = bnx2x_stop_leading(bp);
7273         if (rc) {
7274                 BNX2X_ERR("Stop leading failed!\n");
7275 #ifdef BNX2X_STOP_ON_ERROR
7276                 return -EBUSY;
7277 #else
7278                 goto unload_error;
7279 #endif
7280         }
7281
7282 unload_error:
7283         if (!BP_NOMCP(bp))
7284                 reset_code = bnx2x_fw_command(bp, reset_code);
7285         else {
7286                 DP(NETIF_MSG_IFDOWN, "NO MCP - load counts      %d, %d, %d\n",
7287                    load_count[0], load_count[1], load_count[2]);
7288                 load_count[0]--;
7289                 load_count[1 + port]--;
7290                 DP(NETIF_MSG_IFDOWN, "NO MCP - new load counts  %d, %d, %d\n",
7291                    load_count[0], load_count[1], load_count[2]);
7292                 if (load_count[0] == 0)
7293                         reset_code = FW_MSG_CODE_DRV_UNLOAD_COMMON;
7294                 else if (load_count[1 + port] == 0)
7295                         reset_code = FW_MSG_CODE_DRV_UNLOAD_PORT;
7296                 else
7297                         reset_code = FW_MSG_CODE_DRV_UNLOAD_FUNCTION;
7298         }
7299
7300         if ((reset_code == FW_MSG_CODE_DRV_UNLOAD_COMMON) ||
7301             (reset_code == FW_MSG_CODE_DRV_UNLOAD_PORT))
7302                 bnx2x__link_reset(bp);
7303
7304         /* Reset the chip */
7305         bnx2x_reset_chip(bp, reset_code);
7306
7307         /* Report UNLOAD_DONE to MCP */
7308         if (!BP_NOMCP(bp))
7309                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
7310
7311         bp->port.pmf = 0;
7312
7313         /* Free SKBs, SGEs, TPA pool and driver internals */
7314         bnx2x_free_skbs(bp);
7315         for_each_rx_queue(bp, i)
7316                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
7317         for_each_rx_queue(bp, i)
7318                 netif_napi_del(&bnx2x_fp(bp, i, napi));
7319         bnx2x_free_mem(bp);
7320
7321         bp->state = BNX2X_STATE_CLOSED;
7322
7323         netif_carrier_off(bp->dev);
7324
7325         return 0;
7326 }
7327
7328 static void bnx2x_reset_task(struct work_struct *work)
7329 {
7330         struct bnx2x *bp = container_of(work, struct bnx2x, reset_task);
7331
7332 #ifdef BNX2X_STOP_ON_ERROR
7333         BNX2X_ERR("reset task called but STOP_ON_ERROR defined"
7334                   " so reset not done to allow debug dump,\n"
7335          KERN_ERR " you will need to reboot when done\n");
7336         return;
7337 #endif
7338
7339         rtnl_lock();
7340
7341         if (!netif_running(bp->dev))
7342                 goto reset_task_exit;
7343
7344         bnx2x_nic_unload(bp, UNLOAD_NORMAL);
7345         bnx2x_nic_load(bp, LOAD_NORMAL);
7346
7347 reset_task_exit:
7348         rtnl_unlock();
7349 }
7350
7351 /* end of nic load/unload */
7352
7353 /* ethtool_ops */
7354
7355 /*
7356  * Init service functions
7357  */
7358
7359 static inline u32 bnx2x_get_pretend_reg(struct bnx2x *bp, int func)
7360 {
7361         switch (func) {
7362         case 0: return PXP2_REG_PGL_PRETEND_FUNC_F0;
7363         case 1: return PXP2_REG_PGL_PRETEND_FUNC_F1;
7364         case 2: return PXP2_REG_PGL_PRETEND_FUNC_F2;
7365         case 3: return PXP2_REG_PGL_PRETEND_FUNC_F3;
7366         case 4: return PXP2_REG_PGL_PRETEND_FUNC_F4;
7367         case 5: return PXP2_REG_PGL_PRETEND_FUNC_F5;
7368         case 6: return PXP2_REG_PGL_PRETEND_FUNC_F6;
7369         case 7: return PXP2_REG_PGL_PRETEND_FUNC_F7;
7370         default:
7371                 BNX2X_ERR("Unsupported function index: %d\n", func);
7372                 return (u32)(-1);
7373         }
7374 }
7375
7376 static void bnx2x_undi_int_disable_e1h(struct bnx2x *bp, int orig_func)
7377 {
7378         u32 reg = bnx2x_get_pretend_reg(bp, orig_func), new_val;
7379
7380         /* Flush all outstanding writes */
7381         mmiowb();
7382
7383         /* Pretend to be function 0 */
7384         REG_WR(bp, reg, 0);
7385         /* Flush the GRC transaction (in the chip) */
7386         new_val = REG_RD(bp, reg);
7387         if (new_val != 0) {
7388                 BNX2X_ERR("Hmmm... Pretend register wasn't updated: (0,%d)!\n",
7389                           new_val);
7390                 BUG();
7391         }
7392
7393         /* From now we are in the "like-E1" mode */
7394         bnx2x_int_disable(bp);
7395
7396         /* Flush all outstanding writes */
7397         mmiowb();
7398
7399         /* Restore the original funtion settings */
7400         REG_WR(bp, reg, orig_func);
7401         new_val = REG_RD(bp, reg);
7402         if (new_val != orig_func) {
7403                 BNX2X_ERR("Hmmm... Pretend register wasn't updated: (%d,%d)!\n",
7404                           orig_func, new_val);
7405                 BUG();
7406         }
7407 }
7408
7409 static inline void bnx2x_undi_int_disable(struct bnx2x *bp, int func)
7410 {
7411         if (CHIP_IS_E1H(bp))
7412                 bnx2x_undi_int_disable_e1h(bp, func);
7413         else
7414                 bnx2x_int_disable(bp);
7415 }
7416
7417 static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
7418 {
7419         u32 val;
7420
7421         /* Check if there is any driver already loaded */
7422         val = REG_RD(bp, MISC_REG_UNPREPARED);
7423         if (val == 0x1) {
7424                 /* Check if it is the UNDI driver
7425                  * UNDI driver initializes CID offset for normal bell to 0x7
7426                  */
7427                 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7428                 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
7429                 if (val == 0x7) {
7430                         u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7431                         /* save our func */
7432                         int func = BP_FUNC(bp);
7433                         u32 swap_en;
7434                         u32 swap_val;
7435
7436                         /* clear the UNDI indication */
7437                         REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
7438
7439                         BNX2X_DEV_INFO("UNDI is active! reset device\n");
7440
7441                         /* try unload UNDI on port 0 */
7442                         bp->func = 0;
7443                         bp->fw_seq =
7444                                (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
7445                                 DRV_MSG_SEQ_NUMBER_MASK);
7446                         reset_code = bnx2x_fw_command(bp, reset_code);
7447
7448                         /* if UNDI is loaded on the other port */
7449                         if (reset_code != FW_MSG_CODE_DRV_UNLOAD_COMMON) {
7450
7451                                 /* send "DONE" for previous unload */
7452                                 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
7453
7454                                 /* unload UNDI on port 1 */
7455                                 bp->func = 1;
7456                                 bp->fw_seq =
7457                                (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
7458                                         DRV_MSG_SEQ_NUMBER_MASK);
7459                                 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
7460
7461                                 bnx2x_fw_command(bp, reset_code);
7462                         }
7463
7464                         /* now it's safe to release the lock */
7465                         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7466
7467                         bnx2x_undi_int_disable(bp, func);
7468
7469                         /* close input traffic and wait for it */
7470                         /* Do not rcv packets to BRB */
7471                         REG_WR(bp,
7472                               (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_DRV_MASK :
7473                                              NIG_REG_LLH0_BRB1_DRV_MASK), 0x0);
7474                         /* Do not direct rcv packets that are not for MCP to
7475                          * the BRB */
7476                         REG_WR(bp,
7477                                (BP_PORT(bp) ? NIG_REG_LLH1_BRB1_NOT_MCP :
7478                                               NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
7479                         /* clear AEU */
7480                         REG_WR(bp,
7481                              (BP_PORT(bp) ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
7482                                             MISC_REG_AEU_MASK_ATTN_FUNC_0), 0);
7483                         msleep(10);
7484
7485                         /* save NIG port swap info */
7486                         swap_val = REG_RD(bp, NIG_REG_PORT_SWAP);
7487                         swap_en = REG_RD(bp, NIG_REG_STRAP_OVERRIDE);
7488                         /* reset device */
7489                         REG_WR(bp,
7490                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
7491                                0xd3ffffff);
7492                         REG_WR(bp,
7493                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
7494                                0x1403);
7495                         /* take the NIG out of reset and restore swap values */
7496                         REG_WR(bp,
7497                                GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
7498                                MISC_REGISTERS_RESET_REG_1_RST_NIG);
7499                         REG_WR(bp, NIG_REG_PORT_SWAP, swap_val);
7500                         REG_WR(bp, NIG_REG_STRAP_OVERRIDE, swap_en);
7501
7502                         /* send unload done to the MCP */
7503                         bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
7504
7505                         /* restore our func and fw_seq */
7506                         bp->func = func;
7507                         bp->fw_seq =
7508                                (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
7509                                 DRV_MSG_SEQ_NUMBER_MASK);
7510
7511                 } else
7512                         bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
7513         }
7514 }
7515
7516 static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
7517 {
7518         u32 val, val2, val3, val4, id;
7519         u16 pmc;
7520
7521         /* Get the chip revision id and number. */
7522         /* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
7523         val = REG_RD(bp, MISC_REG_CHIP_NUM);
7524         id = ((val & 0xffff) << 16);
7525         val = REG_RD(bp, MISC_REG_CHIP_REV);
7526         id |= ((val & 0xf) << 12);
7527         val = REG_RD(bp, MISC_REG_CHIP_METAL);
7528         id |= ((val & 0xff) << 4);
7529         val = REG_RD(bp, MISC_REG_BOND_ID);
7530         id |= (val & 0xf);
7531         bp->common.chip_id = id;
7532         bp->link_params.chip_id = bp->common.chip_id;
7533         BNX2X_DEV_INFO("chip ID is 0x%x\n", id);
7534
7535         val = (REG_RD(bp, 0x2874) & 0x55);
7536         if ((bp->common.chip_id & 0x1) ||
7537             (CHIP_IS_E1(bp) && val) || (CHIP_IS_E1H(bp) && (val == 0x55))) {
7538                 bp->flags |= ONE_PORT_FLAG;
7539                 BNX2X_DEV_INFO("single port device\n");
7540         }
7541
7542         val = REG_RD(bp, MCP_REG_MCPR_NVM_CFG4);
7543         bp->common.flash_size = (NVRAM_1MB_SIZE <<
7544                                  (val & MCPR_NVM_CFG4_FLASH_SIZE));
7545         BNX2X_DEV_INFO("flash_size 0x%x (%d)\n",
7546                        bp->common.flash_size, bp->common.flash_size);
7547
7548         bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
7549         bp->link_params.shmem_base = bp->common.shmem_base;
7550         BNX2X_DEV_INFO("shmem offset is 0x%x\n", bp->common.shmem_base);
7551
7552         if (!bp->common.shmem_base ||
7553             (bp->common.shmem_base < 0xA0000) ||
7554             (bp->common.shmem_base >= 0xC0000)) {
7555                 BNX2X_DEV_INFO("MCP not active\n");
7556                 bp->flags |= NO_MCP_FLAG;
7557                 return;
7558         }
7559
7560         val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
7561         if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
7562                 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
7563                 BNX2X_ERR("BAD MCP validity signature\n");
7564
7565         bp->common.hw_config = SHMEM_RD(bp, dev_info.shared_hw_config.config);
7566         BNX2X_DEV_INFO("hw_config 0x%08x\n", bp->common.hw_config);
7567
7568         bp->link_params.hw_led_mode = ((bp->common.hw_config &
7569                                         SHARED_HW_CFG_LED_MODE_MASK) >>
7570                                        SHARED_HW_CFG_LED_MODE_SHIFT);
7571
7572         bp->link_params.feature_config_flags = 0;
7573         val = SHMEM_RD(bp, dev_info.shared_feature_config.config);
7574         if (val & SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_ENABLED)
7575                 bp->link_params.feature_config_flags |=
7576                                 FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
7577         else
7578                 bp->link_params.feature_config_flags &=
7579                                 ~FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
7580
7581         val = SHMEM_RD(bp, dev_info.bc_rev) >> 8;
7582         bp->common.bc_ver = val;
7583         BNX2X_DEV_INFO("bc_ver %X\n", val);
7584         if (val < BNX2X_BC_VER) {
7585                 /* for now only warn
7586                  * later we might need to enforce this */
7587                 BNX2X_ERR("This driver needs bc_ver %X but found %X,"
7588                           " please upgrade BC\n", BNX2X_BC_VER, val);
7589         }
7590
7591         if (BP_E1HVN(bp) == 0) {
7592                 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_PMC, &pmc);
7593                 bp->flags |= (pmc & PCI_PM_CAP_PME_D3cold) ? 0 : NO_WOL_FLAG;
7594         } else {
7595                 /* no WOL capability for E1HVN != 0 */
7596                 bp->flags |= NO_WOL_FLAG;
7597         }
7598         BNX2X_DEV_INFO("%sWoL capable\n",
7599                        (bp->flags & NO_WOL_FLAG) ? "not " : "");
7600
7601         val = SHMEM_RD(bp, dev_info.shared_hw_config.part_num);
7602         val2 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[4]);
7603         val3 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[8]);
7604         val4 = SHMEM_RD(bp, dev_info.shared_hw_config.part_num[12]);
7605
7606         printk(KERN_INFO PFX "part number %X-%X-%X-%X\n",
7607                val, val2, val3, val4);
7608 }
7609
7610 static void __devinit bnx2x_link_settings_supported(struct bnx2x *bp,
7611                                                     u32 switch_cfg)
7612 {
7613         int port = BP_PORT(bp);
7614         u32 ext_phy_type;
7615
7616         switch (switch_cfg) {
7617         case SWITCH_CFG_1G:
7618                 BNX2X_DEV_INFO("switch_cfg 0x%x (1G)\n", switch_cfg);
7619
7620                 ext_phy_type =
7621                         SERDES_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7622                 switch (ext_phy_type) {
7623                 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_DIRECT:
7624                         BNX2X_DEV_INFO("ext_phy_type 0x%x (Direct)\n",
7625                                        ext_phy_type);
7626
7627                         bp->port.supported |= (SUPPORTED_10baseT_Half |
7628                                                SUPPORTED_10baseT_Full |
7629                                                SUPPORTED_100baseT_Half |
7630                                                SUPPORTED_100baseT_Full |
7631                                                SUPPORTED_1000baseT_Full |
7632                                                SUPPORTED_2500baseX_Full |
7633                                                SUPPORTED_TP |
7634                                                SUPPORTED_FIBRE |
7635                                                SUPPORTED_Autoneg |
7636                                                SUPPORTED_Pause |
7637                                                SUPPORTED_Asym_Pause);
7638                         break;
7639
7640                 case PORT_HW_CFG_SERDES_EXT_PHY_TYPE_BCM5482:
7641                         BNX2X_DEV_INFO("ext_phy_type 0x%x (5482)\n",
7642                                        ext_phy_type);
7643
7644                         bp->port.supported |= (SUPPORTED_10baseT_Half |
7645                                                SUPPORTED_10baseT_Full |
7646                                                SUPPORTED_100baseT_Half |
7647                                                SUPPORTED_100baseT_Full |
7648                                                SUPPORTED_1000baseT_Full |
7649                                                SUPPORTED_TP |
7650                                                SUPPORTED_FIBRE |
7651                                                SUPPORTED_Autoneg |
7652                                                SUPPORTED_Pause |
7653                                                SUPPORTED_Asym_Pause);
7654                         break;
7655
7656                 default:
7657                         BNX2X_ERR("NVRAM config error. "
7658                                   "BAD SerDes ext_phy_config 0x%x\n",
7659                                   bp->link_params.ext_phy_config);
7660                         return;
7661                 }
7662
7663                 bp->port.phy_addr = REG_RD(bp, NIG_REG_SERDES0_CTRL_PHY_ADDR +
7664                                            port*0x10);
7665                 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7666                 break;
7667
7668         case SWITCH_CFG_10G:
7669                 BNX2X_DEV_INFO("switch_cfg 0x%x (10G)\n", switch_cfg);
7670
7671                 ext_phy_type =
7672                         XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7673                 switch (ext_phy_type) {
7674                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
7675                         BNX2X_DEV_INFO("ext_phy_type 0x%x (Direct)\n",
7676                                        ext_phy_type);
7677
7678                         bp->port.supported |= (SUPPORTED_10baseT_Half |
7679                                                SUPPORTED_10baseT_Full |
7680                                                SUPPORTED_100baseT_Half |
7681                                                SUPPORTED_100baseT_Full |
7682                                                SUPPORTED_1000baseT_Full |
7683                                                SUPPORTED_2500baseX_Full |
7684                                                SUPPORTED_10000baseT_Full |
7685                                                SUPPORTED_TP |
7686                                                SUPPORTED_FIBRE |
7687                                                SUPPORTED_Autoneg |
7688                                                SUPPORTED_Pause |
7689                                                SUPPORTED_Asym_Pause);
7690                         break;
7691
7692                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
7693                         BNX2X_DEV_INFO("ext_phy_type 0x%x (8072)\n",
7694                                        ext_phy_type);
7695
7696                         bp->port.supported |= (SUPPORTED_10000baseT_Full |
7697                                                SUPPORTED_1000baseT_Full |
7698                                                SUPPORTED_FIBRE |
7699                                                SUPPORTED_Autoneg |
7700                                                SUPPORTED_Pause |
7701                                                SUPPORTED_Asym_Pause);
7702                         break;
7703
7704                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
7705                         BNX2X_DEV_INFO("ext_phy_type 0x%x (8073)\n",
7706                                        ext_phy_type);
7707
7708                         bp->port.supported |= (SUPPORTED_10000baseT_Full |
7709                                                SUPPORTED_2500baseX_Full |
7710                                                SUPPORTED_1000baseT_Full |
7711                                                SUPPORTED_FIBRE |
7712                                                SUPPORTED_Autoneg |
7713                                                SUPPORTED_Pause |
7714                                                SUPPORTED_Asym_Pause);
7715                         break;
7716
7717                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
7718                         BNX2X_DEV_INFO("ext_phy_type 0x%x (8705)\n",
7719                                        ext_phy_type);
7720
7721                         bp->port.supported |= (SUPPORTED_10000baseT_Full |
7722                                                SUPPORTED_FIBRE |
7723                                                SUPPORTED_Pause |
7724                                                SUPPORTED_Asym_Pause);
7725                         break;
7726
7727                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
7728                         BNX2X_DEV_INFO("ext_phy_type 0x%x (8706)\n",
7729                                        ext_phy_type);
7730
7731                         bp->port.supported |= (SUPPORTED_10000baseT_Full |
7732                                                SUPPORTED_1000baseT_Full |
7733                                                SUPPORTED_FIBRE |
7734                                                SUPPORTED_Pause |
7735                                                SUPPORTED_Asym_Pause);
7736                         break;
7737
7738                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
7739                         BNX2X_DEV_INFO("ext_phy_type 0x%x (8726)\n",
7740                                        ext_phy_type);
7741
7742                         bp->port.supported |= (SUPPORTED_10000baseT_Full |
7743                                                SUPPORTED_1000baseT_Full |
7744                                                SUPPORTED_Autoneg |
7745                                                SUPPORTED_FIBRE |
7746                                                SUPPORTED_Pause |
7747                                                SUPPORTED_Asym_Pause);
7748                         break;
7749
7750                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
7751                         BNX2X_DEV_INFO("ext_phy_type 0x%x (SFX7101)\n",
7752                                        ext_phy_type);
7753
7754                         bp->port.supported |= (SUPPORTED_10000baseT_Full |
7755                                                SUPPORTED_TP |
7756                                                SUPPORTED_Autoneg |
7757                                                SUPPORTED_Pause |
7758                                                SUPPORTED_Asym_Pause);
7759                         break;
7760
7761                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
7762                         BNX2X_DEV_INFO("ext_phy_type 0x%x (BCM8481)\n",
7763                                        ext_phy_type);
7764
7765                         bp->port.supported |= (SUPPORTED_10baseT_Half |
7766                                                SUPPORTED_10baseT_Full |
7767                                                SUPPORTED_100baseT_Half |
7768                                                SUPPORTED_100baseT_Full |
7769                                                SUPPORTED_1000baseT_Full |
7770                                                SUPPORTED_10000baseT_Full |
7771                                                SUPPORTED_TP |
7772                                                SUPPORTED_Autoneg |
7773                                                SUPPORTED_Pause |
7774                                                SUPPORTED_Asym_Pause);
7775                         break;
7776
7777                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
7778                         BNX2X_ERR("XGXS PHY Failure detected 0x%x\n",
7779                                   bp->link_params.ext_phy_config);
7780                         break;
7781
7782                 default:
7783                         BNX2X_ERR("NVRAM config error. "
7784                                   "BAD XGXS ext_phy_config 0x%x\n",
7785                                   bp->link_params.ext_phy_config);
7786                         return;
7787                 }
7788
7789                 bp->port.phy_addr = REG_RD(bp, NIG_REG_XGXS0_CTRL_PHY_ADDR +
7790                                            port*0x18);
7791                 BNX2X_DEV_INFO("phy_addr 0x%x\n", bp->port.phy_addr);
7792
7793                 break;
7794
7795         default:
7796                 BNX2X_ERR("BAD switch_cfg link_config 0x%x\n",
7797                           bp->port.link_config);
7798                 return;
7799         }
7800         bp->link_params.phy_addr = bp->port.phy_addr;
7801
7802         /* mask what we support according to speed_cap_mask */
7803         if (!(bp->link_params.speed_cap_mask &
7804                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF))
7805                 bp->port.supported &= ~SUPPORTED_10baseT_Half;
7806
7807         if (!(bp->link_params.speed_cap_mask &
7808                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL))
7809                 bp->port.supported &= ~SUPPORTED_10baseT_Full;
7810
7811         if (!(bp->link_params.speed_cap_mask &
7812                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF))
7813                 bp->port.supported &= ~SUPPORTED_100baseT_Half;
7814
7815         if (!(bp->link_params.speed_cap_mask &
7816                                 PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL))
7817                 bp->port.supported &= ~SUPPORTED_100baseT_Full;
7818
7819         if (!(bp->link_params.speed_cap_mask &
7820                                         PORT_HW_CFG_SPEED_CAPABILITY_D0_1G))
7821                 bp->port.supported &= ~(SUPPORTED_1000baseT_Half |
7822                                         SUPPORTED_1000baseT_Full);
7823
7824         if (!(bp->link_params.speed_cap_mask &
7825                                         PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
7826                 bp->port.supported &= ~SUPPORTED_2500baseX_Full;
7827
7828         if (!(bp->link_params.speed_cap_mask &
7829                                         PORT_HW_CFG_SPEED_CAPABILITY_D0_10G))
7830                 bp->port.supported &= ~SUPPORTED_10000baseT_Full;
7831
7832         BNX2X_DEV_INFO("supported 0x%x\n", bp->port.supported);
7833 }
7834
7835 static void __devinit bnx2x_link_settings_requested(struct bnx2x *bp)
7836 {
7837         bp->link_params.req_duplex = DUPLEX_FULL;
7838
7839         switch (bp->port.link_config & PORT_FEATURE_LINK_SPEED_MASK) {
7840         case PORT_FEATURE_LINK_SPEED_AUTO:
7841                 if (bp->port.supported & SUPPORTED_Autoneg) {
7842                         bp->link_params.req_line_speed = SPEED_AUTO_NEG;
7843                         bp->port.advertising = bp->port.supported;
7844                 } else {
7845                         u32 ext_phy_type =
7846                             XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
7847
7848                         if ((ext_phy_type ==
7849                              PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705) ||
7850                             (ext_phy_type ==
7851                              PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706)) {
7852                                 /* force 10G, no AN */
7853                                 bp->link_params.req_line_speed = SPEED_10000;
7854                                 bp->port.advertising =
7855                                                 (ADVERTISED_10000baseT_Full |
7856                                                  ADVERTISED_FIBRE);
7857                                 break;
7858                         }
7859                         BNX2X_ERR("NVRAM config error. "
7860                                   "Invalid link_config 0x%x"
7861                                   "  Autoneg not supported\n",
7862                                   bp->port.link_config);
7863                         return;
7864                 }
7865                 break;
7866
7867         case PORT_FEATURE_LINK_SPEED_10M_FULL:
7868                 if (bp->port.supported & SUPPORTED_10baseT_Full) {
7869                         bp->link_params.req_line_speed = SPEED_10;
7870                         bp->port.advertising = (ADVERTISED_10baseT_Full |
7871                                                 ADVERTISED_TP);
7872                 } else {
7873                         BNX2X_ERR("NVRAM config error. "
7874                                   "Invalid link_config 0x%x"
7875                                   "  speed_cap_mask 0x%x\n",
7876                                   bp->port.link_config,
7877                                   bp->link_params.speed_cap_mask);
7878                         return;
7879                 }
7880                 break;
7881
7882         case PORT_FEATURE_LINK_SPEED_10M_HALF:
7883                 if (bp->port.supported & SUPPORTED_10baseT_Half) {
7884                         bp->link_params.req_line_speed = SPEED_10;
7885                         bp->link_params.req_duplex = DUPLEX_HALF;
7886                         bp->port.advertising = (ADVERTISED_10baseT_Half |
7887                                                 ADVERTISED_TP);
7888                 } else {
7889                         BNX2X_ERR("NVRAM config error. "
7890                                   "Invalid link_config 0x%x"
7891                                   "  speed_cap_mask 0x%x\n",
7892                                   bp->port.link_config,
7893                                   bp->link_params.speed_cap_mask);
7894                         return;
7895                 }
7896                 break;
7897
7898         case PORT_FEATURE_LINK_SPEED_100M_FULL:
7899                 if (bp->port.supported & SUPPORTED_100baseT_Full) {
7900                         bp->link_params.req_line_speed = SPEED_100;
7901                         bp->port.advertising = (ADVERTISED_100baseT_Full |
7902                                                 ADVERTISED_TP);
7903                 } else {
7904                         BNX2X_ERR("NVRAM config error. "
7905                                   "Invalid link_config 0x%x"
7906                                   "  speed_cap_mask 0x%x\n",
7907                                   bp->port.link_config,
7908                                   bp->link_params.speed_cap_mask);
7909                         return;
7910                 }
7911                 break;
7912
7913         case PORT_FEATURE_LINK_SPEED_100M_HALF:
7914                 if (bp->port.supported & SUPPORTED_100baseT_Half) {
7915                         bp->link_params.req_line_speed = SPEED_100;
7916                         bp->link_params.req_duplex = DUPLEX_HALF;
7917                         bp->port.advertising = (ADVERTISED_100baseT_Half |
7918                                                 ADVERTISED_TP);
7919                 } else {
7920                         BNX2X_ERR("NVRAM config error. "
7921                                   "Invalid link_config 0x%x"
7922                                   "  speed_cap_mask 0x%x\n",
7923                                   bp->port.link_config,
7924                                   bp->link_params.speed_cap_mask);
7925                         return;
7926                 }
7927                 break;
7928
7929         case PORT_FEATURE_LINK_SPEED_1G:
7930                 if (bp->port.supported & SUPPORTED_1000baseT_Full) {
7931                         bp->link_params.req_line_speed = SPEED_1000;
7932                         bp->port.advertising = (ADVERTISED_1000baseT_Full |
7933                                                 ADVERTISED_TP);
7934                 } else {
7935                         BNX2X_ERR("NVRAM config error. "
7936                                   "Invalid link_config 0x%x"
7937                                   "  speed_cap_mask 0x%x\n",
7938                                   bp->port.link_config,
7939                                   bp->link_params.speed_cap_mask);
7940                         return;
7941                 }
7942                 break;
7943
7944         case PORT_FEATURE_LINK_SPEED_2_5G:
7945                 if (bp->port.supported & SUPPORTED_2500baseX_Full) {
7946                         bp->link_params.req_line_speed = SPEED_2500;
7947                         bp->port.advertising = (ADVERTISED_2500baseX_Full |
7948                                                 ADVERTISED_TP);
7949                 } else {
7950                         BNX2X_ERR("NVRAM config error. "
7951                                   "Invalid link_config 0x%x"
7952                                   "  speed_cap_mask 0x%x\n",
7953                                   bp->port.link_config,
7954                                   bp->link_params.speed_cap_mask);
7955                         return;
7956                 }
7957                 break;
7958
7959         case PORT_FEATURE_LINK_SPEED_10G_CX4:
7960         case PORT_FEATURE_LINK_SPEED_10G_KX4:
7961         case PORT_FEATURE_LINK_SPEED_10G_KR:
7962                 if (bp->port.supported & SUPPORTED_10000baseT_Full) {
7963                         bp->link_params.req_line_speed = SPEED_10000;
7964                         bp->port.advertising = (ADVERTISED_10000baseT_Full |
7965                                                 ADVERTISED_FIBRE);
7966                 } else {
7967                         BNX2X_ERR("NVRAM config error. "
7968                                   "Invalid link_config 0x%x"
7969                                   "  speed_cap_mask 0x%x\n",
7970                                   bp->port.link_config,
7971                                   bp->link_params.speed_cap_mask);
7972                         return;
7973                 }
7974                 break;
7975
7976         default:
7977                 BNX2X_ERR("NVRAM config error. "
7978                           "BAD link speed link_config 0x%x\n",
7979                           bp->port.link_config);
7980                 bp->link_params.req_line_speed = SPEED_AUTO_NEG;
7981                 bp->port.advertising = bp->port.supported;
7982                 break;
7983         }
7984
7985         bp->link_params.req_flow_ctrl = (bp->port.link_config &
7986                                          PORT_FEATURE_FLOW_CONTROL_MASK);
7987         if ((bp->link_params.req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO) &&
7988             !(bp->port.supported & SUPPORTED_Autoneg))
7989                 bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_NONE;
7990
7991         BNX2X_DEV_INFO("req_line_speed %d  req_duplex %d  req_flow_ctrl 0x%x"
7992                        "  advertising 0x%x\n",
7993                        bp->link_params.req_line_speed,
7994                        bp->link_params.req_duplex,
7995                        bp->link_params.req_flow_ctrl, bp->port.advertising);
7996 }
7997
7998 static void __devinit bnx2x_get_port_hwinfo(struct bnx2x *bp)
7999 {
8000         int port = BP_PORT(bp);
8001         u32 val, val2;
8002         u32 config;
8003         u16 i;
8004
8005         bp->link_params.bp = bp;
8006         bp->link_params.port = port;
8007
8008         bp->link_params.lane_config =
8009                 SHMEM_RD(bp, dev_info.port_hw_config[port].lane_config);
8010         bp->link_params.ext_phy_config =
8011                 SHMEM_RD(bp,
8012                          dev_info.port_hw_config[port].external_phy_config);
8013         bp->link_params.speed_cap_mask =
8014                 SHMEM_RD(bp,
8015                          dev_info.port_hw_config[port].speed_capability_mask);
8016
8017         bp->port.link_config =
8018                 SHMEM_RD(bp, dev_info.port_feature_config[port].link_config);
8019
8020         /* Get the 4 lanes xgxs config rx and tx */
8021         for (i = 0; i < 2; i++) {
8022                 val = SHMEM_RD(bp,
8023                            dev_info.port_hw_config[port].xgxs_config_rx[i<<1]);
8024                 bp->link_params.xgxs_config_rx[i << 1] = ((val>>16) & 0xffff);
8025                 bp->link_params.xgxs_config_rx[(i << 1) + 1] = (val & 0xffff);
8026
8027                 val = SHMEM_RD(bp,
8028                            dev_info.port_hw_config[port].xgxs_config_tx[i<<1]);
8029                 bp->link_params.xgxs_config_tx[i << 1] = ((val>>16) & 0xffff);
8030                 bp->link_params.xgxs_config_tx[(i << 1) + 1] = (val & 0xffff);
8031         }
8032
8033         config = SHMEM_RD(bp, dev_info.port_feature_config[port].config);
8034         if (config & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_ENABLED)
8035                 bp->link_params.feature_config_flags |=
8036                                 FEATURE_CONFIG_MODULE_ENFORCMENT_ENABLED;
8037         else
8038                 bp->link_params.feature_config_flags &=
8039                                 ~FEATURE_CONFIG_MODULE_ENFORCMENT_ENABLED;
8040
8041         /* If the device is capable of WoL, set the default state according
8042          * to the HW
8043          */
8044         bp->wol = (!(bp->flags & NO_WOL_FLAG) &&
8045                    (config & PORT_FEATURE_WOL_ENABLED));
8046
8047         BNX2X_DEV_INFO("lane_config 0x%08x  ext_phy_config 0x%08x"
8048                        "  speed_cap_mask 0x%08x  link_config 0x%08x\n",
8049                        bp->link_params.lane_config,
8050                        bp->link_params.ext_phy_config,
8051                        bp->link_params.speed_cap_mask, bp->port.link_config);
8052
8053         bp->link_params.switch_cfg = (bp->port.link_config &
8054                                       PORT_FEATURE_CONNECTED_SWITCH_MASK);
8055         bnx2x_link_settings_supported(bp, bp->link_params.switch_cfg);
8056
8057         bnx2x_link_settings_requested(bp);
8058
8059         val2 = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_upper);
8060         val = SHMEM_RD(bp, dev_info.port_hw_config[port].mac_lower);
8061         bp->dev->dev_addr[0] = (u8)(val2 >> 8 & 0xff);
8062         bp->dev->dev_addr[1] = (u8)(val2 & 0xff);
8063         bp->dev->dev_addr[2] = (u8)(val >> 24 & 0xff);
8064         bp->dev->dev_addr[3] = (u8)(val >> 16 & 0xff);
8065         bp->dev->dev_addr[4] = (u8)(val >> 8  & 0xff);
8066         bp->dev->dev_addr[5] = (u8)(val & 0xff);
8067         memcpy(bp->link_params.mac_addr, bp->dev->dev_addr, ETH_ALEN);
8068         memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
8069 }
8070
8071 static int __devinit bnx2x_get_hwinfo(struct bnx2x *bp)
8072 {
8073         int func = BP_FUNC(bp);
8074         u32 val, val2;
8075         int rc = 0;
8076
8077         bnx2x_get_common_hwinfo(bp);
8078
8079         bp->e1hov = 0;
8080         bp->e1hmf = 0;
8081         if (CHIP_IS_E1H(bp)) {
8082                 bp->mf_config =
8083                         SHMEM_RD(bp, mf_cfg.func_mf_config[func].config);
8084
8085                 val = (SHMEM_RD(bp, mf_cfg.func_mf_config[func].e1hov_tag) &
8086                        FUNC_MF_CFG_E1HOV_TAG_MASK);
8087                 if (val != FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
8088
8089                         bp->e1hov = val;
8090                         bp->e1hmf = 1;
8091                         BNX2X_DEV_INFO("MF mode  E1HOV for func %d is %d "
8092                                        "(0x%04x)\n",
8093                                        func, bp->e1hov, bp->e1hov);
8094                 } else {
8095                         BNX2X_DEV_INFO("single function mode\n");
8096                         if (BP_E1HVN(bp)) {
8097                                 BNX2X_ERR("!!!  No valid E1HOV for func %d,"
8098                                           "  aborting\n", func);
8099                                 rc = -EPERM;
8100                         }
8101                 }
8102         }
8103
8104         if (!BP_NOMCP(bp)) {
8105                 bnx2x_get_port_hwinfo(bp);
8106
8107                 bp->fw_seq = (SHMEM_RD(bp, func_mb[func].drv_mb_header) &
8108                               DRV_MSG_SEQ_NUMBER_MASK);
8109                 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
8110         }
8111
8112         if (IS_E1HMF(bp)) {
8113                 val2 = SHMEM_RD(bp, mf_cfg.func_mf_config[func].mac_upper);
8114                 val = SHMEM_RD(bp,  mf_cfg.func_mf_config[func].mac_lower);
8115                 if ((val2 != FUNC_MF_CFG_UPPERMAC_DEFAULT) &&
8116                     (val != FUNC_MF_CFG_LOWERMAC_DEFAULT)) {
8117                         bp->dev->dev_addr[0] = (u8)(val2 >> 8 & 0xff);
8118                         bp->dev->dev_addr[1] = (u8)(val2 & 0xff);
8119                         bp->dev->dev_addr[2] = (u8)(val >> 24 & 0xff);
8120                         bp->dev->dev_addr[3] = (u8)(val >> 16 & 0xff);
8121                         bp->dev->dev_addr[4] = (u8)(val >> 8  & 0xff);
8122                         bp->dev->dev_addr[5] = (u8)(val & 0xff);
8123                         memcpy(bp->link_params.mac_addr, bp->dev->dev_addr,
8124                                ETH_ALEN);
8125                         memcpy(bp->dev->perm_addr, bp->dev->dev_addr,
8126                                ETH_ALEN);
8127                 }
8128
8129                 return rc;
8130         }
8131
8132         if (BP_NOMCP(bp)) {
8133                 /* only supposed to happen on emulation/FPGA */
8134                 BNX2X_ERR("warning random MAC workaround active\n");
8135                 random_ether_addr(bp->dev->dev_addr);
8136                 memcpy(bp->dev->perm_addr, bp->dev->dev_addr, ETH_ALEN);
8137         }
8138
8139         return rc;
8140 }
8141
8142 static int __devinit bnx2x_init_bp(struct bnx2x *bp)
8143 {
8144         int func = BP_FUNC(bp);
8145         int timer_interval;
8146         int rc;
8147
8148         /* Disable interrupt handling until HW is initialized */
8149         atomic_set(&bp->intr_sem, 1);
8150
8151         mutex_init(&bp->port.phy_mutex);
8152
8153         INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
8154         INIT_WORK(&bp->reset_task, bnx2x_reset_task);
8155
8156         rc = bnx2x_get_hwinfo(bp);
8157
8158         /* need to reset chip if undi was active */
8159         if (!BP_NOMCP(bp))
8160                 bnx2x_undi_unload(bp);
8161
8162         if (CHIP_REV_IS_FPGA(bp))
8163                 printk(KERN_ERR PFX "FPGA detected\n");
8164
8165         if (BP_NOMCP(bp) && (func == 0))
8166                 printk(KERN_ERR PFX
8167                        "MCP disabled, must load devices in order!\n");
8168
8169         /* Set multi queue mode */
8170         if ((multi_mode != ETH_RSS_MODE_DISABLED) &&
8171             ((int_mode == INT_MODE_INTx) || (int_mode == INT_MODE_MSI))) {
8172                 printk(KERN_ERR PFX
8173                       "Multi disabled since int_mode requested is not MSI-X\n");
8174                 multi_mode = ETH_RSS_MODE_DISABLED;
8175         }
8176         bp->multi_mode = multi_mode;
8177
8178
8179         /* Set TPA flags */
8180         if (disable_tpa) {
8181                 bp->flags &= ~TPA_ENABLE_FLAG;
8182                 bp->dev->features &= ~NETIF_F_LRO;
8183         } else {
8184                 bp->flags |= TPA_ENABLE_FLAG;
8185                 bp->dev->features |= NETIF_F_LRO;
8186         }
8187
8188         bp->mrrs = mrrs;
8189
8190         bp->tx_ring_size = MAX_TX_AVAIL;
8191         bp->rx_ring_size = MAX_RX_AVAIL;
8192
8193         bp->rx_csum = 1;
8194
8195         bp->tx_ticks = 50;
8196         bp->rx_ticks = 25;
8197
8198         timer_interval = (CHIP_REV_IS_SLOW(bp) ? 5*HZ : HZ);
8199         bp->current_interval = (poll ? poll : timer_interval);
8200
8201         init_timer(&bp->timer);
8202         bp->timer.expires = jiffies + bp->current_interval;
8203         bp->timer.data = (unsigned long) bp;
8204         bp->timer.function = bnx2x_timer;
8205
8206         return rc;
8207 }
8208
8209 /*
8210  * ethtool service functions
8211  */
8212
8213 /* All ethtool functions called with rtnl_lock */
8214
8215 static int bnx2x_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
8216 {
8217         struct bnx2x *bp = netdev_priv(dev);
8218
8219         cmd->supported = bp->port.supported;
8220         cmd->advertising = bp->port.advertising;
8221
8222         if (netif_carrier_ok(dev)) {
8223                 cmd->speed = bp->link_vars.line_speed;
8224                 cmd->duplex = bp->link_vars.duplex;
8225         } else {
8226                 cmd->speed = bp->link_params.req_line_speed;
8227                 cmd->duplex = bp->link_params.req_duplex;
8228         }
8229         if (IS_E1HMF(bp)) {
8230                 u16 vn_max_rate;
8231
8232                 vn_max_rate = ((bp->mf_config & FUNC_MF_CFG_MAX_BW_MASK) >>
8233                                 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
8234                 if (vn_max_rate < cmd->speed)
8235                         cmd->speed = vn_max_rate;
8236         }
8237
8238         if (bp->link_params.switch_cfg == SWITCH_CFG_10G) {
8239                 u32 ext_phy_type =
8240                         XGXS_EXT_PHY_TYPE(bp->link_params.ext_phy_config);
8241
8242                 switch (ext_phy_type) {
8243                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT:
8244                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8072:
8245                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8073:
8246                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8705:
8247                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706:
8248                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8726:
8249                         cmd->port = PORT_FIBRE;
8250                         break;
8251
8252                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_SFX7101:
8253                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8481:
8254                         cmd->port = PORT_TP;
8255                         break;
8256
8257                 case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE:
8258                         BNX2X_ERR("XGXS PHY Failure detected 0x%x\n",
8259                                   bp->link_params.ext_phy_config);
8260                         break;
8261
8262                 default:
8263                         DP(NETIF_MSG_LINK, "BAD XGXS ext_phy_config 0x%x\n",
8264                            bp->link_params.ext_phy_config);
8265                         break;
8266                 }
8267         } else
8268                 cmd->port = PORT_TP;
8269
8270         cmd->phy_address = bp->port.phy_addr;
8271         cmd->transceiver = XCVR_INTERNAL;
8272
8273         if (bp->link_params.req_line_speed == SPEED_AUTO_NEG)
8274                 cmd->autoneg = AUTONEG_ENABLE;
8275         else
8276                 cmd->autoneg = AUTONEG_DISABLE;
8277
8278         cmd->maxtxpkt = 0;
8279         cmd->maxrxpkt = 0;
8280
8281         DP(NETIF_MSG_LINK, "ethtool_cmd: cmd %d\n"
8282            DP_LEVEL "  supported 0x%x  advertising 0x%x  speed %d\n"
8283            DP_LEVEL "  duplex %d  port %d  phy_address %d  transceiver %d\n"
8284            DP_LEVEL "  autoneg %d  maxtxpkt %d  maxrxpkt %d\n",
8285            cmd->cmd, cmd->supported, cmd->advertising, cmd->speed,
8286            cmd->duplex, cmd->port, cmd->phy_address, cmd->transceiver,
8287            cmd->autoneg, cmd->maxtxpkt, cmd->maxrxpkt);
8288
8289         return 0;
8290 }
8291
8292 static int bnx2x_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
8293 {
8294         struct bnx2x *bp = netdev_priv(dev);
8295         u32 advertising;
8296
8297         if (IS_E1HMF(bp))
8298                 return 0;
8299
8300         DP(NETIF_MSG_LINK, "ethtool_cmd: cmd %d\n"
8301            DP_LEVEL "  supported 0x%x  advertising 0x%x  speed %d\n"
8302            DP_LEVEL "  duplex %d  port %d  phy_address %d  transceiver %d\n"
8303            DP_LEVEL "  autoneg %d  maxtxpkt %d  maxrxpkt %d\n",
8304            cmd->cmd, cmd->supported, cmd->advertising, cmd->speed,
8305            cmd->duplex, cmd->port, cmd->phy_address, cmd->transceiver,
8306            cmd->autoneg, cmd->maxtxpkt, cmd->maxrxpkt);
8307
8308         if (cmd->autoneg == AUTONEG_ENABLE) {
8309                 if (!(bp->port.supported & SUPPORTED_Autoneg)) {
8310                         DP(NETIF_MSG_LINK, "Autoneg not supported\n");
8311                         return -EINVAL;
8312                 }
8313
8314                 /* advertise the requested speed and duplex if supported */
8315                 cmd->advertising &= bp->port.supported;
8316
8317                 bp->link_params.req_line_speed = SPEED_AUTO_NEG;
8318                 bp->link_params.req_duplex = DUPLEX_FULL;
8319                 bp->port.advertising |= (ADVERTISED_Autoneg |
8320                                          cmd->advertising);
8321
8322         } else { /* forced speed */
8323                 /* advertise the requested speed and duplex if supported */
8324                 switch (cmd->speed) {
8325                 case SPEED_10:
8326                         if (cmd->duplex == DUPLEX_FULL) {
8327                                 if (!(bp->port.supported &
8328                                       SUPPORTED_10baseT_Full)) {
8329                                         DP(NETIF_MSG_LINK,
8330                                            "10M full not supported\n");
8331                                         return -EINVAL;
8332                                 }
8333
8334                                 advertising = (ADVERTISED_10baseT_Full |
8335                                                ADVERTISED_TP);
8336                         } else {
8337                                 if (!(bp->port.supported &
8338                                       SUPPORTED_10baseT_Half)) {
8339                                         DP(NETIF_MSG_LINK,
8340                                            "10M half not supported\n");
8341                                         return -EINVAL;
8342                                 }
8343
8344                                 advertising = (ADVERTISED_10baseT_Half |
8345                                                ADVERTISED_TP);
8346                         }
8347                         break;
8348
8349                 case SPEED_100:
8350                         if (cmd->duplex == DUPLEX_FULL) {
8351                                 if (!(bp->port.supported &
8352                                                 SUPPORTED_100baseT_Full)) {
8353                                         DP(NETIF_MSG_LINK,
8354                                            "100M full not supported\n");
8355                                         return -EINVAL;
8356                                 }
8357
8358                                 advertising = (ADVERTISED_100baseT_Full |
8359                                                ADVERTISED_TP);
8360                         } else {
8361                                 if (!(bp->port.supported &
8362                                                 SUPPORTED_100baseT_Half)) {
8363                                         DP(NETIF_MSG_LINK,
8364                                            "100M half not supported\n");
8365                                         return -EINVAL;
8366                                 }
8367
8368                                 advertising = (ADVERTISED_100baseT_Half |
8369                                                ADVERTISED_TP);
8370                         }
8371                         break;
8372
8373                 case SPEED_1000:
8374                         if (cmd->duplex != DUPLEX_FULL) {
8375                                 DP(NETIF_MSG_LINK, "1G half not supported\n");
8376                                 return -EINVAL;
8377                         }
8378
8379                         if (!(bp->port.supported & SUPPORTED_1000baseT_Full)) {
8380                                 DP(NETIF_MSG_LINK, "1G full not supported\n");
8381                                 return -EINVAL;
8382                         }
8383
8384                         advertising = (ADVERTISED_1000baseT_Full |
8385                                        ADVERTISED_TP);
8386                         break;
8387
8388                 case SPEED_2500:
8389                         if (cmd->duplex != DUPLEX_FULL) {
8390                                 DP(NETIF_MSG_LINK,
8391                                    "2.5G half not supported\n");
8392                                 return -EINVAL;
8393                         }
8394
8395                         if (!(bp->port.supported & SUPPORTED_2500baseX_Full)) {
8396                                 DP(NETIF_MSG_LINK,
8397                                    "2.5G full not supported\n");
8398                                 return -EINVAL;
8399                         }
8400
8401                         advertising = (ADVERTISED_2500baseX_Full |
8402                                        ADVERTISED_TP);
8403                         break;
8404
8405                 case SPEED_10000:
8406                         if (cmd->duplex != DUPLEX_FULL) {
8407                                 DP(NETIF_MSG_LINK, "10G half not supported\n");
8408                                 return -EINVAL;
8409                         }
8410
8411                         if (!(bp->port.supported & SUPPORTED_10000baseT_Full)) {
8412                                 DP(NETIF_MSG_LINK, "10G full not supported\n");
8413                                 return -EINVAL;
8414                         }
8415
8416                         advertising = (ADVERTISED_10000baseT_Full |
8417                                        ADVERTISED_FIBRE);
8418                         break;
8419
8420                 default:
8421                         DP(NETIF_MSG_LINK, "Unsupported speed\n");
8422                         return -EINVAL;
8423                 }
8424
8425                 bp->link_params.req_line_speed = cmd->speed;
8426                 bp->link_params.req_duplex = cmd->duplex;
8427                 bp->port.advertising = advertising;
8428         }
8429
8430         DP(NETIF_MSG_LINK, "req_line_speed %d\n"
8431            DP_LEVEL "  req_duplex %d  advertising 0x%x\n",
8432            bp->link_params.req_line_speed, bp->link_params.req_duplex,
8433            bp->port.advertising);
8434
8435         if (netif_running(dev)) {
8436                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
8437                 bnx2x_link_set(bp);
8438         }
8439
8440         return 0;
8441 }
8442
8443 #define PHY_FW_VER_LEN                  10
8444
8445 static void bnx2x_get_drvinfo(struct net_device *dev,
8446                               struct ethtool_drvinfo *info)
8447 {
8448         struct bnx2x *bp = netdev_priv(dev);
8449         u8 phy_fw_ver[PHY_FW_VER_LEN];
8450
8451         strcpy(info->driver, DRV_MODULE_NAME);
8452         strcpy(info->version, DRV_MODULE_VERSION);
8453
8454         phy_fw_ver[0] = '\0';
8455         if (bp->port.pmf) {
8456                 bnx2x_acquire_phy_lock(bp);
8457                 bnx2x_get_ext_phy_fw_version(&bp->link_params,
8458                                              (bp->state != BNX2X_STATE_CLOSED),
8459                                              phy_fw_ver, PHY_FW_VER_LEN);
8460                 bnx2x_release_phy_lock(bp);
8461         }
8462
8463         snprintf(info->fw_version, 32, "BC:%d.%d.%d%s%s",
8464                  (bp->common.bc_ver & 0xff0000) >> 16,
8465                  (bp->common.bc_ver & 0xff00) >> 8,
8466                  (bp->common.bc_ver & 0xff),
8467                  ((phy_fw_ver[0] != '\0') ? " PHY:" : ""), phy_fw_ver);
8468         strcpy(info->bus_info, pci_name(bp->pdev));
8469         info->n_stats = BNX2X_NUM_STATS;
8470         info->testinfo_len = BNX2X_NUM_TESTS;
8471         info->eedump_len = bp->common.flash_size;
8472         info->regdump_len = 0;
8473 }
8474
8475 #define IS_E1_ONLINE(info)      (((info) & RI_E1_ONLINE) == RI_E1_ONLINE)
8476 #define IS_E1H_ONLINE(info)     (((info) & RI_E1H_ONLINE) == RI_E1H_ONLINE)
8477
8478 static int bnx2x_get_regs_len(struct net_device *dev)
8479 {
8480         static u32 regdump_len;
8481         struct bnx2x *bp = netdev_priv(dev);
8482         int i;
8483
8484         if (regdump_len)
8485                 return regdump_len;
8486
8487         if (CHIP_IS_E1(bp)) {
8488                 for (i = 0; i < REGS_COUNT; i++)
8489                         if (IS_E1_ONLINE(reg_addrs[i].info))
8490                                 regdump_len += reg_addrs[i].size;
8491
8492                 for (i = 0; i < WREGS_COUNT_E1; i++)
8493                         if (IS_E1_ONLINE(wreg_addrs_e1[i].info))
8494                                 regdump_len += wreg_addrs_e1[i].size *
8495                                         (1 + wreg_addrs_e1[i].read_regs_count);
8496
8497         } else { /* E1H */
8498                 for (i = 0; i < REGS_COUNT; i++)
8499                         if (IS_E1H_ONLINE(reg_addrs[i].info))
8500                                 regdump_len += reg_addrs[i].size;
8501
8502                 for (i = 0; i < WREGS_COUNT_E1H; i++)
8503                         if (IS_E1H_ONLINE(wreg_addrs_e1h[i].info))
8504                                 regdump_len += wreg_addrs_e1h[i].size *
8505                                         (1 + wreg_addrs_e1h[i].read_regs_count);
8506         }
8507         regdump_len *= 4;
8508         regdump_len += sizeof(struct dump_hdr);
8509
8510         return regdump_len;
8511 }
8512
8513 static void bnx2x_get_regs(struct net_device *dev,
8514                            struct ethtool_regs *regs, void *_p)
8515 {
8516         u32 *p = _p, i, j;
8517         struct bnx2x *bp = netdev_priv(dev);
8518         struct dump_hdr dump_hdr = {0};
8519
8520         regs->version = 0;
8521         memset(p, 0, regs->len);
8522
8523         if (!netif_running(bp->dev))
8524                 return;
8525
8526         dump_hdr.hdr_size = (sizeof(struct dump_hdr) / 4) - 1;
8527         dump_hdr.dump_sign = dump_sign_all;
8528         dump_hdr.xstorm_waitp = REG_RD(bp, XSTORM_WAITP_ADDR);
8529         dump_hdr.tstorm_waitp = REG_RD(bp, TSTORM_WAITP_ADDR);
8530         dump_hdr.ustorm_waitp = REG_RD(bp, USTORM_WAITP_ADDR);
8531         dump_hdr.cstorm_waitp = REG_RD(bp, CSTORM_WAITP_ADDR);
8532         dump_hdr.info = CHIP_IS_E1(bp) ? RI_E1_ONLINE : RI_E1H_ONLINE;
8533
8534         memcpy(p, &dump_hdr, sizeof(struct dump_hdr));
8535         p += dump_hdr.hdr_size + 1;
8536
8537         if (CHIP_IS_E1(bp)) {
8538                 for (i = 0; i < REGS_COUNT; i++)
8539                         if (IS_E1_ONLINE(reg_addrs[i].info))
8540                                 for (j = 0; j < reg_addrs[i].size; j++)
8541                                         *p++ = REG_RD(bp,
8542                                                       reg_addrs[i].addr + j*4);
8543
8544         } else { /* E1H */
8545                 for (i = 0; i < REGS_COUNT; i++)
8546                         if (IS_E1H_ONLINE(reg_addrs[i].info))
8547                                 for (j = 0; j < reg_addrs[i].size; j++)
8548                                         *p++ = REG_RD(bp,
8549                                                       reg_addrs[i].addr + j*4);
8550         }
8551 }
8552
8553 static void bnx2x_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
8554 {
8555         struct bnx2x *bp = netdev_priv(dev);
8556
8557         if (bp->flags & NO_WOL_FLAG) {
8558                 wol->supported = 0;
8559                 wol->wolopts = 0;
8560         } else {
8561                 wol->supported = WAKE_MAGIC;
8562                 if (bp->wol)
8563                         wol->wolopts = WAKE_MAGIC;
8564                 else
8565                         wol->wolopts = 0;
8566         }
8567         memset(&wol->sopass, 0, sizeof(wol->sopass));
8568 }
8569
8570 static int bnx2x_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
8571 {
8572         struct bnx2x *bp = netdev_priv(dev);
8573
8574         if (wol->wolopts & ~WAKE_MAGIC)
8575                 return -EINVAL;
8576
8577         if (wol->wolopts & WAKE_MAGIC) {
8578                 if (bp->flags & NO_WOL_FLAG)
8579                         return -EINVAL;
8580
8581                 bp->wol = 1;
8582         } else
8583                 bp->wol = 0;
8584
8585         return 0;
8586 }
8587
8588 static u32 bnx2x_get_msglevel(struct net_device *dev)
8589 {
8590         struct bnx2x *bp = netdev_priv(dev);
8591
8592         return bp->msglevel;
8593 }
8594
8595 static void bnx2x_set_msglevel(struct net_device *dev, u32 level)
8596 {
8597         struct bnx2x *bp = netdev_priv(dev);
8598
8599         if (capable(CAP_NET_ADMIN))
8600                 bp->msglevel = level;
8601 }
8602
8603 static int bnx2x_nway_reset(struct net_device *dev)
8604 {
8605         struct bnx2x *bp = netdev_priv(dev);
8606
8607         if (!bp->port.pmf)
8608                 return 0;
8609
8610         if (netif_running(dev)) {
8611                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
8612                 bnx2x_link_set(bp);
8613         }
8614
8615         return 0;
8616 }
8617
8618 static int bnx2x_get_eeprom_len(struct net_device *dev)
8619 {
8620         struct bnx2x *bp = netdev_priv(dev);
8621
8622         return bp->common.flash_size;
8623 }
8624
8625 static int bnx2x_acquire_nvram_lock(struct bnx2x *bp)
8626 {
8627         int port = BP_PORT(bp);
8628         int count, i;
8629         u32 val = 0;
8630
8631         /* adjust timeout for emulation/FPGA */
8632         count = NVRAM_TIMEOUT_COUNT;
8633         if (CHIP_REV_IS_SLOW(bp))
8634                 count *= 100;
8635
8636         /* request access to nvram interface */
8637         REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
8638                (MCPR_NVM_SW_ARB_ARB_REQ_SET1 << port));
8639
8640         for (i = 0; i < count*10; i++) {
8641                 val = REG_RD(bp, MCP_REG_MCPR_NVM_SW_ARB);
8642                 if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))
8643                         break;
8644
8645                 udelay(5);
8646         }
8647
8648         if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
8649                 DP(BNX2X_MSG_NVM, "cannot get access to nvram interface\n");
8650                 return -EBUSY;
8651         }
8652
8653         return 0;
8654 }
8655
8656 static int bnx2x_release_nvram_lock(struct bnx2x *bp)
8657 {
8658         int port = BP_PORT(bp);
8659         int count, i;
8660         u32 val = 0;
8661
8662         /* adjust timeout for emulation/FPGA */
8663         count = NVRAM_TIMEOUT_COUNT;
8664         if (CHIP_REV_IS_SLOW(bp))
8665                 count *= 100;
8666
8667         /* relinquish nvram interface */
8668         REG_WR(bp, MCP_REG_MCPR_NVM_SW_ARB,
8669                (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << port));
8670
8671         for (i = 0; i < count*10; i++) {
8672                 val = REG_RD(bp, MCP_REG_MCPR_NVM_SW_ARB);
8673                 if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)))
8674                         break;
8675
8676                 udelay(5);
8677         }
8678
8679         if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
8680                 DP(BNX2X_MSG_NVM, "cannot free access to nvram interface\n");
8681                 return -EBUSY;
8682         }
8683
8684         return 0;
8685 }
8686
8687 static void bnx2x_enable_nvram_access(struct bnx2x *bp)
8688 {
8689         u32 val;
8690
8691         val = REG_RD(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
8692
8693         /* enable both bits, even on read */
8694         REG_WR(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
8695                (val | MCPR_NVM_ACCESS_ENABLE_EN |
8696                       MCPR_NVM_ACCESS_ENABLE_WR_EN));
8697 }
8698
8699 static void bnx2x_disable_nvram_access(struct bnx2x *bp)
8700 {
8701         u32 val;
8702
8703         val = REG_RD(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
8704
8705         /* disable both bits, even after read */
8706         REG_WR(bp, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
8707                (val & ~(MCPR_NVM_ACCESS_ENABLE_EN |
8708                         MCPR_NVM_ACCESS_ENABLE_WR_EN)));
8709 }
8710
8711 static int bnx2x_nvram_read_dword(struct bnx2x *bp, u32 offset, __be32 *ret_val,
8712                                   u32 cmd_flags)
8713 {
8714         int count, i, rc;
8715         u32 val;
8716
8717         /* build the command word */
8718         cmd_flags |= MCPR_NVM_COMMAND_DOIT;
8719
8720         /* need to clear DONE bit separately */
8721         REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
8722
8723         /* address of the NVRAM to read from */
8724         REG_WR(bp, MCP_REG_MCPR_NVM_ADDR,
8725                (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
8726
8727         /* issue a read command */
8728         REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
8729
8730         /* adjust timeout for emulation/FPGA */
8731         count = NVRAM_TIMEOUT_COUNT;
8732         if (CHIP_REV_IS_SLOW(bp))
8733                 count *= 100;
8734
8735         /* wait for completion */
8736         *ret_val = 0;
8737         rc = -EBUSY;
8738         for (i = 0; i < count; i++) {
8739                 udelay(5);
8740                 val = REG_RD(bp, MCP_REG_MCPR_NVM_COMMAND);
8741
8742                 if (val & MCPR_NVM_COMMAND_DONE) {
8743                         val = REG_RD(bp, MCP_REG_MCPR_NVM_READ);
8744                         /* we read nvram data in cpu order
8745                          * but ethtool sees it as an array of bytes
8746                          * converting to big-endian will do the work */
8747                         *ret_val = cpu_to_be32(val);
8748                         rc = 0;
8749                         break;
8750                 }
8751         }
8752
8753         return rc;
8754 }
8755
8756 static int bnx2x_nvram_read(struct bnx2x *bp, u32 offset, u8 *ret_buf,
8757                             int buf_size)
8758 {
8759         int rc;
8760         u32 cmd_flags;
8761         __be32 val;
8762
8763         if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
8764                 DP(BNX2X_MSG_NVM,
8765                    "Invalid parameter: offset 0x%x  buf_size 0x%x\n",
8766                    offset, buf_size);
8767                 return -EINVAL;
8768         }
8769
8770         if (offset + buf_size > bp->common.flash_size) {
8771                 DP(BNX2X_MSG_NVM, "Invalid parameter: offset (0x%x) +"
8772                                   " buf_size (0x%x) > flash_size (0x%x)\n",
8773                    offset, buf_size, bp->common.flash_size);
8774                 return -EINVAL;
8775         }
8776
8777         /* request access to nvram interface */
8778         rc = bnx2x_acquire_nvram_lock(bp);
8779         if (rc)
8780                 return rc;
8781
8782         /* enable access to nvram interface */
8783         bnx2x_enable_nvram_access(bp);
8784
8785         /* read the first word(s) */
8786         cmd_flags = MCPR_NVM_COMMAND_FIRST;
8787         while ((buf_size > sizeof(u32)) && (rc == 0)) {
8788                 rc = bnx2x_nvram_read_dword(bp, offset, &val, cmd_flags);
8789                 memcpy(ret_buf, &val, 4);
8790
8791                 /* advance to the next dword */
8792                 offset += sizeof(u32);
8793                 ret_buf += sizeof(u32);
8794                 buf_size -= sizeof(u32);
8795                 cmd_flags = 0;
8796         }
8797
8798         if (rc == 0) {
8799                 cmd_flags |= MCPR_NVM_COMMAND_LAST;
8800                 rc = bnx2x_nvram_read_dword(bp, offset, &val, cmd_flags);
8801                 memcpy(ret_buf, &val, 4);
8802         }
8803
8804         /* disable access to nvram interface */
8805         bnx2x_disable_nvram_access(bp);
8806         bnx2x_release_nvram_lock(bp);
8807
8808         return rc;
8809 }
8810
8811 static int bnx2x_get_eeprom(struct net_device *dev,
8812                             struct ethtool_eeprom *eeprom, u8 *eebuf)
8813 {
8814         struct bnx2x *bp = netdev_priv(dev);
8815         int rc;
8816
8817         if (!netif_running(dev))
8818                 return -EAGAIN;
8819
8820         DP(BNX2X_MSG_NVM, "ethtool_eeprom: cmd %d\n"
8821            DP_LEVEL "  magic 0x%x  offset 0x%x (%d)  len 0x%x (%d)\n",
8822            eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
8823            eeprom->len, eeprom->len);
8824
8825         /* parameters already validated in ethtool_get_eeprom */
8826
8827         rc = bnx2x_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
8828
8829         return rc;
8830 }
8831
8832 static int bnx2x_nvram_write_dword(struct bnx2x *bp, u32 offset, u32 val,
8833                                    u32 cmd_flags)
8834 {
8835         int count, i, rc;
8836
8837         /* build the command word */
8838         cmd_flags |= MCPR_NVM_COMMAND_DOIT | MCPR_NVM_COMMAND_WR;
8839
8840         /* need to clear DONE bit separately */
8841         REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
8842
8843         /* write the data */
8844         REG_WR(bp, MCP_REG_MCPR_NVM_WRITE, val);
8845
8846         /* address of the NVRAM to write to */
8847         REG_WR(bp, MCP_REG_MCPR_NVM_ADDR,
8848                (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
8849
8850         /* issue the write command */
8851         REG_WR(bp, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
8852
8853         /* adjust timeout for emulation/FPGA */
8854         count = NVRAM_TIMEOUT_COUNT;
8855         if (CHIP_REV_IS_SLOW(bp))
8856                 count *= 100;
8857
8858         /* wait for completion */
8859         rc = -EBUSY;
8860         for (i = 0; i < count; i++) {
8861                 udelay(5);
8862                 val = REG_RD(bp, MCP_REG_MCPR_NVM_COMMAND);
8863                 if (val & MCPR_NVM_COMMAND_DONE) {
8864                         rc = 0;
8865                         break;
8866                 }
8867         }
8868
8869         return rc;
8870 }
8871
8872 #define BYTE_OFFSET(offset)             (8 * (offset & 0x03))
8873
8874 static int bnx2x_nvram_write1(struct bnx2x *bp, u32 offset, u8 *data_buf,
8875                               int buf_size)
8876 {
8877         int rc;
8878         u32 cmd_flags;
8879         u32 align_offset;
8880         __be32 val;
8881
8882         if (offset + buf_size > bp->common.flash_size) {
8883                 DP(BNX2X_MSG_NVM, "Invalid parameter: offset (0x%x) +"
8884                                   " buf_size (0x%x) > flash_size (0x%x)\n",
8885                    offset, buf_size, bp->common.flash_size);
8886                 return -EINVAL;
8887         }
8888
8889         /* request access to nvram interface */
8890         rc = bnx2x_acquire_nvram_lock(bp);
8891         if (rc)
8892                 return rc;
8893
8894         /* enable access to nvram interface */
8895         bnx2x_enable_nvram_access(bp);
8896
8897         cmd_flags = (MCPR_NVM_COMMAND_FIRST | MCPR_NVM_COMMAND_LAST);
8898         align_offset = (offset & ~0x03);
8899         rc = bnx2x_nvram_read_dword(bp, align_offset, &val, cmd_flags);
8900
8901         if (rc == 0) {
8902                 val &= ~(0xff << BYTE_OFFSET(offset));
8903                 val |= (*data_buf << BYTE_OFFSET(offset));
8904
8905                 /* nvram data is returned as an array of bytes
8906                  * convert it back to cpu order */
8907                 val = be32_to_cpu(val);
8908
8909                 rc = bnx2x_nvram_write_dword(bp, align_offset, val,
8910                                              cmd_flags);
8911         }
8912
8913         /* disable access to nvram interface */
8914         bnx2x_disable_nvram_access(bp);
8915         bnx2x_release_nvram_lock(bp);
8916
8917         return rc;
8918 }
8919
8920 static int bnx2x_nvram_write(struct bnx2x *bp, u32 offset, u8 *data_buf,
8921                              int buf_size)
8922 {
8923         int rc;
8924         u32 cmd_flags;
8925         u32 val;
8926         u32 written_so_far;
8927
8928         if (buf_size == 1)      /* ethtool */
8929                 return bnx2x_nvram_write1(bp, offset, data_buf, buf_size);
8930
8931         if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
8932                 DP(BNX2X_MSG_NVM,
8933                    "Invalid parameter: offset 0x%x  buf_size 0x%x\n",
8934                    offset, buf_size);
8935                 return -EINVAL;
8936         }
8937
8938         if (offset + buf_size > bp->common.flash_size) {
8939                 DP(BNX2X_MSG_NVM, "Invalid parameter: offset (0x%x) +"
8940                                   " buf_size (0x%x) > flash_size (0x%x)\n",
8941                    offset, buf_size, bp->common.flash_size);
8942                 return -EINVAL;
8943         }
8944
8945         /* request access to nvram interface */
8946         rc = bnx2x_acquire_nvram_lock(bp);
8947         if (rc)
8948                 return rc;
8949
8950         /* enable access to nvram interface */
8951         bnx2x_enable_nvram_access(bp);
8952
8953         written_so_far = 0;
8954         cmd_flags = MCPR_NVM_COMMAND_FIRST;
8955         while ((written_so_far < buf_size) && (rc == 0)) {
8956                 if (written_so_far == (buf_size - sizeof(u32)))
8957                         cmd_flags |= MCPR_NVM_COMMAND_LAST;
8958                 else if (((offset + 4) % NVRAM_PAGE_SIZE) == 0)
8959                         cmd_flags |= MCPR_NVM_COMMAND_LAST;
8960                 else if ((offset % NVRAM_PAGE_SIZE) == 0)
8961                         cmd_flags |= MCPR_NVM_COMMAND_FIRST;
8962
8963                 memcpy(&val, data_buf, 4);
8964
8965                 rc = bnx2x_nvram_write_dword(bp, offset, val, cmd_flags);
8966
8967                 /* advance to the next dword */
8968                 offset += sizeof(u32);
8969                 data_buf += sizeof(u32);
8970                 written_so_far += sizeof(u32);
8971                 cmd_flags = 0;
8972         }
8973
8974         /* disable access to nvram interface */
8975         bnx2x_disable_nvram_access(bp);
8976         bnx2x_release_nvram_lock(bp);
8977
8978         return rc;
8979 }
8980
8981 static int bnx2x_set_eeprom(struct net_device *dev,
8982                             struct ethtool_eeprom *eeprom, u8 *eebuf)
8983 {
8984         struct bnx2x *bp = netdev_priv(dev);
8985         int rc;
8986
8987         if (!netif_running(dev))
8988                 return -EAGAIN;
8989
8990         DP(BNX2X_MSG_NVM, "ethtool_eeprom: cmd %d\n"
8991            DP_LEVEL "  magic 0x%x  offset 0x%x (%d)  len 0x%x (%d)\n",
8992            eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
8993            eeprom->len, eeprom->len);
8994
8995         /* parameters already validated in ethtool_set_eeprom */
8996
8997         /* If the magic number is PHY (0x00504859) upgrade the PHY FW */
8998         if (eeprom->magic == 0x00504859)
8999                 if (bp->port.pmf) {
9000
9001                         bnx2x_acquire_phy_lock(bp);
9002                         rc = bnx2x_flash_download(bp, BP_PORT(bp),
9003                                              bp->link_params.ext_phy_config,
9004                                              (bp->state != BNX2X_STATE_CLOSED),
9005                                              eebuf, eeprom->len);
9006                         if ((bp->state == BNX2X_STATE_OPEN) ||
9007                             (bp->state == BNX2X_STATE_DISABLED)) {
9008                                 rc |= bnx2x_link_reset(&bp->link_params,
9009                                                        &bp->link_vars, 1);
9010                                 rc |= bnx2x_phy_init(&bp->link_params,
9011                                                      &bp->link_vars);
9012                         }
9013                         bnx2x_release_phy_lock(bp);
9014
9015                 } else /* Only the PMF can access the PHY */
9016                         return -EINVAL;
9017         else
9018                 rc = bnx2x_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
9019
9020         return rc;
9021 }
9022
9023 static int bnx2x_get_coalesce(struct net_device *dev,
9024                               struct ethtool_coalesce *coal)
9025 {
9026         struct bnx2x *bp = netdev_priv(dev);
9027
9028         memset(coal, 0, sizeof(struct ethtool_coalesce));
9029
9030         coal->rx_coalesce_usecs = bp->rx_ticks;
9031         coal->tx_coalesce_usecs = bp->tx_ticks;
9032
9033         return 0;
9034 }
9035
9036 static int bnx2x_set_coalesce(struct net_device *dev,
9037                               struct ethtool_coalesce *coal)
9038 {
9039         struct bnx2x *bp = netdev_priv(dev);
9040
9041         bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
9042         if (bp->rx_ticks > 3000)
9043                 bp->rx_ticks = 3000;
9044
9045         bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
9046         if (bp->tx_ticks > 0x3000)
9047                 bp->tx_ticks = 0x3000;
9048
9049         if (netif_running(dev))
9050                 bnx2x_update_coalesce(bp);
9051
9052         return 0;
9053 }
9054
9055 static void bnx2x_get_ringparam(struct net_device *dev,
9056                                 struct ethtool_ringparam *ering)
9057 {
9058         struct bnx2x *bp = netdev_priv(dev);
9059
9060         ering->rx_max_pending = MAX_RX_AVAIL;
9061         ering->rx_mini_max_pending = 0;
9062         ering->rx_jumbo_max_pending = 0;
9063
9064         ering->rx_pending = bp->rx_ring_size;
9065         ering->rx_mini_pending = 0;
9066         ering->rx_jumbo_pending = 0;
9067
9068         ering->tx_max_pending = MAX_TX_AVAIL;
9069         ering->tx_pending = bp->tx_ring_size;
9070 }
9071
9072 static int bnx2x_set_ringparam(struct net_device *dev,
9073                                struct ethtool_ringparam *ering)
9074 {
9075         struct bnx2x *bp = netdev_priv(dev);
9076         int rc = 0;
9077
9078         if ((ering->rx_pending > MAX_RX_AVAIL) ||
9079             (ering->tx_pending > MAX_TX_AVAIL) ||
9080             (ering->tx_pending <= MAX_SKB_FRAGS + 4))
9081                 return -EINVAL;
9082
9083         bp->rx_ring_size = ering->rx_pending;
9084         bp->tx_ring_size = ering->tx_pending;
9085
9086         if (netif_running(dev)) {
9087                 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
9088                 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
9089         }
9090
9091         return rc;
9092 }
9093
9094 static void bnx2x_get_pauseparam(struct net_device *dev,
9095                                  struct ethtool_pauseparam *epause)
9096 {
9097         struct bnx2x *bp = netdev_priv(dev);
9098
9099         epause->autoneg = (bp->link_params.req_flow_ctrl ==
9100                            BNX2X_FLOW_CTRL_AUTO) &&
9101                           (bp->link_params.req_line_speed == SPEED_AUTO_NEG);
9102
9103         epause->rx_pause = ((bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_RX) ==
9104                             BNX2X_FLOW_CTRL_RX);
9105         epause->tx_pause = ((bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_TX) ==
9106                             BNX2X_FLOW_CTRL_TX);
9107
9108         DP(NETIF_MSG_LINK, "ethtool_pauseparam: cmd %d\n"
9109            DP_LEVEL "  autoneg %d  rx_pause %d  tx_pause %d\n",
9110            epause->cmd, epause->autoneg, epause->rx_pause, epause->tx_pause);
9111 }
9112
9113 static int bnx2x_set_pauseparam(struct net_device *dev,
9114                                 struct ethtool_pauseparam *epause)
9115 {
9116         struct bnx2x *bp = netdev_priv(dev);
9117
9118         if (IS_E1HMF(bp))
9119                 return 0;
9120
9121         DP(NETIF_MSG_LINK, "ethtool_pauseparam: cmd %d\n"
9122            DP_LEVEL "  autoneg %d  rx_pause %d  tx_pause %d\n",
9123            epause->cmd, epause->autoneg, epause->rx_pause, epause->tx_pause);
9124
9125         bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_AUTO;
9126
9127         if (epause->rx_pause)
9128                 bp->link_params.req_flow_ctrl |= BNX2X_FLOW_CTRL_RX;
9129
9130         if (epause->tx_pause)
9131                 bp->link_params.req_flow_ctrl |= BNX2X_FLOW_CTRL_TX;
9132
9133         if (bp->link_params.req_flow_ctrl == BNX2X_FLOW_CTRL_AUTO)
9134                 bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_NONE;
9135
9136         if (epause->autoneg) {
9137                 if (!(bp->port.supported & SUPPORTED_Autoneg)) {
9138                         DP(NETIF_MSG_LINK, "autoneg not supported\n");
9139                         return -EINVAL;
9140                 }
9141
9142                 if (bp->link_params.req_line_speed == SPEED_AUTO_NEG)
9143                         bp->link_params.req_flow_ctrl = BNX2X_FLOW_CTRL_AUTO;
9144         }
9145
9146         DP(NETIF_MSG_LINK,
9147            "req_flow_ctrl 0x%x\n", bp->link_params.req_flow_ctrl);
9148
9149         if (netif_running(dev)) {
9150                 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
9151                 bnx2x_link_set(bp);
9152         }
9153
9154         return 0;
9155 }
9156
9157 static int bnx2x_set_flags(struct net_device *dev, u32 data)
9158 {
9159         struct bnx2x *bp = netdev_priv(dev);
9160         int changed = 0;
9161         int rc = 0;
9162
9163         /* TPA requires Rx CSUM offloading */
9164         if ((data & ETH_FLAG_LRO) && bp->rx_csum) {
9165                 if (!(dev->features & NETIF_F_LRO)) {
9166                         dev->features |= NETIF_F_LRO;
9167                         bp->flags |= TPA_ENABLE_FLAG;
9168                         changed = 1;
9169                 }
9170
9171         } else if (dev->features & NETIF_F_LRO) {
9172                 dev->features &= ~NETIF_F_LRO;
9173                 bp->flags &= ~TPA_ENABLE_FLAG;
9174                 changed = 1;
9175         }
9176
9177         if (changed && netif_running(dev)) {
9178                 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
9179                 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
9180         }
9181
9182         return rc;
9183 }
9184
9185 static u32 bnx2x_get_rx_csum(struct net_device *dev)
9186 {
9187         struct bnx2x *bp = netdev_priv(dev);
9188
9189         return bp->rx_csum;
9190 }
9191
9192 static int bnx2x_set_rx_csum(struct net_device *dev, u32 data)
9193 {
9194         struct bnx2x *bp = netdev_priv(dev);
9195         int rc = 0;
9196
9197         bp->rx_csum = data;
9198
9199         /* Disable TPA, when Rx CSUM is disabled. Otherwise all
9200            TPA'ed packets will be discarded due to wrong TCP CSUM */
9201         if (!data) {
9202                 u32 flags = ethtool_op_get_flags(dev);
9203
9204                 rc = bnx2x_set_flags(dev, (flags & ~ETH_FLAG_LRO));
9205         }
9206
9207         return rc;
9208 }
9209
9210 static int bnx2x_set_tso(struct net_device *dev, u32 data)
9211 {
9212         if (data) {
9213                 dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
9214                 dev->features |= NETIF_F_TSO6;
9215         } else {
9216                 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO_ECN);
9217                 dev->features &= ~NETIF_F_TSO6;
9218         }
9219
9220         return 0;
9221 }
9222
9223 static const struct {
9224         char string[ETH_GSTRING_LEN];
9225 } bnx2x_tests_str_arr[BNX2X_NUM_TESTS] = {
9226         { "register_test (offline)" },
9227         { "memory_test (offline)" },
9228         { "loopback_test (offline)" },
9229         { "nvram_test (online)" },
9230         { "interrupt_test (online)" },
9231         { "link_test (online)" },
9232         { "idle check (online)" }
9233 };
9234
9235 static int bnx2x_self_test_count(struct net_device *dev)
9236 {
9237         return BNX2X_NUM_TESTS;
9238 }
9239
9240 static int bnx2x_test_registers(struct bnx2x *bp)
9241 {
9242         int idx, i, rc = -ENODEV;
9243         u32 wr_val = 0;
9244         int port = BP_PORT(bp);
9245         static const struct {
9246                 u32  offset0;
9247                 u32  offset1;
9248                 u32  mask;
9249         } reg_tbl[] = {
9250 /* 0 */         { BRB1_REG_PAUSE_LOW_THRESHOLD_0,      4, 0x000003ff },
9251                 { DORQ_REG_DB_ADDR0,                   4, 0xffffffff },
9252                 { HC_REG_AGG_INT_0,                    4, 0x000003ff },
9253                 { PBF_REG_MAC_IF0_ENABLE,              4, 0x00000001 },
9254                 { PBF_REG_P0_INIT_CRD,                 4, 0x000007ff },
9255                 { PRS_REG_CID_PORT_0,                  4, 0x00ffffff },
9256                 { PXP2_REG_PSWRQ_CDU0_L2P,             4, 0x000fffff },
9257                 { PXP2_REG_RQ_CDU0_EFIRST_MEM_ADDR,    8, 0x0003ffff },
9258                 { PXP2_REG_PSWRQ_TM0_L2P,              4, 0x000fffff },
9259                 { PXP2_REG_RQ_USDM0_EFIRST_MEM_ADDR,   8, 0x0003ffff },
9260 /* 10 */        { PXP2_REG_PSWRQ_TSDM0_L2P,            4, 0x000fffff },
9261                 { QM_REG_CONNNUM_0,                    4, 0x000fffff },
9262                 { TM_REG_LIN0_MAX_ACTIVE_CID,          4, 0x0003ffff },
9263                 { SRC_REG_KEYRSS0_0,                  40, 0xffffffff },
9264                 { SRC_REG_KEYRSS0_7,                  40, 0xffffffff },
9265                 { XCM_REG_WU_DA_SET_TMR_CNT_FLG_CMD00, 4, 0x00000001 },
9266                 { XCM_REG_WU_DA_CNT_CMD00,             4, 0x00000003 },
9267                 { XCM_REG_GLB_DEL_ACK_MAX_CNT_0,       4, 0x000000ff },
9268                 { NIG_REG_EGRESS_MNG0_FIFO,           20, 0xffffffff },
9269                 { NIG_REG_LLH0_T_BIT,                  4, 0x00000001 },
9270 /* 20 */        { NIG_REG_EMAC0_IN_EN,                 4, 0x00000001 },
9271                 { NIG_REG_BMAC0_IN_EN,                 4, 0x00000001 },
9272                 { NIG_REG_XCM0_OUT_EN,                 4, 0x00000001 },
9273                 { NIG_REG_BRB0_OUT_EN,                 4, 0x00000001 },
9274                 { NIG_REG_LLH0_XCM_MASK,               4, 0x00000007 },
9275                 { NIG_REG_LLH0_ACPI_PAT_6_LEN,        68, 0x000000ff },
9276                 { NIG_REG_LLH0_ACPI_PAT_0_CRC,        68, 0xffffffff },
9277                 { NIG_REG_LLH0_DEST_MAC_0_0,         160, 0xffffffff },
9278                 { NIG_REG_LLH0_DEST_IP_0_1,          160, 0xffffffff },
9279                 { NIG_REG_LLH0_IPV4_IPV6_0,          160, 0x00000001 },
9280 /* 30 */        { NIG_REG_LLH0_DEST_UDP_0,           160, 0x0000ffff },
9281                 { NIG_REG_LLH0_DEST_TCP_0,           160, 0x0000ffff },
9282                 { NIG_REG_LLH0_VLAN_ID_0,            160, 0x00000fff },
9283                 { NIG_REG_XGXS_SERDES0_MODE_SEL,       4, 0x00000001 },
9284                 { NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0, 4, 0x00000001 },
9285                 { NIG_REG_STATUS_INTERRUPT_PORT0,      4, 0x07ffffff },
9286                 { NIG_REG_XGXS0_CTRL_EXTREMOTEMDIOST, 24, 0x00000001 },
9287                 { NIG_REG_SERDES0_CTRL_PHY_ADDR,      16, 0x0000001f },
9288
9289                 { 0xffffffff, 0, 0x00000000 }
9290         };
9291
9292         if (!netif_running(bp->dev))
9293                 return rc;
9294
9295         /* Repeat the test twice:
9296            First by writing 0x00000000, second by writing 0xffffffff */
9297         for (idx = 0; idx < 2; idx++) {
9298
9299                 switch (idx) {
9300                 case 0:
9301                         wr_val = 0;
9302                         break;
9303                 case 1:
9304                         wr_val = 0xffffffff;
9305                         break;
9306                 }
9307
9308                 for (i = 0; reg_tbl[i].offset0 != 0xffffffff; i++) {
9309                         u32 offset, mask, save_val, val;
9310
9311                         offset = reg_tbl[i].offset0 + port*reg_tbl[i].offset1;
9312                         mask = reg_tbl[i].mask;
9313
9314                         save_val = REG_RD(bp, offset);
9315
9316                         REG_WR(bp, offset, wr_val);
9317                         val = REG_RD(bp, offset);
9318
9319                         /* Restore the original register's value */
9320                         REG_WR(bp, offset, save_val);
9321
9322                         /* verify that value is as expected value */
9323                         if ((val & mask) != (wr_val & mask))
9324                                 goto test_reg_exit;
9325                 }
9326         }
9327
9328         rc = 0;
9329
9330 test_reg_exit:
9331         return rc;
9332 }
9333
9334 static int bnx2x_test_memory(struct bnx2x *bp)
9335 {
9336         int i, j, rc = -ENODEV;
9337         u32 val;
9338         static const struct {
9339                 u32 offset;
9340                 int size;
9341         } mem_tbl[] = {
9342                 { CCM_REG_XX_DESCR_TABLE,   CCM_REG_XX_DESCR_TABLE_SIZE },
9343                 { CFC_REG_ACTIVITY_COUNTER, CFC_REG_ACTIVITY_COUNTER_SIZE },
9344                 { CFC_REG_LINK_LIST,        CFC_REG_LINK_LIST_SIZE },
9345                 { DMAE_REG_CMD_MEM,         DMAE_REG_CMD_MEM_SIZE },
9346                 { TCM_REG_XX_DESCR_TABLE,   TCM_REG_XX_DESCR_TABLE_SIZE },
9347                 { UCM_REG_XX_DESCR_TABLE,   UCM_REG_XX_DESCR_TABLE_SIZE },
9348                 { XCM_REG_XX_DESCR_TABLE,   XCM_REG_XX_DESCR_TABLE_SIZE },
9349
9350                 { 0xffffffff, 0 }
9351         };
9352         static const struct {
9353                 char *name;
9354                 u32 offset;
9355                 u32 e1_mask;
9356                 u32 e1h_mask;
9357         } prty_tbl[] = {
9358                 { "CCM_PRTY_STS",  CCM_REG_CCM_PRTY_STS,   0x3ffc0, 0 },
9359                 { "CFC_PRTY_STS",  CFC_REG_CFC_PRTY_STS,   0x2,     0x2 },
9360                 { "DMAE_PRTY_STS", DMAE_REG_DMAE_PRTY_STS, 0,       0 },
9361                 { "TCM_PRTY_STS",  TCM_REG_TCM_PRTY_STS,   0x3ffc0, 0 },
9362                 { "UCM_PRTY_STS",  UCM_REG_UCM_PRTY_STS,   0x3ffc0, 0 },
9363                 { "XCM_PRTY_STS",  XCM_REG_XCM_PRTY_STS,   0x3ffc1, 0 },
9364
9365                 { NULL, 0xffffffff, 0, 0 }
9366         };
9367
9368         if (!netif_running(bp->dev))
9369                 return rc;
9370
9371         /* Go through all the memories */
9372         for (i = 0; mem_tbl[i].offset != 0xffffffff; i++)
9373                 for (j = 0; j < mem_tbl[i].size; j++)
9374                         REG_RD(bp, mem_tbl[i].offset + j*4);
9375
9376         /* Check the parity status */
9377         for (i = 0; prty_tbl[i].offset != 0xffffffff; i++) {
9378                 val = REG_RD(bp, prty_tbl[i].offset);
9379                 if ((CHIP_IS_E1(bp) && (val & ~(prty_tbl[i].e1_mask))) ||
9380                     (CHIP_IS_E1H(bp) && (val & ~(prty_tbl[i].e1h_mask)))) {
9381                         DP(NETIF_MSG_HW,
9382                            "%s is 0x%x\n", prty_tbl[i].name, val);
9383                         goto test_mem_exit;
9384                 }
9385         }
9386
9387         rc = 0;
9388
9389 test_mem_exit:
9390         return rc;
9391 }
9392
9393 static void bnx2x_wait_for_link(struct bnx2x *bp, u8 link_up)
9394 {
9395         int cnt = 1000;
9396
9397         if (link_up)
9398                 while (bnx2x_link_test(bp) && cnt--)
9399                         msleep(10);
9400 }
9401
9402 static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
9403 {
9404         unsigned int pkt_size, num_pkts, i;
9405         struct sk_buff *skb;
9406         unsigned char *packet;
9407         struct bnx2x_fastpath *fp = &bp->fp[0];
9408         u16 tx_start_idx, tx_idx;
9409         u16 rx_start_idx, rx_idx;
9410         u16 pkt_prod;
9411         struct sw_tx_bd *tx_buf;
9412         struct eth_tx_bd *tx_bd;
9413         dma_addr_t mapping;
9414         union eth_rx_cqe *cqe;
9415         u8 cqe_fp_flags;
9416         struct sw_rx_bd *rx_buf;
9417         u16 len;
9418         int rc = -ENODEV;
9419
9420         /* check the loopback mode */
9421         switch (loopback_mode) {
9422         case BNX2X_PHY_LOOPBACK:
9423                 if (bp->link_params.loopback_mode != LOOPBACK_XGXS_10)
9424                         return -EINVAL;
9425                 break;
9426         case BNX2X_MAC_LOOPBACK:
9427                 bp->link_params.loopback_mode = LOOPBACK_BMAC;
9428                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
9429                 break;
9430         default:
9431                 return -EINVAL;
9432         }
9433
9434         /* prepare the loopback packet */
9435         pkt_size = (((bp->dev->mtu < ETH_MAX_PACKET_SIZE) ?
9436                      bp->dev->mtu : ETH_MAX_PACKET_SIZE) + ETH_HLEN);
9437         skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
9438         if (!skb) {
9439                 rc = -ENOMEM;
9440                 goto test_loopback_exit;
9441         }
9442         packet = skb_put(skb, pkt_size);
9443         memcpy(packet, bp->dev->dev_addr, ETH_ALEN);
9444         memset(packet + ETH_ALEN, 0, (ETH_HLEN - ETH_ALEN));
9445         for (i = ETH_HLEN; i < pkt_size; i++)
9446                 packet[i] = (unsigned char) (i & 0xff);
9447
9448         /* send the loopback packet */
9449         num_pkts = 0;
9450         tx_start_idx = le16_to_cpu(*fp->tx_cons_sb);
9451         rx_start_idx = le16_to_cpu(*fp->rx_cons_sb);
9452
9453         pkt_prod = fp->tx_pkt_prod++;
9454         tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
9455         tx_buf->first_bd = fp->tx_bd_prod;
9456         tx_buf->skb = skb;
9457
9458         tx_bd = &fp->tx_desc_ring[TX_BD(fp->tx_bd_prod)];
9459         mapping = pci_map_single(bp->pdev, skb->data,
9460                                  skb_headlen(skb), PCI_DMA_TODEVICE);
9461         tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
9462         tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
9463         tx_bd->nbd = cpu_to_le16(1);
9464         tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
9465         tx_bd->vlan = cpu_to_le16(pkt_prod);
9466         tx_bd->bd_flags.as_bitfield = (ETH_TX_BD_FLAGS_START_BD |
9467                                        ETH_TX_BD_FLAGS_END_BD);
9468         tx_bd->general_data = ((UNICAST_ADDRESS <<
9469                                 ETH_TX_BD_ETH_ADDR_TYPE_SHIFT) | 1);
9470
9471         wmb();
9472
9473         le16_add_cpu(&fp->hw_tx_prods->bds_prod, 1);
9474         mb(); /* FW restriction: must not reorder writing nbd and packets */
9475         le32_add_cpu(&fp->hw_tx_prods->packets_prod, 1);
9476         DOORBELL(bp, fp->index, 0);
9477
9478         mmiowb();
9479
9480         num_pkts++;
9481         fp->tx_bd_prod++;
9482         bp->dev->trans_start = jiffies;
9483
9484         udelay(100);
9485
9486         tx_idx = le16_to_cpu(*fp->tx_cons_sb);
9487         if (tx_idx != tx_start_idx + num_pkts)
9488                 goto test_loopback_exit;
9489
9490         rx_idx = le16_to_cpu(*fp->rx_cons_sb);
9491         if (rx_idx != rx_start_idx + num_pkts)
9492                 goto test_loopback_exit;
9493
9494         cqe = &fp->rx_comp_ring[RCQ_BD(fp->rx_comp_cons)];
9495         cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
9496         if (CQE_TYPE(cqe_fp_flags) || (cqe_fp_flags & ETH_RX_ERROR_FALGS))
9497                 goto test_loopback_rx_exit;
9498
9499         len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
9500         if (len != pkt_size)
9501                 goto test_loopback_rx_exit;
9502
9503         rx_buf = &fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)];
9504         skb = rx_buf->skb;
9505         skb_reserve(skb, cqe->fast_path_cqe.placement_offset);
9506         for (i = ETH_HLEN; i < pkt_size; i++)
9507                 if (*(skb->data + i) != (unsigned char) (i & 0xff))
9508                         goto test_loopback_rx_exit;
9509
9510         rc = 0;
9511
9512 test_loopback_rx_exit:
9513
9514         fp->rx_bd_cons = NEXT_RX_IDX(fp->rx_bd_cons);
9515         fp->rx_bd_prod = NEXT_RX_IDX(fp->rx_bd_prod);
9516         fp->rx_comp_cons = NEXT_RCQ_IDX(fp->rx_comp_cons);
9517         fp->rx_comp_prod = NEXT_RCQ_IDX(fp->rx_comp_prod);
9518
9519         /* Update producers */
9520         bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
9521                              fp->rx_sge_prod);
9522
9523 test_loopback_exit:
9524         bp->link_params.loopback_mode = LOOPBACK_NONE;
9525
9526         return rc;
9527 }
9528
9529 static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
9530 {
9531         int rc = 0, res;
9532
9533         if (!netif_running(bp->dev))
9534                 return BNX2X_LOOPBACK_FAILED;
9535
9536         bnx2x_netif_stop(bp, 1);
9537         bnx2x_acquire_phy_lock(bp);
9538
9539         res = bnx2x_run_loopback(bp, BNX2X_PHY_LOOPBACK, link_up);
9540         if (res) {
9541                 DP(NETIF_MSG_PROBE, "  PHY loopback failed  (res %d)\n", res);
9542                 rc |= BNX2X_PHY_LOOPBACK_FAILED;
9543         }
9544
9545         res = bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK, link_up);
9546         if (res) {
9547                 DP(NETIF_MSG_PROBE, "  MAC loopback failed  (res %d)\n", res);
9548                 rc |= BNX2X_MAC_LOOPBACK_FAILED;
9549         }
9550
9551         bnx2x_release_phy_lock(bp);
9552         bnx2x_netif_start(bp);
9553
9554         return rc;
9555 }
9556
9557 #define CRC32_RESIDUAL                  0xdebb20e3
9558
9559 static int bnx2x_test_nvram(struct bnx2x *bp)
9560 {
9561         static const struct {
9562                 int offset;
9563                 int size;
9564         } nvram_tbl[] = {
9565                 {     0,  0x14 }, /* bootstrap */
9566                 {  0x14,  0xec }, /* dir */
9567                 { 0x100, 0x350 }, /* manuf_info */
9568                 { 0x450,  0xf0 }, /* feature_info */
9569                 { 0x640,  0x64 }, /* upgrade_key_info */
9570                 { 0x6a4,  0x64 },
9571                 { 0x708,  0x70 }, /* manuf_key_info */
9572                 { 0x778,  0x70 },
9573                 {     0,     0 }
9574         };
9575         __be32 buf[0x350 / 4];
9576         u8 *data = (u8 *)buf;
9577         int i, rc;
9578         u32 magic, csum;
9579
9580         rc = bnx2x_nvram_read(bp, 0, data, 4);
9581         if (rc) {
9582                 DP(NETIF_MSG_PROBE, "magic value read (rc %d)\n", rc);
9583                 goto test_nvram_exit;
9584         }
9585
9586         magic = be32_to_cpu(buf[0]);
9587         if (magic != 0x669955aa) {
9588                 DP(NETIF_MSG_PROBE, "magic value (0x%08x)\n", magic);
9589                 rc = -ENODEV;
9590                 goto test_nvram_exit;
9591         }
9592
9593         for (i = 0; nvram_tbl[i].size; i++) {
9594
9595                 rc = bnx2x_nvram_read(bp, nvram_tbl[i].offset, data,
9596                                       nvram_tbl[i].size);
9597                 if (rc) {
9598                         DP(NETIF_MSG_PROBE,
9599                            "nvram_tbl[%d] read data (rc %d)\n", i, rc);
9600                         goto test_nvram_exit;
9601                 }
9602
9603                 csum = ether_crc_le(nvram_tbl[i].size, data);
9604                 if (csum != CRC32_RESIDUAL) {
9605                         DP(NETIF_MSG_PROBE,
9606                            "nvram_tbl[%d] csum value (0x%08x)\n", i, csum);
9607                         rc = -ENODEV;
9608                         goto test_nvram_exit;
9609                 }
9610         }
9611
9612 test_nvram_exit:
9613         return rc;
9614 }
9615
9616 static int bnx2x_test_intr(struct bnx2x *bp)
9617 {
9618         struct mac_configuration_cmd *config = bnx2x_sp(bp, mac_config);
9619         int i, rc;
9620
9621         if (!netif_running(bp->dev))
9622                 return -ENODEV;
9623
9624         config->hdr.length = 0;
9625         if (CHIP_IS_E1(bp))
9626                 config->hdr.offset = (BP_PORT(bp) ? 32 : 0);
9627         else
9628                 config->hdr.offset = BP_FUNC(bp);
9629         config->hdr.client_id = bp->fp->cl_id;
9630         config->hdr.reserved1 = 0;
9631
9632         rc = bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
9633                            U64_HI(bnx2x_sp_mapping(bp, mac_config)),
9634                            U64_LO(bnx2x_sp_mapping(bp, mac_config)), 0);
9635         if (rc == 0) {
9636                 bp->set_mac_pending++;
9637                 for (i = 0; i < 10; i++) {
9638                         if (!bp->set_mac_pending)
9639                                 break;
9640                         msleep_interruptible(10);
9641                 }
9642                 if (i == 10)
9643                         rc = -ENODEV;
9644         }
9645
9646         return rc;
9647 }
9648
9649 static void bnx2x_self_test(struct net_device *dev,
9650                             struct ethtool_test *etest, u64 *buf)
9651 {
9652         struct bnx2x *bp = netdev_priv(dev);
9653
9654         memset(buf, 0, sizeof(u64) * BNX2X_NUM_TESTS);
9655
9656         if (!netif_running(dev))
9657                 return;
9658
9659         /* offline tests are not supported in MF mode */
9660         if (IS_E1HMF(bp))
9661                 etest->flags &= ~ETH_TEST_FL_OFFLINE;
9662
9663         if (etest->flags & ETH_TEST_FL_OFFLINE) {
9664                 u8 link_up;
9665
9666                 link_up = bp->link_vars.link_up;
9667                 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
9668                 bnx2x_nic_load(bp, LOAD_DIAG);
9669                 /* wait until link state is restored */
9670                 bnx2x_wait_for_link(bp, link_up);
9671
9672                 if (bnx2x_test_registers(bp) != 0) {
9673                         buf[0] = 1;
9674                         etest->flags |= ETH_TEST_FL_FAILED;
9675                 }
9676                 if (bnx2x_test_memory(bp) != 0) {
9677                         buf[1] = 1;
9678                         etest->flags |= ETH_TEST_FL_FAILED;
9679                 }
9680                 buf[2] = bnx2x_test_loopback(bp, link_up);
9681                 if (buf[2] != 0)
9682                         etest->flags |= ETH_TEST_FL_FAILED;
9683
9684                 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
9685                 bnx2x_nic_load(bp, LOAD_NORMAL);
9686                 /* wait until link state is restored */
9687                 bnx2x_wait_for_link(bp, link_up);
9688         }
9689         if (bnx2x_test_nvram(bp) != 0) {
9690                 buf[3] = 1;
9691                 etest->flags |= ETH_TEST_FL_FAILED;
9692         }
9693         if (bnx2x_test_intr(bp) != 0) {
9694                 buf[4] = 1;
9695                 etest->flags |= ETH_TEST_FL_FAILED;
9696         }
9697         if (bp->port.pmf)
9698                 if (bnx2x_link_test(bp) != 0) {
9699                         buf[5] = 1;
9700                         etest->flags |= ETH_TEST_FL_FAILED;
9701                 }
9702
9703 #ifdef BNX2X_EXTRA_DEBUG
9704         bnx2x_panic_dump(bp);
9705 #endif
9706 }
9707
9708 static const struct {
9709         long offset;
9710         int size;
9711         u8 string[ETH_GSTRING_LEN];
9712 } bnx2x_q_stats_arr[BNX2X_NUM_Q_STATS] = {
9713 /* 1 */ { Q_STATS_OFFSET32(total_bytes_received_hi), 8, "[%d]: rx_bytes" },
9714         { Q_STATS_OFFSET32(error_bytes_received_hi),
9715                                                 8, "[%d]: rx_error_bytes" },
9716         { Q_STATS_OFFSET32(total_unicast_packets_received_hi),
9717                                                 8, "[%d]: rx_ucast_packets" },
9718         { Q_STATS_OFFSET32(total_multicast_packets_received_hi),
9719                                                 8, "[%d]: rx_mcast_packets" },
9720         { Q_STATS_OFFSET32(total_broadcast_packets_received_hi),
9721                                                 8, "[%d]: rx_bcast_packets" },
9722         { Q_STATS_OFFSET32(no_buff_discard_hi), 8, "[%d]: rx_discards" },
9723         { Q_STATS_OFFSET32(rx_err_discard_pkt),
9724                                          4, "[%d]: rx_phy_ip_err_discards"},
9725         { Q_STATS_OFFSET32(rx_skb_alloc_failed),
9726                                          4, "[%d]: rx_skb_alloc_discard" },
9727         { Q_STATS_OFFSET32(hw_csum_err), 4, "[%d]: rx_csum_offload_errors" },
9728
9729 /* 10 */{ Q_STATS_OFFSET32(total_bytes_transmitted_hi), 8, "[%d]: tx_bytes" },
9730         { Q_STATS_OFFSET32(total_unicast_packets_transmitted_hi),
9731                                                         8, "[%d]: tx_packets" }
9732 };
9733
9734 static const struct {
9735         long offset;
9736         int size;
9737         u32 flags;
9738 #define STATS_FLAGS_PORT                1
9739 #define STATS_FLAGS_FUNC                2
9740 #define STATS_FLAGS_BOTH                (STATS_FLAGS_FUNC | STATS_FLAGS_PORT)
9741         u8 string[ETH_GSTRING_LEN];
9742 } bnx2x_stats_arr[BNX2X_NUM_STATS] = {
9743 /* 1 */ { STATS_OFFSET32(total_bytes_received_hi),
9744                                 8, STATS_FLAGS_BOTH, "rx_bytes" },
9745         { STATS_OFFSET32(error_bytes_received_hi),
9746                                 8, STATS_FLAGS_BOTH, "rx_error_bytes" },
9747         { STATS_OFFSET32(total_unicast_packets_received_hi),
9748                                 8, STATS_FLAGS_BOTH, "rx_ucast_packets" },
9749         { STATS_OFFSET32(total_multicast_packets_received_hi),
9750                                 8, STATS_FLAGS_BOTH, "rx_mcast_packets" },
9751         { STATS_OFFSET32(total_broadcast_packets_received_hi),
9752                                 8, STATS_FLAGS_BOTH, "rx_bcast_packets" },
9753         { STATS_OFFSET32(rx_stat_dot3statsfcserrors_hi),
9754                                 8, STATS_FLAGS_PORT, "rx_crc_errors" },
9755         { STATS_OFFSET32(rx_stat_dot3statsalignmenterrors_hi),
9756                                 8, STATS_FLAGS_PORT, "rx_align_errors" },
9757         { STATS_OFFSET32(rx_stat_etherstatsundersizepkts_hi),
9758                                 8, STATS_FLAGS_PORT, "rx_undersize_packets" },
9759         { STATS_OFFSET32(etherstatsoverrsizepkts_hi),
9760                                 8, STATS_FLAGS_PORT, "rx_oversize_packets" },
9761 /* 10 */{ STATS_OFFSET32(rx_stat_etherstatsfragments_hi),
9762                                 8, STATS_FLAGS_PORT, "rx_fragments" },
9763         { STATS_OFFSET32(rx_stat_etherstatsjabbers_hi),
9764                                 8, STATS_FLAGS_PORT, "rx_jabbers" },
9765         { STATS_OFFSET32(no_buff_discard_hi),
9766                                 8, STATS_FLAGS_BOTH, "rx_discards" },
9767         { STATS_OFFSET32(mac_filter_discard),
9768                                 4, STATS_FLAGS_PORT, "rx_filtered_packets" },
9769         { STATS_OFFSET32(xxoverflow_discard),
9770                                 4, STATS_FLAGS_PORT, "rx_fw_discards" },
9771         { STATS_OFFSET32(brb_drop_hi),
9772                                 8, STATS_FLAGS_PORT, "rx_brb_discard" },
9773         { STATS_OFFSET32(brb_truncate_hi),
9774                                 8, STATS_FLAGS_PORT, "rx_brb_truncate" },
9775         { STATS_OFFSET32(pause_frames_received_hi),
9776                                 8, STATS_FLAGS_PORT, "rx_pause_frames" },
9777         { STATS_OFFSET32(rx_stat_maccontrolframesreceived_hi),
9778                                 8, STATS_FLAGS_PORT, "rx_mac_ctrl_frames" },
9779         { STATS_OFFSET32(nig_timer_max),
9780                         4, STATS_FLAGS_PORT, "rx_constant_pause_events" },
9781 /* 20 */{ STATS_OFFSET32(rx_err_discard_pkt),
9782                                 4, STATS_FLAGS_BOTH, "rx_phy_ip_err_discards"},
9783         { STATS_OFFSET32(rx_skb_alloc_failed),
9784                                 4, STATS_FLAGS_BOTH, "rx_skb_alloc_discard" },
9785         { STATS_OFFSET32(hw_csum_err),
9786                                 4, STATS_FLAGS_BOTH, "rx_csum_offload_errors" },
9787
9788         { STATS_OFFSET32(total_bytes_transmitted_hi),
9789                                 8, STATS_FLAGS_BOTH, "tx_bytes" },
9790         { STATS_OFFSET32(tx_stat_ifhcoutbadoctets_hi),
9791                                 8, STATS_FLAGS_PORT, "tx_error_bytes" },
9792         { STATS_OFFSET32(total_unicast_packets_transmitted_hi),
9793                                 8, STATS_FLAGS_BOTH, "tx_packets" },
9794         { STATS_OFFSET32(tx_stat_dot3statsinternalmactransmiterrors_hi),
9795                                 8, STATS_FLAGS_PORT, "tx_mac_errors" },
9796         { STATS_OFFSET32(rx_stat_dot3statscarriersenseerrors_hi),
9797                                 8, STATS_FLAGS_PORT, "tx_carrier_errors" },
9798         { STATS_OFFSET32(tx_stat_dot3statssinglecollisionframes_hi),
9799                                 8, STATS_FLAGS_PORT, "tx_single_collisions" },
9800         { STATS_OFFSET32(tx_stat_dot3statsmultiplecollisionframes_hi),
9801                                 8, STATS_FLAGS_PORT, "tx_multi_collisions" },
9802 /* 30 */{ STATS_OFFSET32(tx_stat_dot3statsdeferredtransmissions_hi),
9803                                 8, STATS_FLAGS_PORT, "tx_deferred" },
9804         { STATS_OFFSET32(tx_stat_dot3statsexcessivecollisions_hi),
9805                                 8, STATS_FLAGS_PORT, "tx_excess_collisions" },
9806         { STATS_OFFSET32(tx_stat_dot3statslatecollisions_hi),
9807                                 8, STATS_FLAGS_PORT, "tx_late_collisions" },
9808         { STATS_OFFSET32(tx_stat_etherstatscollisions_hi),
9809                                 8, STATS_FLAGS_PORT, "tx_total_collisions" },
9810         { STATS_OFFSET32(tx_stat_etherstatspkts64octets_hi),
9811                                 8, STATS_FLAGS_PORT, "tx_64_byte_packets" },
9812         { STATS_OFFSET32(tx_stat_etherstatspkts65octetsto127octets_hi),
9813                         8, STATS_FLAGS_PORT, "tx_65_to_127_byte_packets" },
9814         { STATS_OFFSET32(tx_stat_etherstatspkts128octetsto255octets_hi),
9815                         8, STATS_FLAGS_PORT, "tx_128_to_255_byte_packets" },
9816         { STATS_OFFSET32(tx_stat_etherstatspkts256octetsto511octets_hi),
9817                         8, STATS_FLAGS_PORT, "tx_256_to_511_byte_packets" },
9818         { STATS_OFFSET32(tx_stat_etherstatspkts512octetsto1023octets_hi),
9819                         8, STATS_FLAGS_PORT, "tx_512_to_1023_byte_packets" },
9820         { STATS_OFFSET32(etherstatspkts1024octetsto1522octets_hi),
9821                         8, STATS_FLAGS_PORT, "tx_1024_to_1522_byte_packets" },
9822 /* 40 */{ STATS_OFFSET32(etherstatspktsover1522octets_hi),
9823                         8, STATS_FLAGS_PORT, "tx_1523_to_9022_byte_packets" },
9824         { STATS_OFFSET32(pause_frames_sent_hi),
9825                                 8, STATS_FLAGS_PORT, "tx_pause_frames" }
9826 };
9827
9828 #define IS_PORT_STAT(i) \
9829         ((bnx2x_stats_arr[i].flags & STATS_FLAGS_BOTH) == STATS_FLAGS_PORT)
9830 #define IS_FUNC_STAT(i)         (bnx2x_stats_arr[i].flags & STATS_FLAGS_FUNC)
9831 #define IS_E1HMF_MODE_STAT(bp) \
9832                         (IS_E1HMF(bp) && !(bp->msglevel & BNX2X_MSG_STATS))
9833
9834 static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
9835 {
9836         struct bnx2x *bp = netdev_priv(dev);
9837         int i, j, k;
9838
9839         switch (stringset) {
9840         case ETH_SS_STATS:
9841                 if (is_multi(bp)) {
9842                         k = 0;
9843                         for_each_queue(bp, i) {
9844                                 for (j = 0; j < BNX2X_NUM_Q_STATS; j++)
9845                                         sprintf(buf + (k + j)*ETH_GSTRING_LEN,
9846                                                 bnx2x_q_stats_arr[j].string, i);
9847                                 k += BNX2X_NUM_Q_STATS;
9848                         }
9849                         if (IS_E1HMF_MODE_STAT(bp))
9850                                 break;
9851                         for (j = 0; j < BNX2X_NUM_STATS; j++)
9852                                 strcpy(buf + (k + j)*ETH_GSTRING_LEN,
9853                                        bnx2x_stats_arr[j].string);
9854                 } else {
9855                         for (i = 0, j = 0; i < BNX2X_NUM_STATS; i++) {
9856                                 if (IS_E1HMF_MODE_STAT(bp) && IS_PORT_STAT(i))
9857                                         continue;
9858                                 strcpy(buf + j*ETH_GSTRING_LEN,
9859                                        bnx2x_stats_arr[i].string);
9860                                 j++;
9861                         }
9862                 }
9863                 break;
9864
9865         case ETH_SS_TEST:
9866                 memcpy(buf, bnx2x_tests_str_arr, sizeof(bnx2x_tests_str_arr));
9867                 break;
9868         }
9869 }
9870
9871 static int bnx2x_get_stats_count(struct net_device *dev)
9872 {
9873         struct bnx2x *bp = netdev_priv(dev);
9874         int i, num_stats;
9875
9876         if (is_multi(bp)) {
9877                 num_stats = BNX2X_NUM_Q_STATS * BNX2X_NUM_QUEUES(bp);
9878                 if (!IS_E1HMF_MODE_STAT(bp))
9879                         num_stats += BNX2X_NUM_STATS;
9880         } else {
9881                 if (IS_E1HMF_MODE_STAT(bp)) {
9882                         num_stats = 0;
9883                         for (i = 0; i < BNX2X_NUM_STATS; i++)
9884                                 if (IS_FUNC_STAT(i))
9885                                         num_stats++;
9886                 } else
9887                         num_stats = BNX2X_NUM_STATS;
9888         }
9889
9890         return num_stats;
9891 }
9892
9893 static void bnx2x_get_ethtool_stats(struct net_device *dev,
9894                                     struct ethtool_stats *stats, u64 *buf)
9895 {
9896         struct bnx2x *bp = netdev_priv(dev);
9897         u32 *hw_stats, *offset;
9898         int i, j, k;
9899
9900         if (is_multi(bp)) {
9901                 k = 0;
9902                 for_each_queue(bp, i) {
9903                         hw_stats = (u32 *)&bp->fp[i].eth_q_stats;
9904                         for (j = 0; j < BNX2X_NUM_Q_STATS; j++) {
9905                                 if (bnx2x_q_stats_arr[j].size == 0) {
9906                                         /* skip this counter */
9907                                         buf[k + j] = 0;
9908                                         continue;
9909                                 }
9910                                 offset = (hw_stats +
9911                                           bnx2x_q_stats_arr[j].offset);
9912                                 if (bnx2x_q_stats_arr[j].size == 4) {
9913                                         /* 4-byte counter */
9914                                         buf[k + j] = (u64) *offset;
9915                                         continue;
9916                                 }
9917                                 /* 8-byte counter */
9918                                 buf[k + j] = HILO_U64(*offset, *(offset + 1));
9919                         }
9920                         k += BNX2X_NUM_Q_STATS;
9921                 }
9922                 if (IS_E1HMF_MODE_STAT(bp))
9923                         return;
9924                 hw_stats = (u32 *)&bp->eth_stats;
9925                 for (j = 0; j < BNX2X_NUM_STATS; j++) {
9926                         if (bnx2x_stats_arr[j].size == 0) {
9927                                 /* skip this counter */
9928                                 buf[k + j] = 0;
9929                                 continue;
9930                         }
9931                         offset = (hw_stats + bnx2x_stats_arr[j].offset);
9932                         if (bnx2x_stats_arr[j].size == 4) {
9933                                 /* 4-byte counter */
9934                                 buf[k + j] = (u64) *offset;
9935                                 continue;
9936                         }
9937                         /* 8-byte counter */
9938                         buf[k + j] = HILO_U64(*offset, *(offset + 1));
9939                 }
9940         } else {
9941                 hw_stats = (u32 *)&bp->eth_stats;
9942                 for (i = 0, j = 0; i < BNX2X_NUM_STATS; i++) {
9943                         if (IS_E1HMF_MODE_STAT(bp) && IS_PORT_STAT(i))
9944                                 continue;
9945                         if (bnx2x_stats_arr[i].size == 0) {
9946                                 /* skip this counter */
9947                                 buf[j] = 0;
9948                                 j++;
9949                                 continue;
9950                         }
9951                         offset = (hw_stats + bnx2x_stats_arr[i].offset);
9952                         if (bnx2x_stats_arr[i].size == 4) {
9953                                 /* 4-byte counter */
9954                                 buf[j] = (u64) *offset;
9955                                 j++;
9956                                 continue;
9957                         }
9958                         /* 8-byte counter */
9959                         buf[j] = HILO_U64(*offset, *(offset + 1));
9960                         j++;
9961                 }
9962         }
9963 }
9964
9965 static int bnx2x_phys_id(struct net_device *dev, u32 data)
9966 {
9967         struct bnx2x *bp = netdev_priv(dev);
9968         int port = BP_PORT(bp);
9969         int i;
9970
9971         if (!netif_running(dev))
9972                 return 0;
9973
9974         if (!bp->port.pmf)
9975                 return 0;
9976
9977         if (data == 0)
9978                 data = 2;
9979
9980         for (i = 0; i < (data * 2); i++) {
9981                 if ((i % 2) == 0)
9982                         bnx2x_set_led(bp, port, LED_MODE_OPER, SPEED_1000,
9983                                       bp->link_params.hw_led_mode,
9984                                       bp->link_params.chip_id);
9985                 else
9986                         bnx2x_set_led(bp, port, LED_MODE_OFF, 0,
9987                                       bp->link_params.hw_led_mode,
9988                                       bp->link_params.chip_id);
9989
9990                 msleep_interruptible(500);
9991                 if (signal_pending(current))
9992                         break;
9993         }
9994
9995         if (bp->link_vars.link_up)
9996                 bnx2x_set_led(bp, port, LED_MODE_OPER,
9997                               bp->link_vars.line_speed,
9998                               bp->link_params.hw_led_mode,
9999                               bp->link_params.chip_id);
10000
10001         return 0;
10002 }
10003
10004 static struct ethtool_ops bnx2x_ethtool_ops = {
10005         .get_settings           = bnx2x_get_settings,
10006         .set_settings           = bnx2x_set_settings,
10007         .get_drvinfo            = bnx2x_get_drvinfo,
10008         .get_regs_len           = bnx2x_get_regs_len,
10009         .get_regs               = bnx2x_get_regs,
10010         .get_wol                = bnx2x_get_wol,
10011         .set_wol                = bnx2x_set_wol,
10012         .get_msglevel           = bnx2x_get_msglevel,
10013         .set_msglevel           = bnx2x_set_msglevel,
10014         .nway_reset             = bnx2x_nway_reset,
10015         .get_link               = ethtool_op_get_link,
10016         .get_eeprom_len         = bnx2x_get_eeprom_len,
10017         .get_eeprom             = bnx2x_get_eeprom,
10018         .set_eeprom             = bnx2x_set_eeprom,
10019         .get_coalesce           = bnx2x_get_coalesce,
10020         .set_coalesce           = bnx2x_set_coalesce,
10021         .get_ringparam          = bnx2x_get_ringparam,
10022         .set_ringparam          = bnx2x_set_ringparam,
10023         .get_pauseparam         = bnx2x_get_pauseparam,
10024         .set_pauseparam         = bnx2x_set_pauseparam,
10025         .get_rx_csum            = bnx2x_get_rx_csum,
10026         .set_rx_csum            = bnx2x_set_rx_csum,
10027         .get_tx_csum            = ethtool_op_get_tx_csum,
10028         .set_tx_csum            = ethtool_op_set_tx_hw_csum,
10029         .set_flags              = bnx2x_set_flags,
10030         .get_flags              = ethtool_op_get_flags,
10031         .get_sg                 = ethtool_op_get_sg,
10032         .set_sg                 = ethtool_op_set_sg,
10033         .get_tso                = ethtool_op_get_tso,
10034         .set_tso                = bnx2x_set_tso,
10035         .self_test_count        = bnx2x_self_test_count,
10036         .self_test              = bnx2x_self_test,
10037         .get_strings            = bnx2x_get_strings,
10038         .phys_id                = bnx2x_phys_id,
10039         .get_stats_count        = bnx2x_get_stats_count,
10040         .get_ethtool_stats      = bnx2x_get_ethtool_stats,
10041 };
10042
10043 /* end of ethtool_ops */
10044
10045 /****************************************************************************
10046 * General service functions
10047 ****************************************************************************/
10048
10049 static int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state)
10050 {
10051         u16 pmcsr;
10052
10053         pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
10054
10055         switch (state) {
10056         case PCI_D0:
10057                 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
10058                                       ((pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
10059                                        PCI_PM_CTRL_PME_STATUS));
10060
10061                 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
10062                         /* delay required during transition out of D3hot */
10063                         msleep(20);
10064                 break;
10065
10066         case PCI_D3hot:
10067                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
10068                 pmcsr |= 3;
10069
10070                 if (bp->wol)
10071                         pmcsr |= PCI_PM_CTRL_PME_ENABLE;
10072
10073                 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
10074                                       pmcsr);
10075
10076                 /* No more memory access after this point until
10077                 * device is brought back to D0.
10078                 */
10079                 break;
10080
10081         default:
10082                 return -EINVAL;
10083         }
10084         return 0;
10085 }
10086
10087 static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
10088 {
10089         u16 rx_cons_sb;
10090
10091         /* Tell compiler that status block fields can change */
10092         barrier();
10093         rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
10094         if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
10095                 rx_cons_sb++;
10096         return (fp->rx_comp_cons != rx_cons_sb);
10097 }
10098
10099 /*
10100  * net_device service functions
10101  */
10102
10103 static int bnx2x_poll(struct napi_struct *napi, int budget)
10104 {
10105         struct bnx2x_fastpath *fp = container_of(napi, struct bnx2x_fastpath,
10106                                                  napi);
10107         struct bnx2x *bp = fp->bp;
10108         int work_done = 0;
10109
10110 #ifdef BNX2X_STOP_ON_ERROR
10111         if (unlikely(bp->panic))
10112                 goto poll_panic;
10113 #endif
10114
10115         prefetch(fp->tx_buf_ring[TX_BD(fp->tx_pkt_cons)].skb);
10116         prefetch(fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)].skb);
10117         prefetch((char *)(fp->rx_buf_ring[RX_BD(fp->rx_bd_cons)].skb) + 256);
10118
10119         bnx2x_update_fpsb_idx(fp);
10120
10121         if (bnx2x_has_tx_work(fp))
10122                 bnx2x_tx_int(fp);
10123
10124         if (bnx2x_has_rx_work(fp)) {
10125                 work_done = bnx2x_rx_int(fp, budget);
10126
10127                 /* must not complete if we consumed full budget */
10128                 if (work_done >= budget)
10129                         goto poll_again;
10130         }
10131
10132         /* BNX2X_HAS_WORK() reads the status block, thus we need to
10133          * ensure that status block indices have been actually read
10134          * (bnx2x_update_fpsb_idx) prior to this check (BNX2X_HAS_WORK)
10135          * so that we won't write the "newer" value of the status block to IGU
10136          * (if there was a DMA right after BNX2X_HAS_WORK and
10137          * if there is no rmb, the memory reading (bnx2x_update_fpsb_idx)
10138          * may be postponed to right before bnx2x_ack_sb). In this case
10139          * there will never be another interrupt until there is another update
10140          * of the status block, while there is still unhandled work.
10141          */
10142         rmb();
10143
10144         if (!BNX2X_HAS_WORK(fp)) {
10145 #ifdef BNX2X_STOP_ON_ERROR
10146 poll_panic:
10147 #endif
10148                 napi_complete(napi);
10149
10150                 bnx2x_ack_sb(bp, fp->sb_id, USTORM_ID,
10151                              le16_to_cpu(fp->fp_u_idx), IGU_INT_NOP, 1);
10152                 bnx2x_ack_sb(bp, fp->sb_id, CSTORM_ID,
10153                              le16_to_cpu(fp->fp_c_idx), IGU_INT_ENABLE, 1);
10154         }
10155
10156 poll_again:
10157         return work_done;
10158 }
10159
10160
10161 /* we split the first BD into headers and data BDs
10162  * to ease the pain of our fellow microcode engineers
10163  * we use one mapping for both BDs
10164  * So far this has only been observed to happen
10165  * in Other Operating Systems(TM)
10166  */
10167 static noinline u16 bnx2x_tx_split(struct bnx2x *bp,
10168                                    struct bnx2x_fastpath *fp,
10169                                    struct eth_tx_bd **tx_bd, u16 hlen,
10170                                    u16 bd_prod, int nbd)
10171 {
10172         struct eth_tx_bd *h_tx_bd = *tx_bd;
10173         struct eth_tx_bd *d_tx_bd;
10174         dma_addr_t mapping;
10175         int old_len = le16_to_cpu(h_tx_bd->nbytes);
10176
10177         /* first fix first BD */
10178         h_tx_bd->nbd = cpu_to_le16(nbd);
10179         h_tx_bd->nbytes = cpu_to_le16(hlen);
10180
10181         DP(NETIF_MSG_TX_QUEUED, "TSO split header size is %d "
10182            "(%x:%x) nbd %d\n", h_tx_bd->nbytes, h_tx_bd->addr_hi,
10183            h_tx_bd->addr_lo, h_tx_bd->nbd);
10184
10185         /* now get a new data BD
10186          * (after the pbd) and fill it */
10187         bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
10188         d_tx_bd = &fp->tx_desc_ring[bd_prod];
10189
10190         mapping = HILO_U64(le32_to_cpu(h_tx_bd->addr_hi),
10191                            le32_to_cpu(h_tx_bd->addr_lo)) + hlen;
10192
10193         d_tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
10194         d_tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
10195         d_tx_bd->nbytes = cpu_to_le16(old_len - hlen);
10196         d_tx_bd->vlan = 0;
10197         /* this marks the BD as one that has no individual mapping
10198          * the FW ignores this flag in a BD not marked start
10199          */
10200         d_tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_SW_LSO;
10201         DP(NETIF_MSG_TX_QUEUED,
10202            "TSO split data size is %d (%x:%x)\n",
10203            d_tx_bd->nbytes, d_tx_bd->addr_hi, d_tx_bd->addr_lo);
10204
10205         /* update tx_bd for marking the last BD flag */
10206         *tx_bd = d_tx_bd;
10207
10208         return bd_prod;
10209 }
10210
10211 static inline u16 bnx2x_csum_fix(unsigned char *t_header, u16 csum, s8 fix)
10212 {
10213         if (fix > 0)
10214                 csum = (u16) ~csum_fold(csum_sub(csum,
10215                                 csum_partial(t_header - fix, fix, 0)));
10216
10217         else if (fix < 0)
10218                 csum = (u16) ~csum_fold(csum_add(csum,
10219                                 csum_partial(t_header, -fix, 0)));
10220
10221         return swab16(csum);
10222 }
10223
10224 static inline u32 bnx2x_xmit_type(struct bnx2x *bp, struct sk_buff *skb)
10225 {
10226         u32 rc;
10227
10228         if (skb->ip_summed != CHECKSUM_PARTIAL)
10229                 rc = XMIT_PLAIN;
10230
10231         else {
10232                 if (skb->protocol == htons(ETH_P_IPV6)) {
10233                         rc = XMIT_CSUM_V6;
10234                         if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
10235                                 rc |= XMIT_CSUM_TCP;
10236
10237                 } else {
10238                         rc = XMIT_CSUM_V4;
10239                         if (ip_hdr(skb)->protocol == IPPROTO_TCP)
10240                                 rc |= XMIT_CSUM_TCP;
10241                 }
10242         }
10243
10244         if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
10245                 rc |= XMIT_GSO_V4;
10246
10247         else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
10248                 rc |= XMIT_GSO_V6;
10249
10250         return rc;
10251 }
10252
10253 #if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
10254 /* check if packet requires linearization (packet is too fragmented)
10255    no need to check fragmentation if page size > 8K (there will be no
10256    violation to FW restrictions) */
10257 static int bnx2x_pkt_req_lin(struct bnx2x *bp, struct sk_buff *skb,
10258                              u32 xmit_type)
10259 {
10260         int to_copy = 0;
10261         int hlen = 0;
10262         int first_bd_sz = 0;
10263
10264         /* 3 = 1 (for linear data BD) + 2 (for PBD and last BD) */
10265         if (skb_shinfo(skb)->nr_frags >= (MAX_FETCH_BD - 3)) {
10266
10267                 if (xmit_type & XMIT_GSO) {
10268                         unsigned short lso_mss = skb_shinfo(skb)->gso_size;
10269                         /* Check if LSO packet needs to be copied:
10270                            3 = 1 (for headers BD) + 2 (for PBD and last BD) */
10271                         int wnd_size = MAX_FETCH_BD - 3;
10272                         /* Number of windows to check */
10273                         int num_wnds = skb_shinfo(skb)->nr_frags - wnd_size;
10274                         int wnd_idx = 0;
10275                         int frag_idx = 0;
10276                         u32 wnd_sum = 0;
10277
10278                         /* Headers length */
10279                         hlen = (int)(skb_transport_header(skb) - skb->data) +
10280                                 tcp_hdrlen(skb);
10281
10282                         /* Amount of data (w/o headers) on linear part of SKB*/
10283                         first_bd_sz = skb_headlen(skb) - hlen;
10284
10285                         wnd_sum  = first_bd_sz;
10286
10287                         /* Calculate the first sum - it's special */
10288                         for (frag_idx = 0; frag_idx < wnd_size - 1; frag_idx++)
10289                                 wnd_sum +=
10290                                         skb_shinfo(skb)->frags[frag_idx].size;
10291
10292                         /* If there was data on linear skb data - check it */
10293                         if (first_bd_sz > 0) {
10294                                 if (unlikely(wnd_sum < lso_mss)) {
10295                                         to_copy = 1;
10296                                         goto exit_lbl;
10297                                 }
10298
10299                                 wnd_sum -= first_bd_sz;
10300                         }
10301
10302                         /* Others are easier: run through the frag list and
10303                            check all windows */
10304                         for (wnd_idx = 0; wnd_idx <= num_wnds; wnd_idx++) {
10305                                 wnd_sum +=
10306                           skb_shinfo(skb)->frags[wnd_idx + wnd_size - 1].size;
10307
10308                                 if (unlikely(wnd_sum < lso_mss)) {
10309                                         to_copy = 1;
10310                                         break;
10311                                 }
10312                                 wnd_sum -=
10313                                         skb_shinfo(skb)->frags[wnd_idx].size;
10314                         }
10315                 } else {
10316                         /* in non-LSO too fragmented packet should always
10317                            be linearized */
10318                         to_copy = 1;
10319                 }
10320         }
10321
10322 exit_lbl:
10323         if (unlikely(to_copy))
10324                 DP(NETIF_MSG_TX_QUEUED,
10325                    "Linearization IS REQUIRED for %s packet. "
10326                    "num_frags %d  hlen %d  first_bd_sz %d\n",
10327                    (xmit_type & XMIT_GSO) ? "LSO" : "non-LSO",
10328                    skb_shinfo(skb)->nr_frags, hlen, first_bd_sz);
10329
10330         return to_copy;
10331 }
10332 #endif
10333
10334 /* called with netif_tx_lock
10335  * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
10336  * netif_wake_queue()
10337  */
10338 static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
10339 {
10340         struct bnx2x *bp = netdev_priv(dev);
10341         struct bnx2x_fastpath *fp;
10342         struct netdev_queue *txq;
10343         struct sw_tx_bd *tx_buf;
10344         struct eth_tx_bd *tx_bd;
10345         struct eth_tx_parse_bd *pbd = NULL;
10346         u16 pkt_prod, bd_prod;
10347         int nbd, fp_index;
10348         dma_addr_t mapping;
10349         u32 xmit_type = bnx2x_xmit_type(bp, skb);
10350         int vlan_off = (bp->e1hov ? 4 : 0);
10351         int i;
10352         u8 hlen = 0;
10353
10354 #ifdef BNX2X_STOP_ON_ERROR
10355         if (unlikely(bp->panic))
10356                 return NETDEV_TX_BUSY;
10357 #endif
10358
10359         fp_index = skb_get_queue_mapping(skb);
10360         txq = netdev_get_tx_queue(dev, fp_index);
10361
10362         fp = &bp->fp[fp_index];
10363
10364         if (unlikely(bnx2x_tx_avail(fp) < (skb_shinfo(skb)->nr_frags + 3))) {
10365                 fp->eth_q_stats.driver_xoff++,
10366                 netif_tx_stop_queue(txq);
10367                 BNX2X_ERR("BUG! Tx ring full when queue awake!\n");
10368                 return NETDEV_TX_BUSY;
10369         }
10370
10371         DP(NETIF_MSG_TX_QUEUED, "SKB: summed %x  protocol %x  protocol(%x,%x)"
10372            "  gso type %x  xmit_type %x\n",
10373            skb->ip_summed, skb->protocol, ipv6_hdr(skb)->nexthdr,
10374            ip_hdr(skb)->protocol, skb_shinfo(skb)->gso_type, xmit_type);
10375
10376 #if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
10377         /* First, check if we need to linearize the skb (due to FW
10378            restrictions). No need to check fragmentation if page size > 8K
10379            (there will be no violation to FW restrictions) */
10380         if (bnx2x_pkt_req_lin(bp, skb, xmit_type)) {
10381                 /* Statistics of linearization */
10382                 bp->lin_cnt++;
10383                 if (skb_linearize(skb) != 0) {
10384                         DP(NETIF_MSG_TX_QUEUED, "SKB linearization failed - "
10385                            "silently dropping this SKB\n");
10386                         dev_kfree_skb_any(skb);
10387                         return NETDEV_TX_OK;
10388                 }
10389         }
10390 #endif
10391
10392         /*
10393         Please read carefully. First we use one BD which we mark as start,
10394         then for TSO or xsum we have a parsing info BD,
10395         and only then we have the rest of the TSO BDs.
10396         (don't forget to mark the last one as last,
10397         and to unmap only AFTER you write to the BD ...)
10398         And above all, all pdb sizes are in words - NOT DWORDS!
10399         */
10400
10401         pkt_prod = fp->tx_pkt_prod++;
10402         bd_prod = TX_BD(fp->tx_bd_prod);
10403
10404         /* get a tx_buf and first BD */
10405         tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
10406         tx_bd = &fp->tx_desc_ring[bd_prod];
10407
10408         tx_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
10409         tx_bd->general_data = (UNICAST_ADDRESS <<
10410                                ETH_TX_BD_ETH_ADDR_TYPE_SHIFT);
10411         /* header nbd */
10412         tx_bd->general_data |= (1 << ETH_TX_BD_HDR_NBDS_SHIFT);
10413
10414         /* remember the first BD of the packet */
10415         tx_buf->first_bd = fp->tx_bd_prod;
10416         tx_buf->skb = skb;
10417
10418         DP(NETIF_MSG_TX_QUEUED,
10419            "sending pkt %u @%p  next_idx %u  bd %u @%p\n",
10420            pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_bd);
10421
10422 #ifdef BCM_VLAN
10423         if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb) &&
10424             (bp->flags & HW_VLAN_TX_FLAG)) {
10425                 tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
10426                 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
10427                 vlan_off += 4;
10428         } else
10429 #endif
10430                 tx_bd->vlan = cpu_to_le16(pkt_prod);
10431
10432         if (xmit_type) {
10433                 /* turn on parsing and get a BD */
10434                 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
10435                 pbd = (void *)&fp->tx_desc_ring[bd_prod];
10436
10437                 memset(pbd, 0, sizeof(struct eth_tx_parse_bd));
10438         }
10439
10440         if (xmit_type & XMIT_CSUM) {
10441                 hlen = (skb_network_header(skb) - skb->data + vlan_off) / 2;
10442
10443                 /* for now NS flag is not used in Linux */
10444                 pbd->global_data =
10445                         (hlen | ((skb->protocol == cpu_to_be16(ETH_P_8021Q)) <<
10446                                  ETH_TX_PARSE_BD_LLC_SNAP_EN_SHIFT));
10447
10448                 pbd->ip_hlen = (skb_transport_header(skb) -
10449                                 skb_network_header(skb)) / 2;
10450
10451                 hlen += pbd->ip_hlen + tcp_hdrlen(skb) / 2;
10452
10453                 pbd->total_hlen = cpu_to_le16(hlen);
10454                 hlen = hlen*2 - vlan_off;
10455
10456                 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_TCP_CSUM;
10457
10458                 if (xmit_type & XMIT_CSUM_V4)
10459                         tx_bd->bd_flags.as_bitfield |=
10460                                                 ETH_TX_BD_FLAGS_IP_CSUM;
10461                 else
10462                         tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IPV6;
10463
10464                 if (xmit_type & XMIT_CSUM_TCP) {
10465                         pbd->tcp_pseudo_csum = swab16(tcp_hdr(skb)->check);
10466
10467                 } else {
10468                         s8 fix = SKB_CS_OFF(skb); /* signed! */
10469
10470                         pbd->global_data |= ETH_TX_PARSE_BD_CS_ANY_FLG;
10471                         pbd->cs_offset = fix / 2;
10472
10473                         DP(NETIF_MSG_TX_QUEUED,
10474                            "hlen %d  offset %d  fix %d  csum before fix %x\n",
10475                            le16_to_cpu(pbd->total_hlen), pbd->cs_offset, fix,
10476                            SKB_CS(skb));
10477
10478                         /* HW bug: fixup the CSUM */
10479                         pbd->tcp_pseudo_csum =
10480                                 bnx2x_csum_fix(skb_transport_header(skb),
10481                                                SKB_CS(skb), fix);
10482
10483                         DP(NETIF_MSG_TX_QUEUED, "csum after fix %x\n",
10484                            pbd->tcp_pseudo_csum);
10485                 }
10486         }
10487
10488         mapping = pci_map_single(bp->pdev, skb->data,
10489                                  skb_headlen(skb), PCI_DMA_TODEVICE);
10490
10491         tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
10492         tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
10493         nbd = skb_shinfo(skb)->nr_frags + ((pbd == NULL) ? 1 : 2);
10494         tx_bd->nbd = cpu_to_le16(nbd);
10495         tx_bd->nbytes = cpu_to_le16(skb_headlen(skb));
10496
10497         DP(NETIF_MSG_TX_QUEUED, "first bd @%p  addr (%x:%x)  nbd %d"
10498            "  nbytes %d  flags %x  vlan %x\n",
10499            tx_bd, tx_bd->addr_hi, tx_bd->addr_lo, le16_to_cpu(tx_bd->nbd),
10500            le16_to_cpu(tx_bd->nbytes), tx_bd->bd_flags.as_bitfield,
10501            le16_to_cpu(tx_bd->vlan));
10502
10503         if (xmit_type & XMIT_GSO) {
10504
10505                 DP(NETIF_MSG_TX_QUEUED,
10506                    "TSO packet len %d  hlen %d  total len %d  tso size %d\n",
10507                    skb->len, hlen, skb_headlen(skb),
10508                    skb_shinfo(skb)->gso_size);
10509
10510                 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
10511
10512                 if (unlikely(skb_headlen(skb) > hlen))
10513                         bd_prod = bnx2x_tx_split(bp, fp, &tx_bd, hlen,
10514                                                  bd_prod, ++nbd);
10515
10516                 pbd->lso_mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
10517                 pbd->tcp_send_seq = swab32(tcp_hdr(skb)->seq);
10518                 pbd->tcp_flags = pbd_tcp_flags(skb);
10519
10520                 if (xmit_type & XMIT_GSO_V4) {
10521                         pbd->ip_id = swab16(ip_hdr(skb)->id);
10522                         pbd->tcp_pseudo_csum =
10523                                 swab16(~csum_tcpudp_magic(ip_hdr(skb)->saddr,
10524                                                           ip_hdr(skb)->daddr,
10525                                                           0, IPPROTO_TCP, 0));
10526
10527                 } else
10528                         pbd->tcp_pseudo_csum =
10529                                 swab16(~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
10530                                                         &ipv6_hdr(skb)->daddr,
10531                                                         0, IPPROTO_TCP, 0));
10532
10533                 pbd->global_data |= ETH_TX_PARSE_BD_PSEUDO_CS_WITHOUT_LEN;
10534         }
10535
10536         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
10537                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
10538
10539                 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
10540                 tx_bd = &fp->tx_desc_ring[bd_prod];
10541
10542                 mapping = pci_map_page(bp->pdev, frag->page, frag->page_offset,
10543                                        frag->size, PCI_DMA_TODEVICE);
10544
10545                 tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
10546                 tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
10547                 tx_bd->nbytes = cpu_to_le16(frag->size);
10548                 tx_bd->vlan = cpu_to_le16(pkt_prod);
10549                 tx_bd->bd_flags.as_bitfield = 0;
10550
10551                 DP(NETIF_MSG_TX_QUEUED,
10552                    "frag %d  bd @%p  addr (%x:%x)  nbytes %d  flags %x\n",
10553                    i, tx_bd, tx_bd->addr_hi, tx_bd->addr_lo,
10554                    le16_to_cpu(tx_bd->nbytes), tx_bd->bd_flags.as_bitfield);
10555         }
10556
10557         /* now at last mark the BD as the last BD */
10558         tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_END_BD;
10559
10560         DP(NETIF_MSG_TX_QUEUED, "last bd @%p  flags %x\n",
10561            tx_bd, tx_bd->bd_flags.as_bitfield);
10562
10563         bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
10564
10565         /* now send a tx doorbell, counting the next BD
10566          * if the packet contains or ends with it
10567          */
10568         if (TX_BD_POFF(bd_prod) < nbd)
10569                 nbd++;
10570
10571         if (pbd)
10572                 DP(NETIF_MSG_TX_QUEUED,
10573                    "PBD @%p  ip_data %x  ip_hlen %u  ip_id %u  lso_mss %u"
10574                    "  tcp_flags %x  xsum %x  seq %u  hlen %u\n",
10575                    pbd, pbd->global_data, pbd->ip_hlen, pbd->ip_id,
10576                    pbd->lso_mss, pbd->tcp_flags, pbd->tcp_pseudo_csum,
10577                    pbd->tcp_send_seq, le16_to_cpu(pbd->total_hlen));
10578
10579         DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d  bd %u\n", nbd, bd_prod);
10580
10581         /*
10582          * Make sure that the BD data is updated before updating the producer
10583          * since FW might read the BD right after the producer is updated.
10584          * This is only applicable for weak-ordered memory model archs such
10585          * as IA-64. The following barrier is also mandatory since FW will
10586          * assumes packets must have BDs.
10587          */
10588         wmb();
10589
10590         le16_add_cpu(&fp->hw_tx_prods->bds_prod, nbd);
10591         mb(); /* FW restriction: must not reorder writing nbd and packets */
10592         le32_add_cpu(&fp->hw_tx_prods->packets_prod, 1);
10593         DOORBELL(bp, fp->index, 0);
10594
10595         mmiowb();
10596
10597         fp->tx_bd_prod += nbd;
10598         dev->trans_start = jiffies;
10599
10600         if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
10601                 /* We want bnx2x_tx_int to "see" the updated tx_bd_prod
10602                    if we put Tx into XOFF state. */
10603                 smp_mb();
10604                 netif_tx_stop_queue(txq);
10605                 fp->eth_q_stats.driver_xoff++;
10606                 if (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3)
10607                         netif_tx_wake_queue(txq);
10608         }
10609         fp->tx_pkt++;
10610
10611         return NETDEV_TX_OK;
10612 }
10613
10614 /* called with rtnl_lock */
10615 static int bnx2x_open(struct net_device *dev)
10616 {
10617         struct bnx2x *bp = netdev_priv(dev);
10618
10619         netif_carrier_off(dev);
10620
10621         bnx2x_set_power_state(bp, PCI_D0);
10622
10623         return bnx2x_nic_load(bp, LOAD_OPEN);
10624 }
10625
10626 /* called with rtnl_lock */
10627 static int bnx2x_close(struct net_device *dev)
10628 {
10629         struct bnx2x *bp = netdev_priv(dev);
10630
10631         /* Unload the driver, release IRQs */
10632         bnx2x_nic_unload(bp, UNLOAD_CLOSE);
10633         if (atomic_read(&bp->pdev->enable_cnt) == 1)
10634                 if (!CHIP_REV_IS_SLOW(bp))
10635                         bnx2x_set_power_state(bp, PCI_D3hot);
10636
10637         return 0;
10638 }
10639
10640 /* called with netif_tx_lock from dev_mcast.c */
10641 static void bnx2x_set_rx_mode(struct net_device *dev)
10642 {
10643         struct bnx2x *bp = netdev_priv(dev);
10644         u32 rx_mode = BNX2X_RX_MODE_NORMAL;
10645         int port = BP_PORT(bp);
10646
10647         if (bp->state != BNX2X_STATE_OPEN) {
10648                 DP(NETIF_MSG_IFUP, "state is %x, returning\n", bp->state);
10649                 return;
10650         }
10651
10652         DP(NETIF_MSG_IFUP, "dev->flags = %x\n", dev->flags);
10653
10654         if (dev->flags & IFF_PROMISC)
10655                 rx_mode = BNX2X_RX_MODE_PROMISC;
10656
10657         else if ((dev->flags & IFF_ALLMULTI) ||
10658                  ((dev->mc_count > BNX2X_MAX_MULTICAST) && CHIP_IS_E1(bp)))
10659                 rx_mode = BNX2X_RX_MODE_ALLMULTI;
10660
10661         else { /* some multicasts */
10662                 if (CHIP_IS_E1(bp)) {
10663                         int i, old, offset;
10664                         struct dev_mc_list *mclist;
10665                         struct mac_configuration_cmd *config =
10666                                                 bnx2x_sp(bp, mcast_config);
10667
10668                         for (i = 0, mclist = dev->mc_list;
10669                              mclist && (i < dev->mc_count);
10670                              i++, mclist = mclist->next) {
10671
10672                                 config->config_table[i].
10673                                         cam_entry.msb_mac_addr =
10674                                         swab16(*(u16 *)&mclist->dmi_addr[0]);
10675                                 config->config_table[i].
10676                                         cam_entry.middle_mac_addr =
10677                                         swab16(*(u16 *)&mclist->dmi_addr[2]);
10678                                 config->config_table[i].
10679                                         cam_entry.lsb_mac_addr =
10680                                         swab16(*(u16 *)&mclist->dmi_addr[4]);
10681                                 config->config_table[i].cam_entry.flags =
10682                                                         cpu_to_le16(port);
10683                                 config->config_table[i].
10684                                         target_table_entry.flags = 0;
10685                                 config->config_table[i].
10686                                         target_table_entry.client_id = 0;
10687                                 config->config_table[i].
10688                                         target_table_entry.vlan_id = 0;
10689
10690                                 DP(NETIF_MSG_IFUP,
10691                                    "setting MCAST[%d] (%04x:%04x:%04x)\n", i,
10692                                    config->config_table[i].
10693                                                 cam_entry.msb_mac_addr,
10694                                    config->config_table[i].
10695                                                 cam_entry.middle_mac_addr,
10696                                    config->config_table[i].
10697                                                 cam_entry.lsb_mac_addr);
10698                         }
10699                         old = config->hdr.length;
10700                         if (old > i) {
10701                                 for (; i < old; i++) {
10702                                         if (CAM_IS_INVALID(config->
10703                                                            config_table[i])) {
10704                                                 /* already invalidated */
10705                                                 break;
10706                                         }
10707                                         /* invalidate */
10708                                         CAM_INVALIDATE(config->
10709                                                        config_table[i]);
10710                                 }
10711                         }
10712
10713                         if (CHIP_REV_IS_SLOW(bp))
10714                                 offset = BNX2X_MAX_EMUL_MULTI*(1 + port);
10715                         else
10716                                 offset = BNX2X_MAX_MULTICAST*(1 + port);
10717
10718                         config->hdr.length = i;
10719                         config->hdr.offset = offset;
10720                         config->hdr.client_id = bp->fp->cl_id;
10721                         config->hdr.reserved1 = 0;
10722
10723                         bnx2x_sp_post(bp, RAMROD_CMD_ID_ETH_SET_MAC, 0,
10724                                    U64_HI(bnx2x_sp_mapping(bp, mcast_config)),
10725                                    U64_LO(bnx2x_sp_mapping(bp, mcast_config)),
10726                                       0);
10727                 } else { /* E1H */
10728                         /* Accept one or more multicasts */
10729                         struct dev_mc_list *mclist;
10730                         u32 mc_filter[MC_HASH_SIZE];
10731                         u32 crc, bit, regidx;
10732                         int i;
10733
10734                         memset(mc_filter, 0, 4 * MC_HASH_SIZE);
10735
10736                         for (i = 0, mclist = dev->mc_list;
10737                              mclist && (i < dev->mc_count);
10738                              i++, mclist = mclist->next) {
10739
10740                                 DP(NETIF_MSG_IFUP, "Adding mcast MAC: %pM\n",
10741                                    mclist->dmi_addr);
10742
10743                                 crc = crc32c_le(0, mclist->dmi_addr, ETH_ALEN);
10744                                 bit = (crc >> 24) & 0xff;
10745                                 regidx = bit >> 5;
10746                                 bit &= 0x1f;
10747                                 mc_filter[regidx] |= (1 << bit);
10748                         }
10749
10750                         for (i = 0; i < MC_HASH_SIZE; i++)
10751                                 REG_WR(bp, MC_HASH_OFFSET(bp, i),
10752                                        mc_filter[i]);
10753                 }
10754         }
10755
10756         bp->rx_mode = rx_mode;
10757         bnx2x_set_storm_rx_mode(bp);
10758 }
10759
10760 /* called with rtnl_lock */
10761 static int bnx2x_change_mac_addr(struct net_device *dev, void *p)
10762 {
10763         struct sockaddr *addr = p;
10764         struct bnx2x *bp = netdev_priv(dev);
10765
10766         if (!is_valid_ether_addr((u8 *)(addr->sa_data)))
10767                 return -EINVAL;
10768
10769         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
10770         if (netif_running(dev)) {
10771                 if (CHIP_IS_E1(bp))
10772                         bnx2x_set_mac_addr_e1(bp, 1);
10773                 else
10774                         bnx2x_set_mac_addr_e1h(bp, 1);
10775         }
10776
10777         return 0;
10778 }
10779
10780 /* called with rtnl_lock */
10781 static int bnx2x_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
10782 {
10783         struct mii_ioctl_data *data = if_mii(ifr);
10784         struct bnx2x *bp = netdev_priv(dev);
10785         int port = BP_PORT(bp);
10786         int err;
10787
10788         switch (cmd) {
10789         case SIOCGMIIPHY:
10790                 data->phy_id = bp->port.phy_addr;
10791
10792                 /* fallthrough */
10793
10794         case SIOCGMIIREG: {
10795                 u16 mii_regval;
10796
10797                 if (!netif_running(dev))
10798                         return -EAGAIN;
10799
10800                 mutex_lock(&bp->port.phy_mutex);
10801                 err = bnx2x_cl45_read(bp, port, 0, bp->port.phy_addr,
10802                                       DEFAULT_PHY_DEV_ADDR,
10803                                       (data->reg_num & 0x1f), &mii_regval);
10804                 data->val_out = mii_regval;
10805                 mutex_unlock(&bp->port.phy_mutex);
10806                 return err;
10807         }
10808
10809         case SIOCSMIIREG:
10810                 if (!capable(CAP_NET_ADMIN))
10811                         return -EPERM;
10812
10813                 if (!netif_running(dev))
10814                         return -EAGAIN;
10815
10816                 mutex_lock(&bp->port.phy_mutex);
10817                 err = bnx2x_cl45_write(bp, port, 0, bp->port.phy_addr,
10818                                        DEFAULT_PHY_DEV_ADDR,
10819                                        (data->reg_num & 0x1f), data->val_in);
10820                 mutex_unlock(&bp->port.phy_mutex);
10821                 return err;
10822
10823         default:
10824                 /* do nothing */
10825                 break;
10826         }
10827
10828         return -EOPNOTSUPP;
10829 }
10830
10831 /* called with rtnl_lock */
10832 static int bnx2x_change_mtu(struct net_device *dev, int new_mtu)
10833 {
10834         struct bnx2x *bp = netdev_priv(dev);
10835         int rc = 0;
10836
10837         if ((new_mtu > ETH_MAX_JUMBO_PACKET_SIZE) ||
10838             ((new_mtu + ETH_HLEN) < ETH_MIN_PACKET_SIZE))
10839                 return -EINVAL;
10840
10841         /* This does not race with packet allocation
10842          * because the actual alloc size is
10843          * only updated as part of load
10844          */
10845         dev->mtu = new_mtu;
10846
10847         if (netif_running(dev)) {
10848                 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
10849                 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
10850         }
10851
10852         return rc;
10853 }
10854
10855 static void bnx2x_tx_timeout(struct net_device *dev)
10856 {
10857         struct bnx2x *bp = netdev_priv(dev);
10858
10859 #ifdef BNX2X_STOP_ON_ERROR
10860         if (!bp->panic)
10861                 bnx2x_panic();
10862 #endif
10863         /* This allows the netif to be shutdown gracefully before resetting */
10864         schedule_work(&bp->reset_task);
10865 }
10866
10867 #ifdef BCM_VLAN
10868 /* called with rtnl_lock */
10869 static void bnx2x_vlan_rx_register(struct net_device *dev,
10870                                    struct vlan_group *vlgrp)
10871 {
10872         struct bnx2x *bp = netdev_priv(dev);
10873
10874         bp->vlgrp = vlgrp;
10875
10876         /* Set flags according to the required capabilities */
10877         bp->flags &= ~(HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
10878
10879         if (dev->features & NETIF_F_HW_VLAN_TX)
10880                 bp->flags |= HW_VLAN_TX_FLAG;
10881
10882         if (dev->features & NETIF_F_HW_VLAN_RX)
10883                 bp->flags |= HW_VLAN_RX_FLAG;
10884
10885         if (netif_running(dev))
10886                 bnx2x_set_client_config(bp);
10887 }
10888
10889 #endif
10890
10891 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
10892 static void poll_bnx2x(struct net_device *dev)
10893 {
10894         struct bnx2x *bp = netdev_priv(dev);
10895
10896         disable_irq(bp->pdev->irq);
10897         bnx2x_interrupt(bp->pdev->irq, dev);
10898         enable_irq(bp->pdev->irq);
10899 }
10900 #endif
10901
10902 static const struct net_device_ops bnx2x_netdev_ops = {
10903         .ndo_open               = bnx2x_open,
10904         .ndo_stop               = bnx2x_close,
10905         .ndo_start_xmit         = bnx2x_start_xmit,
10906         .ndo_set_multicast_list = bnx2x_set_rx_mode,
10907         .ndo_set_mac_address    = bnx2x_change_mac_addr,
10908         .ndo_validate_addr      = eth_validate_addr,
10909         .ndo_do_ioctl           = bnx2x_ioctl,
10910         .ndo_change_mtu         = bnx2x_change_mtu,
10911         .ndo_tx_timeout         = bnx2x_tx_timeout,
10912 #ifdef BCM_VLAN
10913         .ndo_vlan_rx_register   = bnx2x_vlan_rx_register,
10914 #endif
10915 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
10916         .ndo_poll_controller    = poll_bnx2x,
10917 #endif
10918 };
10919
10920 static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
10921                                     struct net_device *dev)
10922 {
10923         struct bnx2x *bp;
10924         int rc;
10925
10926         SET_NETDEV_DEV(dev, &pdev->dev);
10927         bp = netdev_priv(dev);
10928
10929         bp->dev = dev;
10930         bp->pdev = pdev;
10931         bp->flags = 0;
10932         bp->func = PCI_FUNC(pdev->devfn);
10933
10934         rc = pci_enable_device(pdev);
10935         if (rc) {
10936                 printk(KERN_ERR PFX "Cannot enable PCI device, aborting\n");
10937                 goto err_out;
10938         }
10939
10940         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
10941                 printk(KERN_ERR PFX "Cannot find PCI device base address,"
10942                        " aborting\n");
10943                 rc = -ENODEV;
10944                 goto err_out_disable;
10945         }
10946
10947         if (!(pci_resource_flags(pdev, 2) & IORESOURCE_MEM)) {
10948                 printk(KERN_ERR PFX "Cannot find second PCI device"
10949                        " base address, aborting\n");
10950                 rc = -ENODEV;
10951                 goto err_out_disable;
10952         }
10953
10954         if (atomic_read(&pdev->enable_cnt) == 1) {
10955                 rc = pci_request_regions(pdev, DRV_MODULE_NAME);
10956                 if (rc) {
10957                         printk(KERN_ERR PFX "Cannot obtain PCI resources,"
10958                                " aborting\n");
10959                         goto err_out_disable;
10960                 }
10961
10962                 pci_set_master(pdev);
10963                 pci_save_state(pdev);
10964         }
10965
10966         bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
10967         if (bp->pm_cap == 0) {
10968                 printk(KERN_ERR PFX "Cannot find power management"
10969                        " capability, aborting\n");
10970                 rc = -EIO;
10971                 goto err_out_release;
10972         }
10973
10974         bp->pcie_cap = pci_find_capability(pdev, PCI_CAP_ID_EXP);
10975         if (bp->pcie_cap == 0) {
10976                 printk(KERN_ERR PFX "Cannot find PCI Express capability,"
10977                        " aborting\n");
10978                 rc = -EIO;
10979                 goto err_out_release;
10980         }
10981
10982         if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) == 0) {
10983                 bp->flags |= USING_DAC_FLAG;
10984                 if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
10985                         printk(KERN_ERR PFX "pci_set_consistent_dma_mask"
10986                                " failed, aborting\n");
10987                         rc = -EIO;
10988                         goto err_out_release;
10989                 }
10990
10991         } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) {
10992                 printk(KERN_ERR PFX "System does not support DMA,"
10993                        " aborting\n");
10994                 rc = -EIO;
10995                 goto err_out_release;
10996         }
10997
10998         dev->mem_start = pci_resource_start(pdev, 0);
10999         dev->base_addr = dev->mem_start;
11000         dev->mem_end = pci_resource_end(pdev, 0);
11001
11002         dev->irq = pdev->irq;
11003
11004         bp->regview = pci_ioremap_bar(pdev, 0);
11005         if (!bp->regview) {
11006                 printk(KERN_ERR PFX "Cannot map register space, aborting\n");
11007                 rc = -ENOMEM;
11008                 goto err_out_release;
11009         }
11010
11011         bp->doorbells = ioremap_nocache(pci_resource_start(pdev, 2),
11012                                         min_t(u64, BNX2X_DB_SIZE,
11013                                               pci_resource_len(pdev, 2)));
11014         if (!bp->doorbells) {
11015                 printk(KERN_ERR PFX "Cannot map doorbell space, aborting\n");
11016                 rc = -ENOMEM;
11017                 goto err_out_unmap;
11018         }
11019
11020         bnx2x_set_power_state(bp, PCI_D0);
11021
11022         /* clean indirect addresses */
11023         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
11024                                PCICFG_VENDOR_ID_OFFSET);
11025         REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0 + BP_PORT(bp)*16, 0);
11026         REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0 + BP_PORT(bp)*16, 0);
11027         REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
11028         REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
11029
11030         dev->watchdog_timeo = TX_TIMEOUT;
11031
11032         dev->netdev_ops = &bnx2x_netdev_ops;
11033         dev->ethtool_ops = &bnx2x_ethtool_ops;
11034         dev->features |= NETIF_F_SG;
11035         dev->features |= NETIF_F_HW_CSUM;
11036         if (bp->flags & USING_DAC_FLAG)
11037                 dev->features |= NETIF_F_HIGHDMA;
11038 #ifdef BCM_VLAN
11039         dev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
11040         bp->flags |= (HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
11041 #endif
11042         dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
11043         dev->features |= NETIF_F_TSO6;
11044
11045         return 0;
11046
11047 err_out_unmap:
11048         if (bp->regview) {
11049                 iounmap(bp->regview);
11050                 bp->regview = NULL;
11051         }
11052         if (bp->doorbells) {
11053                 iounmap(bp->doorbells);
11054                 bp->doorbells = NULL;
11055         }
11056
11057 err_out_release:
11058         if (atomic_read(&pdev->enable_cnt) == 1)
11059                 pci_release_regions(pdev);
11060
11061 err_out_disable:
11062         pci_disable_device(pdev);
11063         pci_set_drvdata(pdev, NULL);
11064
11065 err_out:
11066         return rc;
11067 }
11068
11069 static int __devinit bnx2x_get_pcie_width(struct bnx2x *bp)
11070 {
11071         u32 val = REG_RD(bp, PCICFG_OFFSET + PCICFG_LINK_CONTROL);
11072
11073         val = (val & PCICFG_LINK_WIDTH) >> PCICFG_LINK_WIDTH_SHIFT;
11074         return val;
11075 }
11076
11077 /* return value of 1=2.5GHz 2=5GHz */
11078 static int __devinit bnx2x_get_pcie_speed(struct bnx2x *bp)
11079 {
11080         u32 val = REG_RD(bp, PCICFG_OFFSET + PCICFG_LINK_CONTROL);
11081
11082         val = (val & PCICFG_LINK_SPEED) >> PCICFG_LINK_SPEED_SHIFT;
11083         return val;
11084 }
11085
11086 static int __devinit bnx2x_init_one(struct pci_dev *pdev,
11087                                     const struct pci_device_id *ent)
11088 {
11089         static int version_printed;
11090         struct net_device *dev = NULL;
11091         struct bnx2x *bp;
11092         int rc;
11093
11094         if (version_printed++ == 0)
11095                 printk(KERN_INFO "%s", version);
11096
11097         /* dev zeroed in init_etherdev */
11098         dev = alloc_etherdev_mq(sizeof(*bp), MAX_CONTEXT);
11099         if (!dev) {
11100                 printk(KERN_ERR PFX "Cannot allocate net device\n");
11101                 return -ENOMEM;
11102         }
11103
11104         bp = netdev_priv(dev);
11105         bp->msglevel = debug;
11106
11107         rc = bnx2x_init_dev(pdev, dev);
11108         if (rc < 0) {
11109                 free_netdev(dev);
11110                 return rc;
11111         }
11112
11113         pci_set_drvdata(pdev, dev);
11114
11115         rc = bnx2x_init_bp(bp);
11116         if (rc)
11117                 goto init_one_exit;
11118
11119         rc = register_netdev(dev);
11120         if (rc) {
11121                 dev_err(&pdev->dev, "Cannot register net device\n");
11122                 goto init_one_exit;
11123         }
11124
11125         printk(KERN_INFO "%s: %s (%c%d) PCI-E x%d %s found at mem %lx,"
11126                " IRQ %d, ", dev->name, board_info[ent->driver_data].name,
11127                (CHIP_REV(bp) >> 12) + 'A', (CHIP_METAL(bp) >> 4),
11128                bnx2x_get_pcie_width(bp),
11129                (bnx2x_get_pcie_speed(bp) == 2) ? "5GHz (Gen2)" : "2.5GHz",
11130                dev->base_addr, bp->pdev->irq);
11131         printk(KERN_CONT "node addr %pM\n", dev->dev_addr);
11132
11133         return 0;
11134
11135 init_one_exit:
11136         if (bp->regview)
11137                 iounmap(bp->regview);
11138
11139         if (bp->doorbells)
11140                 iounmap(bp->doorbells);
11141
11142         free_netdev(dev);
11143
11144         if (atomic_read(&pdev->enable_cnt) == 1)
11145                 pci_release_regions(pdev);
11146
11147         pci_disable_device(pdev);
11148         pci_set_drvdata(pdev, NULL);
11149
11150         return rc;
11151 }
11152
11153 static void __devexit bnx2x_remove_one(struct pci_dev *pdev)
11154 {
11155         struct net_device *dev = pci_get_drvdata(pdev);
11156         struct bnx2x *bp;
11157
11158         if (!dev) {
11159                 printk(KERN_ERR PFX "BAD net device from bnx2x_init_one\n");
11160                 return;
11161         }
11162         bp = netdev_priv(dev);
11163
11164         unregister_netdev(dev);
11165
11166         if (bp->regview)
11167                 iounmap(bp->regview);
11168
11169         if (bp->doorbells)
11170                 iounmap(bp->doorbells);
11171
11172         free_netdev(dev);
11173
11174         if (atomic_read(&pdev->enable_cnt) == 1)
11175                 pci_release_regions(pdev);
11176
11177         pci_disable_device(pdev);
11178         pci_set_drvdata(pdev, NULL);
11179 }
11180
11181 static int bnx2x_suspend(struct pci_dev *pdev, pm_message_t state)
11182 {
11183         struct net_device *dev = pci_get_drvdata(pdev);
11184         struct bnx2x *bp;
11185
11186         if (!dev) {
11187                 printk(KERN_ERR PFX "BAD net device from bnx2x_init_one\n");
11188                 return -ENODEV;
11189         }
11190         bp = netdev_priv(dev);
11191
11192         rtnl_lock();
11193
11194         pci_save_state(pdev);
11195
11196         if (!netif_running(dev)) {
11197                 rtnl_unlock();
11198                 return 0;
11199         }
11200
11201         netif_device_detach(dev);
11202
11203         bnx2x_nic_unload(bp, UNLOAD_CLOSE);
11204
11205         bnx2x_set_power_state(bp, pci_choose_state(pdev, state));
11206
11207         rtnl_unlock();
11208
11209         return 0;
11210 }
11211
11212 static int bnx2x_resume(struct pci_dev *pdev)
11213 {
11214         struct net_device *dev = pci_get_drvdata(pdev);
11215         struct bnx2x *bp;
11216         int rc;
11217
11218         if (!dev) {
11219                 printk(KERN_ERR PFX "BAD net device from bnx2x_init_one\n");
11220                 return -ENODEV;
11221         }
11222         bp = netdev_priv(dev);
11223
11224         rtnl_lock();
11225
11226         pci_restore_state(pdev);
11227
11228         if (!netif_running(dev)) {
11229                 rtnl_unlock();
11230                 return 0;
11231         }
11232
11233         bnx2x_set_power_state(bp, PCI_D0);
11234         netif_device_attach(dev);
11235
11236         rc = bnx2x_nic_load(bp, LOAD_OPEN);
11237
11238         rtnl_unlock();
11239
11240         return rc;
11241 }
11242
11243 static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
11244 {
11245         int i;
11246
11247         bp->state = BNX2X_STATE_ERROR;
11248
11249         bp->rx_mode = BNX2X_RX_MODE_NONE;
11250
11251         bnx2x_netif_stop(bp, 0);
11252
11253         del_timer_sync(&bp->timer);
11254         bp->stats_state = STATS_STATE_DISABLED;
11255         DP(BNX2X_MSG_STATS, "stats_state - DISABLED\n");
11256
11257         /* Release IRQs */
11258         bnx2x_free_irq(bp);
11259
11260         if (CHIP_IS_E1(bp)) {
11261                 struct mac_configuration_cmd *config =
11262                                                 bnx2x_sp(bp, mcast_config);
11263
11264                 for (i = 0; i < config->hdr.length; i++)
11265                         CAM_INVALIDATE(config->config_table[i]);
11266         }
11267
11268         /* Free SKBs, SGEs, TPA pool and driver internals */
11269         bnx2x_free_skbs(bp);
11270         for_each_rx_queue(bp, i)
11271                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
11272         for_each_rx_queue(bp, i)
11273                 netif_napi_del(&bnx2x_fp(bp, i, napi));
11274         bnx2x_free_mem(bp);
11275
11276         bp->state = BNX2X_STATE_CLOSED;
11277
11278         netif_carrier_off(bp->dev);
11279
11280         return 0;
11281 }
11282
11283 static void bnx2x_eeh_recover(struct bnx2x *bp)
11284 {
11285         u32 val;
11286
11287         mutex_init(&bp->port.phy_mutex);
11288
11289         bp->common.shmem_base = REG_RD(bp, MISC_REG_SHARED_MEM_ADDR);
11290         bp->link_params.shmem_base = bp->common.shmem_base;
11291         BNX2X_DEV_INFO("shmem offset is 0x%x\n", bp->common.shmem_base);
11292
11293         if (!bp->common.shmem_base ||
11294             (bp->common.shmem_base < 0xA0000) ||
11295             (bp->common.shmem_base >= 0xC0000)) {
11296                 BNX2X_DEV_INFO("MCP not active\n");
11297                 bp->flags |= NO_MCP_FLAG;
11298                 return;
11299         }
11300
11301         val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
11302         if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
11303                 != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
11304                 BNX2X_ERR("BAD MCP validity signature\n");
11305
11306         if (!BP_NOMCP(bp)) {
11307                 bp->fw_seq = (SHMEM_RD(bp, func_mb[BP_FUNC(bp)].drv_mb_header)
11308                               & DRV_MSG_SEQ_NUMBER_MASK);
11309                 BNX2X_DEV_INFO("fw_seq 0x%08x\n", bp->fw_seq);
11310         }
11311 }
11312
11313 /**
11314  * bnx2x_io_error_detected - called when PCI error is detected
11315  * @pdev: Pointer to PCI device
11316  * @state: The current pci connection state
11317  *
11318  * This function is called after a PCI bus error affecting
11319  * this device has been detected.
11320  */
11321 static pci_ers_result_t bnx2x_io_error_detected(struct pci_dev *pdev,
11322                                                 pci_channel_state_t state)
11323 {
11324         struct net_device *dev = pci_get_drvdata(pdev);
11325         struct bnx2x *bp = netdev_priv(dev);
11326
11327         rtnl_lock();
11328
11329         netif_device_detach(dev);
11330
11331         if (netif_running(dev))
11332                 bnx2x_eeh_nic_unload(bp);
11333
11334         pci_disable_device(pdev);
11335
11336         rtnl_unlock();
11337
11338         /* Request a slot reset */
11339         return PCI_ERS_RESULT_NEED_RESET;
11340 }
11341
11342 /**
11343  * bnx2x_io_slot_reset - called after the PCI bus has been reset
11344  * @pdev: Pointer to PCI device
11345  *
11346  * Restart the card from scratch, as if from a cold-boot.
11347  */
11348 static pci_ers_result_t bnx2x_io_slot_reset(struct pci_dev *pdev)
11349 {
11350         struct net_device *dev = pci_get_drvdata(pdev);
11351         struct bnx2x *bp = netdev_priv(dev);
11352
11353         rtnl_lock();
11354
11355         if (pci_enable_device(pdev)) {
11356                 dev_err(&pdev->dev,
11357                         "Cannot re-enable PCI device after reset\n");
11358                 rtnl_unlock();
11359                 return PCI_ERS_RESULT_DISCONNECT;
11360         }
11361
11362         pci_set_master(pdev);
11363         pci_restore_state(pdev);
11364
11365         if (netif_running(dev))
11366                 bnx2x_set_power_state(bp, PCI_D0);
11367
11368         rtnl_unlock();
11369
11370         return PCI_ERS_RESULT_RECOVERED;
11371 }
11372
11373 /**
11374  * bnx2x_io_resume - called when traffic can start flowing again
11375  * @pdev: Pointer to PCI device
11376  *
11377  * This callback is called when the error recovery driver tells us that
11378  * its OK to resume normal operation.
11379  */
11380 static void bnx2x_io_resume(struct pci_dev *pdev)
11381 {
11382         struct net_device *dev = pci_get_drvdata(pdev);
11383         struct bnx2x *bp = netdev_priv(dev);
11384
11385         rtnl_lock();
11386
11387         bnx2x_eeh_recover(bp);
11388
11389         if (netif_running(dev))
11390                 bnx2x_nic_load(bp, LOAD_NORMAL);
11391
11392         netif_device_attach(dev);
11393
11394         rtnl_unlock();
11395 }
11396
11397 static struct pci_error_handlers bnx2x_err_handler = {
11398         .error_detected = bnx2x_io_error_detected,
11399         .slot_reset     = bnx2x_io_slot_reset,
11400         .resume         = bnx2x_io_resume,
11401 };
11402
11403 static struct pci_driver bnx2x_pci_driver = {
11404         .name        = DRV_MODULE_NAME,
11405         .id_table    = bnx2x_pci_tbl,
11406         .probe       = bnx2x_init_one,
11407         .remove      = __devexit_p(bnx2x_remove_one),
11408         .suspend     = bnx2x_suspend,
11409         .resume      = bnx2x_resume,
11410         .err_handler = &bnx2x_err_handler,
11411 };
11412
11413 static int __init bnx2x_init(void)
11414 {
11415         bnx2x_wq = create_singlethread_workqueue("bnx2x");
11416         if (bnx2x_wq == NULL) {
11417                 printk(KERN_ERR PFX "Cannot create workqueue\n");
11418                 return -ENOMEM;
11419         }
11420
11421         return pci_register_driver(&bnx2x_pci_driver);
11422 }
11423
11424 static void __exit bnx2x_cleanup(void)
11425 {
11426         pci_unregister_driver(&bnx2x_pci_driver);
11427
11428         destroy_workqueue(bnx2x_wq);
11429 }
11430
11431 module_init(bnx2x_init);
11432 module_exit(bnx2x_cleanup);
11433