SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/bnx2.c

   1 /* bnx2.c: Broadcom NX2 network driver.
   2  *
   3  * Copyright (c) 2004-2008 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  * Written by: Michael Chan  (mchan@broadcom.com)
  10  */
  11
  12
  13 #include <linux/module.h>
  14 #include <linux/moduleparam.h>
  15
  16 #include <linux/kernel.h>
  17 #include <linux/timer.h>
  18 #include <linux/errno.h>
  19 #include <linux/ioport.h>
  20 #include <linux/slab.h>
  21 #include <linux/vmalloc.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/pci.h>
  24 #include <linux/init.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/etherdevice.h>
  27 #include <linux/skbuff.h>
  28 #include <linux/dma-mapping.h>
  29 #include <linux/bitops.h>
  30 #include <asm/io.h>
  31 #include <asm/irq.h>
  32 #include <linux/delay.h>
  33 #include <asm/byteorder.h>
  34 #include <asm/page.h>
  35 #include <linux/time.h>
  36 #include <linux/ethtool.h>
  37 #include <linux/mii.h>
  38 #include <linux/if_vlan.h>
  39 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
  40 #define BCM_VLAN 1
  41 #endif
  42 #include <net/ip.h>
  43 #include <net/tcp.h>
  44 #include <net/checksum.h>
  45 #include <linux/workqueue.h>
  46 #include <linux/crc32.h>
  47 #include <linux/prefetch.h>
  48 #include <linux/cache.h>
  49 #include <linux/zlib.h>
  50 #include <linux/log2.h>
  51
  52 #include "bnx2.h"
  53 #include "bnx2_fw.h"
  54 #include "bnx2_fw2.h"
  55
  56 #define FW_BUF_SIZE             0x10000
  57
  58 #define DRV_MODULE_NAME         "bnx2"
  59 #define PFX DRV_MODULE_NAME     ": "
  60 #define DRV_MODULE_VERSION      "1.8.0"
  61 #define DRV_MODULE_RELDATE      "Aug 14, 2008"
  62
  63 #define RUN_AT(x) (jiffies + (x))
  64
  65 /* Time in jiffies before concluding the transmitter is hung. */
  66 #define TX_TIMEOUT  (5*HZ)
  67
  68 static char version[] __devinitdata =
  69         "Broadcom NetXtreme II Gigabit Ethernet Driver " DRV_MODULE_NAME " v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  70
  71 MODULE_AUTHOR("Michael Chan <mchan@broadcom.com>");
  72 MODULE_DESCRIPTION("Broadcom NetXtreme II BCM5706/5708/5709 Driver");
  73 MODULE_LICENSE("GPL");
  74 MODULE_VERSION(DRV_MODULE_VERSION);
  75
  76 static int disable_msi = 0;
  77
  78 module_param(disable_msi, int, 0);
  79 MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
  80
  81 typedef enum {
  82         BCM5706 = 0,
  83         NC370T,
  84         NC370I,
  85         BCM5706S,
  86         NC370F,
  87         BCM5708,
  88         BCM5708S,
  89         BCM5709,
  90         BCM5709S,
  91         BCM5716,
  92 } board_t;
  93
  94 /* indexed by board_t, above */
  95 static struct {
  96         char *name;
  97 } board_info[] __devinitdata = {
  98         { "Broadcom NetXtreme II BCM5706 1000Base-T" },
  99         { "HP NC370T Multifunction Gigabit Server Adapter" },
 100         { "HP NC370i Multifunction Gigabit Server Adapter" },
 101         { "Broadcom NetXtreme II BCM5706 1000Base-SX" },
 102         { "HP NC370F Multifunction Gigabit Server Adapter" },
 103         { "Broadcom NetXtreme II BCM5708 1000Base-T" },
 104         { "Broadcom NetXtreme II BCM5708 1000Base-SX" },
 105         { "Broadcom NetXtreme II BCM5709 1000Base-T" },
 106         { "Broadcom NetXtreme II BCM5709 1000Base-SX" },
 107         { "Broadcom NetXtreme II BCM5716 1000Base-T" },
 108         };
 109
 110 static DEFINE_PCI_DEVICE_TABLE(bnx2_pci_tbl) = {
 111         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
 112           PCI_VENDOR_ID_HP, 0x3101, 0, 0, NC370T },
 113         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
 114           PCI_VENDOR_ID_HP, 0x3106, 0, 0, NC370I },
 115         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
 116           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706 },
 117         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708,
 118           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708 },
 119         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
 120           PCI_VENDOR_ID_HP, 0x3102, 0, 0, NC370F },
 121         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
 122           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706S },
 123         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708S,
 124           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708S },
 125         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709,
 126           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709 },
 127         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709S,
 128           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709S },
 129         { PCI_VENDOR_ID_BROADCOM, 0x163b,
 130           PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5716 },
 131         { 0, }
 132 };
 133
 134 static struct flash_spec flash_table[] =
 135 {
 136 #define BUFFERED_FLAGS          (BNX2_NV_BUFFERED | BNX2_NV_TRANSLATE)
 137 #define NONBUFFERED_FLAGS       (BNX2_NV_WREN)
 138         /* Slow EEPROM */
 139         {0x00000000, 0x40830380, 0x009f0081, 0xa184a053, 0xaf000400,
 140          BUFFERED_FLAGS, SEEPROM_PAGE_BITS, SEEPROM_PAGE_SIZE,
 141          SEEPROM_BYTE_ADDR_MASK, SEEPROM_TOTAL_SIZE,
 142          "EEPROM - slow"},
 143         /* Expansion entry 0001 */
 144         {0x08000002, 0x4b808201, 0x00050081, 0x03840253, 0xaf020406,
 145          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 146          SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
 147          "Entry 0001"},
 148         /* Saifun SA25F010 (non-buffered flash) */
 149         /* strap, cfg1, & write1 need updates */
 150         {0x04000001, 0x47808201, 0x00050081, 0x03840253, 0xaf020406,
 151          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 152          SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE*2,
 153          "Non-buffered flash (128kB)"},
 154         /* Saifun SA25F020 (non-buffered flash) */
 155         /* strap, cfg1, & write1 need updates */
 156         {0x0c000003, 0x4f808201, 0x00050081, 0x03840253, 0xaf020406,
 157          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 158          SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE*4,
 159          "Non-buffered flash (256kB)"},
 160         /* Expansion entry 0100 */
 161         {0x11000000, 0x53808201, 0x00050081, 0x03840253, 0xaf020406,
 162          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 163          SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
 164          "Entry 0100"},
 165         /* Entry 0101: ST M45PE10 (non-buffered flash, TetonII B0) */
 166         {0x19000002, 0x5b808201, 0x000500db, 0x03840253, 0xaf020406,
 167          NONBUFFERED_FLAGS, ST_MICRO_FLASH_PAGE_BITS, ST_MICRO_FLASH_PAGE_SIZE,
 168          ST_MICRO_FLASH_BYTE_ADDR_MASK, ST_MICRO_FLASH_BASE_TOTAL_SIZE*2,
 169          "Entry 0101: ST M45PE10 (128kB non-bufferred)"},
 170         /* Entry 0110: ST M45PE20 (non-buffered flash)*/
 171         {0x15000001, 0x57808201, 0x000500db, 0x03840253, 0xaf020406,
 172          NONBUFFERED_FLAGS, ST_MICRO_FLASH_PAGE_BITS, ST_MICRO_FLASH_PAGE_SIZE,
 173          ST_MICRO_FLASH_BYTE_ADDR_MASK, ST_MICRO_FLASH_BASE_TOTAL_SIZE*4,
 174          "Entry 0110: ST M45PE20 (256kB non-bufferred)"},
 175         /* Saifun SA25F005 (non-buffered flash) */
 176         /* strap, cfg1, & write1 need updates */
 177         {0x1d000003, 0x5f808201, 0x00050081, 0x03840253, 0xaf020406,
 178          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 179          SAIFUN_FLASH_BYTE_ADDR_MASK, SAIFUN_FLASH_BASE_TOTAL_SIZE,
 180          "Non-buffered flash (64kB)"},
 181         /* Fast EEPROM */
 182         {0x22000000, 0x62808380, 0x009f0081, 0xa184a053, 0xaf000400,
 183          BUFFERED_FLAGS, SEEPROM_PAGE_BITS, SEEPROM_PAGE_SIZE,
 184          SEEPROM_BYTE_ADDR_MASK, SEEPROM_TOTAL_SIZE,
 185          "EEPROM - fast"},
 186         /* Expansion entry 1001 */
 187         {0x2a000002, 0x6b808201, 0x00050081, 0x03840253, 0xaf020406,
 188          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 189          SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
 190          "Entry 1001"},
 191         /* Expansion entry 1010 */
 192         {0x26000001, 0x67808201, 0x00050081, 0x03840253, 0xaf020406,
 193          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 194          SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
 195          "Entry 1010"},
 196         /* ATMEL AT45DB011B (buffered flash) */
 197         {0x2e000003, 0x6e808273, 0x00570081, 0x68848353, 0xaf000400,
 198          BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
 199          BUFFERED_FLASH_BYTE_ADDR_MASK, BUFFERED_FLASH_TOTAL_SIZE,
 200          "Buffered flash (128kB)"},
 201         /* Expansion entry 1100 */
 202         {0x33000000, 0x73808201, 0x00050081, 0x03840253, 0xaf020406,
 203          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 204          SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
 205          "Entry 1100"},
 206         /* Expansion entry 1101 */
 207         {0x3b000002, 0x7b808201, 0x00050081, 0x03840253, 0xaf020406,
 208          NONBUFFERED_FLAGS, SAIFUN_FLASH_PAGE_BITS, SAIFUN_FLASH_PAGE_SIZE,
 209          SAIFUN_FLASH_BYTE_ADDR_MASK, 0,
 210          "Entry 1101"},
 211         /* Ateml Expansion entry 1110 */
 212         {0x37000001, 0x76808273, 0x00570081, 0x68848353, 0xaf000400,
 213          BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
 214          BUFFERED_FLASH_BYTE_ADDR_MASK, 0,
 215          "Entry 1110 (Atmel)"},
 216         /* ATMEL AT45DB021B (buffered flash) */
 217         {0x3f000003, 0x7e808273, 0x00570081, 0x68848353, 0xaf000400,
 218          BUFFERED_FLAGS, BUFFERED_FLASH_PAGE_BITS, BUFFERED_FLASH_PAGE_SIZE,
 219          BUFFERED_FLASH_BYTE_ADDR_MASK, BUFFERED_FLASH_TOTAL_SIZE*2,
 220          "Buffered flash (256kB)"},
 221 };
 222
 223 static struct flash_spec flash_5709 = {
 224         .flags          = BNX2_NV_BUFFERED,
 225         .page_bits      = BCM5709_FLASH_PAGE_BITS,
 226         .page_size      = BCM5709_FLASH_PAGE_SIZE,
 227         .addr_mask      = BCM5709_FLASH_BYTE_ADDR_MASK,
 228         .total_size     = BUFFERED_FLASH_TOTAL_SIZE*2,
 229         .name           = "5709 Buffered flash (256kB)",
 230 };
 231
 232 MODULE_DEVICE_TABLE(pci, bnx2_pci_tbl);
 233
 234 static inline u32 bnx2_tx_avail(struct bnx2 *bp, struct bnx2_tx_ring_info *txr)
 235 {
 236         u32 diff;
 237
 238         smp_mb();
 239
 240         /* The ring uses 256 indices for 255 entries, one of them
 241          * needs to be skipped.
 242          */
 243         diff = txr->tx_prod - txr->tx_cons;
 244         if (unlikely(diff >= TX_DESC_CNT)) {
 245                 diff &= 0xffff;
 246                 if (diff == TX_DESC_CNT)
 247                         diff = MAX_TX_DESC_CNT;
 248         }
 249         return (bp->tx_ring_size - diff);
 250 }
 251
 252 static u32
 253 bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset)
 254 {
 255         u32 val;
 256
 257         spin_lock_bh(&bp->indirect_lock);
 258         REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
 259         val = REG_RD(bp, BNX2_PCICFG_REG_WINDOW);
 260         spin_unlock_bh(&bp->indirect_lock);
 261         return val;
 262 }
 263
 264 static void
 265 bnx2_reg_wr_ind(struct bnx2 *bp, u32 offset, u32 val)
 266 {
 267         spin_lock_bh(&bp->indirect_lock);
 268         REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
 269         REG_WR(bp, BNX2_PCICFG_REG_WINDOW, val);
 270         spin_unlock_bh(&bp->indirect_lock);
 271 }
 272
 273 static void
 274 bnx2_shmem_wr(struct bnx2 *bp, u32 offset, u32 val)
 275 {
 276         bnx2_reg_wr_ind(bp, bp->shmem_base + offset, val);
 277 }
 278
 279 static u32
 280 bnx2_shmem_rd(struct bnx2 *bp, u32 offset)
 281 {
 282         return (bnx2_reg_rd_ind(bp, bp->shmem_base + offset));
 283 }
 284
 285 static void
 286 bnx2_ctx_wr(struct bnx2 *bp, u32 cid_addr, u32 offset, u32 val)
 287 {
 288         offset += cid_addr;
 289         spin_lock_bh(&bp->indirect_lock);
 290         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
 291                 int i;
 292
 293                 REG_WR(bp, BNX2_CTX_CTX_DATA, val);
 294                 REG_WR(bp, BNX2_CTX_CTX_CTRL,
 295                        offset | BNX2_CTX_CTX_CTRL_WRITE_REQ);
 296                 for (i = 0; i < 5; i++) {
 297                         val = REG_RD(bp, BNX2_CTX_CTX_CTRL);
 298                         if ((val & BNX2_CTX_CTX_CTRL_WRITE_REQ) == 0)
 299                                 break;
 300                         udelay(5);
 301                 }
 302         } else {
 303                 REG_WR(bp, BNX2_CTX_DATA_ADR, offset);
 304                 REG_WR(bp, BNX2_CTX_DATA, val);
 305         }
 306         spin_unlock_bh(&bp->indirect_lock);
 307 }
 308
 309 static int
 310 bnx2_read_phy(struct bnx2 *bp, u32 reg, u32 *val)
 311 {
 312         u32 val1;
 313         int i, ret;
 314
 315         if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
 316                 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 317                 val1 &= ~BNX2_EMAC_MDIO_MODE_AUTO_POLL;
 318
 319                 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
 320                 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 321
 322                 udelay(40);
 323         }
 324
 325         val1 = (bp->phy_addr << 21) | (reg << 16) |
 326                 BNX2_EMAC_MDIO_COMM_COMMAND_READ | BNX2_EMAC_MDIO_COMM_DISEXT |
 327                 BNX2_EMAC_MDIO_COMM_START_BUSY;
 328         REG_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
 329
 330         for (i = 0; i < 50; i++) {
 331                 udelay(10);
 332
 333                 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
 334                 if (!(val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)) {
 335                         udelay(5);
 336
 337                         val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
 338                         val1 &= BNX2_EMAC_MDIO_COMM_DATA;
 339
 340                         break;
 341                 }
 342         }
 343
 344         if (val1 & BNX2_EMAC_MDIO_COMM_START_BUSY) {
 345                 *val = 0x0;
 346                 ret = -EBUSY;
 347         }
 348         else {
 349                 *val = val1;
 350                 ret = 0;
 351         }
 352
 353         if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
 354                 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 355                 val1 |= BNX2_EMAC_MDIO_MODE_AUTO_POLL;
 356
 357                 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
 358                 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 359
 360                 udelay(40);
 361         }
 362
 363         return ret;
 364 }
 365
 366 static int
 367 bnx2_write_phy(struct bnx2 *bp, u32 reg, u32 val)
 368 {
 369         u32 val1;
 370         int i, ret;
 371
 372         if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
 373                 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 374                 val1 &= ~BNX2_EMAC_MDIO_MODE_AUTO_POLL;
 375
 376                 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
 377                 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 378
 379                 udelay(40);
 380         }
 381
 382         val1 = (bp->phy_addr << 21) | (reg << 16) | val |
 383                 BNX2_EMAC_MDIO_COMM_COMMAND_WRITE |
 384                 BNX2_EMAC_MDIO_COMM_START_BUSY | BNX2_EMAC_MDIO_COMM_DISEXT;
 385         REG_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
 386
 387         for (i = 0; i < 50; i++) {
 388                 udelay(10);
 389
 390                 val1 = REG_RD(bp, BNX2_EMAC_MDIO_COMM);
 391                 if (!(val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)) {
 392                         udelay(5);
 393                         break;
 394                 }
 395         }
 396
 397         if (val1 & BNX2_EMAC_MDIO_COMM_START_BUSY)
 398                 ret = -EBUSY;
 399         else
 400                 ret = 0;
 401
 402         if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
 403                 val1 = REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 404                 val1 |= BNX2_EMAC_MDIO_MODE_AUTO_POLL;
 405
 406                 REG_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
 407                 REG_RD(bp, BNX2_EMAC_MDIO_MODE);
 408
 409                 udelay(40);
 410         }
 411
 412         return ret;
 413 }
 414
 415 static void
 416 bnx2_disable_int(struct bnx2 *bp)
 417 {
 418         int i;
 419         struct bnx2_napi *bnapi;
 420
 421         for (i = 0; i < bp->irq_nvecs; i++) {
 422                 bnapi = &bp->bnx2_napi[i];
 423                 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
 424                        BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
 425         }
 426         REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
 427 }
 428
 429 static void
 430 bnx2_enable_int(struct bnx2 *bp)
 431 {
 432         int i;
 433         struct bnx2_napi *bnapi;
 434
 435         for (i = 0; i < bp->irq_nvecs; i++) {
 436                 bnapi = &bp->bnx2_napi[i];
 437
 438                 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
 439                        BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
 440                        BNX2_PCICFG_INT_ACK_CMD_MASK_INT |
 441                        bnapi->last_status_idx);
 442
 443                 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
 444                        BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
 445                        bnapi->last_status_idx);
 446         }
 447         REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
 448 }
 449
 450 static void
 451 bnx2_disable_int_sync(struct bnx2 *bp)
 452 {
 453         int i;
 454
 455         atomic_inc(&bp->intr_sem);
 456         bnx2_disable_int(bp);
 457         for (i = 0; i < bp->irq_nvecs; i++)
 458                 synchronize_irq(bp->irq_tbl[i].vector);
 459 }
 460
 461 static void
 462 bnx2_napi_disable(struct bnx2 *bp)
 463 {
 464         int i;
 465
 466         for (i = 0; i < bp->irq_nvecs; i++)
 467                 napi_disable(&bp->bnx2_napi[i].napi);
 468 }
 469
 470 static void
 471 bnx2_napi_enable(struct bnx2 *bp)
 472 {
 473         int i;
 474
 475         for (i = 0; i < bp->irq_nvecs; i++)
 476                 napi_enable(&bp->bnx2_napi[i].napi);
 477 }
 478
 479 static void
 480 bnx2_netif_stop(struct bnx2 *bp)
 481 {
 482         bnx2_disable_int_sync(bp);
 483         if (netif_running(bp->dev)) {
 484                 bnx2_napi_disable(bp);
 485                 netif_tx_disable(bp->dev);
 486                 bp->dev->trans_start = jiffies; /* prevent tx timeout */
 487         }
 488 }
 489
 490 static void
 491 bnx2_netif_start(struct bnx2 *bp)
 492 {
 493         if (atomic_dec_and_test(&bp->intr_sem)) {
 494                 if (netif_running(bp->dev)) {
 495                         netif_tx_wake_all_queues(bp->dev);
 496                         bnx2_napi_enable(bp);
 497                         bnx2_enable_int(bp);
 498                 }
 499         }
 500 }
 501
 502 static void
 503 bnx2_free_tx_mem(struct bnx2 *bp)
 504 {
 505         int i;
 506
 507         for (i = 0; i < bp->num_tx_rings; i++) {
 508                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
 509                 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
 510
 511                 if (txr->tx_desc_ring) {
 512                         pci_free_consistent(bp->pdev, TXBD_RING_SIZE,
 513                                             txr->tx_desc_ring,
 514                                             txr->tx_desc_mapping);
 515                         txr->tx_desc_ring = NULL;
 516                 }
 517                 kfree(txr->tx_buf_ring);
 518                 txr->tx_buf_ring = NULL;
 519         }
 520 }
 521
 522 static void
 523 bnx2_free_rx_mem(struct bnx2 *bp)
 524 {
 525         int i;
 526
 527         for (i = 0; i < bp->num_rx_rings; i++) {
 528                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
 529                 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
 530                 int j;
 531
 532                 for (j = 0; j < bp->rx_max_ring; j++) {
 533                         if (rxr->rx_desc_ring[j])
 534                                 pci_free_consistent(bp->pdev, RXBD_RING_SIZE,
 535                                                     rxr->rx_desc_ring[j],
 536                                                     rxr->rx_desc_mapping[j]);
 537                         rxr->rx_desc_ring[j] = NULL;
 538                 }
 539                 if (rxr->rx_buf_ring)
 540                         vfree(rxr->rx_buf_ring);
 541                 rxr->rx_buf_ring = NULL;
 542
 543                 for (j = 0; j < bp->rx_max_pg_ring; j++) {
 544                         if (rxr->rx_pg_desc_ring[j])
 545                                 pci_free_consistent(bp->pdev, RXBD_RING_SIZE,
 546                                                     rxr->rx_pg_desc_ring[i],
 547                                                     rxr->rx_pg_desc_mapping[i]);
 548                         rxr->rx_pg_desc_ring[i] = NULL;
 549                 }
 550                 if (rxr->rx_pg_ring)
 551                         vfree(rxr->rx_pg_ring);
 552                 rxr->rx_pg_ring = NULL;
 553         }
 554 }
 555
 556 static int
 557 bnx2_alloc_tx_mem(struct bnx2 *bp)
 558 {
 559         int i;
 560
 561         for (i = 0; i < bp->num_tx_rings; i++) {
 562                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
 563                 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
 564
 565                 txr->tx_buf_ring = kzalloc(SW_TXBD_RING_SIZE, GFP_KERNEL);
 566                 if (txr->tx_buf_ring == NULL)
 567                         return -ENOMEM;
 568
 569                 txr->tx_desc_ring =
 570                         pci_alloc_consistent(bp->pdev, TXBD_RING_SIZE,
 571                                              &txr->tx_desc_mapping);
 572                 if (txr->tx_desc_ring == NULL)
 573                         return -ENOMEM;
 574         }
 575         return 0;
 576 }
 577
 578 static int
 579 bnx2_alloc_rx_mem(struct bnx2 *bp)
 580 {
 581         int i;
 582
 583         for (i = 0; i < bp->num_rx_rings; i++) {
 584                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
 585                 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
 586                 int j;
 587
 588                 rxr->rx_buf_ring =
 589                         vmalloc(SW_RXBD_RING_SIZE * bp->rx_max_ring);
 590                 if (rxr->rx_buf_ring == NULL)
 591                         return -ENOMEM;
 592
 593                 memset(rxr->rx_buf_ring, 0,
 594                        SW_RXBD_RING_SIZE * bp->rx_max_ring);
 595
 596                 for (j = 0; j < bp->rx_max_ring; j++) {
 597                         rxr->rx_desc_ring[j] =
 598                                 pci_alloc_consistent(bp->pdev, RXBD_RING_SIZE,
 599                                                      &rxr->rx_desc_mapping[j]);
 600                         if (rxr->rx_desc_ring[j] == NULL)
 601                                 return -ENOMEM;
 602
 603                 }
 604
 605                 if (bp->rx_pg_ring_size) {
 606                         rxr->rx_pg_ring = vmalloc(SW_RXPG_RING_SIZE *
 607                                                   bp->rx_max_pg_ring);
 608                         if (rxr->rx_pg_ring == NULL)
 609                                 return -ENOMEM;
 610
 611                         memset(rxr->rx_pg_ring, 0, SW_RXPG_RING_SIZE *
 612                                bp->rx_max_pg_ring);
 613                 }
 614
 615                 for (j = 0; j < bp->rx_max_pg_ring; j++) {
 616                         rxr->rx_pg_desc_ring[j] =
 617                                 pci_alloc_consistent(bp->pdev, RXBD_RING_SIZE,
 618                                                 &rxr->rx_pg_desc_mapping[j]);
 619                         if (rxr->rx_pg_desc_ring[j] == NULL)
 620                                 return -ENOMEM;
 621
 622                 }
 623         }
 624         return 0;
 625 }
 626
 627 static void
 628 bnx2_free_mem(struct bnx2 *bp)
 629 {
 630         int i;
 631         struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
 632
 633         bnx2_free_tx_mem(bp);
 634         bnx2_free_rx_mem(bp);
 635
 636         for (i = 0; i < bp->ctx_pages; i++) {
 637                 if (bp->ctx_blk[i]) {
 638                         pci_free_consistent(bp->pdev, BCM_PAGE_SIZE,
 639                                             bp->ctx_blk[i],
 640                                             bp->ctx_blk_mapping[i]);
 641                         bp->ctx_blk[i] = NULL;
 642                 }
 643         }
 644         if (bnapi->status_blk.msi) {
 645                 pci_free_consistent(bp->pdev, bp->status_stats_size,
 646                                     bnapi->status_blk.msi,
 647                                     bp->status_blk_mapping);
 648                 bnapi->status_blk.msi = NULL;
 649                 bp->stats_blk = NULL;
 650         }
 651 }
 652
 653 static int
 654 bnx2_alloc_mem(struct bnx2 *bp)
 655 {
 656         int i, status_blk_size, err;
 657         struct bnx2_napi *bnapi;
 658         void *status_blk;
 659
 660         /* Combine status and statistics blocks into one allocation. */
 661         status_blk_size = L1_CACHE_ALIGN(sizeof(struct status_block));
 662         if (bp->flags & BNX2_FLAG_MSIX_CAP)
 663                 status_blk_size = L1_CACHE_ALIGN(BNX2_MAX_MSIX_HW_VEC *
 664                                                  BNX2_SBLK_MSIX_ALIGN_SIZE);
 665         bp->status_stats_size = status_blk_size +
 666                                 sizeof(struct statistics_block);
 667
 668         status_blk = pci_alloc_consistent(bp->pdev, bp->status_stats_size,
 669                                           &bp->status_blk_mapping);
 670         if (status_blk == NULL)
 671                 goto alloc_mem_err;
 672
 673         memset(status_blk, 0, bp->status_stats_size);
 674
 675         bnapi = &bp->bnx2_napi[0];
 676         bnapi->status_blk.msi = status_blk;
 677         bnapi->hw_tx_cons_ptr =
 678                 &bnapi->status_blk.msi->status_tx_quick_consumer_index0;
 679         bnapi->hw_rx_cons_ptr =
 680                 &bnapi->status_blk.msi->status_rx_quick_consumer_index0;
 681         if (bp->flags & BNX2_FLAG_MSIX_CAP) {
 682                 for (i = 1; i < BNX2_MAX_MSIX_VEC; i++) {
 683                         struct status_block_msix *sblk;
 684
 685                         bnapi = &bp->bnx2_napi[i];
 686
 687                         sblk = (void *) (status_blk +
 688                                          BNX2_SBLK_MSIX_ALIGN_SIZE * i);
 689                         bnapi->status_blk.msix = sblk;
 690                         bnapi->hw_tx_cons_ptr =
 691                                 &sblk->status_tx_quick_consumer_index;
 692                         bnapi->hw_rx_cons_ptr =
 693                                 &sblk->status_rx_quick_consumer_index;
 694                         bnapi->int_num = i << 24;
 695                 }
 696         }
 697
 698         bp->stats_blk = status_blk + status_blk_size;
 699
 700         bp->stats_blk_mapping = bp->status_blk_mapping + status_blk_size;
 701
 702         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
 703                 bp->ctx_pages = 0x2000 / BCM_PAGE_SIZE;
 704                 if (bp->ctx_pages == 0)
 705                         bp->ctx_pages = 1;
 706                 for (i = 0; i < bp->ctx_pages; i++) {
 707                         bp->ctx_blk[i] = pci_alloc_consistent(bp->pdev,
 708                                                 BCM_PAGE_SIZE,
 709                                                 &bp->ctx_blk_mapping[i]);
 710                         if (bp->ctx_blk[i] == NULL)
 711                                 goto alloc_mem_err;
 712                 }
 713         }
 714
 715         err = bnx2_alloc_rx_mem(bp);
 716         if (err)
 717                 goto alloc_mem_err;
 718
 719         err = bnx2_alloc_tx_mem(bp);
 720         if (err)
 721                 goto alloc_mem_err;
 722
 723         return 0;
 724
 725 alloc_mem_err:
 726         bnx2_free_mem(bp);
 727         return -ENOMEM;
 728 }
 729
 730 static void
 731 bnx2_report_fw_link(struct bnx2 *bp)
 732 {
 733         u32 fw_link_status = 0;
 734
 735         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
 736                 return;
 737
 738         if (bp->link_up) {
 739                 u32 bmsr;
 740
 741                 switch (bp->line_speed) {
 742                 case SPEED_10:
 743                         if (bp->duplex == DUPLEX_HALF)
 744                                 fw_link_status = BNX2_LINK_STATUS_10HALF;
 745                         else
 746                                 fw_link_status = BNX2_LINK_STATUS_10FULL;
 747                         break;
 748                 case SPEED_100:
 749                         if (bp->duplex == DUPLEX_HALF)
 750                                 fw_link_status = BNX2_LINK_STATUS_100HALF;
 751                         else
 752                                 fw_link_status = BNX2_LINK_STATUS_100FULL;
 753                         break;
 754                 case SPEED_1000:
 755                         if (bp->duplex == DUPLEX_HALF)
 756                                 fw_link_status = BNX2_LINK_STATUS_1000HALF;
 757                         else
 758                                 fw_link_status = BNX2_LINK_STATUS_1000FULL;
 759                         break;
 760                 case SPEED_2500:
 761                         if (bp->duplex == DUPLEX_HALF)
 762                                 fw_link_status = BNX2_LINK_STATUS_2500HALF;
 763                         else
 764                                 fw_link_status = BNX2_LINK_STATUS_2500FULL;
 765                         break;
 766                 }
 767
 768                 fw_link_status |= BNX2_LINK_STATUS_LINK_UP;
 769
 770                 if (bp->autoneg) {
 771                         fw_link_status |= BNX2_LINK_STATUS_AN_ENABLED;
 772
 773                         bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
 774                         bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
 775
 776                         if (!(bmsr & BMSR_ANEGCOMPLETE) ||
 777                             bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT)
 778                                 fw_link_status |= BNX2_LINK_STATUS_PARALLEL_DET;
 779                         else
 780                                 fw_link_status |= BNX2_LINK_STATUS_AN_COMPLETE;
 781                 }
 782         }
 783         else
 784                 fw_link_status = BNX2_LINK_STATUS_LINK_DOWN;
 785
 786         bnx2_shmem_wr(bp, BNX2_LINK_STATUS, fw_link_status);
 787 }
 788
 789 static char *
 790 bnx2_xceiver_str(struct bnx2 *bp)
 791 {
 792         return ((bp->phy_port == PORT_FIBRE) ? "SerDes" :
 793                 ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) ? "Remote Copper" :
 794                  "Copper"));
 795 }
 796
 797 static void
 798 bnx2_report_link(struct bnx2 *bp)
 799 {
 800         if (bp->link_up) {
 801                 netif_carrier_on(bp->dev);
 802                 printk(KERN_INFO PFX "%s NIC %s Link is Up, ", bp->dev->name,
 803                        bnx2_xceiver_str(bp));
 804
 805                 printk("%d Mbps ", bp->line_speed);
 806
 807                 if (bp->duplex == DUPLEX_FULL)
 808                         printk("full duplex");
 809                 else
 810                         printk("half duplex");
 811
 812                 if (bp->flow_ctrl) {
 813                         if (bp->flow_ctrl & FLOW_CTRL_RX) {
 814                                 printk(", receive ");
 815                                 if (bp->flow_ctrl & FLOW_CTRL_TX)
 816                                         printk("& transmit ");
 817                         }
 818                         else {
 819                                 printk(", transmit ");
 820                         }
 821                         printk("flow control ON");
 822                 }
 823                 printk("\n");
 824         }
 825         else {
 826                 netif_carrier_off(bp->dev);
 827                 printk(KERN_ERR PFX "%s NIC %s Link is Down\n", bp->dev->name,
 828                        bnx2_xceiver_str(bp));
 829         }
 830
 831         bnx2_report_fw_link(bp);
 832 }
 833
 834 static void
 835 bnx2_resolve_flow_ctrl(struct bnx2 *bp)
 836 {
 837         u32 local_adv, remote_adv;
 838
 839         bp->flow_ctrl = 0;
 840         if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
 841                 (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) {
 842
 843                 if (bp->duplex == DUPLEX_FULL) {
 844                         bp->flow_ctrl = bp->req_flow_ctrl;
 845                 }
 846                 return;
 847         }
 848
 849         if (bp->duplex != DUPLEX_FULL) {
 850                 return;
 851         }
 852
 853         if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
 854             (CHIP_NUM(bp) == CHIP_NUM_5708)) {
 855                 u32 val;
 856
 857                 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
 858                 if (val & BCM5708S_1000X_STAT1_TX_PAUSE)
 859                         bp->flow_ctrl |= FLOW_CTRL_TX;
 860                 if (val & BCM5708S_1000X_STAT1_RX_PAUSE)
 861                         bp->flow_ctrl |= FLOW_CTRL_RX;
 862                 return;
 863         }
 864
 865         bnx2_read_phy(bp, bp->mii_adv, &local_adv);
 866         bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
 867
 868         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
 869                 u32 new_local_adv = 0;
 870                 u32 new_remote_adv = 0;
 871
 872                 if (local_adv & ADVERTISE_1000XPAUSE)
 873                         new_local_adv |= ADVERTISE_PAUSE_CAP;
 874                 if (local_adv & ADVERTISE_1000XPSE_ASYM)
 875                         new_local_adv |= ADVERTISE_PAUSE_ASYM;
 876                 if (remote_adv & ADVERTISE_1000XPAUSE)
 877                         new_remote_adv |= ADVERTISE_PAUSE_CAP;
 878                 if (remote_adv & ADVERTISE_1000XPSE_ASYM)
 879                         new_remote_adv |= ADVERTISE_PAUSE_ASYM;
 880
 881                 local_adv = new_local_adv;
 882                 remote_adv = new_remote_adv;
 883         }
 884
 885         /* See Table 28B-3 of 802.3ab-1999 spec. */
 886         if (local_adv & ADVERTISE_PAUSE_CAP) {
 887                 if(local_adv & ADVERTISE_PAUSE_ASYM) {
 888                         if (remote_adv & ADVERTISE_PAUSE_CAP) {
 889                                 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
 890                         }
 891                         else if (remote_adv & ADVERTISE_PAUSE_ASYM) {
 892                                 bp->flow_ctrl = FLOW_CTRL_RX;
 893                         }
 894                 }
 895                 else {
 896                         if (remote_adv & ADVERTISE_PAUSE_CAP) {
 897                                 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
 898                         }
 899                 }
 900         }
 901         else if (local_adv & ADVERTISE_PAUSE_ASYM) {
 902                 if ((remote_adv & ADVERTISE_PAUSE_CAP) &&
 903                         (remote_adv & ADVERTISE_PAUSE_ASYM)) {
 904
 905                         bp->flow_ctrl = FLOW_CTRL_TX;
 906                 }
 907         }
 908 }
 909
 910 static int
 911 bnx2_5709s_linkup(struct bnx2 *bp)
 912 {
 913         u32 val, speed;
 914
 915         bp->link_up = 1;
 916
 917         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_GP_STATUS);
 918         bnx2_read_phy(bp, MII_BNX2_GP_TOP_AN_STATUS1, &val);
 919         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
 920
 921         if ((bp->autoneg & AUTONEG_SPEED) == 0) {
 922                 bp->line_speed = bp->req_line_speed;
 923                 bp->duplex = bp->req_duplex;
 924                 return 0;
 925         }
 926         speed = val & MII_BNX2_GP_TOP_AN_SPEED_MSK;
 927         switch (speed) {
 928                 case MII_BNX2_GP_TOP_AN_SPEED_10:
 929                         bp->line_speed = SPEED_10;
 930                         break;
 931                 case MII_BNX2_GP_TOP_AN_SPEED_100:
 932                         bp->line_speed = SPEED_100;
 933                         break;
 934                 case MII_BNX2_GP_TOP_AN_SPEED_1G:
 935                 case MII_BNX2_GP_TOP_AN_SPEED_1GKV:
 936                         bp->line_speed = SPEED_1000;
 937                         break;
 938                 case MII_BNX2_GP_TOP_AN_SPEED_2_5G:
 939                         bp->line_speed = SPEED_2500;
 940                         break;
 941         }
 942         if (val & MII_BNX2_GP_TOP_AN_FD)
 943                 bp->duplex = DUPLEX_FULL;
 944         else
 945                 bp->duplex = DUPLEX_HALF;
 946         return 0;
 947 }
 948
 949 static int
 950 bnx2_5708s_linkup(struct bnx2 *bp)
 951 {
 952         u32 val;
 953
 954         bp->link_up = 1;
 955         bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
 956         switch (val & BCM5708S_1000X_STAT1_SPEED_MASK) {
 957                 case BCM5708S_1000X_STAT1_SPEED_10:
 958                         bp->line_speed = SPEED_10;
 959                         break;
 960                 case BCM5708S_1000X_STAT1_SPEED_100:
 961                         bp->line_speed = SPEED_100;
 962                         break;
 963                 case BCM5708S_1000X_STAT1_SPEED_1G:
 964                         bp->line_speed = SPEED_1000;
 965                         break;
 966                 case BCM5708S_1000X_STAT1_SPEED_2G5:
 967                         bp->line_speed = SPEED_2500;
 968                         break;
 969         }
 970         if (val & BCM5708S_1000X_STAT1_FD)
 971                 bp->duplex = DUPLEX_FULL;
 972         else
 973                 bp->duplex = DUPLEX_HALF;
 974
 975         return 0;
 976 }
 977
 978 static int
 979 bnx2_5706s_linkup(struct bnx2 *bp)
 980 {
 981         u32 bmcr, local_adv, remote_adv, common;
 982
 983         bp->link_up = 1;
 984         bp->line_speed = SPEED_1000;
 985
 986         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
 987         if (bmcr & BMCR_FULLDPLX) {
 988                 bp->duplex = DUPLEX_FULL;
 989         }
 990         else {
 991                 bp->duplex = DUPLEX_HALF;
 992         }
 993
 994         if (!(bmcr & BMCR_ANENABLE)) {
 995                 return 0;
 996         }
 997
 998         bnx2_read_phy(bp, bp->mii_adv, &local_adv);
 999         bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
1000
1001         common = local_adv & remote_adv;
1002         if (common & (ADVERTISE_1000XHALF | ADVERTISE_1000XFULL)) {
1003
1004                 if (common & ADVERTISE_1000XFULL) {
1005                         bp->duplex = DUPLEX_FULL;
1006                 }
1007                 else {
1008                         bp->duplex = DUPLEX_HALF;
1009                 }
1010         }
1011
1012         return 0;
1013 }
1014
1015 static int
1016 bnx2_copper_linkup(struct bnx2 *bp)
1017 {
1018         u32 bmcr;
1019
1020         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1021         if (bmcr & BMCR_ANENABLE) {
1022                 u32 local_adv, remote_adv, common;
1023
1024                 bnx2_read_phy(bp, MII_CTRL1000, &local_adv);
1025                 bnx2_read_phy(bp, MII_STAT1000, &remote_adv);
1026
1027                 common = local_adv & (remote_adv >> 2);
1028                 if (common & ADVERTISE_1000FULL) {
1029                         bp->line_speed = SPEED_1000;
1030                         bp->duplex = DUPLEX_FULL;
1031                 }
1032                 else if (common & ADVERTISE_1000HALF) {
1033                         bp->line_speed = SPEED_1000;
1034                         bp->duplex = DUPLEX_HALF;
1035                 }
1036                 else {
1037                         bnx2_read_phy(bp, bp->mii_adv, &local_adv);
1038                         bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
1039
1040                         common = local_adv & remote_adv;
1041                         if (common & ADVERTISE_100FULL) {
1042                                 bp->line_speed = SPEED_100;
1043                                 bp->duplex = DUPLEX_FULL;
1044                         }
1045                         else if (common & ADVERTISE_100HALF) {
1046                                 bp->line_speed = SPEED_100;
1047                                 bp->duplex = DUPLEX_HALF;
1048                         }
1049                         else if (common & ADVERTISE_10FULL) {
1050                                 bp->line_speed = SPEED_10;
1051                                 bp->duplex = DUPLEX_FULL;
1052                         }
1053                         else if (common & ADVERTISE_10HALF) {
1054                                 bp->line_speed = SPEED_10;
1055                                 bp->duplex = DUPLEX_HALF;
1056                         }
1057                         else {
1058                                 bp->line_speed = 0;
1059                                 bp->link_up = 0;
1060                         }
1061                 }
1062         }
1063         else {
1064                 if (bmcr & BMCR_SPEED100) {
1065                         bp->line_speed = SPEED_100;
1066                 }
1067                 else {
1068                         bp->line_speed = SPEED_10;
1069                 }
1070                 if (bmcr & BMCR_FULLDPLX) {
1071                         bp->duplex = DUPLEX_FULL;
1072                 }
1073                 else {
1074                         bp->duplex = DUPLEX_HALF;
1075                 }
1076         }
1077
1078         return 0;
1079 }
1080
1081 static void
1082 bnx2_init_rx_context(struct bnx2 *bp, u32 cid)
1083 {
1084         u32 val, rx_cid_addr = GET_CID_ADDR(cid);
1085
1086         val = BNX2_L2CTX_CTX_TYPE_CTX_BD_CHN_TYPE_VALUE;
1087         val |= BNX2_L2CTX_CTX_TYPE_SIZE_L2;
1088         val |= 0x02 << 8;
1089
1090         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1091                 u32 lo_water, hi_water;
1092
1093                 if (bp->flow_ctrl & FLOW_CTRL_TX)
1094                         lo_water = BNX2_L2CTX_LO_WATER_MARK_DEFAULT;
1095                 else
1096                         lo_water = BNX2_L2CTX_LO_WATER_MARK_DIS;
1097                 if (lo_water >= bp->rx_ring_size)
1098                         lo_water = 0;
1099
1100                 hi_water = bp->rx_ring_size / 4;
1101
1102                 if (hi_water <= lo_water)
1103                         lo_water = 0;
1104
1105                 hi_water /= BNX2_L2CTX_HI_WATER_MARK_SCALE;
1106                 lo_water /= BNX2_L2CTX_LO_WATER_MARK_SCALE;
1107
1108                 if (hi_water > 0xf)
1109                         hi_water = 0xf;
1110                 else if (hi_water == 0)
1111                         lo_water = 0;
1112                 val |= lo_water | (hi_water << BNX2_L2CTX_HI_WATER_MARK_SHIFT);
1113         }
1114         bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_CTX_TYPE, val);
1115 }
1116
1117 static void
1118 bnx2_init_all_rx_contexts(struct bnx2 *bp)
1119 {
1120         int i;
1121         u32 cid;
1122
1123         for (i = 0, cid = RX_CID; i < bp->num_rx_rings; i++, cid++) {
1124                 if (i == 1)
1125                         cid = RX_RSS_CID;
1126                 bnx2_init_rx_context(bp, cid);
1127         }
1128 }
1129
1130 static int
1131 bnx2_set_mac_link(struct bnx2 *bp)
1132 {
1133         u32 val;
1134
1135         REG_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x2620);
1136         if (bp->link_up && (bp->line_speed == SPEED_1000) &&
1137                 (bp->duplex == DUPLEX_HALF)) {
1138                 REG_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x26ff);
1139         }
1140
1141         /* Configure the EMAC mode register. */
1142         val = REG_RD(bp, BNX2_EMAC_MODE);
1143
1144         val &= ~(BNX2_EMAC_MODE_PORT | BNX2_EMAC_MODE_HALF_DUPLEX |
1145                 BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK |
1146                 BNX2_EMAC_MODE_25G_MODE);
1147
1148         if (bp->link_up) {
1149                 switch (bp->line_speed) {
1150                         case SPEED_10:
1151                                 if (CHIP_NUM(bp) != CHIP_NUM_5706) {
1152                                         val |= BNX2_EMAC_MODE_PORT_MII_10M;
1153                                         break;
1154                                 }
1155                                 /* fall through */
1156                         case SPEED_100:
1157                                 val |= BNX2_EMAC_MODE_PORT_MII;
1158                                 break;
1159                         case SPEED_2500:
1160                                 val |= BNX2_EMAC_MODE_25G_MODE;
1161                                 /* fall through */
1162                         case SPEED_1000:
1163                                 val |= BNX2_EMAC_MODE_PORT_GMII;
1164                                 break;
1165                 }
1166         }
1167         else {
1168                 val |= BNX2_EMAC_MODE_PORT_GMII;
1169         }
1170
1171         /* Set the MAC to operate in the appropriate duplex mode. */
1172         if (bp->duplex == DUPLEX_HALF)
1173                 val |= BNX2_EMAC_MODE_HALF_DUPLEX;
1174         REG_WR(bp, BNX2_EMAC_MODE, val);
1175
1176         /* Enable/disable rx PAUSE. */
1177         bp->rx_mode &= ~BNX2_EMAC_RX_MODE_FLOW_EN;
1178
1179         if (bp->flow_ctrl & FLOW_CTRL_RX)
1180                 bp->rx_mode |= BNX2_EMAC_RX_MODE_FLOW_EN;
1181         REG_WR(bp, BNX2_EMAC_RX_MODE, bp->rx_mode);
1182
1183         /* Enable/disable tx PAUSE. */
1184         val = REG_RD(bp, BNX2_EMAC_TX_MODE);
1185         val &= ~BNX2_EMAC_TX_MODE_FLOW_EN;
1186
1187         if (bp->flow_ctrl & FLOW_CTRL_TX)
1188                 val |= BNX2_EMAC_TX_MODE_FLOW_EN;
1189         REG_WR(bp, BNX2_EMAC_TX_MODE, val);
1190
1191         /* Acknowledge the interrupt. */
1192         REG_WR(bp, BNX2_EMAC_STATUS, BNX2_EMAC_STATUS_LINK_CHANGE);
1193
1194         if (CHIP_NUM(bp) == CHIP_NUM_5709)
1195                 bnx2_init_all_rx_contexts(bp);
1196
1197         return 0;
1198 }
1199
1200 static void
1201 bnx2_enable_bmsr1(struct bnx2 *bp)
1202 {
1203         if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1204             (CHIP_NUM(bp) == CHIP_NUM_5709))
1205                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1206                                MII_BNX2_BLK_ADDR_GP_STATUS);
1207 }
1208
1209 static void
1210 bnx2_disable_bmsr1(struct bnx2 *bp)
1211 {
1212         if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1213             (CHIP_NUM(bp) == CHIP_NUM_5709))
1214                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1215                                MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1216 }
1217
1218 static int
1219 bnx2_test_and_enable_2g5(struct bnx2 *bp)
1220 {
1221         u32 up1;
1222         int ret = 1;
1223
1224         if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1225                 return 0;
1226
1227         if (bp->autoneg & AUTONEG_SPEED)
1228                 bp->advertising |= ADVERTISED_2500baseX_Full;
1229
1230         if (CHIP_NUM(bp) == CHIP_NUM_5709)
1231                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1232
1233         bnx2_read_phy(bp, bp->mii_up1, &up1);
1234         if (!(up1 & BCM5708S_UP1_2G5)) {
1235                 up1 |= BCM5708S_UP1_2G5;
1236                 bnx2_write_phy(bp, bp->mii_up1, up1);
1237                 ret = 0;
1238         }
1239
1240         if (CHIP_NUM(bp) == CHIP_NUM_5709)
1241                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1242                                MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1243
1244         return ret;
1245 }
1246
1247 static int
1248 bnx2_test_and_disable_2g5(struct bnx2 *bp)
1249 {
1250         u32 up1;
1251         int ret = 0;
1252
1253         if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1254                 return 0;
1255
1256         if (CHIP_NUM(bp) == CHIP_NUM_5709)
1257                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1258
1259         bnx2_read_phy(bp, bp->mii_up1, &up1);
1260         if (up1 & BCM5708S_UP1_2G5) {
1261                 up1 &= ~BCM5708S_UP1_2G5;
1262                 bnx2_write_phy(bp, bp->mii_up1, up1);
1263                 ret = 1;
1264         }
1265
1266         if (CHIP_NUM(bp) == CHIP_NUM_5709)
1267                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1268                                MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1269
1270         return ret;
1271 }
1272
1273 static void
1274 bnx2_enable_forced_2g5(struct bnx2 *bp)
1275 {
1276         u32 bmcr;
1277
1278         if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1279                 return;
1280
1281         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1282                 u32 val;
1283
1284                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1285                                MII_BNX2_BLK_ADDR_SERDES_DIG);
1286                 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val);
1287                 val &= ~MII_BNX2_SD_MISC1_FORCE_MSK;
1288                 val |= MII_BNX2_SD_MISC1_FORCE | MII_BNX2_SD_MISC1_FORCE_2_5G;
1289                 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1290
1291                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1292                                MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1293                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1294
1295         } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
1296                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1297                 bmcr |= BCM5708S_BMCR_FORCE_2500;
1298         }
1299
1300         if (bp->autoneg & AUTONEG_SPEED) {
1301                 bmcr &= ~BMCR_ANENABLE;
1302                 if (bp->req_duplex == DUPLEX_FULL)
1303                         bmcr |= BMCR_FULLDPLX;
1304         }
1305         bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1306 }
1307
1308 static void
1309 bnx2_disable_forced_2g5(struct bnx2 *bp)
1310 {
1311         u32 bmcr;
1312
1313         if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1314                 return;
1315
1316         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1317                 u32 val;
1318
1319                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1320                                MII_BNX2_BLK_ADDR_SERDES_DIG);
1321                 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val);
1322                 val &= ~MII_BNX2_SD_MISC1_FORCE;
1323                 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1324
1325                 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1326                                MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1327                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1328
1329         } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
1330                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1331                 bmcr &= ~BCM5708S_BMCR_FORCE_2500;
1332         }
1333
1334         if (bp->autoneg & AUTONEG_SPEED)
1335                 bmcr |= BMCR_SPEED1000 | BMCR_ANENABLE | BMCR_ANRESTART;
1336         bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1337 }
1338
1339 static void
1340 bnx2_5706s_force_link_dn(struct bnx2 *bp, int start)
1341 {
1342         u32 val;
1343
1344         bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS, MII_EXPAND_SERDES_CTL);
1345         bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
1346         if (start)
1347                 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val & 0xff0f);
1348         else
1349                 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val | 0xc0);
1350 }
1351
1352 static int
1353 bnx2_set_link(struct bnx2 *bp)
1354 {
1355         u32 bmsr;
1356         u8 link_up;
1357
1358         if (bp->loopback == MAC_LOOPBACK || bp->loopback == PHY_LOOPBACK) {
1359                 bp->link_up = 1;
1360                 return 0;
1361         }
1362
1363         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
1364                 return 0;
1365
1366         link_up = bp->link_up;
1367
1368         bnx2_enable_bmsr1(bp);
1369         bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1370         bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1371         bnx2_disable_bmsr1(bp);
1372
1373         if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1374             (CHIP_NUM(bp) == CHIP_NUM_5706)) {
1375                 u32 val, an_dbg;
1376
1377                 if (bp->phy_flags & BNX2_PHY_FLAG_FORCED_DOWN) {
1378                         bnx2_5706s_force_link_dn(bp, 0);
1379                         bp->phy_flags &= ~BNX2_PHY_FLAG_FORCED_DOWN;
1380                 }
1381                 val = REG_RD(bp, BNX2_EMAC_STATUS);
1382
1383                 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
1384                 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
1385                 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
1386
1387                 if ((val & BNX2_EMAC_STATUS_LINK) &&
1388                     !(an_dbg & MISC_SHDW_AN_DBG_NOSYNC))
1389                         bmsr |= BMSR_LSTATUS;
1390                 else
1391                         bmsr &= ~BMSR_LSTATUS;
1392         }
1393
1394         if (bmsr & BMSR_LSTATUS) {
1395                 bp->link_up = 1;
1396
1397                 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1398                         if (CHIP_NUM(bp) == CHIP_NUM_5706)
1399                                 bnx2_5706s_linkup(bp);
1400                         else if (CHIP_NUM(bp) == CHIP_NUM_5708)
1401                                 bnx2_5708s_linkup(bp);
1402                         else if (CHIP_NUM(bp) == CHIP_NUM_5709)
1403                                 bnx2_5709s_linkup(bp);
1404                 }
1405                 else {
1406                         bnx2_copper_linkup(bp);
1407                 }
1408                 bnx2_resolve_flow_ctrl(bp);
1409         }
1410         else {
1411                 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1412                     (bp->autoneg & AUTONEG_SPEED))
1413                         bnx2_disable_forced_2g5(bp);
1414
1415                 if (bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT) {
1416                         u32 bmcr;
1417
1418                         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1419                         bmcr |= BMCR_ANENABLE;
1420                         bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1421
1422                         bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
1423                 }
1424                 bp->link_up = 0;
1425         }
1426
1427         if (bp->link_up != link_up) {
1428                 bnx2_report_link(bp);
1429         }
1430
1431         bnx2_set_mac_link(bp);
1432
1433         return 0;
1434 }
1435
1436 static int
1437 bnx2_reset_phy(struct bnx2 *bp)
1438 {
1439         int i;
1440         u32 reg;
1441
1442         bnx2_write_phy(bp, bp->mii_bmcr, BMCR_RESET);
1443
1444 #define PHY_RESET_MAX_WAIT 100
1445         for (i = 0; i < PHY_RESET_MAX_WAIT; i++) {
1446                 udelay(10);
1447
1448                 bnx2_read_phy(bp, bp->mii_bmcr, &reg);
1449                 if (!(reg & BMCR_RESET)) {
1450                         udelay(20);
1451                         break;
1452                 }
1453         }
1454         if (i == PHY_RESET_MAX_WAIT) {
1455                 return -EBUSY;
1456         }
1457         return 0;
1458 }
1459
1460 static u32
1461 bnx2_phy_get_pause_adv(struct bnx2 *bp)
1462 {
1463         u32 adv = 0;
1464
1465         if ((bp->req_flow_ctrl & (FLOW_CTRL_RX | FLOW_CTRL_TX)) ==
1466                 (FLOW_CTRL_RX | FLOW_CTRL_TX)) {
1467
1468                 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1469                         adv = ADVERTISE_1000XPAUSE;
1470                 }
1471                 else {
1472                         adv = ADVERTISE_PAUSE_CAP;
1473                 }
1474         }
1475         else if (bp->req_flow_ctrl & FLOW_CTRL_TX) {
1476                 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1477                         adv = ADVERTISE_1000XPSE_ASYM;
1478                 }
1479                 else {
1480                         adv = ADVERTISE_PAUSE_ASYM;
1481                 }
1482         }
1483         else if (bp->req_flow_ctrl & FLOW_CTRL_RX) {
1484                 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1485                         adv = ADVERTISE_1000XPAUSE | ADVERTISE_1000XPSE_ASYM;
1486                 }
1487                 else {
1488                         adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
1489                 }
1490         }
1491         return adv;
1492 }
1493
1494 static int bnx2_fw_sync(struct bnx2 *, u32, int, int);
1495
1496 static int
1497 bnx2_setup_remote_phy(struct bnx2 *bp, u8 port)
1498 {
1499         u32 speed_arg = 0, pause_adv;
1500
1501         pause_adv = bnx2_phy_get_pause_adv(bp);
1502
1503         if (bp->autoneg & AUTONEG_SPEED) {
1504                 speed_arg |= BNX2_NETLINK_SET_LINK_ENABLE_AUTONEG;
1505                 if (bp->advertising & ADVERTISED_10baseT_Half)
1506                         speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_10HALF;
1507                 if (bp->advertising & ADVERTISED_10baseT_Full)
1508                         speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_10FULL;
1509                 if (bp->advertising & ADVERTISED_100baseT_Half)
1510                         speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_100HALF;
1511                 if (bp->advertising & ADVERTISED_100baseT_Full)
1512                         speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_100FULL;
1513                 if (bp->advertising & ADVERTISED_1000baseT_Full)
1514                         speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_1GFULL;
1515                 if (bp->advertising & ADVERTISED_2500baseX_Full)
1516                         speed_arg |= BNX2_NETLINK_SET_LINK_SPEED_2G5FULL;
1517         } else {
1518                 if (bp->req_line_speed == SPEED_2500)
1519                         speed_arg = BNX2_NETLINK_SET_LINK_SPEED_2G5FULL;
1520                 else if (bp->req_line_speed == SPEED_1000)
1521                         speed_arg = BNX2_NETLINK_SET_LINK_SPEED_1GFULL;
1522                 else if (bp->req_line_speed == SPEED_100) {
1523                         if (bp->req_duplex == DUPLEX_FULL)
1524                                 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_100FULL;
1525                         else
1526                                 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_100HALF;
1527                 } else if (bp->req_line_speed == SPEED_10) {
1528                         if (bp->req_duplex == DUPLEX_FULL)
1529                                 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_10FULL;
1530                         else
1531                                 speed_arg = BNX2_NETLINK_SET_LINK_SPEED_10HALF;
1532                 }
1533         }
1534
1535         if (pause_adv & (ADVERTISE_1000XPAUSE | ADVERTISE_PAUSE_CAP))
1536                 speed_arg |= BNX2_NETLINK_SET_LINK_FC_SYM_PAUSE;
1537         if (pause_adv & (ADVERTISE_1000XPSE_ASYM | ADVERTISE_PAUSE_ASYM))
1538                 speed_arg |= BNX2_NETLINK_SET_LINK_FC_ASYM_PAUSE;
1539
1540         if (port == PORT_TP)
1541                 speed_arg |= BNX2_NETLINK_SET_LINK_PHY_APP_REMOTE |
1542                              BNX2_NETLINK_SET_LINK_ETH_AT_WIRESPEED;
1543
1544         bnx2_shmem_wr(bp, BNX2_DRV_MB_ARG0, speed_arg);
1545
1546         spin_unlock_bh(&bp->phy_lock);
1547         bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_CMD_SET_LINK, 1, 0);
1548         spin_lock_bh(&bp->phy_lock);
1549
1550         return 0;
1551 }
1552
1553 static int
1554 bnx2_setup_serdes_phy(struct bnx2 *bp, u8 port)
1555 {
1556         u32 adv, bmcr;
1557         u32 new_adv = 0;
1558
1559         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
1560                 return (bnx2_setup_remote_phy(bp, port));
1561
1562         if (!(bp->autoneg & AUTONEG_SPEED)) {
1563                 u32 new_bmcr;
1564                 int force_link_down = 0;
1565
1566                 if (bp->req_line_speed == SPEED_2500) {
1567                         if (!bnx2_test_and_enable_2g5(bp))
1568                                 force_link_down = 1;
1569                 } else if (bp->req_line_speed == SPEED_1000) {
1570                         if (bnx2_test_and_disable_2g5(bp))
1571                                 force_link_down = 1;
1572                 }
1573                 bnx2_read_phy(bp, bp->mii_adv, &adv);
1574                 adv &= ~(ADVERTISE_1000XFULL | ADVERTISE_1000XHALF);
1575
1576                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1577                 new_bmcr = bmcr & ~BMCR_ANENABLE;
1578                 new_bmcr |= BMCR_SPEED1000;
1579
1580                 if (CHIP_NUM(bp) == CHIP_NUM_5709) {
1581                         if (bp->req_line_speed == SPEED_2500)
1582                                 bnx2_enable_forced_2g5(bp);
1583                         else if (bp->req_line_speed == SPEED_1000) {
1584                                 bnx2_disable_forced_2g5(bp);
1585                                 new_bmcr &= ~0x2000;
1586                         }
1587
1588                 } else if (CHIP_NUM(bp) == CHIP_NUM_5708) {
1589                         if (bp->req_line_speed == SPEED_2500)
1590                                 new_bmcr |= BCM5708S_BMCR_FORCE_2500;
1591                         else
1592                                 new_bmcr = bmcr & ~BCM5708S_BMCR_FORCE_2500;
1593                 }
1594
1595                 if (bp->req_duplex == DUPLEX_FULL) {
1596                         adv |= ADVERTISE_1000XFULL;
1597                         new_bmcr |= BMCR_FULLDPLX;
1598                 }
1599                 else {
1600                         adv |= ADVERTISE_1000XHALF;
1601                         new_bmcr &= ~BMCR_FULLDPLX;
1602                 }
1603                 if ((new_bmcr != bmcr) || (force_link_down)) {
1604                         /* Force a link down visible on the other side */
1605                         if (bp->link_up) {
1606                                 bnx2_write_phy(bp, bp->mii_adv, adv &
1607                                                ~(ADVERTISE_1000XFULL |
1608                                                  ADVERTISE_1000XHALF));
1609                                 bnx2_write_phy(bp, bp->mii_bmcr, bmcr |
1610                                         BMCR_ANRESTART | BMCR_ANENABLE);
1611
1612                                 bp->link_up = 0;
1613                                 netif_carrier_off(bp->dev);
1614                                 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
1615                                 bnx2_report_link(bp);
1616                         }
1617                         bnx2_write_phy(bp, bp->mii_adv, adv);
1618                         bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
1619                 } else {
1620                         bnx2_resolve_flow_ctrl(bp);
1621                         bnx2_set_mac_link(bp);
1622                 }
1623                 return 0;
1624         }
1625
1626         bnx2_test_and_enable_2g5(bp);
1627
1628         if (bp->advertising & ADVERTISED_1000baseT_Full)
1629                 new_adv |= ADVERTISE_1000XFULL;
1630
1631         new_adv |= bnx2_phy_get_pause_adv(bp);
1632
1633         bnx2_read_phy(bp, bp->mii_adv, &adv);
1634         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1635
1636         bp->serdes_an_pending = 0;
1637         if ((adv != new_adv) || ((bmcr & BMCR_ANENABLE) == 0)) {
1638                 /* Force a link down visible on the other side */
1639                 if (bp->link_up) {
1640                         bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
1641                         spin_unlock_bh(&bp->phy_lock);
1642                         msleep(20);
1643                         spin_lock_bh(&bp->phy_lock);
1644                 }
1645
1646                 bnx2_write_phy(bp, bp->mii_adv, new_adv);
1647                 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART |
1648                         BMCR_ANENABLE);
1649                 /* Speed up link-up time when the link partner
1650                  * does not autonegotiate which is very common
1651                  * in blade servers. Some blade servers use
1652                  * IPMI for kerboard input and it's important
1653                  * to minimize link disruptions. Autoneg. involves
1654                  * exchanging base pages plus 3 next pages and
1655                  * normally completes in about 120 msec.
1656                  */
1657                 bp->current_interval = SERDES_AN_TIMEOUT;
1658                 bp->serdes_an_pending = 1;
1659                 mod_timer(&bp->timer, jiffies + bp->current_interval);
1660         } else {
1661                 bnx2_resolve_flow_ctrl(bp);
1662                 bnx2_set_mac_link(bp);
1663         }
1664
1665         return 0;
1666 }
1667
1668 #define ETHTOOL_ALL_FIBRE_SPEED                                         \
1669         (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) ?                  \
1670                 (ADVERTISED_2500baseX_Full | ADVERTISED_1000baseT_Full) :\
1671                 (ADVERTISED_1000baseT_Full)
1672
1673 #define ETHTOOL_ALL_COPPER_SPEED                                        \
1674         (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |            \
1675         ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |           \
1676         ADVERTISED_1000baseT_Full)
1677
1678 #define PHY_ALL_10_100_SPEED (ADVERTISE_10HALF | ADVERTISE_10FULL | \
1679         ADVERTISE_100HALF | ADVERTISE_100FULL | ADVERTISE_CSMA)
1680
1681 #define PHY_ALL_1000_SPEED (ADVERTISE_1000HALF | ADVERTISE_1000FULL)
1682
1683 static void
1684 bnx2_set_default_remote_link(struct bnx2 *bp)
1685 {
1686         u32 link;
1687
1688         if (bp->phy_port == PORT_TP)
1689                 link = bnx2_shmem_rd(bp, BNX2_RPHY_COPPER_LINK);
1690         else
1691                 link = bnx2_shmem_rd(bp, BNX2_RPHY_SERDES_LINK);
1692
1693         if (link & BNX2_NETLINK_SET_LINK_ENABLE_AUTONEG) {
1694                 bp->req_line_speed = 0;
1695                 bp->autoneg |= AUTONEG_SPEED;
1696                 bp->advertising = ADVERTISED_Autoneg;
1697                 if (link & BNX2_NETLINK_SET_LINK_SPEED_10HALF)
1698                         bp->advertising |= ADVERTISED_10baseT_Half;
1699                 if (link & BNX2_NETLINK_SET_LINK_SPEED_10FULL)
1700                         bp->advertising |= ADVERTISED_10baseT_Full;
1701                 if (link & BNX2_NETLINK_SET_LINK_SPEED_100HALF)
1702                         bp->advertising |= ADVERTISED_100baseT_Half;
1703                 if (link & BNX2_NETLINK_SET_LINK_SPEED_100FULL)
1704                         bp->advertising |= ADVERTISED_100baseT_Full;
1705                 if (link & BNX2_NETLINK_SET_LINK_SPEED_1GFULL)
1706                         bp->advertising |= ADVERTISED_1000baseT_Full;
1707                 if (link & BNX2_NETLINK_SET_LINK_SPEED_2G5FULL)
1708                         bp->advertising |= ADVERTISED_2500baseX_Full;
1709         } else {
1710                 bp->autoneg = 0;
1711                 bp->advertising = 0;
1712                 bp->req_duplex = DUPLEX_FULL;
1713                 if (link & BNX2_NETLINK_SET_LINK_SPEED_10) {
1714                         bp->req_line_speed = SPEED_10;
1715                         if (link & BNX2_NETLINK_SET_LINK_SPEED_10HALF)
1716                                 bp->req_duplex = DUPLEX_HALF;
1717                 }
1718                 if (link & BNX2_NETLINK_SET_LINK_SPEED_100) {
1719                         bp->req_line_speed = SPEED_100;
1720                         if (link & BNX2_NETLINK_SET_LINK_SPEED_100HALF)
1721                                 bp->req_duplex = DUPLEX_HALF;
1722                 }
1723                 if (link & BNX2_NETLINK_SET_LINK_SPEED_1GFULL)
1724                         bp->req_line_speed = SPEED_1000;
1725                 if (link & BNX2_NETLINK_SET_LINK_SPEED_2G5FULL)
1726                         bp->req_line_speed = SPEED_2500;
1727         }
1728 }
1729
1730 static void
1731 bnx2_set_default_link(struct bnx2 *bp)
1732 {
1733         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
1734                 bnx2_set_default_remote_link(bp);
1735                 return;
1736         }
1737
1738         bp->autoneg = AUTONEG_SPEED | AUTONEG_FLOW_CTRL;
1739         bp->req_line_speed = 0;
1740         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1741                 u32 reg;
1742
1743                 bp->advertising = ETHTOOL_ALL_FIBRE_SPEED | ADVERTISED_Autoneg;
1744
1745                 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_CONFIG);
1746                 reg &= BNX2_PORT_HW_CFG_CFG_DFLT_LINK_MASK;
1747                 if (reg == BNX2_PORT_HW_CFG_CFG_DFLT_LINK_1G) {
1748                         bp->autoneg = 0;
1749                         bp->req_line_speed = bp->line_speed = SPEED_1000;
1750                         bp->req_duplex = DUPLEX_FULL;
1751                 }
1752         } else
1753                 bp->advertising = ETHTOOL_ALL_COPPER_SPEED | ADVERTISED_Autoneg;
1754 }
1755
1756 static void
1757 bnx2_send_heart_beat(struct bnx2 *bp)
1758 {
1759         u32 msg;
1760         u32 addr;
1761
1762         spin_lock(&bp->indirect_lock);
1763         msg = (u32) (++bp->fw_drv_pulse_wr_seq & BNX2_DRV_PULSE_SEQ_MASK);
1764         addr = bp->shmem_base + BNX2_DRV_PULSE_MB;
1765         REG_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, addr);
1766         REG_WR(bp, BNX2_PCICFG_REG_WINDOW, msg);
1767         spin_unlock(&bp->indirect_lock);
1768 }
1769
1770 static void
1771 bnx2_remote_phy_event(struct bnx2 *bp)
1772 {
1773         u32 msg;
1774         u8 link_up = bp->link_up;
1775         u8 old_port;
1776
1777         msg = bnx2_shmem_rd(bp, BNX2_LINK_STATUS);
1778
1779         if (msg & BNX2_LINK_STATUS_HEART_BEAT_EXPIRED)
1780                 bnx2_send_heart_beat(bp);
1781
1782         msg &= ~BNX2_LINK_STATUS_HEART_BEAT_EXPIRED;
1783
1784         if ((msg & BNX2_LINK_STATUS_LINK_UP) == BNX2_LINK_STATUS_LINK_DOWN)
1785                 bp->link_up = 0;
1786         else {
1787                 u32 speed;
1788
1789                 bp->link_up = 1;
1790                 speed = msg & BNX2_LINK_STATUS_SPEED_MASK;
1791                 bp->duplex = DUPLEX_FULL;
1792                 switch (speed) {
1793                         case BNX2_LINK_STATUS_10HALF:
1794                                 bp->duplex = DUPLEX_HALF;
1795                         case BNX2_LINK_STATUS_10FULL:
1796                                 bp->line_speed = SPEED_10;
1797                                 break;
1798                         case BNX2_LINK_STATUS_100HALF:
1799                                 bp->duplex = DUPLEX_HALF;
1800                         case BNX2_LINK_STATUS_100BASE_T4:
1801                         case BNX2_LINK_STATUS_100FULL:
1802                                 bp->line_speed = SPEED_100;
1803                                 break;
1804                         case BNX2_LINK_STATUS_1000HALF:
1805                                 bp->duplex = DUPLEX_HALF;
1806                         case BNX2_LINK_STATUS_1000FULL:
1807                                 bp->line_speed = SPEED_1000;
1808                                 break;
1809                         case BNX2_LINK_STATUS_2500HALF:
1810                                 bp->duplex = DUPLEX_HALF;
1811                         case BNX2_LINK_STATUS_2500FULL:
1812                                 bp->line_speed = SPEED_2500;
1813                                 break;
1814                         default:
1815                                 bp->line_speed = 0;
1816                                 break;
1817                 }
1818
1819                 bp->flow_ctrl = 0;
1820                 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
1821                     (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) {
1822                         if (bp->duplex == DUPLEX_FULL)
1823                                 bp->flow_ctrl = bp->req_flow_ctrl;
1824                 } else {
1825                         if (msg & BNX2_LINK_STATUS_TX_FC_ENABLED)
1826                                 bp->flow_ctrl |= FLOW_CTRL_TX;
1827                         if (msg & BNX2_LINK_STATUS_RX_FC_ENABLED)
1828                                 bp->flow_ctrl |= FLOW_CTRL_RX;
1829                 }
1830
1831                 old_port = bp->phy_port;
1832                 if (msg & BNX2_LINK_STATUS_SERDES_LINK)
1833                         bp->phy_port = PORT_FIBRE;
1834                 else
1835                         bp->phy_port = PORT_TP;
1836
1837                 if (old_port != bp->phy_port)
1838                         bnx2_set_default_link(bp);
1839
1840         }
1841         if (bp->link_up != link_up)
1842                 bnx2_report_link(bp);
1843
1844         bnx2_set_mac_link(bp);
1845 }
1846
1847 static int
1848 bnx2_set_remote_link(struct bnx2 *bp)
1849 {
1850         u32 evt_code;
1851
1852         evt_code = bnx2_shmem_rd(bp, BNX2_FW_EVT_CODE_MB);
1853         switch (evt_code) {
1854                 case BNX2_FW_EVT_CODE_LINK_EVENT:
1855                         bnx2_remote_phy_event(bp);
1856                         break;
1857                 case BNX2_FW_EVT_CODE_SW_TIMER_EXPIRATION_EVENT:
1858                 default:
1859                         bnx2_send_heart_beat(bp);
1860                         break;
1861         }
1862         return 0;
1863 }
1864
1865 static int
1866 bnx2_setup_copper_phy(struct bnx2 *bp)
1867 {
1868         u32 bmcr;
1869         u32 new_bmcr;
1870
1871         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1872
1873         if (bp->autoneg & AUTONEG_SPEED) {
1874                 u32 adv_reg, adv1000_reg;
1875                 u32 new_adv_reg = 0;
1876                 u32 new_adv1000_reg = 0;
1877
1878                 bnx2_read_phy(bp, bp->mii_adv, &adv_reg);
1879                 adv_reg &= (PHY_ALL_10_100_SPEED | ADVERTISE_PAUSE_CAP |
1880                         ADVERTISE_PAUSE_ASYM);
1881
1882                 bnx2_read_phy(bp, MII_CTRL1000, &adv1000_reg);
1883                 adv1000_reg &= PHY_ALL_1000_SPEED;
1884
1885                 if (bp->advertising & ADVERTISED_10baseT_Half)
1886                         new_adv_reg |= ADVERTISE_10HALF;
1887                 if (bp->advertising & ADVERTISED_10baseT_Full)
1888                         new_adv_reg |= ADVERTISE_10FULL;
1889                 if (bp->advertising & ADVERTISED_100baseT_Half)
1890                         new_adv_reg |= ADVERTISE_100HALF;
1891                 if (bp->advertising & ADVERTISED_100baseT_Full)
1892                         new_adv_reg |= ADVERTISE_100FULL;
1893                 if (bp->advertising & ADVERTISED_1000baseT_Full)
1894                         new_adv1000_reg |= ADVERTISE_1000FULL;
1895
1896                 new_adv_reg |= ADVERTISE_CSMA;
1897
1898                 new_adv_reg |= bnx2_phy_get_pause_adv(bp);
1899
1900                 if ((adv1000_reg != new_adv1000_reg) ||
1901                         (adv_reg != new_adv_reg) ||
1902                         ((bmcr & BMCR_ANENABLE) == 0)) {
1903
1904                         bnx2_write_phy(bp, bp->mii_adv, new_adv_reg);
1905                         bnx2_write_phy(bp, MII_CTRL1000, new_adv1000_reg);
1906                         bnx2_write_phy(bp, bp->mii_bmcr, BMCR_ANRESTART |
1907                                 BMCR_ANENABLE);
1908                 }
1909                 else if (bp->link_up) {
1910                         /* Flow ctrl may have changed from auto to forced */
1911                         /* or vice-versa. */
1912
1913                         bnx2_resolve_flow_ctrl(bp);
1914                         bnx2_set_mac_link(bp);
1915                 }
1916                 return 0;
1917         }
1918
1919         new_bmcr = 0;
1920         if (bp->req_line_speed == SPEED_100) {
1921                 new_bmcr |= BMCR_SPEED100;
1922         }
1923         if (bp->req_duplex == DUPLEX_FULL) {
1924                 new_bmcr |= BMCR_FULLDPLX;
1925         }
1926         if (new_bmcr != bmcr) {
1927                 u32 bmsr;
1928
1929                 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1930                 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1931
1932                 if (bmsr & BMSR_LSTATUS) {
1933                         /* Force link down */
1934                         bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
1935                         spin_unlock_bh(&bp->phy_lock);
1936                         msleep(50);
1937                         spin_lock_bh(&bp->phy_lock);
1938
1939                         bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1940                         bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
1941                 }
1942
1943                 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
1944
1945                 /* Normally, the new speed is setup after the link has
1946                  * gone down and up again. In some cases, link will not go
1947                  * down so we need to set up the new speed here.
1948                  */
1949                 if (bmsr & BMSR_LSTATUS) {
1950                         bp->line_speed = bp->req_line_speed;
1951                         bp->duplex = bp->req_duplex;
1952                         bnx2_resolve_flow_ctrl(bp);
1953                         bnx2_set_mac_link(bp);
1954                 }
1955         } else {
1956                 bnx2_resolve_flow_ctrl(bp);
1957                 bnx2_set_mac_link(bp);
1958         }
1959         return 0;
1960 }
1961
1962 static int
1963 bnx2_setup_phy(struct bnx2 *bp, u8 port)
1964 {
1965         if (bp->loopback == MAC_LOOPBACK)
1966                 return 0;
1967
1968         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1969                 return (bnx2_setup_serdes_phy(bp, port));
1970         }
1971         else {
1972                 return (bnx2_setup_copper_phy(bp));
1973         }
1974 }
1975
1976 static int
1977 bnx2_init_5709s_phy(struct bnx2 *bp, int reset_phy)
1978 {
1979         u32 val;
1980
1981         bp->mii_bmcr = MII_BMCR + 0x10;
1982         bp->mii_bmsr = MII_BMSR + 0x10;
1983         bp->mii_bmsr1 = MII_BNX2_GP_TOP_AN_STATUS1;
1984         bp->mii_adv = MII_ADVERTISE + 0x10;
1985         bp->mii_lpa = MII_LPA + 0x10;
1986         bp->mii_up1 = MII_BNX2_OVER1G_UP1;
1987
1988         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_AER);
1989         bnx2_write_phy(bp, MII_BNX2_AER_AER, MII_BNX2_AER_AER_AN_MMD);
1990
1991         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1992         if (reset_phy)
1993                 bnx2_reset_phy(bp);
1994
1995         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_SERDES_DIG);
1996
1997         bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, &val);
1998         val &= ~MII_BNX2_SD_1000XCTL1_AUTODET;
1999         val |= MII_BNX2_SD_1000XCTL1_FIBER;
2000         bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, val);
2001
2002         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
2003         bnx2_read_phy(bp, MII_BNX2_OVER1G_UP1, &val);
2004         if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE)
2005                 val |= BCM5708S_UP1_2G5;
2006         else
2007                 val &= ~BCM5708S_UP1_2G5;
2008         bnx2_write_phy(bp, MII_BNX2_OVER1G_UP1, val);
2009
2010         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_BAM_NXTPG);
2011         bnx2_read_phy(bp, MII_BNX2_BAM_NXTPG_CTL, &val);
2012         val |= MII_BNX2_NXTPG_CTL_T2 | MII_BNX2_NXTPG_CTL_BAM;
2013         bnx2_write_phy(bp, MII_BNX2_BAM_NXTPG_CTL, val);
2014
2015         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_CL73_USERB0);
2016
2017         val = MII_BNX2_CL73_BAM_EN | MII_BNX2_CL73_BAM_STA_MGR_EN |
2018               MII_BNX2_CL73_BAM_NP_AFT_BP_EN;
2019         bnx2_write_phy(bp, MII_BNX2_CL73_BAM_CTL1, val);
2020
2021         bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
2022
2023         return 0;
2024 }
2025
2026 static int
2027 bnx2_init_5708s_phy(struct bnx2 *bp, int reset_phy)
2028 {
2029         u32 val;
2030
2031         if (reset_phy)
2032                 bnx2_reset_phy(bp);
2033
2034         bp->mii_up1 = BCM5708S_UP1;
2035
2036         bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG3);
2037         bnx2_write_phy(bp, BCM5708S_DIG_3_0, BCM5708S_DIG_3_0_USE_IEEE);
2038         bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
2039
2040         bnx2_read_phy(bp, BCM5708S_1000X_CTL1, &val);
2041         val |= BCM5708S_1000X_CTL1_FIBER_MODE | BCM5708S_1000X_CTL1_AUTODET_EN;
2042         bnx2_write_phy(bp, BCM5708S_1000X_CTL1, val);
2043
2044         bnx2_read_phy(bp, BCM5708S_1000X_CTL2, &val);
2045         val |= BCM5708S_1000X_CTL2_PLLEL_DET_EN;
2046         bnx2_write_phy(bp, BCM5708S_1000X_CTL2, val);
2047
2048         if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) {
2049                 bnx2_read_phy(bp, BCM5708S_UP1, &val);
2050                 val |= BCM5708S_UP1_2G5;
2051                 bnx2_write_phy(bp, BCM5708S_UP1, val);
2052         }
2053
2054         if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
2055             (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
2056             (CHIP_ID(bp) == CHIP_ID_5708_B1)) {
2057                 /* increase tx signal amplitude */
2058                 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2059                                BCM5708S_BLK_ADDR_TX_MISC);
2060                 bnx2_read_phy(bp, BCM5708S_TX_ACTL1, &val);
2061                 val &= ~BCM5708S_TX_ACTL1_DRIVER_VCM;
2062                 bnx2_write_phy(bp, BCM5708S_TX_ACTL1, val);
2063                 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
2064         }
2065
2066         val = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_CONFIG) &
2067               BNX2_PORT_HW_CFG_CFG_TXCTL3_MASK;
2068
2069         if (val) {
2070                 u32 is_backplane;
2071
2072                 is_backplane = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG);
2073                 if (is_backplane & BNX2_SHARED_HW_CFG_PHY_BACKPLANE) {
2074                         bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2075                                        BCM5708S_BLK_ADDR_TX_MISC);
2076                         bnx2_write_phy(bp, BCM5708S_TX_ACTL3, val);
2077                         bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2078                                        BCM5708S_BLK_ADDR_DIG);
2079                 }
2080         }
2081         return 0;
2082 }
2083
2084 static int
2085 bnx2_init_5706s_phy(struct bnx2 *bp, int reset_phy)
2086 {
2087         if (reset_phy)
2088                 bnx2_reset_phy(bp);
2089
2090         bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
2091
2092         if (CHIP_NUM(bp) == CHIP_NUM_5706)
2093                 REG_WR(bp, BNX2_MISC_GP_HW_CTL0, 0x300);
2094
2095         if (bp->dev->mtu > 1500) {
2096                 u32 val;
2097
2098                 /* Set extended packet length bit */
2099                 bnx2_write_phy(bp, 0x18, 0x7);
2100                 bnx2_read_phy(bp, 0x18, &val);
2101                 bnx2_write_phy(bp, 0x18, (val & 0xfff8) | 0x4000);
2102
2103                 bnx2_write_phy(bp, 0x1c, 0x6c00);
2104                 bnx2_read_phy(bp, 0x1c, &val);
2105                 bnx2_write_phy(bp, 0x1c, (val & 0x3ff) | 0xec02);
2106         }
2107         else {
2108                 u32 val;
2109
2110                 bnx2_write_phy(bp, 0x18, 0x7);
2111                 bnx2_read_phy(bp, 0x18, &val);
2112                 bnx2_write_phy(bp, 0x18, val & ~0x4007);
2113
2114                 bnx2_write_phy(bp, 0x1c, 0x6c00);
2115                 bnx2_read_phy(bp, 0x1c, &val);
2116                 bnx2_write_phy(bp, 0x1c, (val & 0x3fd) | 0xec00);
2117         }
2118
2119         return 0;
2120 }
2121
2122 static int
2123 bnx2_init_copper_phy(struct bnx2 *bp, int reset_phy)
2124 {
2125         u32 val;
2126
2127         if (reset_phy)
2128                 bnx2_reset_phy(bp);
2129
2130         if (bp->phy_flags & BNX2_PHY_FLAG_CRC_FIX) {
2131                 bnx2_write_phy(bp, 0x18, 0x0c00);
2132                 bnx2_write_phy(bp, 0x17, 0x000a);
2133                 bnx2_write_phy(bp, 0x15, 0x310b);
2134                 bnx2_write_phy(bp, 0x17, 0x201f);
2135                 bnx2_write_phy(bp, 0x15, 0x9506);
2136                 bnx2_write_phy(bp, 0x17, 0x401f);
2137                 bnx2_write_phy(bp, 0x15, 0x14e2);
2138                 bnx2_write_phy(bp, 0x18, 0x0400);
2139         }
2140
2141         if (bp->phy_flags & BNX2_PHY_FLAG_DIS_EARLY_DAC) {
2142                 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS,
2143                                MII_BNX2_DSP_EXPAND_REG | 0x8);
2144                 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
2145                 val &= ~(1 << 8);
2146                 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val);
2147         }
2148
2149         if (bp->dev->mtu > 1500) {
2150                 /* Set extended packet length bit */
2151                 bnx2_write_phy(bp, 0x18, 0x7);
2152                 bnx2_read_phy(bp, 0x18, &val);
2153                 bnx2_write_phy(bp, 0x18, val | 0x4000);
2154
2155                 bnx2_read_phy(bp, 0x10, &val);
2156                 bnx2_write_phy(bp, 0x10, val | 0x1);
2157         }
2158         else {
2159                 bnx2_write_phy(bp, 0x18, 0x7);
2160                 bnx2_read_phy(bp, 0x18, &val);
2161                 bnx2_write_phy(bp, 0x18, val & ~0x4007);
2162
2163                 bnx2_read_phy(bp, 0x10, &val);
2164                 bnx2_write_phy(bp, 0x10, val & ~0x1);
2165         }
2166
2167         /* ethernet@wirespeed */
2168         bnx2_write_phy(bp, 0x18, 0x7007);
2169         bnx2_read_phy(bp, 0x18, &val);
2170         bnx2_write_phy(bp, 0x18, val | (1 << 15) | (1 << 4));
2171         return 0;
2172 }
2173
2174
2175 static int
2176 bnx2_init_phy(struct bnx2 *bp, int reset_phy)
2177 {
2178         u32 val;
2179         int rc = 0;
2180
2181         bp->phy_flags &= ~BNX2_PHY_FLAG_INT_MODE_MASK;
2182         bp->phy_flags |= BNX2_PHY_FLAG_INT_MODE_LINK_READY;
2183
2184         bp->mii_bmcr = MII_BMCR;
2185         bp->mii_bmsr = MII_BMSR;
2186         bp->mii_bmsr1 = MII_BMSR;
2187         bp->mii_adv = MII_ADVERTISE;
2188         bp->mii_lpa = MII_LPA;
2189
2190         REG_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
2191
2192         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
2193                 goto setup_phy;
2194
2195         bnx2_read_phy(bp, MII_PHYSID1, &val);
2196         bp->phy_id = val << 16;
2197         bnx2_read_phy(bp, MII_PHYSID2, &val);
2198         bp->phy_id |= val & 0xffff;
2199
2200         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
2201                 if (CHIP_NUM(bp) == CHIP_NUM_5706)
2202                         rc = bnx2_init_5706s_phy(bp, reset_phy);
2203                 else if (CHIP_NUM(bp) == CHIP_NUM_5708)
2204                         rc = bnx2_init_5708s_phy(bp, reset_phy);
2205                 else if (CHIP_NUM(bp) == CHIP_NUM_5709)
2206                         rc = bnx2_init_5709s_phy(bp, reset_phy);
2207         }
2208         else {
2209                 rc = bnx2_init_copper_phy(bp, reset_phy);
2210         }
2211
2212 setup_phy:
2213         if (!rc)
2214                 rc = bnx2_setup_phy(bp, bp->phy_port);
2215
2216         return rc;
2217 }
2218
2219 static int
2220 bnx2_set_mac_loopback(struct bnx2 *bp)
2221 {
2222         u32 mac_mode;
2223
2224         mac_mode = REG_RD(bp, BNX2_EMAC_MODE);
2225         mac_mode &= ~BNX2_EMAC_MODE_PORT;
2226         mac_mode |= BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK;
2227         REG_WR(bp, BNX2_EMAC_MODE, mac_mode);
2228         bp->link_up = 1;
2229         return 0;
2230 }
2231
2232 static int bnx2_test_link(struct bnx2 *);
2233
2234 static int
2235 bnx2_set_phy_loopback(struct bnx2 *bp)
2236 {
2237         u32 mac_mode;
2238         int rc, i;
2239
2240         spin_lock_bh(&bp->phy_lock);
2241         rc = bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK | BMCR_FULLDPLX |
2242                             BMCR_SPEED1000);
2243         spin_unlock_bh(&bp->phy_lock);
2244         if (rc)
2245                 return rc;
2246
2247         for (i = 0; i < 10; i++) {
2248                 if (bnx2_test_link(bp) == 0)
2249                         break;
2250                 msleep(100);
2251         }
2252
2253         mac_mode = REG_RD(bp, BNX2_EMAC_MODE);
2254         mac_mode &= ~(BNX2_EMAC_MODE_PORT | BNX2_EMAC_MODE_HALF_DUPLEX |
2255                       BNX2_EMAC_MODE_MAC_LOOP | BNX2_EMAC_MODE_FORCE_LINK |
2256                       BNX2_EMAC_MODE_25G_MODE);
2257
2258         mac_mode |= BNX2_EMAC_MODE_PORT_GMII;
2259         REG_WR(bp, BNX2_EMAC_MODE, mac_mode);
2260         bp->link_up = 1;
2261         return 0;
2262 }
2263
2264 static int
2265 bnx2_fw_sync(struct bnx2 *bp, u32 msg_data, int ack, int silent)
2266 {
2267         int i;
2268         u32 val;
2269
2270         bp->fw_wr_seq++;
2271         msg_data |= bp->fw_wr_seq;
2272
2273         bnx2_shmem_wr(bp, BNX2_DRV_MB, msg_data);
2274
2275         if (!ack)
2276                 return 0;
2277
2278         /* wait for an acknowledgement. */
2279         for (i = 0; i < (FW_ACK_TIME_OUT_MS / 10); i++) {
2280                 msleep(10);
2281
2282                 val = bnx2_shmem_rd(bp, BNX2_FW_MB);
2283
2284                 if ((val & BNX2_FW_MSG_ACK) == (msg_data & BNX2_DRV_MSG_SEQ))
2285                         break;
2286         }
2287         if ((msg_data & BNX2_DRV_MSG_DATA) == BNX2_DRV_MSG_DATA_WAIT0)
2288                 return 0;
2289
2290         /* If we timed out, inform the firmware that this is the case. */
2291         if ((val & BNX2_FW_MSG_ACK) != (msg_data & BNX2_DRV_MSG_SEQ)) {
2292                 if (!silent)
2293                         printk(KERN_ERR PFX "fw sync timeout, reset code = "
2294                                             "%x\n", msg_data);
2295
2296                 msg_data &= ~BNX2_DRV_MSG_CODE;
2297                 msg_data |= BNX2_DRV_MSG_CODE_FW_TIMEOUT;
2298
2299                 bnx2_shmem_wr(bp, BNX2_DRV_MB, msg_data);
2300
2301                 return -EBUSY;
2302         }
2303
2304         if ((val & BNX2_FW_MSG_STATUS_MASK) != BNX2_FW_MSG_STATUS_OK)
2305                 return -EIO;
2306
2307         return 0;
2308 }
2309
2310 static int
2311 bnx2_init_5709_context(struct bnx2 *bp)
2312 {
2313         int i, ret = 0;
2314         u32 val;
2315
2316         val = BNX2_CTX_COMMAND_ENABLED | BNX2_CTX_COMMAND_MEM_INIT | (1 << 12);
2317         val |= (BCM_PAGE_BITS - 8) << 16;
2318         REG_WR(bp, BNX2_CTX_COMMAND, val);
2319         for (i = 0; i < 10; i++) {
2320                 val = REG_RD(bp, BNX2_CTX_COMMAND);
2321                 if (!(val & BNX2_CTX_COMMAND_MEM_INIT))
2322                         break;
2323                 udelay(2);
2324         }
2325         if (val & BNX2_CTX_COMMAND_MEM_INIT)
2326                 return -EBUSY;
2327
2328         for (i = 0; i < bp->ctx_pages; i++) {
2329                 int j;
2330
2331                 if (bp->ctx_blk[i])
2332                         memset(bp->ctx_blk[i], 0, BCM_PAGE_SIZE);
2333                 else
2334                         return -ENOMEM;
2335
2336                 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA0,
2337                        (bp->ctx_blk_mapping[i] & 0xffffffff) |
2338                        BNX2_CTX_HOST_PAGE_TBL_DATA0_VALID);
2339                 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA1,
2340                        (u64) bp->ctx_blk_mapping[i] >> 32);
2341                 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL, i |
2342                        BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ);
2343                 for (j = 0; j < 10; j++) {
2344
2345                         val = REG_RD(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL);
2346                         if (!(val & BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ))
2347                                 break;
2348                         udelay(5);
2349                 }
2350                 if (val & BNX2_CTX_HOST_PAGE_TBL_CTRL_WRITE_REQ) {
2351                         ret = -EBUSY;
2352                         break;
2353                 }
2354         }
2355         return ret;
2356 }
2357
2358 static void
2359 bnx2_init_context(struct bnx2 *bp)
2360 {
2361         u32 vcid;
2362
2363         vcid = 96;
2364         while (vcid) {
2365                 u32 vcid_addr, pcid_addr, offset;
2366                 int i;
2367
2368                 vcid--;
2369
2370                 if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
2371                         u32 new_vcid;
2372
2373                         vcid_addr = GET_PCID_ADDR(vcid);
2374                         if (vcid & 0x8) {
2375                                 new_vcid = 0x60 + (vcid & 0xf0) + (vcid & 0x7);
2376                         }
2377                         else {
2378                                 new_vcid = vcid;
2379                         }
2380                         pcid_addr = GET_PCID_ADDR(new_vcid);
2381                 }
2382                 else {
2383                         vcid_addr = GET_CID_ADDR(vcid);
2384                         pcid_addr = vcid_addr;
2385                 }
2386
2387                 for (i = 0; i < (CTX_SIZE / PHY_CTX_SIZE); i++) {
2388                         vcid_addr += (i << PHY_CTX_SHIFT);
2389                         pcid_addr += (i << PHY_CTX_SHIFT);
2390
2391                         REG_WR(bp, BNX2_CTX_VIRT_ADDR, vcid_addr);
2392                         REG_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
2393
2394                         /* Zero out the context. */
2395                         for (offset = 0; offset < PHY_CTX_SIZE; offset += 4)
2396                                 bnx2_ctx_wr(bp, vcid_addr, offset, 0);
2397                 }
2398         }
2399 }
2400
2401 static int
2402 bnx2_alloc_bad_rbuf(struct bnx2 *bp)
2403 {
2404         u16 *good_mbuf;
2405         u32 good_mbuf_cnt;
2406         u32 val;
2407
2408         good_mbuf = kmalloc(512 * sizeof(u16), GFP_KERNEL);
2409         if (good_mbuf == NULL) {
2410                 printk(KERN_ERR PFX "Failed to allocate memory in "
2411                                     "bnx2_alloc_bad_rbuf\n");
2412                 return -ENOMEM;
2413         }
2414
2415         REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
2416                 BNX2_MISC_ENABLE_SET_BITS_RX_MBUF_ENABLE);
2417
2418         good_mbuf_cnt = 0;
2419
2420         /* Allocate a bunch of mbufs and save the good ones in an array. */
2421         val = bnx2_reg_rd_ind(bp, BNX2_RBUF_STATUS1);
2422         while (val & BNX2_RBUF_STATUS1_FREE_COUNT) {
2423                 bnx2_reg_wr_ind(bp, BNX2_RBUF_COMMAND,
2424                                 BNX2_RBUF_COMMAND_ALLOC_REQ);
2425
2426                 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_FW_BUF_ALLOC);
2427
2428                 val &= BNX2_RBUF_FW_BUF_ALLOC_VALUE;
2429
2430                 /* The addresses with Bit 9 set are bad memory blocks. */
2431                 if (!(val & (1 << 9))) {
2432                         good_mbuf[good_mbuf_cnt] = (u16) val;
2433                         good_mbuf_cnt++;
2434                 }
2435
2436                 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_STATUS1);
2437         }
2438
2439         /* Free the good ones back to the mbuf pool thus discarding
2440          * all the bad ones. */
2441         while (good_mbuf_cnt) {
2442                 good_mbuf_cnt--;
2443
2444                 val = good_mbuf[good_mbuf_cnt];
2445                 val = (val << 9) | val | 1;
2446
2447                 bnx2_reg_wr_ind(bp, BNX2_RBUF_FW_BUF_FREE, val);
2448         }
2449         kfree(good_mbuf);
2450         return 0;
2451 }
2452
2453 static void
2454 bnx2_set_mac_addr(struct bnx2 *bp, u8 *mac_addr, u32 pos)
2455 {
2456         u32 val;
2457
2458         val = (mac_addr[0] << 8) | mac_addr[1];
2459
2460         REG_WR(bp, BNX2_EMAC_MAC_MATCH0 + (pos * 8), val);
2461
2462         val = (mac_addr[2] << 24) | (mac_addr[3] << 16) |
2463                 (mac_addr[4] << 8) | mac_addr[5];
2464
2465         REG_WR(bp, BNX2_EMAC_MAC_MATCH1 + (pos * 8), val);
2466 }
2467
2468 static inline int
2469 bnx2_alloc_rx_page(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
2470 {
2471         dma_addr_t mapping;
2472         struct sw_pg *rx_pg = &rxr->rx_pg_ring[index];
2473         struct rx_bd *rxbd =
2474                 &rxr->rx_pg_desc_ring[RX_RING(index)][RX_IDX(index)];
2475         struct page *page = alloc_page(GFP_ATOMIC);
2476
2477         if (!page)
2478                 return -ENOMEM;
2479         mapping = pci_map_page(bp->pdev, page, 0, PAGE_SIZE,
2480                                PCI_DMA_FROMDEVICE);
2481         rx_pg->page = page;
2482         pci_unmap_addr_set(rx_pg, mapping, mapping);
2483         rxbd->rx_bd_haddr_hi = (u64) mapping >> 32;
2484         rxbd->rx_bd_haddr_lo = (u64) mapping & 0xffffffff;
2485         return 0;
2486 }
2487
2488 static void
2489 bnx2_free_rx_page(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
2490 {
2491         struct sw_pg *rx_pg = &rxr->rx_pg_ring[index];
2492         struct page *page = rx_pg->page;
2493
2494         if (!page)
2495                 return;
2496
2497         pci_unmap_page(bp->pdev, pci_unmap_addr(rx_pg, mapping), PAGE_SIZE,
2498                        PCI_DMA_FROMDEVICE);
2499
2500         __free_page(page);
2501         rx_pg->page = NULL;
2502 }
2503
2504 static inline int
2505 bnx2_alloc_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
2506 {
2507         struct sk_buff *skb;
2508         struct sw_bd *rx_buf = &rxr->rx_buf_ring[index];
2509         dma_addr_t mapping;
2510         struct rx_bd *rxbd = &rxr->rx_desc_ring[RX_RING(index)][RX_IDX(index)];
2511         unsigned long align;
2512
2513         skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
2514         if (skb == NULL) {
2515                 return -ENOMEM;
2516         }
2517
2518         if (unlikely((align = (unsigned long) skb->data & (BNX2_RX_ALIGN - 1))))
2519                 skb_reserve(skb, BNX2_RX_ALIGN - align);
2520
2521         mapping = pci_map_single(bp->pdev, skb->data, bp->rx_buf_use_size,
2522                 PCI_DMA_FROMDEVICE);
2523
2524         rx_buf->skb = skb;
2525         pci_unmap_addr_set(rx_buf, mapping, mapping);
2526
2527         rxbd->rx_bd_haddr_hi = (u64) mapping >> 32;
2528         rxbd->rx_bd_haddr_lo = (u64) mapping & 0xffffffff;
2529
2530         rxr->rx_prod_bseq += bp->rx_buf_use_size;
2531
2532         return 0;
2533 }
2534
2535 static int
2536 bnx2_phy_event_is_set(struct bnx2 *bp, struct bnx2_napi *bnapi, u32 event)
2537 {
2538         struct status_block *sblk = bnapi->status_blk.msi;
2539         u32 new_link_state, old_link_state;
2540         int is_set = 1;
2541
2542         new_link_state = sblk->status_attn_bits & event;
2543         old_link_state = sblk->status_attn_bits_ack & event;
2544         if (new_link_state != old_link_state) {
2545                 if (new_link_state)
2546                         REG_WR(bp, BNX2_PCICFG_STATUS_BIT_SET_CMD, event);
2547                 else
2548                         REG_WR(bp, BNX2_PCICFG_STATUS_BIT_CLEAR_CMD, event);
2549         } else
2550                 is_set = 0;
2551
2552         return is_set;
2553 }
2554
2555 static void
2556 bnx2_phy_int(struct bnx2 *bp, struct bnx2_napi *bnapi)
2557 {
2558         spin_lock(&bp->phy_lock);
2559
2560         if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_LINK_STATE))
2561                 bnx2_set_link(bp);
2562         if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_TIMER_ABORT))
2563                 bnx2_set_remote_link(bp);
2564
2565         spin_unlock(&bp->phy_lock);
2566
2567 }
2568
2569 static inline u16
2570 bnx2_get_hw_tx_cons(struct bnx2_napi *bnapi)
2571 {
2572         u16 cons;
2573
2574         /* Tell compiler that status block fields can change. */
2575         barrier();
2576         cons = *bnapi->hw_tx_cons_ptr;
2577         if (unlikely((cons & MAX_TX_DESC_CNT) == MAX_TX_DESC_CNT))
2578                 cons++;
2579         return cons;
2580 }
2581
2582 static int
2583 bnx2_tx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
2584 {
2585         struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
2586         u16 hw_cons, sw_cons, sw_ring_cons;
2587         int tx_pkt = 0, index;
2588         struct netdev_queue *txq;
2589
2590         index = (bnapi - bp->bnx2_napi);
2591         txq = netdev_get_tx_queue(bp->dev, index);
2592
2593         hw_cons = bnx2_get_hw_tx_cons(bnapi);
2594         sw_cons = txr->tx_cons;
2595
2596         while (sw_cons != hw_cons) {
2597                 struct sw_bd *tx_buf;
2598                 struct sk_buff *skb;
2599                 int i, last;
2600
2601                 sw_ring_cons = TX_RING_IDX(sw_cons);
2602
2603                 tx_buf = &txr->tx_buf_ring[sw_ring_cons];
2604                 skb = tx_buf->skb;
2605
2606                 /* partial BD completions possible with TSO packets */
2607                 if (skb_is_gso(skb)) {
2608                         u16 last_idx, last_ring_idx;
2609
2610                         last_idx = sw_cons +
2611                                 skb_shinfo(skb)->nr_frags + 1;
2612                         last_ring_idx = sw_ring_cons +
2613                                 skb_shinfo(skb)->nr_frags + 1;
2614                         if (unlikely(last_ring_idx >= MAX_TX_DESC_CNT)) {
2615                                 last_idx++;
2616                         }
2617                         if (((s16) ((s16) last_idx - (s16) hw_cons)) > 0) {
2618                                 break;
2619                         }
2620                 }
2621
2622                 pci_unmap_single(bp->pdev, pci_unmap_addr(tx_buf, mapping),
2623                         skb_headlen(skb), PCI_DMA_TODEVICE);
2624
2625                 tx_buf->skb = NULL;
2626                 last = skb_shinfo(skb)->nr_frags;
2627
2628                 for (i = 0; i < last; i++) {
2629                         sw_cons = NEXT_TX_BD(sw_cons);
2630
2631                         pci_unmap_page(bp->pdev,
2632                                 pci_unmap_addr(
2633                                         &txr->tx_buf_ring[TX_RING_IDX(sw_cons)],
2634                                         mapping),
2635                                 skb_shinfo(skb)->frags[i].size,
2636                                 PCI_DMA_TODEVICE);
2637                 }
2638
2639                 sw_cons = NEXT_TX_BD(sw_cons);
2640
2641                 dev_kfree_skb(skb);
2642                 tx_pkt++;
2643                 if (tx_pkt == budget)
2644                         break;
2645
2646                 hw_cons = bnx2_get_hw_tx_cons(bnapi);
2647         }
2648
2649         txr->hw_tx_cons = hw_cons;
2650         txr->tx_cons = sw_cons;
2651
2652         /* Need to make the tx_cons update visible to bnx2_start_xmit()
2653          * before checking for netif_tx_queue_stopped().  Without the
2654          * memory barrier, there is a small possibility that bnx2_start_xmit()
2655          * will miss it and cause the queue to be stopped forever.
2656          */
2657         smp_mb();
2658
2659         if (unlikely(netif_tx_queue_stopped(txq)) &&
2660                      (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh)) {
2661                 __netif_tx_lock(txq, smp_processor_id());
2662                 if ((netif_tx_queue_stopped(txq)) &&
2663                     (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh))
2664                         netif_tx_wake_queue(txq);
2665                 __netif_tx_unlock(txq);
2666         }
2667
2668         return tx_pkt;
2669 }
2670
2671 static void
2672 bnx2_reuse_rx_skb_pages(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr,
2673                         struct sk_buff *skb, int count)
2674 {
2675         struct sw_pg *cons_rx_pg, *prod_rx_pg;
2676         struct rx_bd *cons_bd, *prod_bd;
2677         dma_addr_t mapping;
2678         int i;
2679         u16 hw_prod = rxr->rx_pg_prod, prod;
2680         u16 cons = rxr->rx_pg_cons;
2681
2682         for (i = 0; i < count; i++) {
2683                 prod = RX_PG_RING_IDX(hw_prod);
2684
2685                 prod_rx_pg = &rxr->rx_pg_ring[prod];
2686                 cons_rx_pg = &rxr->rx_pg_ring[cons];
2687                 cons_bd = &rxr->rx_pg_desc_ring[RX_RING(cons)][RX_IDX(cons)];
2688                 prod_bd = &rxr->rx_pg_desc_ring[RX_RING(prod)][RX_IDX(prod)];
2689
2690                 if (i == 0 && skb) {
2691                         struct page *page;
2692                         struct skb_shared_info *shinfo;
2693
2694                         shinfo = skb_shinfo(skb);
2695                         shinfo->nr_frags--;
2696                         page = shinfo->frags[shinfo->nr_frags].page;
2697                         shinfo->frags[shinfo->nr_frags].page = NULL;
2698                         mapping = pci_map_page(bp->pdev, page, 0, PAGE_SIZE,
2699                                                PCI_DMA_FROMDEVICE);
2700                         cons_rx_pg->page = page;
2701                         pci_unmap_addr_set(cons_rx_pg, mapping, mapping);
2702                         dev_kfree_skb(skb);
2703                 }
2704                 if (prod != cons) {
2705                         prod_rx_pg->page = cons_rx_pg->page;
2706                         cons_rx_pg->page = NULL;
2707                         pci_unmap_addr_set(prod_rx_pg, mapping,
2708                                 pci_unmap_addr(cons_rx_pg, mapping));
2709
2710                         prod_bd->rx_bd_haddr_hi = cons_bd->rx_bd_haddr_hi;
2711                         prod_bd->rx_bd_haddr_lo = cons_bd->rx_bd_haddr_lo;
2712
2713                 }
2714                 cons = RX_PG_RING_IDX(NEXT_RX_BD(cons));
2715                 hw_prod = NEXT_RX_BD(hw_prod);
2716         }
2717         rxr->rx_pg_prod = hw_prod;
2718         rxr->rx_pg_cons = cons;
2719 }
2720
2721 static inline void
2722 bnx2_reuse_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr,
2723                   struct sk_buff *skb, u16 cons, u16 prod)
2724 {
2725         struct sw_bd *cons_rx_buf, *prod_rx_buf;
2726         struct rx_bd *cons_bd, *prod_bd;
2727
2728         cons_rx_buf = &rxr->rx_buf_ring[cons];
2729         prod_rx_buf = &rxr->rx_buf_ring[prod];
2730
2731         pci_dma_sync_single_for_device(bp->pdev,
2732                 pci_unmap_addr(cons_rx_buf, mapping),
2733                 BNX2_RX_OFFSET + BNX2_RX_COPY_THRESH, PCI_DMA_FROMDEVICE);
2734
2735         rxr->rx_prod_bseq += bp->rx_buf_use_size;
2736
2737         prod_rx_buf->skb = skb;
2738
2739         if (cons == prod)
2740                 return;
2741
2742         pci_unmap_addr_set(prod_rx_buf, mapping,
2743                         pci_unmap_addr(cons_rx_buf, mapping));
2744
2745         cons_bd = &rxr->rx_desc_ring[RX_RING(cons)][RX_IDX(cons)];
2746         prod_bd = &rxr->rx_desc_ring[RX_RING(prod)][RX_IDX(prod)];
2747         prod_bd->rx_bd_haddr_hi = cons_bd->rx_bd_haddr_hi;
2748         prod_bd->rx_bd_haddr_lo = cons_bd->rx_bd_haddr_lo;
2749 }
2750
2751 static int
2752 bnx2_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, struct sk_buff *skb,
2753             unsigned int len, unsigned int hdr_len, dma_addr_t dma_addr,
2754             u32 ring_idx)
2755 {
2756         int err;
2757         u16 prod = ring_idx & 0xffff;
2758
2759         err = bnx2_alloc_rx_skb(bp, rxr, prod);
2760         if (unlikely(err)) {
2761                 bnx2_reuse_rx_skb(bp, rxr, skb, (u16) (ring_idx >> 16), prod);
2762                 if (hdr_len) {
2763                         unsigned int raw_len = len + 4;
2764                         int pages = PAGE_ALIGN(raw_len - hdr_len) >> PAGE_SHIFT;
2765
2766                         bnx2_reuse_rx_skb_pages(bp, rxr, NULL, pages);
2767                 }
2768                 return err;
2769         }
2770
2771         skb_reserve(skb, BNX2_RX_OFFSET);
2772         pci_unmap_single(bp->pdev, dma_addr, bp->rx_buf_use_size,
2773                          PCI_DMA_FROMDEVICE);
2774
2775         if (hdr_len == 0) {
2776                 skb_put(skb, len);
2777                 return 0;
2778         } else {
2779                 unsigned int i, frag_len, frag_size, pages;
2780                 struct sw_pg *rx_pg;
2781                 u16 pg_cons = rxr->rx_pg_cons;
2782                 u16 pg_prod = rxr->rx_pg_prod;
2783
2784                 frag_size = len + 4 - hdr_len;
2785                 pages = PAGE_ALIGN(frag_size) >> PAGE_SHIFT;
2786                 skb_put(skb, hdr_len);
2787
2788                 for (i = 0; i < pages; i++) {
2789                         frag_len = min(frag_size, (unsigned int) PAGE_SIZE);
2790                         if (unlikely(frag_len <= 4)) {
2791                                 unsigned int tail = 4 - frag_len;
2792
2793                                 rxr->rx_pg_cons = pg_cons;
2794                                 rxr->rx_pg_prod = pg_prod;
2795                                 bnx2_reuse_rx_skb_pages(bp, rxr, NULL,
2796                                                         pages - i);
2797                                 skb->len -= tail;
2798                                 if (i == 0) {
2799                                         skb->tail -= tail;
2800                                 } else {
2801                                         skb_frag_t *frag =
2802                                                 &skb_shinfo(skb)->frags[i - 1];
2803                                         frag->size -= tail;
2804                                         skb->data_len -= tail;
2805                                         skb->truesize -= tail;
2806                                 }
2807                                 return 0;
2808                         }
2809                         rx_pg = &rxr->rx_pg_ring[pg_cons];
2810
2811                         pci_unmap_page(bp->pdev, pci_unmap_addr(rx_pg, mapping),
2812                                        PAGE_SIZE, PCI_DMA_FROMDEVICE);
2813
2814                         if (i == pages - 1)
2815                                 frag_len -= 4;
2816
2817                         skb_fill_page_desc(skb, i, rx_pg->page, 0, frag_len);
2818                         rx_pg->page = NULL;
2819
2820                         err = bnx2_alloc_rx_page(bp, rxr,
2821                                                  RX_PG_RING_IDX(pg_prod));
2822                         if (unlikely(err)) {
2823                                 rxr->rx_pg_cons = pg_cons;
2824                                 rxr->rx_pg_prod = pg_prod;
2825                                 bnx2_reuse_rx_skb_pages(bp, rxr, skb,
2826                                                         pages - i);
2827                                 return err;
2828                         }
2829
2830                         frag_size -= frag_len;
2831                         skb->data_len += frag_len;
2832                         skb->truesize += frag_len;
2833                         skb->len += frag_len;
2834
2835                         pg_prod = NEXT_RX_BD(pg_prod);
2836                         pg_cons = RX_PG_RING_IDX(NEXT_RX_BD(pg_cons));
2837                 }
2838                 rxr->rx_pg_prod = pg_prod;
2839                 rxr->rx_pg_cons = pg_cons;
2840         }
2841         return 0;
2842 }
2843
2844 static inline u16
2845 bnx2_get_hw_rx_cons(struct bnx2_napi *bnapi)
2846 {
2847         u16 cons;
2848
2849         /* Tell compiler that status block fields can change. */
2850         barrier();
2851         cons = *bnapi->hw_rx_cons_ptr;
2852         if (unlikely((cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT))
2853                 cons++;
2854         return cons;
2855 }
2856
2857 static int
2858 bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
2859 {
2860         struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
2861         u16 hw_cons, sw_cons, sw_ring_cons, sw_prod, sw_ring_prod;
2862         struct l2_fhdr *rx_hdr;
2863         int rx_pkt = 0, pg_ring_used = 0;
2864
2865         hw_cons = bnx2_get_hw_rx_cons(bnapi);
2866         sw_cons = rxr->rx_cons;
2867         sw_prod = rxr->rx_prod;
2868
2869         /* Memory barrier necessary as speculative reads of the rx
2870          * buffer can be ahead of the index in the status block
2871          */
2872         rmb();
2873         while (sw_cons != hw_cons) {
2874                 unsigned int len, hdr_len;
2875                 u32 status;
2876                 struct sw_bd *rx_buf;
2877                 struct sk_buff *skb;
2878                 dma_addr_t dma_addr;
2879                 u16 vtag = 0;
2880                 int hw_vlan __maybe_unused = 0;
2881
2882                 sw_ring_cons = RX_RING_IDX(sw_cons);
2883                 sw_ring_prod = RX_RING_IDX(sw_prod);
2884
2885                 rx_buf = &rxr->rx_buf_ring[sw_ring_cons];
2886                 skb = rx_buf->skb;
2887
2888                 rx_buf->skb = NULL;
2889
2890                 dma_addr = pci_unmap_addr(rx_buf, mapping);
2891
2892                 pci_dma_sync_single_for_cpu(bp->pdev, dma_addr,
2893                         BNX2_RX_OFFSET + BNX2_RX_COPY_THRESH,
2894                         PCI_DMA_FROMDEVICE);
2895
2896                 rx_hdr = (struct l2_fhdr *) skb->data;
2897                 len = rx_hdr->l2_fhdr_pkt_len;
2898
2899                 if ((status = rx_hdr->l2_fhdr_status) &
2900                         (L2_FHDR_ERRORS_BAD_CRC |
2901                         L2_FHDR_ERRORS_PHY_DECODE |
2902                         L2_FHDR_ERRORS_ALIGNMENT |
2903                         L2_FHDR_ERRORS_TOO_SHORT |
2904                         L2_FHDR_ERRORS_GIANT_FRAME)) {
2905
2906                         bnx2_reuse_rx_skb(bp, rxr, skb, sw_ring_cons,
2907                                           sw_ring_prod);
2908                         goto next_rx;
2909                 }
2910                 hdr_len = 0;
2911                 if (status & L2_FHDR_STATUS_SPLIT) {
2912                         hdr_len = rx_hdr->l2_fhdr_ip_xsum;
2913                         pg_ring_used = 1;
2914                 } else if (len > bp->rx_jumbo_thresh) {
2915                         hdr_len = bp->rx_jumbo_thresh;
2916                         pg_ring_used = 1;
2917                 }
2918
2919                 len -= 4;
2920
2921                 if (len <= bp->rx_copy_thresh) {
2922                         struct sk_buff *new_skb;
2923
2924                         new_skb = netdev_alloc_skb(bp->dev, len + 6);
2925                         if (new_skb == NULL) {
2926                                 bnx2_reuse_rx_skb(bp, rxr, skb, sw_ring_cons,
2927                                                   sw_ring_prod);
2928                                 goto next_rx;
2929                         }
2930
2931                         /* aligned copy */
2932                         skb_copy_from_linear_data_offset(skb,
2933                                                          BNX2_RX_OFFSET - 6,
2934                                       new_skb->data, len + 6);
2935                         skb_reserve(new_skb, 6);
2936                         skb_put(new_skb, len);
2937
2938                         bnx2_reuse_rx_skb(bp, rxr, skb,
2939                                 sw_ring_cons, sw_ring_prod);
2940
2941                         skb = new_skb;
2942                 } else if (unlikely(bnx2_rx_skb(bp, rxr, skb, len, hdr_len,
2943                            dma_addr, (sw_ring_cons << 16) | sw_ring_prod)))
2944                         goto next_rx;
2945
2946                 if ((status & L2_FHDR_STATUS_L2_VLAN_TAG) &&
2947                     !(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG)) {
2948                         vtag = rx_hdr->l2_fhdr_vlan_tag;
2949 #ifdef BCM_VLAN
2950                         if (bp->vlgrp)
2951                                 hw_vlan = 1;
2952                         else
2953 #endif
2954                         {
2955                                 struct vlan_ethhdr *ve = (struct vlan_ethhdr *)
2956                                         __skb_push(skb, 4);
2957
2958                                 memmove(ve, skb->data + 4, ETH_ALEN * 2);
2959                                 ve->h_vlan_proto = htons(ETH_P_8021Q);
2960                                 ve->h_vlan_TCI = htons(vtag);
2961                                 len += 4;
2962                         }
2963                 }
2964
2965                 skb->protocol = eth_type_trans(skb, bp->dev);
2966
2967                 if ((len > (bp->dev->mtu + ETH_HLEN)) &&
2968                         (ntohs(skb->protocol) != 0x8100)) {
2969
2970                         dev_kfree_skb(skb);
2971                         goto next_rx;
2972
2973                 }
2974
2975                 skb->ip_summed = CHECKSUM_NONE;
2976                 if (bp->rx_csum &&
2977                         (status & (L2_FHDR_STATUS_TCP_SEGMENT |
2978                         L2_FHDR_STATUS_UDP_DATAGRAM))) {
2979
2980                         if (likely((status & (L2_FHDR_ERRORS_TCP_XSUM |
2981                                               L2_FHDR_ERRORS_UDP_XSUM)) == 0))
2982                                 skb->ip_summed = CHECKSUM_UNNECESSARY;
2983                 }
2984
2985 #ifdef BCM_VLAN
2986                 if (hw_vlan)
2987                         vlan_hwaccel_receive_skb(skb, bp->vlgrp, vtag);
2988                 else
2989 #endif
2990                         netif_receive_skb(skb);
2991
2992                 bp->dev->last_rx = jiffies;
2993                 rx_pkt++;
2994
2995 next_rx:
2996                 sw_cons = NEXT_RX_BD(sw_cons);
2997                 sw_prod = NEXT_RX_BD(sw_prod);
2998
2999                 if ((rx_pkt == budget))
3000                         break;
3001
3002                 /* Refresh hw_cons to see if there is new work */
3003                 if (sw_cons == hw_cons) {
3004                         hw_cons = bnx2_get_hw_rx_cons(bnapi);
3005                         rmb();
3006                 }
3007         }
3008         rxr->rx_cons = sw_cons;
3009         rxr->rx_prod = sw_prod;
3010
3011         if (pg_ring_used)
3012                 REG_WR16(bp, rxr->rx_pg_bidx_addr, rxr->rx_pg_prod);
3013
3014         REG_WR16(bp, rxr->rx_bidx_addr, sw_prod);
3015
3016         REG_WR(bp, rxr->rx_bseq_addr, rxr->rx_prod_bseq);
3017
3018         mmiowb();
3019
3020         return rx_pkt;
3021
3022 }
3023
3024 /* MSI ISR - The only difference between this and the INTx ISR
3025  * is that the MSI interrupt is always serviced.
3026  */
3027 static irqreturn_t
3028 bnx2_msi(int irq, void *dev_instance)
3029 {
3030         struct bnx2_napi *bnapi = dev_instance;
3031         struct bnx2 *bp = bnapi->bp;
3032         struct net_device *dev = bp->dev;
3033
3034         prefetch(bnapi->status_blk.msi);
3035         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3036                 BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
3037                 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
3038
3039         /* Return here if interrupt is disabled. */
3040         if (unlikely(atomic_read(&bp->intr_sem) != 0))
3041                 return IRQ_HANDLED;
3042
3043         netif_rx_schedule(dev, &bnapi->napi);
3044
3045         return IRQ_HANDLED;
3046 }
3047
3048 static irqreturn_t
3049 bnx2_msi_1shot(int irq, void *dev_instance)
3050 {
3051         struct bnx2_napi *bnapi = dev_instance;
3052         struct bnx2 *bp = bnapi->bp;
3053         struct net_device *dev = bp->dev;
3054
3055         prefetch(bnapi->status_blk.msi);
3056
3057         /* Return here if interrupt is disabled. */
3058         if (unlikely(atomic_read(&bp->intr_sem) != 0))
3059                 return IRQ_HANDLED;
3060
3061         netif_rx_schedule(dev, &bnapi->napi);
3062
3063         return IRQ_HANDLED;
3064 }
3065
3066 static irqreturn_t
3067 bnx2_interrupt(int irq, void *dev_instance)
3068 {
3069         struct bnx2_napi *bnapi = dev_instance;
3070         struct bnx2 *bp = bnapi->bp;
3071         struct net_device *dev = bp->dev;
3072         struct status_block *sblk = bnapi->status_blk.msi;
3073
3074         /* When using INTx, it is possible for the interrupt to arrive
3075          * at the CPU before the status block posted prior to the
3076          * interrupt. Reading a register will flush the status block.
3077          * When using MSI, the MSI message will always complete after
3078          * the status block write.
3079          */
3080         if ((sblk->status_idx == bnapi->last_status_idx) &&
3081             (REG_RD(bp, BNX2_PCICFG_MISC_STATUS) &
3082              BNX2_PCICFG_MISC_STATUS_INTA_VALUE))
3083                 return IRQ_NONE;
3084
3085         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3086                 BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
3087                 BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
3088
3089         /* Read back to deassert IRQ immediately to avoid too many
3090          * spurious interrupts.
3091          */
3092         REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
3093
3094         /* Return here if interrupt is shared and is disabled. */
3095         if (unlikely(atomic_read(&bp->intr_sem) != 0))
3096                 return IRQ_HANDLED;
3097
3098         if (netif_rx_schedule_prep(dev, &bnapi->napi)) {
3099                 bnapi->last_status_idx = sblk->status_idx;
3100                 __netif_rx_schedule(dev, &bnapi->napi);
3101         }
3102
3103         return IRQ_HANDLED;
3104 }
3105
3106 static inline int
3107 bnx2_has_fast_work(struct bnx2_napi *bnapi)
3108 {
3109         struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
3110         struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
3111
3112         if ((bnx2_get_hw_rx_cons(bnapi) != rxr->rx_cons) ||
3113             (bnx2_get_hw_tx_cons(bnapi) != txr->hw_tx_cons))
3114                 return 1;
3115         return 0;
3116 }
3117
3118 #define STATUS_ATTN_EVENTS      (STATUS_ATTN_BITS_LINK_STATE | \
3119                                  STATUS_ATTN_BITS_TIMER_ABORT)
3120
3121 static inline int
3122 bnx2_has_work(struct bnx2_napi *bnapi)
3123 {
3124         struct status_block *sblk = bnapi->status_blk.msi;
3125
3126         if (bnx2_has_fast_work(bnapi))
3127                 return 1;
3128
3129         if ((sblk->status_attn_bits & STATUS_ATTN_EVENTS) !=
3130             (sblk->status_attn_bits_ack & STATUS_ATTN_EVENTS))
3131                 return 1;
3132
3133         return 0;
3134 }
3135
3136 static void bnx2_poll_link(struct bnx2 *bp, struct bnx2_napi *bnapi)
3137 {
3138         struct status_block *sblk = bnapi->status_blk.msi;
3139         u32 status_attn_bits = sblk->status_attn_bits;
3140         u32 status_attn_bits_ack = sblk->status_attn_bits_ack;
3141
3142         if ((status_attn_bits & STATUS_ATTN_EVENTS) !=
3143             (status_attn_bits_ack & STATUS_ATTN_EVENTS)) {
3144
3145                 bnx2_phy_int(bp, bnapi);
3146
3147                 /* This is needed to take care of transient status
3148                  * during link changes.
3149                  */
3150                 REG_WR(bp, BNX2_HC_COMMAND,
3151                        bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
3152                 REG_RD(bp, BNX2_HC_COMMAND);
3153         }
3154 }
3155
3156 static int bnx2_poll_work(struct bnx2 *bp, struct bnx2_napi *bnapi,
3157                           int work_done, int budget)
3158 {
3159         struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
3160         struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
3161
3162         if (bnx2_get_hw_tx_cons(bnapi) != txr->hw_tx_cons)
3163                 bnx2_tx_int(bp, bnapi, 0);
3164
3165         if (bnx2_get_hw_rx_cons(bnapi) != rxr->rx_cons)
3166                 work_done += bnx2_rx_int(bp, bnapi, budget - work_done);
3167
3168         return work_done;
3169 }
3170
3171 static int bnx2_poll_msix(struct napi_struct *napi, int budget)
3172 {
3173         struct bnx2_napi *bnapi = container_of(napi, struct bnx2_napi, napi);
3174         struct bnx2 *bp = bnapi->bp;
3175         int work_done = 0;
3176         struct status_block_msix *sblk = bnapi->status_blk.msix;
3177
3178         while (1) {
3179                 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
3180                 if (unlikely(work_done >= budget))
3181                         break;
3182
3183                 bnapi->last_status_idx = sblk->status_idx;
3184                 /* status idx must be read before checking for more work. */
3185                 rmb();
3186                 if (likely(!bnx2_has_fast_work(bnapi))) {
3187
3188                         netif_rx_complete(bp->dev, napi);
3189                         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
3190                                BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
3191                                bnapi->last_status_idx);
3192                         break;
3193                 }
3194         }
3195         return work_done;
3196 }
3197
3198 static int bnx2_poll(struct napi_struct *napi, int budget)
3199 {
3200         struct bnx2_napi *bnapi = container_of(napi, struct bnx2_napi, napi);
3201         struct bnx2 *bp = bnapi->bp;
3202         int work_done = 0;
3203         struct status_block *sblk = bnapi->status_blk.msi;
3204
3205         while (1) {
3206                 bnx2_poll_link(bp, bnapi);
3207
3208                 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
3209
3210                 if (unlikely(work_done >= budget))
3211                         break;
3212
3213                 /* bnapi->last_status_idx is used below to tell the hw how
3214                  * much work has been processed, so we must read it before
3215                  * checking for more work.
3216                  */
3217                 bnapi->last_status_idx = sblk->status_idx;
3218                 rmb();
3219                 if (likely(!bnx2_has_work(bnapi))) {
3220                         netif_rx_complete(bp->dev, napi);
3221                         if (likely(bp->flags & BNX2_FLAG_USING_MSI_OR_MSIX)) {
3222                                 REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3223                                        BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
3224                                        bnapi->last_status_idx);
3225                                 break;
3226                         }
3227                         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3228                                BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
3229                                BNX2_PCICFG_INT_ACK_CMD_MASK_INT |
3230                                bnapi->last_status_idx);
3231
3232                         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3233                                BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
3234                                bnapi->last_status_idx);
3235                         break;
3236                 }
3237         }
3238
3239         return work_done;
3240 }
3241
3242 /* Called with rtnl_lock from vlan functions and also netif_tx_lock
3243  * from set_multicast.
3244  */
3245 static void
3246 bnx2_set_rx_mode(struct net_device *dev)
3247 {
3248         struct bnx2 *bp = netdev_priv(dev);
3249         u32 rx_mode, sort_mode;
3250         struct dev_addr_list *uc_ptr;
3251         int i;
3252
3253         spin_lock_bh(&bp->phy_lock);
3254
3255         rx_mode = bp->rx_mode & ~(BNX2_EMAC_RX_MODE_PROMISCUOUS |
3256                                   BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG);
3257         sort_mode = 1 | BNX2_RPM_SORT_USER0_BC_EN;
3258 #ifdef BCM_VLAN
3259         if (!bp->vlgrp && (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
3260                 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
3261 #else
3262         if (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN)
3263                 rx_mode |= BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG;
3264 #endif
3265         if (dev->flags & IFF_PROMISC) {
3266                 /* Promiscuous mode. */
3267                 rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
3268                 sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
3269                              BNX2_RPM_SORT_USER0_PROM_VLAN;
3270         }
3271         else if (dev->flags & IFF_ALLMULTI) {
3272                 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3273                         REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3274                                0xffffffff);
3275                 }
3276                 sort_mode |= BNX2_RPM_SORT_USER0_MC_EN;
3277         }
3278         else {
3279                 /* Accept one or more multicast(s). */
3280                 struct dev_mc_list *mclist;
3281                 u32 mc_filter[NUM_MC_HASH_REGISTERS];
3282                 u32 regidx;
3283                 u32 bit;
3284                 u32 crc;
3285
3286                 memset(mc_filter, 0, 4 * NUM_MC_HASH_REGISTERS);
3287
3288                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3289                      i++, mclist = mclist->next) {
3290
3291                         crc = ether_crc_le(ETH_ALEN, mclist->dmi_addr);
3292                         bit = crc & 0xff;
3293                         regidx = (bit & 0xe0) >> 5;
3294                         bit &= 0x1f;
3295                         mc_filter[regidx] |= (1 << bit);
3296                 }
3297
3298                 for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3299                         REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3300                                mc_filter[i]);
3301                 }
3302
3303                 sort_mode |= BNX2_RPM_SORT_USER0_MC_HSH_EN;
3304         }
3305
3306         uc_ptr = NULL;
3307         if (dev->uc_count > BNX2_MAX_UNICAST_ADDRESSES) {
3308                 rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
3309                 sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
3310                              BNX2_RPM_SORT_USER0_PROM_VLAN;
3311         } else if (!(dev->flags & IFF_PROMISC)) {
3312                 uc_ptr = dev->uc_list;
3313
3314                 /* Add all entries into to the match filter list */
3315                 for (i = 0; i < dev->uc_count; i++) {
3316                         bnx2_set_mac_addr(bp, uc_ptr->da_addr,
3317                                           i + BNX2_START_UNICAST_ADDRESS_INDEX);
3318                         sort_mode |= (1 <<
3319                                       (i + BNX2_START_UNICAST_ADDRESS_INDEX));
3320                         uc_ptr = uc_ptr->next;
3321                 }
3322
3323         }
3324
3325         if (rx_mode != bp->rx_mode) {
3326                 bp->rx_mode = rx_mode;
3327                 REG_WR(bp, BNX2_EMAC_RX_MODE, rx_mode);
3328         }
3329
3330         REG_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
3331         REG_WR(bp, BNX2_RPM_SORT_USER0, sort_mode);
3332         REG_WR(bp, BNX2_RPM_SORT_USER0, sort_mode | BNX2_RPM_SORT_USER0_ENA);
3333
3334         spin_unlock_bh(&bp->phy_lock);
3335 }
3336
3337 static void
3338 load_rv2p_fw(struct bnx2 *bp, __le32 *rv2p_code, u32 rv2p_code_len,
3339         u32 rv2p_proc)
3340 {
3341         int i;
3342         u32 val;
3343
3344         if (rv2p_proc == RV2P_PROC2 && CHIP_NUM(bp) == CHIP_NUM_5709) {
3345                 val = le32_to_cpu(rv2p_code[XI_RV2P_PROC2_MAX_BD_PAGE_LOC]);
3346                 val &= ~XI_RV2P_PROC2_BD_PAGE_SIZE_MSK;
3347                 val |= XI_RV2P_PROC2_BD_PAGE_SIZE;
3348                 rv2p_code[XI_RV2P_PROC2_MAX_BD_PAGE_LOC] = cpu_to_le32(val);
3349         }
3350
3351         for (i = 0; i < rv2p_code_len; i += 8) {
3352                 REG_WR(bp, BNX2_RV2P_INSTR_HIGH, le32_to_cpu(*rv2p_code));
3353                 rv2p_code++;
3354                 REG_WR(bp, BNX2_RV2P_INSTR_LOW, le32_to_cpu(*rv2p_code));
3355                 rv2p_code++;
3356
3357                 if (rv2p_proc == RV2P_PROC1) {
3358                         val = (i / 8) | BNX2_RV2P_PROC1_ADDR_CMD_RDWR;
3359                         REG_WR(bp, BNX2_RV2P_PROC1_ADDR_CMD, val);
3360                 }
3361                 else {
3362                         val = (i / 8) | BNX2_RV2P_PROC2_ADDR_CMD_RDWR;
3363                         REG_WR(bp, BNX2_RV2P_PROC2_ADDR_CMD, val);
3364                 }
3365         }
3366
3367         /* Reset the processor, un-stall is done later. */
3368         if (rv2p_proc == RV2P_PROC1) {
3369                 REG_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC1_RESET);
3370         }
3371         else {
3372                 REG_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC2_RESET);
3373         }
3374 }
3375
3376 static int
3377 load_cpu_fw(struct bnx2 *bp, const struct cpu_reg *cpu_reg, struct fw_info *fw)
3378 {
3379         u32 offset;
3380         u32 val;
3381         int rc;
3382
3383         /* Halt the CPU. */
3384         val = bnx2_reg_rd_ind(bp, cpu_reg->mode);
3385         val |= cpu_reg->mode_value_halt;
3386         bnx2_reg_wr_ind(bp, cpu_reg->mode, val);
3387         bnx2_reg_wr_ind(bp, cpu_reg->state, cpu_reg->state_value_clear);
3388
3389         /* Load the Text area. */
3390         offset = cpu_reg->spad_base + (fw->text_addr - cpu_reg->mips_view_base);
3391         if (fw->gz_text) {
3392                 int j;
3393
3394                 rc = zlib_inflate_blob(fw->text, FW_BUF_SIZE, fw->gz_text,
3395                                        fw->gz_text_len);
3396                 if (rc < 0)
3397                         return rc;
3398
3399                 for (j = 0; j < (fw->text_len / 4); j++, offset += 4) {
3400                         bnx2_reg_wr_ind(bp, offset, le32_to_cpu(fw->text[j]));
3401                 }
3402         }
3403
3404         /* Load the Data area. */
3405         offset = cpu_reg->spad_base + (fw->data_addr - cpu_reg->mips_view_base);
3406         if (fw->data) {
3407                 int j;
3408
3409                 for (j = 0; j < (fw->data_len / 4); j++, offset += 4) {
3410                         bnx2_reg_wr_ind(bp, offset, fw->data[j]);
3411                 }
3412         }
3413
3414         /* Load the SBSS area. */
3415         offset = cpu_reg->spad_base + (fw->sbss_addr - cpu_reg->mips_view_base);
3416         if (fw->sbss_len) {
3417                 int j;
3418
3419                 for (j = 0; j < (fw->sbss_len / 4); j++, offset += 4) {
3420                         bnx2_reg_wr_ind(bp, offset, 0);
3421                 }
3422         }
3423
3424         /* Load the BSS area. */
3425         offset = cpu_reg->spad_base + (fw->bss_addr - cpu_reg->mips_view_base);
3426         if (fw->bss_len) {
3427                 int j;
3428
3429                 for (j = 0; j < (fw->bss_len/4); j++, offset += 4) {
3430                         bnx2_reg_wr_ind(bp, offset, 0);
3431                 }
3432         }
3433
3434         /* Load the Read-Only area. */
3435         offset = cpu_reg->spad_base +
3436                 (fw->rodata_addr - cpu_reg->mips_view_base);
3437         if (fw->rodata) {
3438                 int j;
3439
3440                 for (j = 0; j < (fw->rodata_len / 4); j++, offset += 4) {
3441                         bnx2_reg_wr_ind(bp, offset, fw->rodata[j]);
3442                 }
3443         }
3444
3445         /* Clear the pre-fetch instruction. */
3446         bnx2_reg_wr_ind(bp, cpu_reg->inst, 0);
3447         bnx2_reg_wr_ind(bp, cpu_reg->pc, fw->start_addr);
3448
3449         /* Start the CPU. */
3450         val = bnx2_reg_rd_ind(bp, cpu_reg->mode);
3451         val &= ~cpu_reg->mode_value_halt;
3452         bnx2_reg_wr_ind(bp, cpu_reg->state, cpu_reg->state_value_clear);
3453         bnx2_reg_wr_ind(bp, cpu_reg->mode, val);
3454
3455         return 0;
3456 }
3457
3458 static int
3459 bnx2_init_cpus(struct bnx2 *bp)
3460 {
3461         struct fw_info *fw;
3462         int rc, rv2p_len;
3463         void *text, *rv2p;
3464
3465         /* Initialize the RV2P processor. */
3466         text = vmalloc(FW_BUF_SIZE);
3467         if (!text)
3468                 return -ENOMEM;
3469         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3470                 rv2p = bnx2_xi_rv2p_proc1;
3471                 rv2p_len = sizeof(bnx2_xi_rv2p_proc1);
3472         } else {
3473                 rv2p = bnx2_rv2p_proc1;
3474                 rv2p_len = sizeof(bnx2_rv2p_proc1);
3475         }
3476         rc = zlib_inflate_blob(text, FW_BUF_SIZE, rv2p, rv2p_len);
3477         if (rc < 0)
3478                 goto init_cpu_err;
3479
3480         load_rv2p_fw(bp, text, rc /* == len */, RV2P_PROC1);
3481
3482         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3483                 rv2p = bnx2_xi_rv2p_proc2;
3484                 rv2p_len = sizeof(bnx2_xi_rv2p_proc2);
3485         } else {
3486                 rv2p = bnx2_rv2p_proc2;
3487                 rv2p_len = sizeof(bnx2_rv2p_proc2);
3488         }
3489         rc = zlib_inflate_blob(text, FW_BUF_SIZE, rv2p, rv2p_len);
3490         if (rc < 0)
3491                 goto init_cpu_err;
3492
3493         load_rv2p_fw(bp, text, rc /* == len */, RV2P_PROC2);
3494
3495         /* Initialize the RX Processor. */
3496         if (CHIP_NUM(bp) == CHIP_NUM_5709)
3497                 fw = &bnx2_rxp_fw_09;
3498         else
3499                 fw = &bnx2_rxp_fw_06;
3500
3501         fw->text = text;
3502         rc = load_cpu_fw(bp, &cpu_reg_rxp, fw);
3503         if (rc)
3504                 goto init_cpu_err;
3505
3506         /* Initialize the TX Processor. */
3507         if (CHIP_NUM(bp) == CHIP_NUM_5709)
3508                 fw = &bnx2_txp_fw_09;
3509         else
3510                 fw = &bnx2_txp_fw_06;
3511
3512         fw->text = text;
3513         rc = load_cpu_fw(bp, &cpu_reg_txp, fw);
3514         if (rc)
3515                 goto init_cpu_err;
3516
3517         /* Initialize the TX Patch-up Processor. */
3518         if (CHIP_NUM(bp) == CHIP_NUM_5709)
3519                 fw = &bnx2_tpat_fw_09;
3520         else
3521                 fw = &bnx2_tpat_fw_06;
3522
3523         fw->text = text;
3524         rc = load_cpu_fw(bp, &cpu_reg_tpat, fw);
3525         if (rc)
3526                 goto init_cpu_err;
3527
3528         /* Initialize the Completion Processor. */
3529         if (CHIP_NUM(bp) == CHIP_NUM_5709)
3530                 fw = &bnx2_com_fw_09;
3531         else
3532                 fw = &bnx2_com_fw_06;
3533
3534         fw->text = text;
3535         rc = load_cpu_fw(bp, &cpu_reg_com, fw);
3536         if (rc)
3537                 goto init_cpu_err;
3538
3539         /* Initialize the Command Processor. */
3540         if (CHIP_NUM(bp) == CHIP_NUM_5709)
3541                 fw = &bnx2_cp_fw_09;
3542         else
3543                 fw = &bnx2_cp_fw_06;
3544
3545         fw->text = text;
3546         rc = load_cpu_fw(bp, &cpu_reg_cp, fw);
3547
3548 init_cpu_err:
3549         vfree(text);
3550         return rc;
3551 }
3552
3553 static int
3554 bnx2_set_power_state(struct bnx2 *bp, pci_power_t state)
3555 {
3556         u16 pmcsr;
3557
3558         pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
3559
3560         switch (state) {
3561         case PCI_D0: {
3562                 u32 val;
3563
3564                 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
3565                         (pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
3566                         PCI_PM_CTRL_PME_STATUS);
3567
3568                 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
3569                         /* delay required during transition out of D3hot */
3570                         msleep(20);
3571
3572                 val = REG_RD(bp, BNX2_EMAC_MODE);
3573                 val |= BNX2_EMAC_MODE_MPKT_RCVD | BNX2_EMAC_MODE_ACPI_RCVD;
3574                 val &= ~BNX2_EMAC_MODE_MPKT;
3575                 REG_WR(bp, BNX2_EMAC_MODE, val);
3576
3577                 val = REG_RD(bp, BNX2_RPM_CONFIG);
3578                 val &= ~BNX2_RPM_CONFIG_ACPI_ENA;
3579                 REG_WR(bp, BNX2_RPM_CONFIG, val);
3580                 break;
3581         }
3582         case PCI_D3hot: {
3583                 int i;
3584                 u32 val, wol_msg;
3585
3586                 if (bp->wol) {
3587                         u32 advertising;
3588                         u8 autoneg;
3589
3590                         autoneg = bp->autoneg;
3591                         advertising = bp->advertising;
3592
3593                         if (bp->phy_port == PORT_TP) {
3594                                 bp->autoneg = AUTONEG_SPEED;
3595                                 bp->advertising = ADVERTISED_10baseT_Half |
3596                                         ADVERTISED_10baseT_Full |
3597                                         ADVERTISED_100baseT_Half |
3598                                         ADVERTISED_100baseT_Full |
3599                                         ADVERTISED_Autoneg;
3600                         }
3601
3602                         spin_lock_bh(&bp->phy_lock);
3603                         bnx2_setup_phy(bp, bp->phy_port);
3604                         spin_unlock_bh(&bp->phy_lock);
3605
3606                         bp->autoneg = autoneg;
3607                         bp->advertising = advertising;
3608
3609                         bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
3610
3611                         val = REG_RD(bp, BNX2_EMAC_MODE);
3612
3613                         /* Enable port mode. */
3614                         val &= ~BNX2_EMAC_MODE_PORT;
3615                         val |= BNX2_EMAC_MODE_MPKT_RCVD |
3616                                BNX2_EMAC_MODE_ACPI_RCVD |
3617                                BNX2_EMAC_MODE_MPKT;
3618                         if (bp->phy_port == PORT_TP)
3619                                 val |= BNX2_EMAC_MODE_PORT_MII;
3620                         else {
3621                                 val |= BNX2_EMAC_MODE_PORT_GMII;
3622                                 if (bp->line_speed == SPEED_2500)
3623                                         val |= BNX2_EMAC_MODE_25G_MODE;
3624                         }
3625
3626                         REG_WR(bp, BNX2_EMAC_MODE, val);
3627
3628                         /* receive all multicast */
3629                         for (i = 0; i < NUM_MC_HASH_REGISTERS; i++) {
3630                                 REG_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3631                                        0xffffffff);
3632                         }
3633                         REG_WR(bp, BNX2_EMAC_RX_MODE,
3634                                BNX2_EMAC_RX_MODE_SORT_MODE);
3635
3636                         val = 1 | BNX2_RPM_SORT_USER0_BC_EN |
3637                               BNX2_RPM_SORT_USER0_MC_EN;
3638                         REG_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
3639                         REG_WR(bp, BNX2_RPM_SORT_USER0, val);
3640                         REG_WR(bp, BNX2_RPM_SORT_USER0, val |
3641                                BNX2_RPM_SORT_USER0_ENA);
3642
3643                         /* Need to enable EMAC and RPM for WOL. */
3644                         REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
3645                                BNX2_MISC_ENABLE_SET_BITS_RX_PARSER_MAC_ENABLE |
3646                                BNX2_MISC_ENABLE_SET_BITS_TX_HEADER_Q_ENABLE |
3647                                BNX2_MISC_ENABLE_SET_BITS_EMAC_ENABLE);
3648
3649                         val = REG_RD(bp, BNX2_RPM_CONFIG);
3650                         val &= ~BNX2_RPM_CONFIG_ACPI_ENA;
3651                         REG_WR(bp, BNX2_RPM_CONFIG, val);
3652
3653                         wol_msg = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
3654                 }
3655                 else {
3656                         wol_msg = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
3657                 }
3658
3659                 if (!(bp->flags & BNX2_FLAG_NO_WOL))
3660                         bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT3 | wol_msg,
3661                                      1, 0);
3662
3663                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
3664                 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
3665                     (CHIP_ID(bp) == CHIP_ID_5706_A1)) {
3666
3667                         if (bp->wol)
3668                                 pmcsr |= 3;
3669                 }
3670                 else {
3671                         pmcsr |= 3;
3672                 }
3673                 if (bp->wol) {
3674                         pmcsr |= PCI_PM_CTRL_PME_ENABLE;
3675                 }
3676                 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
3677                                       pmcsr);
3678
3679                 /* No more memory access after this point until
3680                  * device is brought back to D0.
3681                  */
3682                 udelay(50);
3683                 break;
3684         }
3685         default:
3686                 return -EINVAL;
3687         }
3688         return 0;
3689 }
3690
3691 static int
3692 bnx2_acquire_nvram_lock(struct bnx2 *bp)
3693 {
3694         u32 val;
3695         int j;
3696
3697         /* Request access to the flash interface. */
3698         REG_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_SET2);
3699         for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3700                 val = REG_RD(bp, BNX2_NVM_SW_ARB);
3701                 if (val & BNX2_NVM_SW_ARB_ARB_ARB2)
3702                         break;
3703
3704                 udelay(5);
3705         }
3706
3707         if (j >= NVRAM_TIMEOUT_COUNT)
3708                 return -EBUSY;
3709
3710         return 0;
3711 }
3712
3713 static int
3714 bnx2_release_nvram_lock(struct bnx2 *bp)
3715 {
3716         int j;
3717         u32 val;
3718
3719         /* Relinquish nvram interface. */
3720         REG_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_CLR2);
3721
3722         for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3723                 val = REG_RD(bp, BNX2_NVM_SW_ARB);
3724                 if (!(val & BNX2_NVM_SW_ARB_ARB_ARB2))
3725                         break;
3726
3727                 udelay(5);
3728         }
3729
3730         if (j >= NVRAM_TIMEOUT_COUNT)
3731                 return -EBUSY;
3732
3733         return 0;
3734 }
3735
3736
3737 static int
3738 bnx2_enable_nvram_write(struct bnx2 *bp)
3739 {
3740         u32 val;
3741
3742         val = REG_RD(bp, BNX2_MISC_CFG);
3743         REG_WR(bp, BNX2_MISC_CFG, val | BNX2_MISC_CFG_NVM_WR_EN_PCI);
3744
3745         if (bp->flash_info->flags & BNX2_NV_WREN) {
3746                 int j;
3747
3748                 REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3749                 REG_WR(bp, BNX2_NVM_COMMAND,
3750                        BNX2_NVM_COMMAND_WREN | BNX2_NVM_COMMAND_DOIT);
3751
3752                 for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3753                         udelay(5);
3754
3755                         val = REG_RD(bp, BNX2_NVM_COMMAND);
3756                         if (val & BNX2_NVM_COMMAND_DONE)
3757                                 break;
3758                 }
3759
3760                 if (j >= NVRAM_TIMEOUT_COUNT)
3761                         return -EBUSY;
3762         }
3763         return 0;
3764 }
3765
3766 static void
3767 bnx2_disable_nvram_write(struct bnx2 *bp)
3768 {
3769         u32 val;
3770
3771         val = REG_RD(bp, BNX2_MISC_CFG);
3772         REG_WR(bp, BNX2_MISC_CFG, val & ~BNX2_MISC_CFG_NVM_WR_EN);
3773 }
3774
3775
3776 static void
3777 bnx2_enable_nvram_access(struct bnx2 *bp)
3778 {
3779         u32 val;
3780
3781         val = REG_RD(bp, BNX2_NVM_ACCESS_ENABLE);
3782         /* Enable both bits, even on read. */
3783         REG_WR(bp, BNX2_NVM_ACCESS_ENABLE,
3784                val | BNX2_NVM_ACCESS_ENABLE_EN | BNX2_NVM_ACCESS_ENABLE_WR_EN);
3785 }
3786
3787 static void
3788 bnx2_disable_nvram_access(struct bnx2 *bp)
3789 {
3790         u32 val;
3791
3792         val = REG_RD(bp, BNX2_NVM_ACCESS_ENABLE);
3793         /* Disable both bits, even after read. */
3794         REG_WR(bp, BNX2_NVM_ACCESS_ENABLE,
3795                 val & ~(BNX2_NVM_ACCESS_ENABLE_EN |
3796                         BNX2_NVM_ACCESS_ENABLE_WR_EN));
3797 }
3798
3799 static int
3800 bnx2_nvram_erase_page(struct bnx2 *bp, u32 offset)
3801 {
3802         u32 cmd;
3803         int j;
3804
3805         if (bp->flash_info->flags & BNX2_NV_BUFFERED)
3806                 /* Buffered flash, no erase needed */
3807                 return 0;
3808
3809         /* Build an erase command */
3810         cmd = BNX2_NVM_COMMAND_ERASE | BNX2_NVM_COMMAND_WR |
3811               BNX2_NVM_COMMAND_DOIT;
3812
3813         /* Need to clear DONE bit separately. */
3814         REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3815
3816         /* Address of the NVRAM to read from. */
3817         REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3818
3819         /* Issue an erase command. */
3820         REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3821
3822         /* Wait for completion. */
3823         for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3824                 u32 val;
3825
3826                 udelay(5);
3827
3828                 val = REG_RD(bp, BNX2_NVM_COMMAND);
3829                 if (val & BNX2_NVM_COMMAND_DONE)
3830                         break;
3831         }
3832
3833         if (j >= NVRAM_TIMEOUT_COUNT)
3834                 return -EBUSY;
3835
3836         return 0;
3837 }
3838
3839 static int
3840 bnx2_nvram_read_dword(struct bnx2 *bp, u32 offset, u8 *ret_val, u32 cmd_flags)
3841 {
3842         u32 cmd;
3843         int j;
3844
3845         /* Build the command word. */
3846         cmd = BNX2_NVM_COMMAND_DOIT | cmd_flags;
3847
3848         /* Calculate an offset of a buffered flash, not needed for 5709. */
3849         if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
3850                 offset = ((offset / bp->flash_info->page_size) <<
3851                            bp->flash_info->page_bits) +
3852                           (offset % bp->flash_info->page_size);
3853         }
3854
3855         /* Need to clear DONE bit separately. */
3856         REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3857
3858         /* Address of the NVRAM to read from. */
3859         REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3860
3861         /* Issue a read command. */
3862         REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3863
3864         /* Wait for completion. */
3865         for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3866                 u32 val;
3867
3868                 udelay(5);
3869
3870                 val = REG_RD(bp, BNX2_NVM_COMMAND);
3871                 if (val & BNX2_NVM_COMMAND_DONE) {
3872                         __be32 v = cpu_to_be32(REG_RD(bp, BNX2_NVM_READ));
3873                         memcpy(ret_val, &v, 4);
3874                         break;
3875                 }
3876         }
3877         if (j >= NVRAM_TIMEOUT_COUNT)
3878                 return -EBUSY;
3879
3880         return 0;
3881 }
3882
3883
3884 static int
3885 bnx2_nvram_write_dword(struct bnx2 *bp, u32 offset, u8 *val, u32 cmd_flags)
3886 {
3887         u32 cmd;
3888         __be32 val32;
3889         int j;
3890
3891         /* Build the command word. */
3892         cmd = BNX2_NVM_COMMAND_DOIT | BNX2_NVM_COMMAND_WR | cmd_flags;
3893
3894         /* Calculate an offset of a buffered flash, not needed for 5709. */
3895         if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
3896                 offset = ((offset / bp->flash_info->page_size) <<
3897                           bp->flash_info->page_bits) +
3898                          (offset % bp->flash_info->page_size);
3899         }
3900
3901         /* Need to clear DONE bit separately. */
3902         REG_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
3903
3904         memcpy(&val32, val, 4);
3905
3906         /* Write the data. */
3907         REG_WR(bp, BNX2_NVM_WRITE, be32_to_cpu(val32));
3908
3909         /* Address of the NVRAM to write to. */
3910         REG_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
3911
3912         /* Issue the write command. */
3913         REG_WR(bp, BNX2_NVM_COMMAND, cmd);
3914
3915         /* Wait for completion. */
3916         for (j = 0; j < NVRAM_TIMEOUT_COUNT; j++) {
3917                 udelay(5);
3918
3919                 if (REG_RD(bp, BNX2_NVM_COMMAND) & BNX2_NVM_COMMAND_DONE)
3920                         break;
3921         }
3922         if (j >= NVRAM_TIMEOUT_COUNT)
3923                 return -EBUSY;
3924
3925         return 0;
3926 }
3927
3928 static int
3929 bnx2_init_nvram(struct bnx2 *bp)
3930 {
3931         u32 val;
3932         int j, entry_count, rc = 0;
3933         struct flash_spec *flash;
3934
3935         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
3936                 bp->flash_info = &flash_5709;
3937                 goto get_flash_size;
3938         }
3939
3940         /* Determine the selected interface. */
3941         val = REG_RD(bp, BNX2_NVM_CFG1);
3942
3943         entry_count = ARRAY_SIZE(flash_table);
3944
3945         if (val & 0x40000000) {
3946
3947                 /* Flash interface has been reconfigured */
3948                 for (j = 0, flash = &flash_table[0]; j < entry_count;
3949                      j++, flash++) {
3950                         if ((val & FLASH_BACKUP_STRAP_MASK) ==
3951                             (flash->config1 & FLASH_BACKUP_STRAP_MASK)) {
3952                                 bp->flash_info = flash;
3953                                 break;
3954                         }
3955                 }
3956         }
3957         else {
3958                 u32 mask;
3959                 /* Not yet been reconfigured */
3960
3961                 if (val & (1 << 23))
3962                         mask = FLASH_BACKUP_STRAP_MASK;
3963                 else
3964                         mask = FLASH_STRAP_MASK;
3965
3966                 for (j = 0, flash = &flash_table[0]; j < entry_count;
3967                         j++, flash++) {
3968
3969                         if ((val & mask) == (flash->strapping & mask)) {
3970                                 bp->flash_info = flash;
3971
3972                                 /* Request access to the flash interface. */
3973                                 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
3974                                         return rc;
3975
3976                                 /* Enable access to flash interface */
3977                                 bnx2_enable_nvram_access(bp);
3978
3979                                 /* Reconfigure the flash interface */
3980                                 REG_WR(bp, BNX2_NVM_CFG1, flash->config1);
3981                                 REG_WR(bp, BNX2_NVM_CFG2, flash->config2);
3982                                 REG_WR(bp, BNX2_NVM_CFG3, flash->config3);
3983                                 REG_WR(bp, BNX2_NVM_WRITE1, flash->write1);
3984
3985                                 /* Disable access to flash interface */
3986                                 bnx2_disable_nvram_access(bp);
3987                                 bnx2_release_nvram_lock(bp);
3988
3989                                 break;
3990                         }
3991                 }
3992         } /* if (val & 0x40000000) */
3993
3994         if (j == entry_count) {
3995                 bp->flash_info = NULL;
3996                 printk(KERN_ALERT PFX "Unknown flash/EEPROM type.\n");
3997                 return -ENODEV;
3998         }
3999
4000 get_flash_size:
4001         val = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG2);
4002         val &= BNX2_SHARED_HW_CFG2_NVM_SIZE_MASK;
4003         if (val)
4004                 bp->flash_size = val;
4005         else
4006                 bp->flash_size = bp->flash_info->total_size;
4007
4008         return rc;
4009 }
4010
4011 static int
4012 bnx2_nvram_read(struct bnx2 *bp, u32 offset, u8 *ret_buf,
4013                 int buf_size)
4014 {
4015         int rc = 0;
4016         u32 cmd_flags, offset32, len32, extra;
4017
4018         if (buf_size == 0)
4019                 return 0;
4020
4021         /* Request access to the flash interface. */
4022         if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4023                 return rc;
4024
4025         /* Enable access to flash interface */
4026         bnx2_enable_nvram_access(bp);
4027
4028         len32 = buf_size;
4029         offset32 = offset;
4030         extra = 0;
4031
4032         cmd_flags = 0;
4033
4034         if (offset32 & 3) {
4035                 u8 buf[4];
4036                 u32 pre_len;
4037
4038                 offset32 &= ~3;
4039                 pre_len = 4 - (offset & 3);
4040
4041                 if (pre_len >= len32) {
4042                         pre_len = len32;
4043                         cmd_flags = BNX2_NVM_COMMAND_FIRST |
4044                                     BNX2_NVM_COMMAND_LAST;
4045                 }
4046                 else {
4047                         cmd_flags = BNX2_NVM_COMMAND_FIRST;
4048                 }
4049
4050                 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4051
4052                 if (rc)
4053                         return rc;
4054
4055                 memcpy(ret_buf, buf + (offset & 3), pre_len);
4056
4057                 offset32 += 4;
4058                 ret_buf += pre_len;
4059                 len32 -= pre_len;
4060         }
4061         if (len32 & 3) {
4062                 extra = 4 - (len32 & 3);
4063                 len32 = (len32 + 4) & ~3;
4064         }
4065
4066         if (len32 == 4) {
4067                 u8 buf[4];
4068
4069                 if (cmd_flags)
4070                         cmd_flags = BNX2_NVM_COMMAND_LAST;
4071                 else
4072                         cmd_flags = BNX2_NVM_COMMAND_FIRST |
4073                                     BNX2_NVM_COMMAND_LAST;
4074
4075                 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4076
4077                 memcpy(ret_buf, buf, 4 - extra);
4078         }
4079         else if (len32 > 0) {
4080                 u8 buf[4];
4081
4082                 /* Read the first word. */
4083                 if (cmd_flags)
4084                         cmd_flags = 0;
4085                 else
4086                         cmd_flags = BNX2_NVM_COMMAND_FIRST;
4087
4088                 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, cmd_flags);
4089
4090                 /* Advance to the next dword. */
4091                 offset32 += 4;
4092                 ret_buf += 4;
4093                 len32 -= 4;
4094
4095                 while (len32 > 4 && rc == 0) {
4096                         rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, 0);
4097
4098                         /* Advance to the next dword. */
4099                         offset32 += 4;
4100                         ret_buf += 4;
4101                         len32 -= 4;
4102                 }
4103
4104                 if (rc)
4105                         return rc;
4106
4107                 cmd_flags = BNX2_NVM_COMMAND_LAST;
4108                 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4109
4110                 memcpy(ret_buf, buf, 4 - extra);
4111         }
4112
4113         /* Disable access to flash interface */
4114         bnx2_disable_nvram_access(bp);
4115
4116         bnx2_release_nvram_lock(bp);
4117
4118         return rc;
4119 }
4120
4121 static int
4122 bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
4123                 int buf_size)
4124 {
4125         u32 written, offset32, len32;
4126         u8 *buf, start[4], end[4], *align_buf = NULL, *flash_buffer = NULL;
4127         int rc = 0;
4128         int align_start, align_end;
4129
4130         buf = data_buf;
4131         offset32 = offset;
4132         len32 = buf_size;
4133         align_start = align_end = 0;
4134
4135         if ((align_start = (offset32 & 3))) {
4136                 offset32 &= ~3;
4137                 len32 += align_start;
4138                 if (len32 < 4)
4139                         len32 = 4;
4140                 if ((rc = bnx2_nvram_read(bp, offset32, start, 4)))
4141                         return rc;
4142         }
4143
4144         if (len32 & 3) {
4145                 align_end = 4 - (len32 & 3);
4146                 len32 += align_end;
4147                 if ((rc = bnx2_nvram_read(bp, offset32 + len32 - 4, end, 4)))
4148                         return rc;
4149         }
4150
4151         if (align_start || align_end) {
4152                 align_buf = kmalloc(len32, GFP_KERNEL);
4153                 if (align_buf == NULL)
4154                         return -ENOMEM;
4155                 if (align_start) {
4156                         memcpy(align_buf, start, 4);
4157                 }
4158                 if (align_end) {
4159                         memcpy(align_buf + len32 - 4, end, 4);
4160                 }
4161                 memcpy(align_buf + align_start, data_buf, buf_size);
4162                 buf = align_buf;
4163         }
4164
4165         if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4166                 flash_buffer = kmalloc(264, GFP_KERNEL);
4167                 if (flash_buffer == NULL) {
4168                         rc = -ENOMEM;
4169                         goto nvram_write_end;
4170                 }
4171         }
4172
4173         written = 0;
4174         while ((written < len32) && (rc == 0)) {
4175                 u32 page_start, page_end, data_start, data_end;
4176                 u32 addr, cmd_flags;
4177                 int i;
4178
4179                 /* Find the page_start addr */
4180                 page_start = offset32 + written;
4181                 page_start -= (page_start % bp->flash_info->page_size);
4182                 /* Find the page_end addr */
4183                 page_end = page_start + bp->flash_info->page_size;
4184                 /* Find the data_start addr */
4185                 data_start = (written == 0) ? offset32 : page_start;
4186                 /* Find the data_end addr */
4187                 data_end = (page_end > offset32 + len32) ?
4188                         (offset32 + len32) : page_end;
4189
4190                 /* Request access to the flash interface. */
4191                 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4192                         goto nvram_write_end;
4193
4194                 /* Enable access to flash interface */
4195                 bnx2_enable_nvram_access(bp);
4196
4197                 cmd_flags = BNX2_NVM_COMMAND_FIRST;
4198                 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4199                         int j;
4200
4201                         /* Read the whole page into the buffer
4202                          * (non-buffer flash only) */
4203                         for (j = 0; j < bp->flash_info->page_size; j += 4) {
4204                                 if (j == (bp->flash_info->page_size - 4)) {
4205                                         cmd_flags |= BNX2_NVM_COMMAND_LAST;
4206                                 }
4207                                 rc = bnx2_nvram_read_dword(bp,
4208                                         page_start + j,
4209                                         &flash_buffer[j],
4210                                         cmd_flags);
4211
4212                                 if (rc)
4213                                         goto nvram_write_end;
4214
4215                                 cmd_flags = 0;
4216                         }
4217                 }
4218
4219                 /* Enable writes to flash interface (unlock write-protect) */
4220                 if ((rc = bnx2_enable_nvram_write(bp)) != 0)
4221                         goto nvram_write_end;
4222
4223                 /* Loop to write back the buffer data from page_start to
4224                  * data_start */
4225                 i = 0;
4226                 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4227                         /* Erase the page */
4228                         if ((rc = bnx2_nvram_erase_page(bp, page_start)) != 0)
4229                                 goto nvram_write_end;
4230
4231                         /* Re-enable the write again for the actual write */
4232                         bnx2_enable_nvram_write(bp);
4233
4234                         for (addr = page_start; addr < data_start;
4235                                 addr += 4, i += 4) {
4236
4237                                 rc = bnx2_nvram_write_dword(bp, addr,
4238                                         &flash_buffer[i], cmd_flags);
4239
4240                                 if (rc != 0)
4241                                         goto nvram_write_end;
4242
4243                                 cmd_flags = 0;
4244                         }
4245                 }
4246
4247                 /* Loop to write the new data from data_start to data_end */
4248                 for (addr = data_start; addr < data_end; addr += 4, i += 4) {
4249                         if ((addr == page_end - 4) ||
4250                                 ((bp->flash_info->flags & BNX2_NV_BUFFERED) &&
4251                                  (addr == data_end - 4))) {
4252
4253                                 cmd_flags |= BNX2_NVM_COMMAND_LAST;
4254                         }
4255                         rc = bnx2_nvram_write_dword(bp, addr, buf,
4256                                 cmd_flags);
4257
4258                         if (rc != 0)
4259                                 goto nvram_write_end;
4260
4261                         cmd_flags = 0;
4262                         buf += 4;
4263                 }
4264
4265                 /* Loop to write back the buffer data from data_end
4266                  * to page_end */
4267                 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4268                         for (addr = data_end; addr < page_end;
4269                                 addr += 4, i += 4) {
4270
4271                                 if (addr == page_end-4) {
4272                                         cmd_flags = BNX2_NVM_COMMAND_LAST;
4273                                 }
4274                                 rc = bnx2_nvram_write_dword(bp, addr,
4275                                         &flash_buffer[i], cmd_flags);
4276
4277                                 if (rc != 0)
4278                                         goto nvram_write_end;
4279
4280                                 cmd_flags = 0;
4281                         }
4282                 }
4283
4284                 /* Disable writes to flash interface (lock write-protect) */
4285                 bnx2_disable_nvram_write(bp);
4286
4287                 /* Disable access to flash interface */
4288                 bnx2_disable_nvram_access(bp);
4289                 bnx2_release_nvram_lock(bp);
4290
4291                 /* Increment written */
4292                 written += data_end - data_start;
4293         }
4294
4295 nvram_write_end:
4296         kfree(flash_buffer);
4297         kfree(align_buf);
4298         return rc;
4299 }
4300
4301 static void
4302 bnx2_init_fw_cap(struct bnx2 *bp)
4303 {
4304         u32 val, sig = 0;
4305
4306         bp->phy_flags &= ~BNX2_PHY_FLAG_REMOTE_PHY_CAP;
4307         bp->flags &= ~BNX2_FLAG_CAN_KEEP_VLAN;
4308
4309         if (!(bp->flags & BNX2_FLAG_ASF_ENABLE))
4310                 bp->flags |= BNX2_FLAG_CAN_KEEP_VLAN;
4311
4312         val = bnx2_shmem_rd(bp, BNX2_FW_CAP_MB);
4313         if ((val & BNX2_FW_CAP_SIGNATURE_MASK) != BNX2_FW_CAP_SIGNATURE)
4314                 return;
4315
4316         if ((val & BNX2_FW_CAP_CAN_KEEP_VLAN) == BNX2_FW_CAP_CAN_KEEP_VLAN) {
4317                 bp->flags |= BNX2_FLAG_CAN_KEEP_VLAN;
4318                 sig |= BNX2_DRV_ACK_CAP_SIGNATURE | BNX2_FW_CAP_CAN_KEEP_VLAN;
4319         }
4320
4321         if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
4322             (val & BNX2_FW_CAP_REMOTE_PHY_CAPABLE)) {
4323                 u32 link;
4324
4325                 bp->phy_flags |= BNX2_PHY_FLAG_REMOTE_PHY_CAP;
4326
4327                 link = bnx2_shmem_rd(bp, BNX2_LINK_STATUS);
4328                 if (link & BNX2_LINK_STATUS_SERDES_LINK)
4329                         bp->phy_port = PORT_FIBRE;
4330                 else
4331                         bp->phy_port = PORT_TP;
4332
4333                 sig |= BNX2_DRV_ACK_CAP_SIGNATURE |
4334                        BNX2_FW_CAP_REMOTE_PHY_CAPABLE;
4335         }
4336
4337         if (netif_running(bp->dev) && sig)
4338                 bnx2_shmem_wr(bp, BNX2_DRV_ACK_CAP_MB, sig);
4339 }
4340
4341 static void
4342 bnx2_setup_msix_tbl(struct bnx2 *bp)
4343 {
4344         REG_WR(bp, BNX2_PCI_GRC_WINDOW_ADDR, BNX2_PCI_GRC_WINDOW_ADDR_SEP_WIN);
4345
4346         REG_WR(bp, BNX2_PCI_GRC_WINDOW2_ADDR, BNX2_MSIX_TABLE_ADDR);
4347         REG_WR(bp, BNX2_PCI_GRC_WINDOW3_ADDR, BNX2_MSIX_PBA_ADDR);
4348 }
4349
4350 static int
4351 bnx2_reset_chip(struct bnx2 *bp, u32 reset_code)
4352 {
4353         u32 val;
4354         int i, rc = 0;
4355         u8 old_port;
4356
4357         /* Wait for the current PCI transaction to complete before
4358          * issuing a reset. */
4359         REG_WR(bp, BNX2_MISC_ENABLE_CLR_BITS,
4360                BNX2_MISC_ENABLE_CLR_BITS_TX_DMA_ENABLE |
4361                BNX2_MISC_ENABLE_CLR_BITS_DMA_ENGINE_ENABLE |
4362                BNX2_MISC_ENABLE_CLR_BITS_RX_DMA_ENABLE |
4363                BNX2_MISC_ENABLE_CLR_BITS_HOST_COALESCE_ENABLE);
4364         val = REG_RD(bp, BNX2_MISC_ENABLE_CLR_BITS);
4365         udelay(5);
4366
4367         /* Wait for the firmware to tell us it is ok to issue a reset. */
4368         bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT0 | reset_code, 1, 1);
4369
4370         /* Deposit a driver reset signature so the firmware knows that
4371          * this is a soft reset. */
4372         bnx2_shmem_wr(bp, BNX2_DRV_RESET_SIGNATURE,
4373                       BNX2_DRV_RESET_SIGNATURE_MAGIC);
4374
4375         /* Do a dummy read to force the chip to complete all current transaction
4376          * before we issue a reset. */
4377         val = REG_RD(bp, BNX2_MISC_ID);
4378
4379         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4380                 REG_WR(bp, BNX2_MISC_COMMAND, BNX2_MISC_COMMAND_SW_RESET);
4381                 REG_RD(bp, BNX2_MISC_COMMAND);
4382                 udelay(5);
4383
4384                 val = BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
4385                       BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
4386
4387                 pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG, val);
4388
4389         } else {
4390                 val = BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
4391                       BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
4392                       BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP;
4393
4394                 /* Chip reset. */
4395                 REG_WR(bp, BNX2_PCICFG_MISC_CONFIG, val);
4396
4397                 /* Reading back any register after chip reset will hang the
4398                  * bus on 5706 A0 and A1.  The msleep below provides plenty
4399                  * of margin for write posting.
4400                  */
4401                 if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
4402                     (CHIP_ID(bp) == CHIP_ID_5706_A1))
4403                         msleep(20);
4404
4405                 /* Reset takes approximate 30 usec */
4406                 for (i = 0; i < 10; i++) {
4407                         val = REG_RD(bp, BNX2_PCICFG_MISC_CONFIG);
4408                         if ((val & (BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
4409                                     BNX2_PCICFG_MISC_CONFIG_CORE_RST_BSY)) == 0)
4410                                 break;
4411                         udelay(10);
4412                 }
4413
4414                 if (val & (BNX2_PCICFG_MISC_CONFIG_CORE_RST_REQ |
4415                            BNX2_PCICFG_MISC_CONFIG_CORE_RST_BSY)) {
4416                         printk(KERN_ERR PFX "Chip reset did not complete\n");
4417                         return -EBUSY;
4418                 }
4419         }
4420
4421         /* Make sure byte swapping is properly configured. */
4422         val = REG_RD(bp, BNX2_PCI_SWAP_DIAG0);
4423         if (val != 0x01020304) {
4424                 printk(KERN_ERR PFX "Chip not in correct endian mode\n");
4425                 return -ENODEV;
4426         }
4427
4428         /* Wait for the firmware to finish its initialization. */
4429         rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT1 | reset_code, 1, 0);
4430         if (rc)
4431                 return rc;
4432
4433         spin_lock_bh(&bp->phy_lock);
4434         old_port = bp->phy_port;
4435         bnx2_init_fw_cap(bp);
4436         if ((bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) &&
4437             old_port != bp->phy_port)
4438                 bnx2_set_default_remote_link(bp);
4439         spin_unlock_bh(&bp->phy_lock);
4440
4441         if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
4442                 /* Adjust the voltage regular to two steps lower.  The default
4443                  * of this register is 0x0000000e. */
4444                 REG_WR(bp, BNX2_MISC_VREG_CONTROL, 0x000000fa);
4445
4446                 /* Remove bad rbuf memory from the free pool. */
4447                 rc = bnx2_alloc_bad_rbuf(bp);
4448         }
4449
4450         if (bp->flags & BNX2_FLAG_USING_MSIX)
4451                 bnx2_setup_msix_tbl(bp);
4452
4453         return rc;
4454 }
4455
4456 static int
4457 bnx2_init_chip(struct bnx2 *bp)
4458 {
4459         u32 val;
4460         int rc, i;
4461
4462         /* Make sure the interrupt is not active. */
4463         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD, BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
4464
4465         val = BNX2_DMA_CONFIG_DATA_BYTE_SWAP |
4466               BNX2_DMA_CONFIG_DATA_WORD_SWAP |
4467 #ifdef __BIG_ENDIAN
4468               BNX2_DMA_CONFIG_CNTL_BYTE_SWAP |
4469 #endif
4470               BNX2_DMA_CONFIG_CNTL_WORD_SWAP |
4471               DMA_READ_CHANS << 12 |
4472               DMA_WRITE_CHANS << 16;
4473
4474         val |= (0x2 << 20) | (1 << 11);
4475
4476         if ((bp->flags & BNX2_FLAG_PCIX) && (bp->bus_speed_mhz == 133))
4477                 val |= (1 << 23);
4478
4479         if ((CHIP_NUM(bp) == CHIP_NUM_5706) &&
4480             (CHIP_ID(bp) != CHIP_ID_5706_A0) && !(bp->flags & BNX2_FLAG_PCIX))
4481                 val |= BNX2_DMA_CONFIG_CNTL_PING_PONG_DMA;
4482
4483         REG_WR(bp, BNX2_DMA_CONFIG, val);
4484
4485         if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
4486                 val = REG_RD(bp, BNX2_TDMA_CONFIG);
4487                 val |= BNX2_TDMA_CONFIG_ONE_DMA;
4488                 REG_WR(bp, BNX2_TDMA_CONFIG, val);
4489         }
4490
4491         if (bp->flags & BNX2_FLAG_PCIX) {
4492                 u16 val16;
4493
4494                 pci_read_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4495                                      &val16);
4496                 pci_write_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4497                                       val16 & ~PCI_X_CMD_ERO);
4498         }
4499
4500         REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
4501                BNX2_MISC_ENABLE_SET_BITS_HOST_COALESCE_ENABLE |
4502                BNX2_MISC_ENABLE_STATUS_BITS_RX_V2P_ENABLE |
4503                BNX2_MISC_ENABLE_STATUS_BITS_CONTEXT_ENABLE);
4504
4505         /* Initialize context mapping and zero out the quick contexts.  The
4506          * context block must have already been enabled. */
4507         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4508                 rc = bnx2_init_5709_context(bp);
4509                 if (rc)
4510                         return rc;
4511         } else
4512                 bnx2_init_context(bp);
4513
4514         if ((rc = bnx2_init_cpus(bp)) != 0)
4515                 return rc;
4516
4517         bnx2_init_nvram(bp);
4518
4519         bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
4520
4521         val = REG_RD(bp, BNX2_MQ_CONFIG);
4522         val &= ~BNX2_MQ_CONFIG_KNL_BYP_BLK_SIZE;
4523         val |= BNX2_MQ_CONFIG_KNL_BYP_BLK_SIZE_256;
4524         if (CHIP_ID(bp) == CHIP_ID_5709_A0 || CHIP_ID(bp) == CHIP_ID_5709_A1)
4525                 val |= BNX2_MQ_CONFIG_HALT_DIS;
4526
4527         REG_WR(bp, BNX2_MQ_CONFIG, val);
4528
4529         val = 0x10000 + (MAX_CID_CNT * MB_KERNEL_CTX_SIZE);
4530         REG_WR(bp, BNX2_MQ_KNL_BYP_WIND_START, val);
4531         REG_WR(bp, BNX2_MQ_KNL_WIND_END, val);
4532
4533         val = (BCM_PAGE_BITS - 8) << 24;
4534         REG_WR(bp, BNX2_RV2P_CONFIG, val);
4535
4536         /* Configure page size. */
4537         val = REG_RD(bp, BNX2_TBDR_CONFIG);
4538         val &= ~BNX2_TBDR_CONFIG_PAGE_SIZE;
4539         val |= (BCM_PAGE_BITS - 8) << 24 | 0x40;
4540         REG_WR(bp, BNX2_TBDR_CONFIG, val);
4541
4542         val = bp->mac_addr[0] +
4543               (bp->mac_addr[1] << 8) +
4544               (bp->mac_addr[2] << 16) +
4545               bp->mac_addr[3] +
4546               (bp->mac_addr[4] << 8) +
4547               (bp->mac_addr[5] << 16);
4548         REG_WR(bp, BNX2_EMAC_BACKOFF_SEED, val);
4549
4550         /* Program the MTU.  Also include 4 bytes for CRC32. */
4551         val = bp->dev->mtu + ETH_HLEN + 4;
4552         if (val > (MAX_ETHERNET_PACKET_SIZE + 4))
4553                 val |= BNX2_EMAC_RX_MTU_SIZE_JUMBO_ENA;
4554         REG_WR(bp, BNX2_EMAC_RX_MTU_SIZE, val);
4555
4556         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++)
4557                 bp->bnx2_napi[i].last_status_idx = 0;
4558
4559         bp->rx_mode = BNX2_EMAC_RX_MODE_SORT_MODE;
4560
4561         /* Set up how to generate a link change interrupt. */
4562         REG_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
4563
4564         REG_WR(bp, BNX2_HC_STATUS_ADDR_L,
4565                (u64) bp->status_blk_mapping & 0xffffffff);
4566         REG_WR(bp, BNX2_HC_STATUS_ADDR_H, (u64) bp->status_blk_mapping >> 32);
4567
4568         REG_WR(bp, BNX2_HC_STATISTICS_ADDR_L,
4569                (u64) bp->stats_blk_mapping & 0xffffffff);
4570         REG_WR(bp, BNX2_HC_STATISTICS_ADDR_H,
4571                (u64) bp->stats_blk_mapping >> 32);
4572
4573         REG_WR(bp, BNX2_HC_TX_QUICK_CONS_TRIP,
4574                (bp->tx_quick_cons_trip_int << 16) | bp->tx_quick_cons_trip);
4575
4576         REG_WR(bp, BNX2_HC_RX_QUICK_CONS_TRIP,
4577                (bp->rx_quick_cons_trip_int << 16) | bp->rx_quick_cons_trip);
4578
4579         REG_WR(bp, BNX2_HC_COMP_PROD_TRIP,
4580                (bp->comp_prod_trip_int << 16) | bp->comp_prod_trip);
4581
4582         REG_WR(bp, BNX2_HC_TX_TICKS, (bp->tx_ticks_int << 16) | bp->tx_ticks);
4583
4584         REG_WR(bp, BNX2_HC_RX_TICKS, (bp->rx_ticks_int << 16) | bp->rx_ticks);
4585
4586         REG_WR(bp, BNX2_HC_COM_TICKS,
4587                (bp->com_ticks_int << 16) | bp->com_ticks);
4588
4589         REG_WR(bp, BNX2_HC_CMD_TICKS,
4590                (bp->cmd_ticks_int << 16) | bp->cmd_ticks);
4591
4592         if (CHIP_NUM(bp) == CHIP_NUM_5708)
4593                 REG_WR(bp, BNX2_HC_STATS_TICKS, 0);
4594         else
4595                 REG_WR(bp, BNX2_HC_STATS_TICKS, bp->stats_ticks);
4596         REG_WR(bp, BNX2_HC_STAT_COLLECT_TICKS, 0xbb8);  /* 3ms */
4597
4598         if (CHIP_ID(bp) == CHIP_ID_5706_A1)
4599                 val = BNX2_HC_CONFIG_COLLECT_STATS;
4600         else {
4601                 val = BNX2_HC_CONFIG_RX_TMR_MODE | BNX2_HC_CONFIG_TX_TMR_MODE |
4602                       BNX2_HC_CONFIG_COLLECT_STATS;
4603         }
4604
4605         if (bp->irq_nvecs > 1) {
4606                 REG_WR(bp, BNX2_HC_MSIX_BIT_VECTOR,
4607                        BNX2_HC_MSIX_BIT_VECTOR_VAL);
4608
4609                 val |= BNX2_HC_CONFIG_SB_ADDR_INC_128B;
4610         }
4611
4612         if (bp->flags & BNX2_FLAG_ONE_SHOT_MSI)
4613                 val |= BNX2_HC_CONFIG_ONE_SHOT;
4614
4615         REG_WR(bp, BNX2_HC_CONFIG, val);
4616
4617         for (i = 1; i < bp->irq_nvecs; i++) {
4618                 u32 base = ((i - 1) * BNX2_HC_SB_CONFIG_SIZE) +
4619                            BNX2_HC_SB_CONFIG_1;
4620
4621                 REG_WR(bp, base,
4622                         BNX2_HC_SB_CONFIG_1_TX_TMR_MODE |
4623                         BNX2_HC_SB_CONFIG_1_RX_TMR_MODE |
4624                         BNX2_HC_SB_CONFIG_1_ONE_SHOT);
4625
4626                 REG_WR(bp, base + BNX2_HC_TX_QUICK_CONS_TRIP_OFF,
4627                         (bp->tx_quick_cons_trip_int << 16) |
4628                          bp->tx_quick_cons_trip);
4629
4630                 REG_WR(bp, base + BNX2_HC_TX_TICKS_OFF,
4631                         (bp->tx_ticks_int << 16) | bp->tx_ticks);
4632
4633                 REG_WR(bp, base + BNX2_HC_RX_QUICK_CONS_TRIP_OFF,
4634                        (bp->rx_quick_cons_trip_int << 16) |
4635                         bp->rx_quick_cons_trip);
4636
4637                 REG_WR(bp, base + BNX2_HC_RX_TICKS_OFF,
4638                         (bp->rx_ticks_int << 16) | bp->rx_ticks);
4639         }
4640
4641         /* Clear internal stats counters. */
4642         REG_WR(bp, BNX2_HC_COMMAND, BNX2_HC_COMMAND_CLR_STAT_NOW);
4643
4644         REG_WR(bp, BNX2_HC_ATTN_BITS_ENABLE, STATUS_ATTN_EVENTS);
4645
4646         /* Initialize the receive filter. */
4647         bnx2_set_rx_mode(bp->dev);
4648
4649         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4650                 val = REG_RD(bp, BNX2_MISC_NEW_CORE_CTL);
4651                 val |= BNX2_MISC_NEW_CORE_CTL_DMA_ENABLE;
4652                 REG_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
4653         }
4654         rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT2 | BNX2_DRV_MSG_CODE_RESET,
4655                           1, 0);
4656
4657         REG_WR(bp, BNX2_MISC_ENABLE_SET_BITS, BNX2_MISC_ENABLE_DEFAULT);
4658         REG_RD(bp, BNX2_MISC_ENABLE_SET_BITS);
4659
4660         udelay(20);
4661
4662         bp->hc_cmd = REG_RD(bp, BNX2_HC_COMMAND);
4663
4664         return rc;
4665 }
4666
4667 static void
4668 bnx2_clear_ring_states(struct bnx2 *bp)
4669 {
4670         struct bnx2_napi *bnapi;
4671         struct bnx2_tx_ring_info *txr;
4672         struct bnx2_rx_ring_info *rxr;
4673         int i;
4674
4675         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
4676                 bnapi = &bp->bnx2_napi[i];
4677                 txr = &bnapi->tx_ring;
4678                 rxr = &bnapi->rx_ring;
4679
4680                 txr->tx_cons = 0;
4681                 txr->hw_tx_cons = 0;
4682                 rxr->rx_prod_bseq = 0;
4683                 rxr->rx_prod = 0;
4684                 rxr->rx_cons = 0;
4685                 rxr->rx_pg_prod = 0;
4686                 rxr->rx_pg_cons = 0;
4687         }
4688 }
4689
4690 static void
4691 bnx2_init_tx_context(struct bnx2 *bp, u32 cid, struct bnx2_tx_ring_info *txr)
4692 {
4693         u32 val, offset0, offset1, offset2, offset3;
4694         u32 cid_addr = GET_CID_ADDR(cid);
4695
4696         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4697                 offset0 = BNX2_L2CTX_TYPE_XI;
4698                 offset1 = BNX2_L2CTX_CMD_TYPE_XI;
4699                 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI_XI;
4700                 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO_XI;
4701         } else {
4702                 offset0 = BNX2_L2CTX_TYPE;
4703                 offset1 = BNX2_L2CTX_CMD_TYPE;
4704                 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI;
4705                 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO;
4706         }
4707         val = BNX2_L2CTX_TYPE_TYPE_L2 | BNX2_L2CTX_TYPE_SIZE_L2;
4708         bnx2_ctx_wr(bp, cid_addr, offset0, val);
4709
4710         val = BNX2_L2CTX_CMD_TYPE_TYPE_L2 | (8 << 16);
4711         bnx2_ctx_wr(bp, cid_addr, offset1, val);
4712
4713         val = (u64) txr->tx_desc_mapping >> 32;
4714         bnx2_ctx_wr(bp, cid_addr, offset2, val);
4715
4716         val = (u64) txr->tx_desc_mapping & 0xffffffff;
4717         bnx2_ctx_wr(bp, cid_addr, offset3, val);
4718 }
4719
4720 static void
4721 bnx2_init_tx_ring(struct bnx2 *bp, int ring_num)
4722 {
4723         struct tx_bd *txbd;
4724         u32 cid = TX_CID;
4725         struct bnx2_napi *bnapi;
4726         struct bnx2_tx_ring_info *txr;
4727
4728         bnapi = &bp->bnx2_napi[ring_num];
4729         txr = &bnapi->tx_ring;
4730
4731         if (ring_num == 0)
4732                 cid = TX_CID;
4733         else
4734                 cid = TX_TSS_CID + ring_num - 1;
4735
4736         bp->tx_wake_thresh = bp->tx_ring_size / 2;
4737
4738         txbd = &txr->tx_desc_ring[MAX_TX_DESC_CNT];
4739
4740         txbd->tx_bd_haddr_hi = (u64) txr->tx_desc_mapping >> 32;
4741         txbd->tx_bd_haddr_lo = (u64) txr->tx_desc_mapping & 0xffffffff;
4742
4743         txr->tx_prod = 0;
4744         txr->tx_prod_bseq = 0;
4745
4746         txr->tx_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_TX_HOST_BIDX;
4747         txr->tx_bseq_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_TX_HOST_BSEQ;
4748
4749         bnx2_init_tx_context(bp, cid, txr);
4750 }
4751
4752 static void
4753 bnx2_init_rxbd_rings(struct rx_bd *rx_ring[], dma_addr_t dma[], u32 buf_size,
4754                      int num_rings)
4755 {
4756         int i;
4757         struct rx_bd *rxbd;
4758
4759         for (i = 0; i < num_rings; i++) {
4760                 int j;
4761
4762                 rxbd = &rx_ring[i][0];
4763                 for (j = 0; j < MAX_RX_DESC_CNT; j++, rxbd++) {
4764                         rxbd->rx_bd_len = buf_size;
4765                         rxbd->rx_bd_flags = RX_BD_FLAGS_START | RX_BD_FLAGS_END;
4766                 }
4767                 if (i == (num_rings - 1))
4768                         j = 0;
4769                 else
4770                         j = i + 1;
4771                 rxbd->rx_bd_haddr_hi = (u64) dma[j] >> 32;
4772                 rxbd->rx_bd_haddr_lo = (u64) dma[j] & 0xffffffff;
4773         }
4774 }
4775
4776 static void
4777 bnx2_init_rx_ring(struct bnx2 *bp, int ring_num)
4778 {
4779         int i;
4780         u16 prod, ring_prod;
4781         u32 cid, rx_cid_addr, val;
4782         struct bnx2_napi *bnapi = &bp->bnx2_napi[ring_num];
4783         struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
4784
4785         if (ring_num == 0)
4786                 cid = RX_CID;
4787         else
4788                 cid = RX_RSS_CID + ring_num - 1;
4789
4790         rx_cid_addr = GET_CID_ADDR(cid);
4791
4792         bnx2_init_rxbd_rings(rxr->rx_desc_ring, rxr->rx_desc_mapping,
4793                              bp->rx_buf_use_size, bp->rx_max_ring);
4794
4795         bnx2_init_rx_context(bp, cid);
4796
4797         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
4798                 val = REG_RD(bp, BNX2_MQ_MAP_L2_5);
4799                 REG_WR(bp, BNX2_MQ_MAP_L2_5, val | BNX2_MQ_MAP_L2_5_ARM);
4800         }
4801
4802         bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_PG_BUF_SIZE, 0);
4803         if (bp->rx_pg_ring_size) {
4804                 bnx2_init_rxbd_rings(rxr->rx_pg_desc_ring,
4805                                      rxr->rx_pg_desc_mapping,
4806                                      PAGE_SIZE, bp->rx_max_pg_ring);
4807                 val = (bp->rx_buf_use_size << 16) | PAGE_SIZE;
4808                 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_PG_BUF_SIZE, val);
4809                 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_RBDC_KEY,
4810                        BNX2_L2CTX_RBDC_JUMBO_KEY - ring_num);
4811
4812                 val = (u64) rxr->rx_pg_desc_mapping[0] >> 32;
4813                 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_PG_BDHADDR_HI, val);
4814
4815                 val = (u64) rxr->rx_pg_desc_mapping[0] & 0xffffffff;
4816                 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_PG_BDHADDR_LO, val);
4817
4818                 if (CHIP_NUM(bp) == CHIP_NUM_5709)
4819                         REG_WR(bp, BNX2_MQ_MAP_L2_3, BNX2_MQ_MAP_L2_3_DEFAULT);
4820         }
4821
4822         val = (u64) rxr->rx_desc_mapping[0] >> 32;
4823         bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_BDHADDR_HI, val);
4824
4825         val = (u64) rxr->rx_desc_mapping[0] & 0xffffffff;
4826         bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_BDHADDR_LO, val);
4827
4828         ring_prod = prod = rxr->rx_pg_prod;
4829         for (i = 0; i < bp->rx_pg_ring_size; i++) {
4830                 if (bnx2_alloc_rx_page(bp, rxr, ring_prod) < 0)
4831                         break;
4832                 prod = NEXT_RX_BD(prod);
4833                 ring_prod = RX_PG_RING_IDX(prod);
4834         }
4835         rxr->rx_pg_prod = prod;
4836
4837         ring_prod = prod = rxr->rx_prod;
4838         for (i = 0; i < bp->rx_ring_size; i++) {
4839                 if (bnx2_alloc_rx_skb(bp, rxr, ring_prod) < 0)
4840                         break;
4841                 prod = NEXT_RX_BD(prod);
4842                 ring_prod = RX_RING_IDX(prod);
4843         }
4844         rxr->rx_prod = prod;
4845
4846         rxr->rx_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_HOST_BDIDX;
4847         rxr->rx_bseq_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_HOST_BSEQ;
4848         rxr->rx_pg_bidx_addr = MB_GET_CID_ADDR(cid) + BNX2_L2CTX_HOST_PG_BDIDX;
4849
4850         REG_WR16(bp, rxr->rx_pg_bidx_addr, rxr->rx_pg_prod);
4851         REG_WR16(bp, rxr->rx_bidx_addr, prod);
4852
4853         REG_WR(bp, rxr->rx_bseq_addr, rxr->rx_prod_bseq);
4854 }
4855
4856 static void
4857 bnx2_init_all_rings(struct bnx2 *bp)
4858 {
4859         int i;
4860         u32 val;
4861
4862         bnx2_clear_ring_states(bp);
4863
4864         REG_WR(bp, BNX2_TSCH_TSS_CFG, 0);
4865         for (i = 0; i < bp->num_tx_rings; i++)
4866                 bnx2_init_tx_ring(bp, i);
4867
4868         if (bp->num_tx_rings > 1)
4869                 REG_WR(bp, BNX2_TSCH_TSS_CFG, ((bp->num_tx_rings - 1) << 24) |
4870                        (TX_TSS_CID << 7));
4871
4872         REG_WR(bp, BNX2_RLUP_RSS_CONFIG, 0);
4873         bnx2_reg_wr_ind(bp, BNX2_RXP_SCRATCH_RSS_TBL_SZ, 0);
4874
4875         for (i = 0; i < bp->num_rx_rings; i++)
4876                 bnx2_init_rx_ring(bp, i);
4877
4878         if (bp->num_rx_rings > 1) {
4879                 u32 tbl_32;
4880                 u8 *tbl = (u8 *) &tbl_32;
4881
4882                 bnx2_reg_wr_ind(bp, BNX2_RXP_SCRATCH_RSS_TBL_SZ,
4883                                 BNX2_RXP_SCRATCH_RSS_TBL_MAX_ENTRIES);
4884
4885                 for (i = 0; i < BNX2_RXP_SCRATCH_RSS_TBL_MAX_ENTRIES; i++) {
4886                         tbl[i % 4] = i % (bp->num_rx_rings - 1);
4887                         if ((i % 4) == 3)
4888                                 bnx2_reg_wr_ind(bp,
4889                                                 BNX2_RXP_SCRATCH_RSS_TBL + i,
4890                                                 cpu_to_be32(tbl_32));
4891                 }
4892
4893                 val = BNX2_RLUP_RSS_CONFIG_IPV4_RSS_TYPE_ALL_XI |
4894                       BNX2_RLUP_RSS_CONFIG_IPV6_RSS_TYPE_ALL_XI;
4895
4896                 REG_WR(bp, BNX2_RLUP_RSS_CONFIG, val);
4897
4898         }
4899 }
4900
4901 static u32 bnx2_find_max_ring(u32 ring_size, u32 max_size)
4902 {
4903         u32 max, num_rings = 1;
4904
4905         while (ring_size > MAX_RX_DESC_CNT) {
4906                 ring_size -= MAX_RX_DESC_CNT;
4907                 num_rings++;
4908         }
4909         /* round to next power of 2 */
4910         max = max_size;
4911         while ((max & num_rings) == 0)
4912                 max >>= 1;
4913
4914         if (num_rings != max)
4915                 max <<= 1;
4916
4917         return max;
4918 }
4919
4920 static void
4921 bnx2_set_rx_ring_size(struct bnx2 *bp, u32 size)
4922 {
4923         u32 rx_size, rx_space, jumbo_size;
4924
4925         /* 8 for CRC and VLAN */
4926         rx_size = bp->dev->mtu + ETH_HLEN + BNX2_RX_OFFSET + 8;
4927
4928         rx_space = SKB_DATA_ALIGN(rx_size + BNX2_RX_ALIGN) + NET_SKB_PAD +
4929                 sizeof(struct skb_shared_info);
4930
4931         bp->rx_copy_thresh = BNX2_RX_COPY_THRESH;
4932         bp->rx_pg_ring_size = 0;
4933         bp->rx_max_pg_ring = 0;
4934         bp->rx_max_pg_ring_idx = 0;
4935         if ((rx_space > PAGE_SIZE) && !(bp->flags & BNX2_FLAG_JUMBO_BROKEN)) {
4936                 int pages = PAGE_ALIGN(bp->dev->mtu - 40) >> PAGE_SHIFT;
4937
4938                 jumbo_size = size * pages;
4939                 if (jumbo_size > MAX_TOTAL_RX_PG_DESC_CNT)
4940                         jumbo_size = MAX_TOTAL_RX_PG_DESC_CNT;
4941
4942                 bp->rx_pg_ring_size = jumbo_size;
4943                 bp->rx_max_pg_ring = bnx2_find_max_ring(jumbo_size,
4944                                                         MAX_RX_PG_RINGS);
4945                 bp->rx_max_pg_ring_idx = (bp->rx_max_pg_ring * RX_DESC_CNT) - 1;
4946                 rx_size = BNX2_RX_COPY_THRESH + BNX2_RX_OFFSET;
4947                 bp->rx_copy_thresh = 0;
4948         }
4949
4950         bp->rx_buf_use_size = rx_size;
4951         /* hw alignment */
4952         bp->rx_buf_size = bp->rx_buf_use_size + BNX2_RX_ALIGN;
4953         bp->rx_jumbo_thresh = rx_size - BNX2_RX_OFFSET;
4954         bp->rx_ring_size = size;
4955         bp->rx_max_ring = bnx2_find_max_ring(size, MAX_RX_RINGS);
4956         bp->rx_max_ring_idx = (bp->rx_max_ring * RX_DESC_CNT) - 1;
4957 }
4958
4959 static void
4960 bnx2_free_tx_skbs(struct bnx2 *bp)
4961 {
4962         int i;
4963
4964         for (i = 0; i < bp->num_tx_rings; i++) {
4965                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
4966                 struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
4967                 int j;
4968
4969                 if (txr->tx_buf_ring == NULL)
4970                         continue;
4971
4972                 for (j = 0; j < TX_DESC_CNT; ) {
4973                         struct sw_bd *tx_buf = &txr->tx_buf_ring[j];
4974                         struct sk_buff *skb = tx_buf->skb;
4975                         int k, last;
4976
4977                         if (skb == NULL) {
4978                                 j++;
4979                                 continue;
4980                         }
4981
4982                         pci_unmap_single(bp->pdev,
4983                                          pci_unmap_addr(tx_buf, mapping),
4984                         skb_headlen(skb), PCI_DMA_TODEVICE);
4985
4986                         tx_buf->skb = NULL;
4987
4988                         last = skb_shinfo(skb)->nr_frags;
4989                         for (k = 0; k < last; k++) {
4990                                 tx_buf = &txr->tx_buf_ring[j + k + 1];
4991                                 pci_unmap_page(bp->pdev,
4992                                         pci_unmap_addr(tx_buf, mapping),
4993                                         skb_shinfo(skb)->frags[j].size,
4994                                         PCI_DMA_TODEVICE);
4995                         }
4996                         dev_kfree_skb(skb);
4997                         j += k + 1;
4998                 }
4999         }
5000 }
5001
5002 static void
5003 bnx2_free_rx_skbs(struct bnx2 *bp)
5004 {
5005         int i;
5006
5007         for (i = 0; i < bp->num_rx_rings; i++) {
5008                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
5009                 struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
5010                 int j;
5011
5012                 if (rxr->rx_buf_ring == NULL)
5013                         return;
5014
5015                 for (j = 0; j < bp->rx_max_ring_idx; j++) {
5016                         struct sw_bd *rx_buf = &rxr->rx_buf_ring[j];
5017                         struct sk_buff *skb = rx_buf->skb;
5018
5019                         if (skb == NULL)
5020                                 continue;
5021
5022                         pci_unmap_single(bp->pdev,
5023                                          pci_unmap_addr(rx_buf, mapping),
5024                                          bp->rx_buf_use_size,
5025                                          PCI_DMA_FROMDEVICE);
5026
5027                         rx_buf->skb = NULL;
5028
5029                         dev_kfree_skb(skb);
5030                 }
5031                 for (j = 0; j < bp->rx_max_pg_ring_idx; j++)
5032                         bnx2_free_rx_page(bp, rxr, j);
5033         }
5034 }
5035
5036 static void
5037 bnx2_free_skbs(struct bnx2 *bp)
5038 {
5039         bnx2_free_tx_skbs(bp);
5040         bnx2_free_rx_skbs(bp);
5041 }
5042
5043 static int
5044 bnx2_reset_nic(struct bnx2 *bp, u32 reset_code)
5045 {
5046         int rc;
5047
5048         rc = bnx2_reset_chip(bp, reset_code);
5049         bnx2_free_skbs(bp);
5050         if (rc)
5051                 return rc;
5052
5053         if ((rc = bnx2_init_chip(bp)) != 0)
5054                 return rc;
5055
5056         bnx2_init_all_rings(bp);
5057         return 0;
5058 }
5059
5060 static int
5061 bnx2_init_nic(struct bnx2 *bp, int reset_phy)
5062 {
5063         int rc;
5064
5065         if ((rc = bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET)) != 0)
5066                 return rc;
5067
5068         spin_lock_bh(&bp->phy_lock);
5069         bnx2_init_phy(bp, reset_phy);
5070         bnx2_set_link(bp);
5071         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
5072                 bnx2_remote_phy_event(bp);
5073         spin_unlock_bh(&bp->phy_lock);
5074         return 0;
5075 }
5076
5077 static int
5078 bnx2_test_registers(struct bnx2 *bp)
5079 {
5080         int ret;
5081         int i, is_5709;
5082         static const struct {
5083                 u16   offset;
5084                 u16   flags;
5085 #define BNX2_FL_NOT_5709        1
5086                 u32   rw_mask;
5087                 u32   ro_mask;
5088         } reg_tbl[] = {
5089                 { 0x006c, 0, 0x00000000, 0x0000003f },
5090                 { 0x0090, 0, 0xffffffff, 0x00000000 },
5091                 { 0x0094, 0, 0x00000000, 0x00000000 },
5092
5093                 { 0x0404, BNX2_FL_NOT_5709, 0x00003f00, 0x00000000 },
5094                 { 0x0418, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5095                 { 0x041c, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5096                 { 0x0420, BNX2_FL_NOT_5709, 0x00000000, 0x80ffffff },
5097                 { 0x0424, BNX2_FL_NOT_5709, 0x00000000, 0x00000000 },
5098                 { 0x0428, BNX2_FL_NOT_5709, 0x00000000, 0x00000001 },
5099                 { 0x0450, BNX2_FL_NOT_5709, 0x00000000, 0x0000ffff },
5100                 { 0x0454, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5101                 { 0x0458, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5102
5103                 { 0x0808, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5104                 { 0x0854, BNX2_FL_NOT_5709, 0x00000000, 0xffffffff },
5105                 { 0x0868, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5106                 { 0x086c, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5107                 { 0x0870, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5108                 { 0x0874, BNX2_FL_NOT_5709, 0x00000000, 0x77777777 },
5109
5110                 { 0x0c00, BNX2_FL_NOT_5709, 0x00000000, 0x00000001 },
5111                 { 0x0c04, BNX2_FL_NOT_5709, 0x00000000, 0x03ff0001 },
5112                 { 0x0c08, BNX2_FL_NOT_5709,  0x0f0ff073, 0x00000000 },
5113
5114                 { 0x1000, 0, 0x00000000, 0x00000001 },
5115                 { 0x1004, BNX2_FL_NOT_5709, 0x00000000, 0x000f0001 },
5116
5117                 { 0x1408, 0, 0x01c00800, 0x00000000 },
5118                 { 0x149c, 0, 0x8000ffff, 0x00000000 },
5119                 { 0x14a8, 0, 0x00000000, 0x000001ff },
5120                 { 0x14ac, 0, 0x0fffffff, 0x10000000 },
5121                 { 0x14b0, 0, 0x00000002, 0x00000001 },
5122                 { 0x14b8, 0, 0x00000000, 0x00000000 },
5123                 { 0x14c0, 0, 0x00000000, 0x00000009 },
5124                 { 0x14c4, 0, 0x00003fff, 0x00000000 },
5125                 { 0x14cc, 0, 0x00000000, 0x00000001 },
5126                 { 0x14d0, 0, 0xffffffff, 0x00000000 },
5127
5128                 { 0x1800, 0, 0x00000000, 0x00000001 },
5129                 { 0x1804, 0, 0x00000000, 0x00000003 },
5130
5131                 { 0x2800, 0, 0x00000000, 0x00000001 },
5132                 { 0x2804, 0, 0x00000000, 0x00003f01 },
5133                 { 0x2808, 0, 0x0f3f3f03, 0x00000000 },
5134                 { 0x2810, 0, 0xffff0000, 0x00000000 },
5135                 { 0x2814, 0, 0xffff0000, 0x00000000 },
5136                 { 0x2818, 0, 0xffff0000, 0x00000000 },
5137                 { 0x281c, 0, 0xffff0000, 0x00000000 },
5138                 { 0x2834, 0, 0xffffffff, 0x00000000 },
5139                 { 0x2840, 0, 0x00000000, 0xffffffff },
5140                 { 0x2844, 0, 0x00000000, 0xffffffff },
5141                 { 0x2848, 0, 0xffffffff, 0x00000000 },
5142                 { 0x284c, 0, 0xf800f800, 0x07ff07ff },
5143
5144                 { 0x2c00, 0, 0x00000000, 0x00000011 },
5145                 { 0x2c04, 0, 0x00000000, 0x00030007 },
5146
5147                 { 0x3c00, 0, 0x00000000, 0x00000001 },
5148                 { 0x3c04, 0, 0x00000000, 0x00070000 },
5149                 { 0x3c08, 0, 0x00007f71, 0x07f00000 },
5150                 { 0x3c0c, 0, 0x1f3ffffc, 0x00000000 },
5151                 { 0x3c10, 0, 0xffffffff, 0x00000000 },
5152                 { 0x3c14, 0, 0x00000000, 0xffffffff },
5153                 { 0x3c18, 0, 0x00000000, 0xffffffff },
5154                 { 0x3c1c, 0, 0xfffff000, 0x00000000 },
5155                 { 0x3c20, 0, 0xffffff00, 0x00000000 },
5156
5157                 { 0x5004, 0, 0x00000000, 0x0000007f },
5158                 { 0x5008, 0, 0x0f0007ff, 0x00000000 },
5159
5160                 { 0x5c00, 0, 0x00000000, 0x00000001 },
5161                 { 0x5c04, 0, 0x00000000, 0x0003000f },
5162                 { 0x5c08, 0, 0x00000003, 0x00000000 },
5163                 { 0x5c0c, 0, 0x0000fff8, 0x00000000 },
5164                 { 0x5c10, 0, 0x00000000, 0xffffffff },
5165                 { 0x5c80, 0, 0x00000000, 0x0f7113f1 },
5166                 { 0x5c84, 0, 0x00000000, 0x0000f333 },
5167                 { 0x5c88, 0, 0x00000000, 0x00077373 },
5168                 { 0x5c8c, 0, 0x00000000, 0x0007f737 },
5169
5170                 { 0x6808, 0, 0x0000ff7f, 0x00000000 },
5171                 { 0x680c, 0, 0xffffffff, 0x00000000 },
5172                 { 0x6810, 0, 0xffffffff, 0x00000000 },
5173                 { 0x6814, 0, 0xffffffff, 0x00000000 },
5174                 { 0x6818, 0, 0xffffffff, 0x00000000 },
5175                 { 0x681c, 0, 0xffffffff, 0x00000000 },
5176                 { 0x6820, 0, 0x00ff00ff, 0x00000000 },
5177                 { 0x6824, 0, 0x00ff00ff, 0x00000000 },
5178                 { 0x6828, 0, 0x00ff00ff, 0x00000000 },
5179                 { 0x682c, 0, 0x03ff03ff, 0x00000000 },
5180                 { 0x6830, 0, 0x03ff03ff, 0x00000000 },
5181                 { 0x6834, 0, 0x03ff03ff, 0x00000000 },
5182                 { 0x6838, 0, 0x03ff03ff, 0x00000000 },
5183                 { 0x683c, 0, 0x0000ffff, 0x00000000 },
5184                 { 0x6840, 0, 0x00000ff0, 0x00000000 },
5185                 { 0x6844, 0, 0x00ffff00, 0x00000000 },
5186                 { 0x684c, 0, 0xffffffff, 0x00000000 },
5187                 { 0x6850, 0, 0x7f7f7f7f, 0x00000000 },
5188                 { 0x6854, 0, 0x7f7f7f7f, 0x00000000 },
5189                 { 0x6858, 0, 0x7f7f7f7f, 0x00000000 },
5190                 { 0x685c, 0, 0x7f7f7f7f, 0x00000000 },
5191                 { 0x6908, 0, 0x00000000, 0x0001ff0f },
5192                 { 0x690c, 0, 0x00000000, 0x0ffe00f0 },
5193
5194                 { 0xffff, 0, 0x00000000, 0x00000000 },
5195         };
5196
5197         ret = 0;
5198         is_5709 = 0;
5199         if (CHIP_NUM(bp) == CHIP_NUM_5709)
5200                 is_5709 = 1;
5201
5202         for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
5203                 u32 offset, rw_mask, ro_mask, save_val, val;
5204                 u16 flags = reg_tbl[i].flags;
5205
5206                 if (is_5709 && (flags & BNX2_FL_NOT_5709))
5207                         continue;
5208
5209                 offset = (u32) reg_tbl[i].offset;
5210                 rw_mask = reg_tbl[i].rw_mask;
5211                 ro_mask = reg_tbl[i].ro_mask;
5212
5213                 save_val = readl(bp->regview + offset);
5214
5215                 writel(0, bp->regview + offset);
5216
5217                 val = readl(bp->regview + offset);
5218                 if ((val & rw_mask) != 0) {
5219                         goto reg_test_err;
5220                 }
5221
5222                 if ((val & ro_mask) != (save_val & ro_mask)) {
5223                         goto reg_test_err;
5224                 }
5225
5226                 writel(0xffffffff, bp->regview + offset);
5227
5228                 val = readl(bp->regview + offset);
5229                 if ((val & rw_mask) != rw_mask) {
5230                         goto reg_test_err;
5231                 }
5232
5233                 if ((val & ro_mask) != (save_val & ro_mask)) {
5234                         goto reg_test_err;
5235                 }
5236
5237                 writel(save_val, bp->regview + offset);
5238                 continue;
5239
5240 reg_test_err:
5241                 writel(save_val, bp->regview + offset);
5242                 ret = -ENODEV;
5243                 break;
5244         }
5245         return ret;
5246 }
5247
5248 static int
5249 bnx2_do_mem_test(struct bnx2 *bp, u32 start, u32 size)
5250 {
5251         static const u32 test_pattern[] = { 0x00000000, 0xffffffff, 0x55555555,
5252                 0xaaaaaaaa , 0xaa55aa55, 0x55aa55aa };
5253         int i;
5254
5255         for (i = 0; i < sizeof(test_pattern) / 4; i++) {
5256                 u32 offset;
5257
5258                 for (offset = 0; offset < size; offset += 4) {
5259
5260                         bnx2_reg_wr_ind(bp, start + offset, test_pattern[i]);
5261
5262                         if (bnx2_reg_rd_ind(bp, start + offset) !=
5263                                 test_pattern[i]) {
5264                                 return -ENODEV;
5265                         }
5266                 }
5267         }
5268         return 0;
5269 }
5270
5271 static int
5272 bnx2_test_memory(struct bnx2 *bp)
5273 {
5274         int ret = 0;
5275         int i;
5276         static struct mem_entry {
5277                 u32   offset;
5278                 u32   len;
5279         } mem_tbl_5706[] = {
5280                 { 0x60000,  0x4000 },
5281                 { 0xa0000,  0x3000 },
5282                 { 0xe0000,  0x4000 },
5283                 { 0x120000, 0x4000 },
5284                 { 0x1a0000, 0x4000 },
5285                 { 0x160000, 0x4000 },
5286                 { 0xffffffff, 0    },
5287         },
5288         mem_tbl_5709[] = {
5289                 { 0x60000,  0x4000 },
5290                 { 0xa0000,  0x3000 },
5291                 { 0xe0000,  0x4000 },
5292                 { 0x120000, 0x4000 },
5293                 { 0x1a0000, 0x4000 },
5294                 { 0xffffffff, 0    },
5295         };
5296         struct mem_entry *mem_tbl;
5297
5298         if (CHIP_NUM(bp) == CHIP_NUM_5709)
5299                 mem_tbl = mem_tbl_5709;
5300         else
5301                 mem_tbl = mem_tbl_5706;
5302
5303         for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
5304                 if ((ret = bnx2_do_mem_test(bp, mem_tbl[i].offset,
5305                         mem_tbl[i].len)) != 0) {
5306                         return ret;
5307                 }
5308         }
5309
5310         return ret;
5311 }
5312
5313 #define BNX2_MAC_LOOPBACK       0
5314 #define BNX2_PHY_LOOPBACK       1
5315
5316 static int
5317 bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
5318 {
5319         unsigned int pkt_size, num_pkts, i;
5320         struct sk_buff *skb, *rx_skb;
5321         unsigned char *packet;
5322         u16 rx_start_idx, rx_idx;
5323         dma_addr_t map;
5324         struct tx_bd *txbd;
5325         struct sw_bd *rx_buf;
5326         struct l2_fhdr *rx_hdr;
5327         int ret = -ENODEV;
5328         struct bnx2_napi *bnapi = &bp->bnx2_napi[0], *tx_napi;
5329         struct bnx2_tx_ring_info *txr = &bnapi->tx_ring;
5330         struct bnx2_rx_ring_info *rxr = &bnapi->rx_ring;
5331
5332         tx_napi = bnapi;
5333
5334         txr = &tx_napi->tx_ring;
5335         rxr = &bnapi->rx_ring;
5336         if (loopback_mode == BNX2_MAC_LOOPBACK) {
5337                 bp->loopback = MAC_LOOPBACK;
5338                 bnx2_set_mac_loopback(bp);
5339         }
5340         else if (loopback_mode == BNX2_PHY_LOOPBACK) {
5341                 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
5342                         return 0;
5343
5344                 bp->loopback = PHY_LOOPBACK;
5345                 bnx2_set_phy_loopback(bp);
5346         }
5347         else
5348                 return -EINVAL;
5349
5350         pkt_size = min(bp->dev->mtu + ETH_HLEN, bp->rx_jumbo_thresh - 4);
5351         skb = netdev_alloc_skb(bp->dev, pkt_size);
5352         if (!skb)
5353                 return -ENOMEM;
5354         packet = skb_put(skb, pkt_size);
5355         memcpy(packet, bp->dev->dev_addr, 6);
5356         memset(packet + 6, 0x0, 8);
5357         for (i = 14; i < pkt_size; i++)
5358                 packet[i] = (unsigned char) (i & 0xff);
5359
5360         map = pci_map_single(bp->pdev, skb->data, pkt_size,
5361                 PCI_DMA_TODEVICE);
5362
5363         REG_WR(bp, BNX2_HC_COMMAND,
5364                bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
5365
5366         REG_RD(bp, BNX2_HC_COMMAND);
5367
5368         udelay(5);
5369         rx_start_idx = bnx2_get_hw_rx_cons(bnapi);
5370
5371         num_pkts = 0;
5372
5373         txbd = &txr->tx_desc_ring[TX_RING_IDX(txr->tx_prod)];
5374
5375         txbd->tx_bd_haddr_hi = (u64) map >> 32;
5376         txbd->tx_bd_haddr_lo = (u64) map & 0xffffffff;
5377         txbd->tx_bd_mss_nbytes = pkt_size;
5378         txbd->tx_bd_vlan_tag_flags = TX_BD_FLAGS_START | TX_BD_FLAGS_END;
5379
5380         num_pkts++;
5381         txr->tx_prod = NEXT_TX_BD(txr->tx_prod);
5382         txr->tx_prod_bseq += pkt_size;
5383
5384         REG_WR16(bp, txr->tx_bidx_addr, txr->tx_prod);
5385         REG_WR(bp, txr->tx_bseq_addr, txr->tx_prod_bseq);
5386
5387         udelay(100);
5388
5389         REG_WR(bp, BNX2_HC_COMMAND,
5390                bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
5391
5392         REG_RD(bp, BNX2_HC_COMMAND);
5393
5394         udelay(5);
5395
5396         pci_unmap_single(bp->pdev, map, pkt_size, PCI_DMA_TODEVICE);
5397         dev_kfree_skb(skb);
5398
5399         if (bnx2_get_hw_tx_cons(tx_napi) != txr->tx_prod)
5400                 goto loopback_test_done;
5401
5402         rx_idx = bnx2_get_hw_rx_cons(bnapi);
5403         if (rx_idx != rx_start_idx + num_pkts) {
5404                 goto loopback_test_done;
5405         }
5406
5407         rx_buf = &rxr->rx_buf_ring[rx_start_idx];
5408         rx_skb = rx_buf->skb;
5409
5410         rx_hdr = (struct l2_fhdr *) rx_skb->data;
5411         skb_reserve(rx_skb, BNX2_RX_OFFSET);
5412
5413         pci_dma_sync_single_for_cpu(bp->pdev,
5414                 pci_unmap_addr(rx_buf, mapping),
5415                 bp->rx_buf_size, PCI_DMA_FROMDEVICE);
5416
5417         if (rx_hdr->l2_fhdr_status &
5418                 (L2_FHDR_ERRORS_BAD_CRC |
5419                 L2_FHDR_ERRORS_PHY_DECODE |
5420                 L2_FHDR_ERRORS_ALIGNMENT |
5421                 L2_FHDR_ERRORS_TOO_SHORT |
5422                 L2_FHDR_ERRORS_GIANT_FRAME)) {
5423
5424                 goto loopback_test_done;
5425         }
5426
5427         if ((rx_hdr->l2_fhdr_pkt_len - 4) != pkt_size) {
5428                 goto loopback_test_done;
5429         }
5430
5431         for (i = 14; i < pkt_size; i++) {
5432                 if (*(rx_skb->data + i) != (unsigned char) (i & 0xff)) {
5433                         goto loopback_test_done;
5434                 }
5435         }
5436
5437         ret = 0;
5438
5439 loopback_test_done:
5440         bp->loopback = 0;
5441         return ret;
5442 }
5443
5444 #define BNX2_MAC_LOOPBACK_FAILED        1
5445 #define BNX2_PHY_LOOPBACK_FAILED        2
5446 #define BNX2_LOOPBACK_FAILED            (BNX2_MAC_LOOPBACK_FAILED |     \
5447                                          BNX2_PHY_LOOPBACK_FAILED)
5448
5449 static int
5450 bnx2_test_loopback(struct bnx2 *bp)
5451 {
5452         int rc = 0;
5453
5454         if (!netif_running(bp->dev))
5455                 return BNX2_LOOPBACK_FAILED;
5456
5457         bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
5458         spin_lock_bh(&bp->phy_lock);
5459         bnx2_init_phy(bp, 1);
5460         spin_unlock_bh(&bp->phy_lock);
5461         if (bnx2_run_loopback(bp, BNX2_MAC_LOOPBACK))
5462                 rc |= BNX2_MAC_LOOPBACK_FAILED;
5463         if (bnx2_run_loopback(bp, BNX2_PHY_LOOPBACK))
5464                 rc |= BNX2_PHY_LOOPBACK_FAILED;
5465         return rc;
5466 }
5467
5468 #define NVRAM_SIZE 0x200
5469 #define CRC32_RESIDUAL 0xdebb20e3
5470
5471 static int
5472 bnx2_test_nvram(struct bnx2 *bp)
5473 {
5474         __be32 buf[NVRAM_SIZE / 4];
5475         u8 *data = (u8 *) buf;
5476         int rc = 0;
5477         u32 magic, csum;
5478
5479         if ((rc = bnx2_nvram_read(bp, 0, data, 4)) != 0)
5480                 goto test_nvram_done;
5481
5482         magic = be32_to_cpu(buf[0]);
5483         if (magic != 0x669955aa) {
5484                 rc = -ENODEV;
5485                 goto test_nvram_done;
5486         }
5487
5488         if ((rc = bnx2_nvram_read(bp, 0x100, data, NVRAM_SIZE)) != 0)
5489                 goto test_nvram_done;
5490
5491         csum = ether_crc_le(0x100, data);
5492         if (csum != CRC32_RESIDUAL) {
5493                 rc = -ENODEV;
5494                 goto test_nvram_done;
5495         }
5496
5497         csum = ether_crc_le(0x100, data + 0x100);
5498         if (csum != CRC32_RESIDUAL) {
5499                 rc = -ENODEV;
5500         }
5501
5502 test_nvram_done:
5503         return rc;
5504 }
5505
5506 static int
5507 bnx2_test_link(struct bnx2 *bp)
5508 {
5509         u32 bmsr;
5510
5511         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
5512                 if (bp->link_up)
5513                         return 0;
5514                 return -ENODEV;
5515         }
5516         spin_lock_bh(&bp->phy_lock);
5517         bnx2_enable_bmsr1(bp);
5518         bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
5519         bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
5520         bnx2_disable_bmsr1(bp);
5521         spin_unlock_bh(&bp->phy_lock);
5522
5523         if (bmsr & BMSR_LSTATUS) {
5524                 return 0;
5525         }
5526         return -ENODEV;
5527 }
5528
5529 static int
5530 bnx2_test_intr(struct bnx2 *bp)
5531 {
5532         int i;
5533         u16 status_idx;
5534
5535         if (!netif_running(bp->dev))
5536                 return -ENODEV;
5537
5538         status_idx = REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff;
5539
5540         /* This register is not touched during run-time. */
5541         REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
5542         REG_RD(bp, BNX2_HC_COMMAND);
5543
5544         for (i = 0; i < 10; i++) {
5545                 if ((REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff) !=
5546                         status_idx) {
5547
5548                         break;
5549                 }
5550
5551                 msleep_interruptible(10);
5552         }
5553         if (i < 10)
5554                 return 0;
5555
5556         return -ENODEV;
5557 }
5558
5559 /* Determining link for parallel detection. */
5560 static int
5561 bnx2_5706_serdes_has_link(struct bnx2 *bp)
5562 {
5563         u32 mode_ctl, an_dbg, exp;
5564
5565         if (bp->phy_flags & BNX2_PHY_FLAG_NO_PARALLEL)
5566                 return 0;
5567
5568         bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_MODE_CTL);
5569         bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &mode_ctl);
5570
5571         if (!(mode_ctl & MISC_SHDW_MODE_CTL_SIG_DET))
5572                 return 0;
5573
5574         bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
5575         bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
5576         bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
5577
5578         if (an_dbg & (MISC_SHDW_AN_DBG_NOSYNC | MISC_SHDW_AN_DBG_RUDI_INVALID))
5579                 return 0;
5580
5581         bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS, MII_EXPAND_REG1);
5582         bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &exp);
5583         bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &exp);
5584
5585         if (exp & MII_EXPAND_REG1_RUDI_C)       /* receiving CONFIG */
5586                 return 0;
5587
5588         return 1;
5589 }
5590
5591 static void
5592 bnx2_5706_serdes_timer(struct bnx2 *bp)
5593 {
5594         int check_link = 1;
5595
5596         spin_lock(&bp->phy_lock);
5597         if (bp->serdes_an_pending) {
5598                 bp->serdes_an_pending--;
5599                 check_link = 0;
5600         } else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
5601                 u32 bmcr;
5602
5603                 bp->current_interval = bp->timer_interval;
5604
5605                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
5606
5607                 if (bmcr & BMCR_ANENABLE) {
5608                         if (bnx2_5706_serdes_has_link(bp)) {
5609                                 bmcr &= ~BMCR_ANENABLE;
5610                                 bmcr |= BMCR_SPEED1000 | BMCR_FULLDPLX;
5611                                 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
5612                                 bp->phy_flags |= BNX2_PHY_FLAG_PARALLEL_DETECT;
5613                         }
5614                 }
5615         }
5616         else if ((bp->link_up) && (bp->autoneg & AUTONEG_SPEED) &&
5617                  (bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT)) {
5618                 u32 phy2;
5619
5620                 bnx2_write_phy(bp, 0x17, 0x0f01);
5621                 bnx2_read_phy(bp, 0x15, &phy2);
5622                 if (phy2 & 0x20) {
5623                         u32 bmcr;
5624
5625                         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
5626                         bmcr |= BMCR_ANENABLE;
5627                         bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
5628
5629                         bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
5630                 }
5631         } else
5632                 bp->current_interval = bp->timer_interval;
5633
5634         if (check_link) {
5635                 u32 val;
5636
5637                 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
5638                 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &val);
5639                 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &val);
5640
5641                 if (bp->link_up && (val & MISC_SHDW_AN_DBG_NOSYNC)) {
5642                         if (!(bp->phy_flags & BNX2_PHY_FLAG_FORCED_DOWN)) {
5643                                 bnx2_5706s_force_link_dn(bp, 1);
5644                                 bp->phy_flags |= BNX2_PHY_FLAG_FORCED_DOWN;
5645                         } else
5646                                 bnx2_set_link(bp);
5647                 } else if (!bp->link_up && !(val & MISC_SHDW_AN_DBG_NOSYNC))
5648                         bnx2_set_link(bp);
5649         }
5650         spin_unlock(&bp->phy_lock);
5651 }
5652
5653 static void
5654 bnx2_5708_serdes_timer(struct bnx2 *bp)
5655 {
5656         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
5657                 return;
5658
5659         if ((bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) == 0) {
5660                 bp->serdes_an_pending = 0;
5661                 return;
5662         }
5663
5664         spin_lock(&bp->phy_lock);
5665         if (bp->serdes_an_pending)
5666                 bp->serdes_an_pending--;
5667         else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
5668                 u32 bmcr;
5669
5670                 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
5671                 if (bmcr & BMCR_ANENABLE) {
5672                         bnx2_enable_forced_2g5(bp);
5673                         bp->current_interval = SERDES_FORCED_TIMEOUT;
5674                 } else {
5675                         bnx2_disable_forced_2g5(bp);
5676                         bp->serdes_an_pending = 2;
5677                         bp->current_interval = bp->timer_interval;
5678                 }
5679
5680         } else
5681                 bp->current_interval = bp->timer_interval;
5682
5683         spin_unlock(&bp->phy_lock);
5684 }
5685
5686 static void
5687 bnx2_timer(unsigned long data)
5688 {
5689         struct bnx2 *bp = (struct bnx2 *) data;
5690
5691         if (!netif_running(bp->dev))
5692                 return;
5693
5694         if (atomic_read(&bp->intr_sem) != 0)
5695                 goto bnx2_restart_timer;
5696
5697         bnx2_send_heart_beat(bp);
5698
5699         bp->stats_blk->stat_FwRxDrop =
5700                 bnx2_reg_rd_ind(bp, BNX2_FW_RX_DROP_COUNT);
5701
5702         /* workaround occasional corrupted counters */
5703         if (CHIP_NUM(bp) == CHIP_NUM_5708 && bp->stats_ticks)
5704                 REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd |
5705                                             BNX2_HC_COMMAND_STATS_NOW);
5706
5707         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
5708                 if (CHIP_NUM(bp) == CHIP_NUM_5706)
5709                         bnx2_5706_serdes_timer(bp);
5710                 else
5711                         bnx2_5708_serdes_timer(bp);
5712         }
5713
5714 bnx2_restart_timer:
5715         mod_timer(&bp->timer, jiffies + bp->current_interval);
5716 }
5717
5718 static int
5719 bnx2_request_irq(struct bnx2 *bp)
5720 {
5721         unsigned long flags;
5722         struct bnx2_irq *irq;
5723         int rc = 0, i;
5724
5725         if (bp->flags & BNX2_FLAG_USING_MSI_OR_MSIX)
5726                 flags = 0;
5727         else
5728                 flags = IRQF_SHARED;
5729
5730         for (i = 0; i < bp->irq_nvecs; i++) {
5731                 irq = &bp->irq_tbl[i];
5732                 rc = request_irq(irq->vector, irq->handler, flags, irq->name,
5733                                  &bp->bnx2_napi[i]);
5734                 if (rc)
5735                         break;
5736                 irq->requested = 1;
5737         }
5738         return rc;
5739 }
5740
5741 static void
5742 bnx2_free_irq(struct bnx2 *bp)
5743 {
5744         struct bnx2_irq *irq;
5745         int i;
5746
5747         for (i = 0; i < bp->irq_nvecs; i++) {
5748                 irq = &bp->irq_tbl[i];
5749                 if (irq->requested)
5750                         free_irq(irq->vector, &bp->bnx2_napi[i]);
5751                 irq->requested = 0;
5752         }
5753         if (bp->flags & BNX2_FLAG_USING_MSI)
5754                 pci_disable_msi(bp->pdev);
5755         else if (bp->flags & BNX2_FLAG_USING_MSIX)
5756                 pci_disable_msix(bp->pdev);
5757
5758         bp->flags &= ~(BNX2_FLAG_USING_MSI_OR_MSIX | BNX2_FLAG_ONE_SHOT_MSI);
5759 }
5760
5761 static void
5762 bnx2_enable_msix(struct bnx2 *bp, int msix_vecs)
5763 {
5764         int i, rc;
5765         struct msix_entry msix_ent[BNX2_MAX_MSIX_VEC];
5766
5767         bnx2_setup_msix_tbl(bp);
5768         REG_WR(bp, BNX2_PCI_MSIX_CONTROL, BNX2_MAX_MSIX_HW_VEC - 1);
5769         REG_WR(bp, BNX2_PCI_MSIX_TBL_OFF_BIR, BNX2_PCI_GRC_WINDOW2_BASE);
5770         REG_WR(bp, BNX2_PCI_MSIX_PBA_OFF_BIT, BNX2_PCI_GRC_WINDOW3_BASE);
5771
5772         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
5773                 msix_ent[i].entry = i;
5774                 msix_ent[i].vector = 0;
5775
5776                 strcpy(bp->irq_tbl[i].name, bp->dev->name);
5777                 bp->irq_tbl[i].handler = bnx2_msi_1shot;
5778         }
5779
5780         rc = pci_enable_msix(bp->pdev, msix_ent, BNX2_MAX_MSIX_VEC);
5781         if (rc != 0)
5782                 return;
5783
5784         bp->irq_nvecs = msix_vecs;
5785         bp->flags |= BNX2_FLAG_USING_MSIX | BNX2_FLAG_ONE_SHOT_MSI;
5786         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++)
5787                 bp->irq_tbl[i].vector = msix_ent[i].vector;
5788 }
5789
5790 static void
5791 bnx2_setup_int_mode(struct bnx2 *bp, int dis_msi)
5792 {
5793         int cpus = num_online_cpus();
5794         int msix_vecs = min(cpus + 1, RX_MAX_RINGS);
5795
5796         bp->irq_tbl[0].handler = bnx2_interrupt;
5797         strcpy(bp->irq_tbl[0].name, bp->dev->name);
5798         bp->irq_nvecs = 1;
5799         bp->irq_tbl[0].vector = bp->pdev->irq;
5800
5801         if ((bp->flags & BNX2_FLAG_MSIX_CAP) && !dis_msi && cpus > 1)
5802                 bnx2_enable_msix(bp, msix_vecs);
5803
5804         if ((bp->flags & BNX2_FLAG_MSI_CAP) && !dis_msi &&
5805             !(bp->flags & BNX2_FLAG_USING_MSIX)) {
5806                 if (pci_enable_msi(bp->pdev) == 0) {
5807                         bp->flags |= BNX2_FLAG_USING_MSI;
5808                         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
5809                                 bp->flags |= BNX2_FLAG_ONE_SHOT_MSI;
5810                                 bp->irq_tbl[0].handler = bnx2_msi_1shot;
5811                         } else
5812                                 bp->irq_tbl[0].handler = bnx2_msi;
5813
5814                         bp->irq_tbl[0].vector = bp->pdev->irq;
5815                 }
5816         }
5817
5818         bp->num_tx_rings = rounddown_pow_of_two(bp->irq_nvecs);
5819         bp->dev->real_num_tx_queues = bp->num_tx_rings;
5820
5821         bp->num_rx_rings = bp->irq_nvecs;
5822 }
5823
5824 /* Called with rtnl_lock */
5825 static int
5826 bnx2_open(struct net_device *dev)
5827 {
5828         struct bnx2 *bp = netdev_priv(dev);
5829         int rc;
5830
5831         netif_carrier_off(dev);
5832
5833         bnx2_set_power_state(bp, PCI_D0);
5834         bnx2_disable_int(bp);
5835
5836         bnx2_setup_int_mode(bp, disable_msi);
5837         bnx2_napi_enable(bp);
5838         rc = bnx2_alloc_mem(bp);
5839         if (rc)
5840                 goto open_err;
5841
5842         rc = bnx2_request_irq(bp);
5843         if (rc)
5844                 goto open_err;
5845
5846         rc = bnx2_init_nic(bp, 1);
5847         if (rc)
5848                 goto open_err;
5849
5850         mod_timer(&bp->timer, jiffies + bp->current_interval);
5851
5852         atomic_set(&bp->intr_sem, 0);
5853
5854         bnx2_enable_int(bp);
5855
5856         if (bp->flags & BNX2_FLAG_USING_MSI) {
5857                 /* Test MSI to make sure it is working
5858                  * If MSI test fails, go back to INTx mode
5859                  */
5860                 if (bnx2_test_intr(bp) != 0) {
5861                         printk(KERN_WARNING PFX "%s: No interrupt was generated"
5862                                " using MSI, switching to INTx mode. Please"
5863                                " report this failure to the PCI maintainer"
5864                                " and include system chipset information.\n",
5865                                bp->dev->name);
5866
5867                         bnx2_disable_int(bp);
5868                         bnx2_free_irq(bp);
5869
5870                         bnx2_setup_int_mode(bp, 1);
5871
5872                         rc = bnx2_init_nic(bp, 0);
5873
5874                         if (!rc)
5875                                 rc = bnx2_request_irq(bp);
5876
5877                         if (rc) {
5878                                 del_timer_sync(&bp->timer);
5879                                 goto open_err;
5880                         }
5881                         bnx2_enable_int(bp);
5882                 }
5883         }
5884         if (bp->flags & BNX2_FLAG_USING_MSI)
5885                 printk(KERN_INFO PFX "%s: using MSI\n", dev->name);
5886         else if (bp->flags & BNX2_FLAG_USING_MSIX)
5887                 printk(KERN_INFO PFX "%s: using MSIX\n", dev->name);
5888
5889         netif_tx_start_all_queues(dev);
5890
5891         return 0;
5892
5893 open_err:
5894         bnx2_napi_disable(bp);
5895         bnx2_free_skbs(bp);
5896         bnx2_free_irq(bp);
5897         bnx2_free_mem(bp);
5898         return rc;
5899 }
5900
5901 static void
5902 bnx2_reset_task(struct work_struct *work)
5903 {
5904         struct bnx2 *bp = container_of(work, struct bnx2, reset_task);
5905
5906         if (!netif_running(bp->dev))
5907                 return;
5908
5909         bnx2_netif_stop(bp);
5910
5911         bnx2_init_nic(bp, 1);
5912
5913         atomic_set(&bp->intr_sem, 1);
5914         bnx2_netif_start(bp);
5915 }
5916
5917 static void
5918 bnx2_tx_timeout(struct net_device *dev)
5919 {
5920         struct bnx2 *bp = netdev_priv(dev);
5921
5922         /* This allows the netif to be shutdown gracefully before resetting */
5923         schedule_work(&bp->reset_task);
5924 }
5925
5926 #ifdef BCM_VLAN
5927 /* Called with rtnl_lock */
5928 static void
5929 bnx2_vlan_rx_register(struct net_device *dev, struct vlan_group *vlgrp)
5930 {
5931         struct bnx2 *bp = netdev_priv(dev);
5932
5933         bnx2_netif_stop(bp);
5934
5935         bp->vlgrp = vlgrp;
5936         bnx2_set_rx_mode(dev);
5937         if (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN)
5938                 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_KEEP_VLAN_UPDATE, 0, 1);
5939
5940         bnx2_netif_start(bp);
5941 }
5942 #endif
5943
5944 /* Called with netif_tx_lock.
5945  * bnx2_tx_int() runs without netif_tx_lock unless it needs to call
5946  * netif_wake_queue().
5947  */
5948 static int
5949 bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
5950 {
5951         struct bnx2 *bp = netdev_priv(dev);
5952         dma_addr_t mapping;
5953         struct tx_bd *txbd;
5954         struct sw_bd *tx_buf;
5955         u32 len, vlan_tag_flags, last_frag, mss;
5956         u16 prod, ring_prod;
5957         int i;
5958         struct bnx2_napi *bnapi;
5959         struct bnx2_tx_ring_info *txr;
5960         struct netdev_queue *txq;
5961
5962         /*  Determine which tx ring we will be placed on */
5963         i = skb_get_queue_mapping(skb);
5964         bnapi = &bp->bnx2_napi[i];
5965         txr = &bnapi->tx_ring;
5966         txq = netdev_get_tx_queue(dev, i);
5967
5968         if (unlikely(bnx2_tx_avail(bp, txr) <
5969             (skb_shinfo(skb)->nr_frags + 1))) {
5970                 netif_tx_stop_queue(txq);
5971                 printk(KERN_ERR PFX "%s: BUG! Tx ring full when queue awake!\n",
5972                         dev->name);
5973
5974                 return NETDEV_TX_BUSY;
5975         }
5976         len = skb_headlen(skb);
5977         prod = txr->tx_prod;
5978         ring_prod = TX_RING_IDX(prod);
5979
5980         vlan_tag_flags = 0;
5981         if (skb->ip_summed == CHECKSUM_PARTIAL) {
5982                 vlan_tag_flags |= TX_BD_FLAGS_TCP_UDP_CKSUM;
5983         }
5984
5985 #ifdef BCM_VLAN
5986         if (bp->vlgrp && vlan_tx_tag_present(skb)) {
5987                 vlan_tag_flags |=
5988                         (TX_BD_FLAGS_VLAN_TAG | (vlan_tx_tag_get(skb) << 16));
5989         }
5990 #endif
5991         if ((mss = skb_shinfo(skb)->gso_size)) {
5992                 u32 tcp_opt_len, ip_tcp_len;
5993                 struct iphdr *iph;
5994
5995                 vlan_tag_flags |= TX_BD_FLAGS_SW_LSO;
5996
5997                 tcp_opt_len = tcp_optlen(skb);
5998
5999                 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) {
6000                         u32 tcp_off = skb_transport_offset(skb) -
6001                                       sizeof(struct ipv6hdr) - ETH_HLEN;
6002
6003                         vlan_tag_flags |= ((tcp_opt_len >> 2) << 8) |
6004                                           TX_BD_FLAGS_SW_FLAGS;
6005                         if (likely(tcp_off == 0))
6006                                 vlan_tag_flags &= ~TX_BD_FLAGS_TCP6_OFF0_MSK;
6007                         else {
6008                                 tcp_off >>= 3;
6009                                 vlan_tag_flags |= ((tcp_off & 0x3) <<
6010                                                    TX_BD_FLAGS_TCP6_OFF0_SHL) |
6011                                                   ((tcp_off & 0x10) <<
6012                                                    TX_BD_FLAGS_TCP6_OFF4_SHL);
6013                                 mss |= (tcp_off & 0xc) << TX_BD_TCP6_OFF2_SHL;
6014                         }
6015                 } else {
6016                         if (skb_header_cloned(skb) &&
6017                             pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
6018                                 dev_kfree_skb(skb);
6019                                 return NETDEV_TX_OK;
6020                         }
6021
6022                         ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
6023
6024                         iph = ip_hdr(skb);
6025                         iph->check = 0;
6026                         iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len);
6027                         tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
6028                                                                  iph->daddr, 0,
6029                                                                  IPPROTO_TCP,
6030                                                                  0);
6031                         if (tcp_opt_len || (iph->ihl > 5)) {
6032                                 vlan_tag_flags |= ((iph->ihl - 5) +
6033                                                    (tcp_opt_len >> 2)) << 8;
6034                         }
6035                 }
6036         } else
6037                 mss = 0;
6038
6039         mapping = pci_map_single(bp->pdev, skb->data, len, PCI_DMA_TODEVICE);
6040
6041         tx_buf = &txr->tx_buf_ring[ring_prod];
6042         tx_buf->skb = skb;
6043         pci_unmap_addr_set(tx_buf, mapping, mapping);
6044
6045         txbd = &txr->tx_desc_ring[ring_prod];
6046
6047         txbd->tx_bd_haddr_hi = (u64) mapping >> 32;
6048         txbd->tx_bd_haddr_lo = (u64) mapping & 0xffffffff;
6049         txbd->tx_bd_mss_nbytes = len | (mss << 16);
6050         txbd->tx_bd_vlan_tag_flags = vlan_tag_flags | TX_BD_FLAGS_START;
6051
6052         last_frag = skb_shinfo(skb)->nr_frags;
6053
6054         for (i = 0; i < last_frag; i++) {
6055                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
6056
6057                 prod = NEXT_TX_BD(prod);
6058                 ring_prod = TX_RING_IDX(prod);
6059                 txbd = &txr->tx_desc_ring[ring_prod];
6060
6061                 len = frag->size;
6062                 mapping = pci_map_page(bp->pdev, frag->page, frag->page_offset,
6063                         len, PCI_DMA_TODEVICE);
6064                 pci_unmap_addr_set(&txr->tx_buf_ring[ring_prod],
6065                                 mapping, mapping);
6066
6067                 txbd->tx_bd_haddr_hi = (u64) mapping >> 32;
6068                 txbd->tx_bd_haddr_lo = (u64) mapping & 0xffffffff;
6069                 txbd->tx_bd_mss_nbytes = len | (mss << 16);
6070                 txbd->tx_bd_vlan_tag_flags = vlan_tag_flags;
6071
6072         }
6073         txbd->tx_bd_vlan_tag_flags |= TX_BD_FLAGS_END;
6074
6075         prod = NEXT_TX_BD(prod);
6076         txr->tx_prod_bseq += skb->len;
6077
6078         REG_WR16(bp, txr->tx_bidx_addr, prod);
6079         REG_WR(bp, txr->tx_bseq_addr, txr->tx_prod_bseq);
6080
6081         mmiowb();
6082
6083         txr->tx_prod = prod;
6084         dev->trans_start = jiffies;
6085
6086         if (unlikely(bnx2_tx_avail(bp, txr) <= MAX_SKB_FRAGS)) {
6087                 netif_tx_stop_queue(txq);
6088                 if (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh)
6089                         netif_tx_wake_queue(txq);
6090         }
6091
6092         return NETDEV_TX_OK;
6093 }
6094
6095 /* Called with rtnl_lock */
6096 static int
6097 bnx2_close(struct net_device *dev)
6098 {
6099         struct bnx2 *bp = netdev_priv(dev);
6100         u32 reset_code;
6101
6102         cancel_work_sync(&bp->reset_task);
6103
6104         bnx2_disable_int_sync(bp);
6105         bnx2_napi_disable(bp);
6106         del_timer_sync(&bp->timer);
6107         if (bp->flags & BNX2_FLAG_NO_WOL)
6108                 reset_code = BNX2_DRV_MSG_CODE_UNLOAD_LNK_DN;
6109         else if (bp->wol)
6110                 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
6111         else
6112                 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
6113         bnx2_reset_chip(bp, reset_code);
6114         bnx2_free_irq(bp);
6115         bnx2_free_skbs(bp);
6116         bnx2_free_mem(bp);
6117         bp->link_up = 0;
6118         netif_carrier_off(bp->dev);
6119         bnx2_set_power_state(bp, PCI_D3hot);
6120         return 0;
6121 }
6122
6123 #define GET_NET_STATS64(ctr)                                    \
6124         (unsigned long) ((unsigned long) (ctr##_hi) << 32) +    \
6125         (unsigned long) (ctr##_lo)
6126
6127 #define GET_NET_STATS32(ctr)            \
6128         (ctr##_lo)
6129
6130 #if (BITS_PER_LONG == 64)
6131 #define GET_NET_STATS   GET_NET_STATS64
6132 #else
6133 #define GET_NET_STATS   GET_NET_STATS32
6134 #endif
6135
6136 static struct net_device_stats *
6137 bnx2_get_stats(struct net_device *dev)
6138 {
6139         struct bnx2 *bp = netdev_priv(dev);
6140         struct statistics_block *stats_blk = bp->stats_blk;
6141         struct net_device_stats *net_stats = &bp->net_stats;
6142
6143         if (bp->stats_blk == NULL) {
6144                 return net_stats;
6145         }
6146         net_stats->rx_packets =
6147                 GET_NET_STATS(stats_blk->stat_IfHCInUcastPkts) +
6148                 GET_NET_STATS(stats_blk->stat_IfHCInMulticastPkts) +
6149                 GET_NET_STATS(stats_blk->stat_IfHCInBroadcastPkts);
6150
6151         net_stats->tx_packets =
6152                 GET_NET_STATS(stats_blk->stat_IfHCOutUcastPkts) +
6153                 GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts) +
6154                 GET_NET_STATS(stats_blk->stat_IfHCOutBroadcastPkts);
6155
6156         net_stats->rx_bytes =
6157                 GET_NET_STATS(stats_blk->stat_IfHCInOctets);
6158
6159         net_stats->tx_bytes =
6160                 GET_NET_STATS(stats_blk->stat_IfHCOutOctets);
6161
6162         net_stats->multicast =
6163                 GET_NET_STATS(stats_blk->stat_IfHCOutMulticastPkts);
6164
6165         net_stats->collisions =
6166                 (unsigned long) stats_blk->stat_EtherStatsCollisions;
6167
6168         net_stats->rx_length_errors =
6169                 (unsigned long) (stats_blk->stat_EtherStatsUndersizePkts +
6170                 stats_blk->stat_EtherStatsOverrsizePkts);
6171
6172         net_stats->rx_over_errors =
6173                 (unsigned long) stats_blk->stat_IfInMBUFDiscards;
6174
6175         net_stats->rx_frame_errors =
6176                 (unsigned long) stats_blk->stat_Dot3StatsAlignmentErrors;
6177
6178         net_stats->rx_crc_errors =
6179                 (unsigned long) stats_blk->stat_Dot3StatsFCSErrors;
6180
6181         net_stats->rx_errors = net_stats->rx_length_errors +
6182                 net_stats->rx_over_errors + net_stats->rx_frame_errors +
6183                 net_stats->rx_crc_errors;
6184
6185         net_stats->tx_aborted_errors =
6186                 (unsigned long) (stats_blk->stat_Dot3StatsExcessiveCollisions +
6187                 stats_blk->stat_Dot3StatsLateCollisions);
6188
6189         if ((CHIP_NUM(bp) == CHIP_NUM_5706) ||
6190             (CHIP_ID(bp) == CHIP_ID_5708_A0))
6191                 net_stats->tx_carrier_errors = 0;
6192         else {
6193                 net_stats->tx_carrier_errors =
6194                         (unsigned long)
6195                         stats_blk->stat_Dot3StatsCarrierSenseErrors;
6196         }
6197
6198         net_stats->tx_errors =
6199                 (unsigned long)
6200                 stats_blk->stat_emac_tx_stat_dot3statsinternalmactransmiterrors
6201                 +
6202                 net_stats->tx_aborted_errors +
6203                 net_stats->tx_carrier_errors;
6204
6205         net_stats->rx_missed_errors =
6206                 (unsigned long) (stats_blk->stat_IfInMBUFDiscards +
6207                 stats_blk->stat_FwRxDrop);
6208
6209         return net_stats;
6210 }
6211
6212 /* All ethtool functions called with rtnl_lock */
6213
6214 static int
6215 bnx2_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
6216 {
6217         struct bnx2 *bp = netdev_priv(dev);
6218         int support_serdes = 0, support_copper = 0;
6219
6220         cmd->supported = SUPPORTED_Autoneg;
6221         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
6222                 support_serdes = 1;
6223                 support_copper = 1;
6224         } else if (bp->phy_port == PORT_FIBRE)
6225                 support_serdes = 1;
6226         else
6227                 support_copper = 1;
6228
6229         if (support_serdes) {
6230                 cmd->supported |= SUPPORTED_1000baseT_Full |
6231                         SUPPORTED_FIBRE;
6232                 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE)
6233                         cmd->supported |= SUPPORTED_2500baseX_Full;
6234
6235         }
6236         if (support_copper) {
6237                 cmd->supported |= SUPPORTED_10baseT_Half |
6238                         SUPPORTED_10baseT_Full |
6239                         SUPPORTED_100baseT_Half |
6240                         SUPPORTED_100baseT_Full |
6241                         SUPPORTED_1000baseT_Full |
6242                         SUPPORTED_TP;
6243
6244         }
6245
6246         spin_lock_bh(&bp->phy_lock);
6247         cmd->port = bp->phy_port;
6248         cmd->advertising = bp->advertising;
6249
6250         if (bp->autoneg & AUTONEG_SPEED) {
6251                 cmd->autoneg = AUTONEG_ENABLE;
6252         }
6253         else {
6254                 cmd->autoneg = AUTONEG_DISABLE;
6255         }
6256
6257         if (netif_carrier_ok(dev)) {
6258                 cmd->speed = bp->line_speed;
6259                 cmd->duplex = bp->duplex;
6260         }
6261         else {
6262                 cmd->speed = -1;
6263                 cmd->duplex = -1;
6264         }
6265         spin_unlock_bh(&bp->phy_lock);
6266
6267         cmd->transceiver = XCVR_INTERNAL;
6268         cmd->phy_address = bp->phy_addr;
6269
6270         return 0;
6271 }
6272
6273 static int
6274 bnx2_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
6275 {
6276         struct bnx2 *bp = netdev_priv(dev);
6277         u8 autoneg = bp->autoneg;
6278         u8 req_duplex = bp->req_duplex;
6279         u16 req_line_speed = bp->req_line_speed;
6280         u32 advertising = bp->advertising;
6281         int err = -EINVAL;
6282
6283         spin_lock_bh(&bp->phy_lock);
6284
6285         if (cmd->port != PORT_TP && cmd->port != PORT_FIBRE)
6286                 goto err_out_unlock;
6287
6288         if (cmd->port != bp->phy_port &&
6289             !(bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP))
6290                 goto err_out_unlock;
6291
6292         /* If device is down, we can store the settings only if the user
6293          * is setting the currently active port.
6294          */
6295         if (!netif_running(dev) && cmd->port != bp->phy_port)
6296                 goto err_out_unlock;
6297
6298         if (cmd->autoneg == AUTONEG_ENABLE) {
6299                 autoneg |= AUTONEG_SPEED;
6300
6301                 cmd->advertising &= ETHTOOL_ALL_COPPER_SPEED;
6302
6303                 /* allow advertising 1 speed */
6304                 if ((cmd->advertising == ADVERTISED_10baseT_Half) ||
6305                         (cmd->advertising == ADVERTISED_10baseT_Full) ||
6306                         (cmd->advertising == ADVERTISED_100baseT_Half) ||
6307                         (cmd->advertising == ADVERTISED_100baseT_Full)) {
6308
6309                         if (cmd->port == PORT_FIBRE)
6310                                 goto err_out_unlock;
6311
6312                         advertising = cmd->advertising;
6313
6314                 } else if (cmd->advertising == ADVERTISED_2500baseX_Full) {
6315                         if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) ||
6316                             (cmd->port == PORT_TP))
6317                                 goto err_out_unlock;
6318                 } else if (cmd->advertising == ADVERTISED_1000baseT_Full)
6319                         advertising = cmd->advertising;
6320                 else if (cmd->advertising == ADVERTISED_1000baseT_Half)
6321                         goto err_out_unlock;
6322                 else {
6323                         if (cmd->port == PORT_FIBRE)
6324                                 advertising = ETHTOOL_ALL_FIBRE_SPEED;
6325                         else
6326                                 advertising = ETHTOOL_ALL_COPPER_SPEED;
6327                 }
6328                 advertising |= ADVERTISED_Autoneg;
6329         }
6330         else {
6331                 if (cmd->port == PORT_FIBRE) {
6332                         if ((cmd->speed != SPEED_1000 &&
6333                              cmd->speed != SPEED_2500) ||
6334                             (cmd->duplex != DUPLEX_FULL))
6335                                 goto err_out_unlock;
6336
6337                         if (cmd->speed == SPEED_2500 &&
6338                             !(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
6339                                 goto err_out_unlock;
6340                 }
6341                 else if (cmd->speed == SPEED_1000 || cmd->speed == SPEED_2500)
6342                         goto err_out_unlock;
6343
6344                 autoneg &= ~AUTONEG_SPEED;
6345                 req_line_speed = cmd->speed;
6346                 req_duplex = cmd->duplex;
6347                 advertising = 0;
6348         }
6349
6350         bp->autoneg = autoneg;
6351         bp->advertising = advertising;
6352         bp->req_line_speed = req_line_speed;
6353         bp->req_duplex = req_duplex;
6354
6355         err = 0;
6356         /* If device is down, the new settings will be picked up when it is
6357          * brought up.
6358          */
6359         if (netif_running(dev))
6360                 err = bnx2_setup_phy(bp, cmd->port);
6361
6362 err_out_unlock:
6363         spin_unlock_bh(&bp->phy_lock);
6364
6365         return err;
6366 }
6367
6368 static void
6369 bnx2_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
6370 {
6371         struct bnx2 *bp = netdev_priv(dev);
6372
6373         strcpy(info->driver, DRV_MODULE_NAME);
6374         strcpy(info->version, DRV_MODULE_VERSION);
6375         strcpy(info->bus_info, pci_name(bp->pdev));
6376         strcpy(info->fw_version, bp->fw_version);
6377 }
6378
6379 #define BNX2_REGDUMP_LEN                (32 * 1024)
6380
6381 static int
6382 bnx2_get_regs_len(struct net_device *dev)
6383 {
6384         return BNX2_REGDUMP_LEN;
6385 }
6386
6387 static void
6388 bnx2_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
6389 {
6390         u32 *p = _p, i, offset;
6391         u8 *orig_p = _p;
6392         struct bnx2 *bp = netdev_priv(dev);
6393         u32 reg_boundaries[] = { 0x0000, 0x0098, 0x0400, 0x045c,
6394                                  0x0800, 0x0880, 0x0c00, 0x0c10,
6395                                  0x0c30, 0x0d08, 0x1000, 0x101c,
6396                                  0x1040, 0x1048, 0x1080, 0x10a4,
6397                                  0x1400, 0x1490, 0x1498, 0x14f0,
6398                                  0x1500, 0x155c, 0x1580, 0x15dc,
6399                                  0x1600, 0x1658, 0x1680, 0x16d8,
6400                                  0x1800, 0x1820, 0x1840, 0x1854,
6401                                  0x1880, 0x1894, 0x1900, 0x1984,
6402                                  0x1c00, 0x1c0c, 0x1c40, 0x1c54,
6403                                  0x1c80, 0x1c94, 0x1d00, 0x1d84,
6404                                  0x2000, 0x2030, 0x23c0, 0x2400,
6405                                  0x2800, 0x2820, 0x2830, 0x2850,
6406                                  0x2b40, 0x2c10, 0x2fc0, 0x3058,
6407                                  0x3c00, 0x3c94, 0x4000, 0x4010,
6408                                  0x4080, 0x4090, 0x43c0, 0x4458,
6409                                  0x4c00, 0x4c18, 0x4c40, 0x4c54,
6410                                  0x4fc0, 0x5010, 0x53c0, 0x5444,
6411                                  0x5c00, 0x5c18, 0x5c80, 0x5c90,
6412                                  0x5fc0, 0x6000, 0x6400, 0x6428,
6413                                  0x6800, 0x6848, 0x684c, 0x6860,
6414                                  0x6888, 0x6910, 0x8000 };
6415
6416         regs->version = 0;
6417
6418         memset(p, 0, BNX2_REGDUMP_LEN);
6419
6420         if (!netif_running(bp->dev))
6421                 return;
6422
6423         i = 0;
6424         offset = reg_boundaries[0];
6425         p += offset;
6426         while (offset < BNX2_REGDUMP_LEN) {
6427                 *p++ = REG_RD(bp, offset);
6428                 offset += 4;
6429                 if (offset == reg_boundaries[i + 1]) {
6430                         offset = reg_boundaries[i + 2];
6431                         p = (u32 *) (orig_p + offset);
6432                         i += 2;
6433                 }
6434         }
6435 }
6436
6437 static void
6438 bnx2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
6439 {
6440         struct bnx2 *bp = netdev_priv(dev);
6441
6442         if (bp->flags & BNX2_FLAG_NO_WOL) {
6443                 wol->supported = 0;
6444                 wol->wolopts = 0;
6445         }
6446         else {
6447                 wol->supported = WAKE_MAGIC;
6448                 if (bp->wol)
6449                         wol->wolopts = WAKE_MAGIC;
6450                 else
6451                         wol->wolopts = 0;
6452         }
6453         memset(&wol->sopass, 0, sizeof(wol->sopass));
6454 }
6455
6456 static int
6457 bnx2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
6458 {
6459         struct bnx2 *bp = netdev_priv(dev);
6460
6461         if (wol->wolopts & ~WAKE_MAGIC)
6462                 return -EINVAL;
6463
6464         if (wol->wolopts & WAKE_MAGIC) {
6465                 if (bp->flags & BNX2_FLAG_NO_WOL)
6466                         return -EINVAL;
6467
6468                 bp->wol = 1;
6469         }
6470         else {
6471                 bp->wol = 0;
6472         }
6473         return 0;
6474 }
6475
6476 static int
6477 bnx2_nway_reset(struct net_device *dev)
6478 {
6479         struct bnx2 *bp = netdev_priv(dev);
6480         u32 bmcr;
6481
6482         if (!(bp->autoneg & AUTONEG_SPEED)) {
6483                 return -EINVAL;
6484         }
6485
6486         spin_lock_bh(&bp->phy_lock);
6487
6488         if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
6489                 int rc;
6490
6491                 rc = bnx2_setup_remote_phy(bp, bp->phy_port);
6492                 spin_unlock_bh(&bp->phy_lock);
6493                 return rc;
6494         }
6495
6496         /* Force a link down visible on the other side */
6497         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
6498                 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
6499                 spin_unlock_bh(&bp->phy_lock);
6500
6501                 msleep(20);
6502
6503                 spin_lock_bh(&bp->phy_lock);
6504
6505                 bp->current_interval = SERDES_AN_TIMEOUT;
6506                 bp->serdes_an_pending = 1;
6507                 mod_timer(&bp->timer, jiffies + bp->current_interval);
6508         }
6509
6510         bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
6511         bmcr &= ~BMCR_LOOPBACK;
6512         bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART | BMCR_ANENABLE);
6513
6514         spin_unlock_bh(&bp->phy_lock);
6515
6516         return 0;
6517 }
6518
6519 static int
6520 bnx2_get_eeprom_len(struct net_device *dev)
6521 {
6522         struct bnx2 *bp = netdev_priv(dev);
6523
6524         if (bp->flash_info == NULL)
6525                 return 0;
6526
6527         return (int) bp->flash_size;
6528 }
6529
6530 static int
6531 bnx2_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
6532                 u8 *eebuf)
6533 {
6534         struct bnx2 *bp = netdev_priv(dev);
6535         int rc;
6536
6537         /* parameters already validated in ethtool_get_eeprom */
6538
6539         rc = bnx2_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
6540
6541         return rc;
6542 }
6543
6544 static int
6545 bnx2_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
6546                 u8 *eebuf)
6547 {
6548         struct bnx2 *bp = netdev_priv(dev);
6549         int rc;
6550
6551         /* parameters already validated in ethtool_set_eeprom */
6552
6553         rc = bnx2_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
6554
6555         return rc;
6556 }
6557
6558 static int
6559 bnx2_get_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
6560 {
6561         struct bnx2 *bp = netdev_priv(dev);
6562
6563         memset(coal, 0, sizeof(struct ethtool_coalesce));
6564
6565         coal->rx_coalesce_usecs = bp->rx_ticks;
6566         coal->rx_max_coalesced_frames = bp->rx_quick_cons_trip;
6567         coal->rx_coalesce_usecs_irq = bp->rx_ticks_int;
6568         coal->rx_max_coalesced_frames_irq = bp->rx_quick_cons_trip_int;
6569
6570         coal->tx_coalesce_usecs = bp->tx_ticks;
6571         coal->tx_max_coalesced_frames = bp->tx_quick_cons_trip;
6572         coal->tx_coalesce_usecs_irq = bp->tx_ticks_int;
6573         coal->tx_max_coalesced_frames_irq = bp->tx_quick_cons_trip_int;
6574
6575         coal->stats_block_coalesce_usecs = bp->stats_ticks;
6576
6577         return 0;
6578 }
6579
6580 static int
6581 bnx2_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coal)
6582 {
6583         struct bnx2 *bp = netdev_priv(dev);
6584
6585         bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
6586         if (bp->rx_ticks > 0x3ff) bp->rx_ticks = 0x3ff;
6587
6588         bp->rx_quick_cons_trip = (u16) coal->rx_max_coalesced_frames;
6589         if (bp->rx_quick_cons_trip > 0xff) bp->rx_quick_cons_trip = 0xff;
6590
6591         bp->rx_ticks_int = (u16) coal->rx_coalesce_usecs_irq;
6592         if (bp->rx_ticks_int > 0x3ff) bp->rx_ticks_int = 0x3ff;
6593
6594         bp->rx_quick_cons_trip_int = (u16) coal->rx_max_coalesced_frames_irq;
6595         if (bp->rx_quick_cons_trip_int > 0xff)
6596                 bp->rx_quick_cons_trip_int = 0xff;
6597
6598         bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
6599         if (bp->tx_ticks > 0x3ff) bp->tx_ticks = 0x3ff;
6600
6601         bp->tx_quick_cons_trip = (u16) coal->tx_max_coalesced_frames;
6602         if (bp->tx_quick_cons_trip > 0xff) bp->tx_quick_cons_trip = 0xff;
6603
6604         bp->tx_ticks_int = (u16) coal->tx_coalesce_usecs_irq;
6605         if (bp->tx_ticks_int > 0x3ff) bp->tx_ticks_int = 0x3ff;
6606
6607         bp->tx_quick_cons_trip_int = (u16) coal->tx_max_coalesced_frames_irq;
6608         if (bp->tx_quick_cons_trip_int > 0xff) bp->tx_quick_cons_trip_int =
6609                 0xff;
6610
6611         bp->stats_ticks = coal->stats_block_coalesce_usecs;
6612         if (CHIP_NUM(bp) == CHIP_NUM_5708) {
6613                 if (bp->stats_ticks != 0 && bp->stats_ticks != USEC_PER_SEC)
6614                         bp->stats_ticks = USEC_PER_SEC;
6615         }
6616         if (bp->stats_ticks > BNX2_HC_STATS_TICKS_HC_STAT_TICKS)
6617                 bp->stats_ticks = BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
6618         bp->stats_ticks &= BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
6619
6620         if (netif_running(bp->dev)) {
6621                 bnx2_netif_stop(bp);
6622                 bnx2_init_nic(bp, 0);
6623                 bnx2_netif_start(bp);
6624         }
6625
6626         return 0;
6627 }
6628
6629 static void
6630 bnx2_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
6631 {
6632         struct bnx2 *bp = netdev_priv(dev);
6633
6634         ering->rx_max_pending = MAX_TOTAL_RX_DESC_CNT;
6635         ering->rx_mini_max_pending = 0;
6636         ering->rx_jumbo_max_pending = MAX_TOTAL_RX_PG_DESC_CNT;
6637
6638         ering->rx_pending = bp->rx_ring_size;
6639         ering->rx_mini_pending = 0;
6640         ering->rx_jumbo_pending = bp->rx_pg_ring_size;
6641
6642         ering->tx_max_pending = MAX_TX_DESC_CNT;
6643         ering->tx_pending = bp->tx_ring_size;
6644 }
6645
6646 static int
6647 bnx2_change_ring_size(struct bnx2 *bp, u32 rx, u32 tx)
6648 {
6649         if (netif_running(bp->dev)) {
6650                 bnx2_netif_stop(bp);
6651                 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
6652                 bnx2_free_skbs(bp);
6653                 bnx2_free_mem(bp);
6654         }
6655
6656         bnx2_set_rx_ring_size(bp, rx);
6657         bp->tx_ring_size = tx;
6658
6659         if (netif_running(bp->dev)) {
6660                 int rc;
6661
6662                 rc = bnx2_alloc_mem(bp);
6663                 if (rc)
6664                         return rc;
6665                 bnx2_init_nic(bp, 0);
6666                 bnx2_netif_start(bp);
6667         }
6668         return 0;
6669 }
6670
6671 static int
6672 bnx2_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
6673 {
6674         struct bnx2 *bp = netdev_priv(dev);
6675         int rc;
6676
6677         if ((ering->rx_pending > MAX_TOTAL_RX_DESC_CNT) ||
6678                 (ering->tx_pending > MAX_TX_DESC_CNT) ||
6679                 (ering->tx_pending <= MAX_SKB_FRAGS)) {
6680
6681                 return -EINVAL;
6682         }
6683         rc = bnx2_change_ring_size(bp, ering->rx_pending, ering->tx_pending);
6684         return rc;
6685 }
6686
6687 static void
6688 bnx2_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
6689 {
6690         struct bnx2 *bp = netdev_priv(dev);
6691
6692         epause->autoneg = ((bp->autoneg & AUTONEG_FLOW_CTRL) != 0);
6693         epause->rx_pause = ((bp->flow_ctrl & FLOW_CTRL_RX) != 0);
6694         epause->tx_pause = ((bp->flow_ctrl & FLOW_CTRL_TX) != 0);
6695 }
6696
6697 static int
6698 bnx2_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
6699 {
6700         struct bnx2 *bp = netdev_priv(dev);
6701
6702         bp->req_flow_ctrl = 0;
6703         if (epause->rx_pause)
6704                 bp->req_flow_ctrl |= FLOW_CTRL_RX;
6705         if (epause->tx_pause)
6706                 bp->req_flow_ctrl |= FLOW_CTRL_TX;
6707
6708         if (epause->autoneg) {
6709                 bp->autoneg |= AUTONEG_FLOW_CTRL;
6710         }
6711         else {
6712                 bp->autoneg &= ~AUTONEG_FLOW_CTRL;
6713         }
6714
6715         spin_lock_bh(&bp->phy_lock);
6716
6717         bnx2_setup_phy(bp, bp->phy_port);
6718
6719         spin_unlock_bh(&bp->phy_lock);
6720
6721         return 0;
6722 }
6723
6724 static u32
6725 bnx2_get_rx_csum(struct net_device *dev)
6726 {
6727         struct bnx2 *bp = netdev_priv(dev);
6728
6729         return bp->rx_csum;
6730 }
6731
6732 static int
6733 bnx2_set_rx_csum(struct net_device *dev, u32 data)
6734 {
6735         struct bnx2 *bp = netdev_priv(dev);
6736
6737         bp->rx_csum = data;
6738         return 0;
6739 }
6740
6741 static int
6742 bnx2_set_tso(struct net_device *dev, u32 data)
6743 {
6744         struct bnx2 *bp = netdev_priv(dev);
6745
6746         if (data) {
6747                 dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
6748                 if (CHIP_NUM(bp) == CHIP_NUM_5709)
6749                         dev->features |= NETIF_F_TSO6;
6750         } else
6751                 dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
6752                                    NETIF_F_TSO_ECN);
6753         return 0;
6754 }
6755
6756 #define BNX2_NUM_STATS 46
6757
6758 static struct {
6759         char string[ETH_GSTRING_LEN];
6760 } bnx2_stats_str_arr[BNX2_NUM_STATS] = {
6761         { "rx_bytes" },
6762         { "rx_error_bytes" },
6763         { "tx_bytes" },
6764         { "tx_error_bytes" },
6765         { "rx_ucast_packets" },
6766         { "rx_mcast_packets" },
6767         { "rx_bcast_packets" },
6768         { "tx_ucast_packets" },
6769         { "tx_mcast_packets" },
6770         { "tx_bcast_packets" },
6771         { "tx_mac_errors" },
6772         { "tx_carrier_errors" },
6773         { "rx_crc_errors" },
6774         { "rx_align_errors" },
6775         { "tx_single_collisions" },
6776         { "tx_multi_collisions" },
6777         { "tx_deferred" },
6778         { "tx_excess_collisions" },
6779         { "tx_late_collisions" },
6780         { "tx_total_collisions" },
6781         { "rx_fragments" },
6782         { "rx_jabbers" },
6783         { "rx_undersize_packets" },
6784         { "rx_oversize_packets" },
6785         { "rx_64_byte_packets" },
6786         { "rx_65_to_127_byte_packets" },
6787         { "rx_128_to_255_byte_packets" },
6788         { "rx_256_to_511_byte_packets" },
6789         { "rx_512_to_1023_byte_packets" },
6790         { "rx_1024_to_1522_byte_packets" },
6791         { "rx_1523_to_9022_byte_packets" },
6792         { "tx_64_byte_packets" },
6793         { "tx_65_to_127_byte_packets" },
6794         { "tx_128_to_255_byte_packets" },
6795         { "tx_256_to_511_byte_packets" },
6796         { "tx_512_to_1023_byte_packets" },
6797         { "tx_1024_to_1522_byte_packets" },
6798         { "tx_1523_to_9022_byte_packets" },
6799         { "rx_xon_frames" },
6800         { "rx_xoff_frames" },
6801         { "tx_xon_frames" },
6802         { "tx_xoff_frames" },
6803         { "rx_mac_ctrl_frames" },
6804         { "rx_filtered_packets" },
6805         { "rx_discards" },
6806         { "rx_fw_discards" },
6807 };
6808
6809 #define STATS_OFFSET32(offset_name) (offsetof(struct statistics_block, offset_name) / 4)
6810
6811 static const unsigned long bnx2_stats_offset_arr[BNX2_NUM_STATS] = {
6812     STATS_OFFSET32(stat_IfHCInOctets_hi),
6813     STATS_OFFSET32(stat_IfHCInBadOctets_hi),
6814     STATS_OFFSET32(stat_IfHCOutOctets_hi),
6815     STATS_OFFSET32(stat_IfHCOutBadOctets_hi),
6816     STATS_OFFSET32(stat_IfHCInUcastPkts_hi),
6817     STATS_OFFSET32(stat_IfHCInMulticastPkts_hi),
6818     STATS_OFFSET32(stat_IfHCInBroadcastPkts_hi),
6819     STATS_OFFSET32(stat_IfHCOutUcastPkts_hi),
6820     STATS_OFFSET32(stat_IfHCOutMulticastPkts_hi),
6821     STATS_OFFSET32(stat_IfHCOutBroadcastPkts_hi),
6822     STATS_OFFSET32(stat_emac_tx_stat_dot3statsinternalmactransmiterrors),
6823     STATS_OFFSET32(stat_Dot3StatsCarrierSenseErrors),
6824     STATS_OFFSET32(stat_Dot3StatsFCSErrors),
6825     STATS_OFFSET32(stat_Dot3StatsAlignmentErrors),
6826     STATS_OFFSET32(stat_Dot3StatsSingleCollisionFrames),
6827     STATS_OFFSET32(stat_Dot3StatsMultipleCollisionFrames),
6828     STATS_OFFSET32(stat_Dot3StatsDeferredTransmissions),
6829     STATS_OFFSET32(stat_Dot3StatsExcessiveCollisions),
6830     STATS_OFFSET32(stat_Dot3StatsLateCollisions),
6831     STATS_OFFSET32(stat_EtherStatsCollisions),
6832     STATS_OFFSET32(stat_EtherStatsFragments),
6833     STATS_OFFSET32(stat_EtherStatsJabbers),
6834     STATS_OFFSET32(stat_EtherStatsUndersizePkts),
6835     STATS_OFFSET32(stat_EtherStatsOverrsizePkts),
6836     STATS_OFFSET32(stat_EtherStatsPktsRx64Octets),
6837     STATS_OFFSET32(stat_EtherStatsPktsRx65Octetsto127Octets),
6838     STATS_OFFSET32(stat_EtherStatsPktsRx128Octetsto255Octets),
6839     STATS_OFFSET32(stat_EtherStatsPktsRx256Octetsto511Octets),
6840     STATS_OFFSET32(stat_EtherStatsPktsRx512Octetsto1023Octets),
6841     STATS_OFFSET32(stat_EtherStatsPktsRx1024Octetsto1522Octets),
6842     STATS_OFFSET32(stat_EtherStatsPktsRx1523Octetsto9022Octets),
6843     STATS_OFFSET32(stat_EtherStatsPktsTx64Octets),
6844     STATS_OFFSET32(stat_EtherStatsPktsTx65Octetsto127Octets),
6845     STATS_OFFSET32(stat_EtherStatsPktsTx128Octetsto255Octets),
6846     STATS_OFFSET32(stat_EtherStatsPktsTx256Octetsto511Octets),
6847     STATS_OFFSET32(stat_EtherStatsPktsTx512Octetsto1023Octets),
6848     STATS_OFFSET32(stat_EtherStatsPktsTx1024Octetsto1522Octets),
6849     STATS_OFFSET32(stat_EtherStatsPktsTx1523Octetsto9022Octets),
6850     STATS_OFFSET32(stat_XonPauseFramesReceived),
6851     STATS_OFFSET32(stat_XoffPauseFramesReceived),
6852     STATS_OFFSET32(stat_OutXonSent),
6853     STATS_OFFSET32(stat_OutXoffSent),
6854     STATS_OFFSET32(stat_MacControlFramesReceived),
6855     STATS_OFFSET32(stat_IfInFramesL2FilterDiscards),
6856     STATS_OFFSET32(stat_IfInMBUFDiscards),
6857     STATS_OFFSET32(stat_FwRxDrop),
6858 };
6859
6860 /* stat_IfHCInBadOctets and stat_Dot3StatsCarrierSenseErrors are
6861  * skipped because of errata.
6862  */
6863 static u8 bnx2_5706_stats_len_arr[BNX2_NUM_STATS] = {
6864         8,0,8,8,8,8,8,8,8,8,
6865         4,0,4,4,4,4,4,4,4,4,
6866         4,4,4,4,4,4,4,4,4,4,
6867         4,4,4,4,4,4,4,4,4,4,
6868         4,4,4,4,4,4,
6869 };
6870
6871 static u8 bnx2_5708_stats_len_arr[BNX2_NUM_STATS] = {
6872         8,0,8,8,8,8,8,8,8,8,
6873         4,4,4,4,4,4,4,4,4,4,
6874         4,4,4,4,4,4,4,4,4,4,
6875         4,4,4,4,4,4,4,4,4,4,
6876         4,4,4,4,4,4,
6877 };
6878
6879 #define BNX2_NUM_TESTS 6
6880
6881 static struct {
6882         char string[ETH_GSTRING_LEN];
6883 } bnx2_tests_str_arr[BNX2_NUM_TESTS] = {
6884         { "register_test (offline)" },
6885         { "memory_test (offline)" },
6886         { "loopback_test (offline)" },
6887         { "nvram_test (online)" },
6888         { "interrupt_test (online)" },
6889         { "link_test (online)" },
6890 };
6891
6892 static int
6893 bnx2_get_sset_count(struct net_device *dev, int sset)
6894 {
6895         switch (sset) {
6896         case ETH_SS_TEST:
6897                 return BNX2_NUM_TESTS;
6898         case ETH_SS_STATS:
6899                 return BNX2_NUM_STATS;
6900         default:
6901                 return -EOPNOTSUPP;
6902         }
6903 }
6904
6905 static void
6906 bnx2_self_test(struct net_device *dev, struct ethtool_test *etest, u64 *buf)
6907 {
6908         struct bnx2 *bp = netdev_priv(dev);
6909
6910         memset(buf, 0, sizeof(u64) * BNX2_NUM_TESTS);
6911         if (etest->flags & ETH_TEST_FL_OFFLINE) {
6912                 int i;
6913
6914                 bnx2_netif_stop(bp);
6915                 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_DIAG);
6916                 bnx2_free_skbs(bp);
6917
6918                 if (bnx2_test_registers(bp) != 0) {
6919                         buf[0] = 1;
6920                         etest->flags |= ETH_TEST_FL_FAILED;
6921                 }
6922                 if (bnx2_test_memory(bp) != 0) {
6923                         buf[1] = 1;
6924                         etest->flags |= ETH_TEST_FL_FAILED;
6925                 }
6926                 if ((buf[2] = bnx2_test_loopback(bp)) != 0)
6927                         etest->flags |= ETH_TEST_FL_FAILED;
6928
6929                 if (!netif_running(bp->dev)) {
6930                         bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
6931                 }
6932                 else {
6933                         bnx2_init_nic(bp, 1);
6934                         bnx2_netif_start(bp);
6935                 }
6936
6937                 /* wait for link up */
6938                 for (i = 0; i < 7; i++) {
6939                         if (bp->link_up)
6940                                 break;
6941                         msleep_interruptible(1000);
6942                 }
6943         }
6944
6945         if (bnx2_test_nvram(bp) != 0) {
6946                 buf[3] = 1;
6947                 etest->flags |= ETH_TEST_FL_FAILED;
6948         }
6949         if (bnx2_test_intr(bp) != 0) {
6950                 buf[4] = 1;
6951                 etest->flags |= ETH_TEST_FL_FAILED;
6952         }
6953
6954         if (bnx2_test_link(bp) != 0) {
6955                 buf[5] = 1;
6956                 etest->flags |= ETH_TEST_FL_FAILED;
6957
6958         }
6959 }
6960
6961 static void
6962 bnx2_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
6963 {
6964         switch (stringset) {
6965         case ETH_SS_STATS:
6966                 memcpy(buf, bnx2_stats_str_arr,
6967                         sizeof(bnx2_stats_str_arr));
6968                 break;
6969         case ETH_SS_TEST:
6970                 memcpy(buf, bnx2_tests_str_arr,
6971                         sizeof(bnx2_tests_str_arr));
6972                 break;
6973         }
6974 }
6975
6976 static void
6977 bnx2_get_ethtool_stats(struct net_device *dev,
6978                 struct ethtool_stats *stats, u64 *buf)
6979 {
6980         struct bnx2 *bp = netdev_priv(dev);
6981         int i;
6982         u32 *hw_stats = (u32 *) bp->stats_blk;
6983         u8 *stats_len_arr = NULL;
6984
6985         if (hw_stats == NULL) {
6986                 memset(buf, 0, sizeof(u64) * BNX2_NUM_STATS);
6987                 return;
6988         }
6989
6990         if ((CHIP_ID(bp) == CHIP_ID_5706_A0) ||
6991             (CHIP_ID(bp) == CHIP_ID_5706_A1) ||
6992             (CHIP_ID(bp) == CHIP_ID_5706_A2) ||
6993             (CHIP_ID(bp) == CHIP_ID_5708_A0))
6994                 stats_len_arr = bnx2_5706_stats_len_arr;
6995         else
6996                 stats_len_arr = bnx2_5708_stats_len_arr;
6997
6998         for (i = 0; i < BNX2_NUM_STATS; i++) {
6999                 if (stats_len_arr[i] == 0) {
7000                         /* skip this counter */
7001                         buf[i] = 0;
7002                         continue;
7003                 }
7004                 if (stats_len_arr[i] == 4) {
7005                         /* 4-byte counter */
7006                         buf[i] = (u64)
7007                                 *(hw_stats + bnx2_stats_offset_arr[i]);
7008                         continue;
7009                 }
7010                 /* 8-byte counter */
7011                 buf[i] = (((u64) *(hw_stats +
7012                                         bnx2_stats_offset_arr[i])) << 32) +
7013                                 *(hw_stats + bnx2_stats_offset_arr[i] + 1);
7014         }
7015 }
7016
7017 static int
7018 bnx2_phys_id(struct net_device *dev, u32 data)
7019 {
7020         struct bnx2 *bp = netdev_priv(dev);
7021         int i;
7022         u32 save;
7023
7024         if (data == 0)
7025                 data = 2;
7026
7027         save = REG_RD(bp, BNX2_MISC_CFG);
7028         REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
7029
7030         for (i = 0; i < (data * 2); i++) {
7031                 if ((i % 2) == 0) {
7032                         REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
7033                 }
7034                 else {
7035                         REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
7036                                 BNX2_EMAC_LED_1000MB_OVERRIDE |
7037                                 BNX2_EMAC_LED_100MB_OVERRIDE |
7038                                 BNX2_EMAC_LED_10MB_OVERRIDE |
7039                                 BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
7040                                 BNX2_EMAC_LED_TRAFFIC);
7041                 }
7042                 msleep_interruptible(500);
7043                 if (signal_pending(current))
7044                         break;
7045         }
7046         REG_WR(bp, BNX2_EMAC_LED, 0);
7047         REG_WR(bp, BNX2_MISC_CFG, save);
7048         return 0;
7049 }
7050
7051 static int
7052 bnx2_set_tx_csum(struct net_device *dev, u32 data)
7053 {
7054         struct bnx2 *bp = netdev_priv(dev);
7055
7056         if (CHIP_NUM(bp) == CHIP_NUM_5709)
7057                 return (ethtool_op_set_tx_ipv6_csum(dev, data));
7058         else
7059                 return (ethtool_op_set_tx_csum(dev, data));
7060 }
7061
7062 static const struct ethtool_ops bnx2_ethtool_ops = {
7063         .get_settings           = bnx2_get_settings,
7064         .set_settings           = bnx2_set_settings,
7065         .get_drvinfo            = bnx2_get_drvinfo,
7066         .get_regs_len           = bnx2_get_regs_len,
7067         .get_regs               = bnx2_get_regs,
7068         .get_wol                = bnx2_get_wol,
7069         .set_wol                = bnx2_set_wol,
7070         .nway_reset             = bnx2_nway_reset,
7071         .get_link               = ethtool_op_get_link,
7072         .get_eeprom_len         = bnx2_get_eeprom_len,
7073         .get_eeprom             = bnx2_get_eeprom,
7074         .set_eeprom             = bnx2_set_eeprom,
7075         .get_coalesce           = bnx2_get_coalesce,
7076         .set_coalesce           = bnx2_set_coalesce,
7077         .get_ringparam          = bnx2_get_ringparam,
7078         .set_ringparam          = bnx2_set_ringparam,
7079         .get_pauseparam         = bnx2_get_pauseparam,
7080         .set_pauseparam         = bnx2_set_pauseparam,
7081         .get_rx_csum            = bnx2_get_rx_csum,
7082         .set_rx_csum            = bnx2_set_rx_csum,
7083         .set_tx_csum            = bnx2_set_tx_csum,
7084         .set_sg                 = ethtool_op_set_sg,
7085         .set_tso                = bnx2_set_tso,
7086         .self_test              = bnx2_self_test,
7087         .get_strings            = bnx2_get_strings,
7088         .phys_id                = bnx2_phys_id,
7089         .get_ethtool_stats      = bnx2_get_ethtool_stats,
7090         .get_sset_count         = bnx2_get_sset_count,
7091 };
7092
7093 /* Called with rtnl_lock */
7094 static int
7095 bnx2_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
7096 {
7097         struct mii_ioctl_data *data = if_mii(ifr);
7098         struct bnx2 *bp = netdev_priv(dev);
7099         int err;
7100
7101         switch(cmd) {
7102         case SIOCGMIIPHY:
7103                 data->phy_id = bp->phy_addr;
7104
7105                 /* fallthru */
7106         case SIOCGMIIREG: {
7107                 u32 mii_regval;
7108
7109                 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
7110                         return -EOPNOTSUPP;
7111
7112                 if (!netif_running(dev))
7113                         return -EAGAIN;
7114
7115                 spin_lock_bh(&bp->phy_lock);
7116                 err = bnx2_read_phy(bp, data->reg_num & 0x1f, &mii_regval);
7117                 spin_unlock_bh(&bp->phy_lock);
7118
7119                 data->val_out = mii_regval;
7120
7121                 return err;
7122         }
7123
7124         case SIOCSMIIREG:
7125                 if (!capable(CAP_NET_ADMIN))
7126                         return -EPERM;
7127
7128                 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
7129                         return -EOPNOTSUPP;
7130
7131                 if (!netif_running(dev))
7132                         return -EAGAIN;
7133
7134                 spin_lock_bh(&bp->phy_lock);
7135                 err = bnx2_write_phy(bp, data->reg_num & 0x1f, data->val_in);
7136                 spin_unlock_bh(&bp->phy_lock);
7137
7138                 return err;
7139
7140         default:
7141                 /* do nothing */
7142                 break;
7143         }
7144         return -EOPNOTSUPP;
7145 }
7146
7147 /* Called with rtnl_lock */
7148 static int
7149 bnx2_change_mac_addr(struct net_device *dev, void *p)
7150 {
7151         struct sockaddr *addr = p;
7152         struct bnx2 *bp = netdev_priv(dev);
7153
7154         if (!is_valid_ether_addr(addr->sa_data))
7155                 return -EINVAL;
7156
7157         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
7158         if (netif_running(dev))
7159                 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
7160
7161         return 0;
7162 }
7163
7164 /* Called with rtnl_lock */
7165 static int
7166 bnx2_change_mtu(struct net_device *dev, int new_mtu)
7167 {
7168         struct bnx2 *bp = netdev_priv(dev);
7169
7170         if (((new_mtu + ETH_HLEN) > MAX_ETHERNET_JUMBO_PACKET_SIZE) ||
7171                 ((new_mtu + ETH_HLEN) < MIN_ETHERNET_PACKET_SIZE))
7172                 return -EINVAL;
7173
7174         dev->mtu = new_mtu;
7175         return (bnx2_change_ring_size(bp, bp->rx_ring_size, bp->tx_ring_size));
7176 }
7177
7178 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
7179 static void
7180 poll_bnx2(struct net_device *dev)
7181 {
7182         struct bnx2 *bp = netdev_priv(dev);
7183
7184         disable_irq(bp->pdev->irq);
7185         bnx2_interrupt(bp->pdev->irq, dev);
7186         enable_irq(bp->pdev->irq);
7187 }
7188 #endif
7189
7190 static void __devinit
7191 bnx2_get_5709_media(struct bnx2 *bp)
7192 {
7193         u32 val = REG_RD(bp, BNX2_MISC_DUAL_MEDIA_CTRL);
7194         u32 bond_id = val & BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID;
7195         u32 strap;
7196
7197         if (bond_id == BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID_C)
7198                 return;
7199         else if (bond_id == BNX2_MISC_DUAL_MEDIA_CTRL_BOND_ID_S) {
7200                 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7201                 return;
7202         }
7203
7204         if (val & BNX2_MISC_DUAL_MEDIA_CTRL_STRAP_OVERRIDE)
7205                 strap = (val & BNX2_MISC_DUAL_MEDIA_CTRL_PHY_CTRL) >> 21;
7206         else
7207                 strap = (val & BNX2_MISC_DUAL_MEDIA_CTRL_PHY_CTRL_STRAP) >> 8;
7208
7209         if (PCI_FUNC(bp->pdev->devfn) == 0) {
7210                 switch (strap) {
7211                 case 0x4:
7212                 case 0x5:
7213                 case 0x6:
7214                         bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7215                         return;
7216                 }
7217         } else {
7218                 switch (strap) {
7219                 case 0x1:
7220                 case 0x2:
7221                 case 0x4:
7222                         bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7223                         return;
7224                 }
7225         }
7226 }
7227
7228 static void __devinit
7229 bnx2_get_pci_speed(struct bnx2 *bp)
7230 {
7231         u32 reg;
7232
7233         reg = REG_RD(bp, BNX2_PCICFG_MISC_STATUS);
7234         if (reg & BNX2_PCICFG_MISC_STATUS_PCIX_DET) {
7235                 u32 clkreg;
7236
7237                 bp->flags |= BNX2_FLAG_PCIX;
7238
7239                 clkreg = REG_RD(bp, BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS);
7240
7241                 clkreg &= BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET;
7242                 switch (clkreg) {
7243                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_133MHZ:
7244                         bp->bus_speed_mhz = 133;
7245                         break;
7246
7247                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_95MHZ:
7248                         bp->bus_speed_mhz = 100;
7249                         break;
7250
7251                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_66MHZ:
7252                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_80MHZ:
7253                         bp->bus_speed_mhz = 66;
7254                         break;
7255
7256                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_48MHZ:
7257                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_55MHZ:
7258                         bp->bus_speed_mhz = 50;
7259                         break;
7260
7261                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_LOW:
7262                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_32MHZ:
7263                 case BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS_PCI_CLK_SPD_DET_38MHZ:
7264                         bp->bus_speed_mhz = 33;
7265                         break;
7266                 }
7267         }
7268         else {
7269                 if (reg & BNX2_PCICFG_MISC_STATUS_M66EN)
7270                         bp->bus_speed_mhz = 66;
7271                 else
7272                         bp->bus_speed_mhz = 33;
7273         }
7274
7275         if (reg & BNX2_PCICFG_MISC_STATUS_32BIT_DET)
7276                 bp->flags |= BNX2_FLAG_PCI_32BIT;
7277
7278 }
7279
7280 static int __devinit
7281 bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
7282 {
7283         struct bnx2 *bp;
7284         unsigned long mem_len;
7285         int rc, i, j;
7286         u32 reg;
7287         u64 dma_mask, persist_dma_mask;
7288
7289         SET_NETDEV_DEV(dev, &pdev->dev);
7290         bp = netdev_priv(dev);
7291
7292         bp->flags = 0;
7293         bp->phy_flags = 0;
7294
7295         /* enable device (incl. PCI PM wakeup), and bus-mastering */
7296         rc = pci_enable_device(pdev);
7297         if (rc) {
7298                 dev_err(&pdev->dev, "Cannot enable PCI device, aborting.\n");
7299                 goto err_out;
7300         }
7301
7302         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
7303                 dev_err(&pdev->dev,
7304                         "Cannot find PCI device base address, aborting.\n");
7305                 rc = -ENODEV;
7306                 goto err_out_disable;
7307         }
7308
7309         rc = pci_request_regions(pdev, DRV_MODULE_NAME);
7310         if (rc) {
7311                 dev_err(&pdev->dev, "Cannot obtain PCI resources, aborting.\n");
7312                 goto err_out_disable;
7313         }
7314
7315         pci_set_master(pdev);
7316         pci_save_state(pdev);
7317
7318         bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
7319         if (bp->pm_cap == 0) {
7320                 dev_err(&pdev->dev,
7321                         "Cannot find power management capability, aborting.\n");
7322                 rc = -EIO;
7323                 goto err_out_release;
7324         }
7325
7326         bp->dev = dev;
7327         bp->pdev = pdev;
7328
7329         spin_lock_init(&bp->phy_lock);
7330         spin_lock_init(&bp->indirect_lock);
7331         INIT_WORK(&bp->reset_task, bnx2_reset_task);
7332
7333         dev->base_addr = dev->mem_start = pci_resource_start(pdev, 0);
7334         mem_len = MB_GET_CID_ADDR(TX_TSS_CID + TX_MAX_TSS_RINGS);
7335         dev->mem_end = dev->mem_start + mem_len;
7336         dev->irq = pdev->irq;
7337
7338         bp->regview = ioremap_nocache(dev->base_addr, mem_len);
7339
7340         if (!bp->regview) {
7341                 dev_err(&pdev->dev, "Cannot map register space, aborting.\n");
7342                 rc = -ENOMEM;
7343                 goto err_out_release;
7344         }
7345
7346         /* Configure byte swap and enable write to the reg_window registers.
7347          * Rely on CPU to do target byte swapping on big endian systems
7348          * The chip's target access swapping will not swap all accesses
7349          */
7350         pci_write_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG,
7351                                BNX2_PCICFG_MISC_CONFIG_REG_WINDOW_ENA |
7352                                BNX2_PCICFG_MISC_CONFIG_TARGET_MB_WORD_SWAP);
7353
7354         bnx2_set_power_state(bp, PCI_D0);
7355
7356         bp->chip_id = REG_RD(bp, BNX2_MISC_ID);
7357
7358         if (CHIP_NUM(bp) == CHIP_NUM_5709) {
7359                 if (pci_find_capability(pdev, PCI_CAP_ID_EXP) == 0) {
7360                         dev_err(&pdev->dev,
7361                                 "Cannot find PCIE capability, aborting.\n");
7362                         rc = -EIO;
7363                         goto err_out_unmap;
7364                 }
7365                 bp->flags |= BNX2_FLAG_PCIE;
7366                 if (CHIP_REV(bp) == CHIP_REV_Ax)
7367                         bp->flags |= BNX2_FLAG_JUMBO_BROKEN;
7368         } else {
7369                 bp->pcix_cap = pci_find_capability(pdev, PCI_CAP_ID_PCIX);
7370                 if (bp->pcix_cap == 0) {
7371                         dev_err(&pdev->dev,
7372                                 "Cannot find PCIX capability, aborting.\n");
7373                         rc = -EIO;
7374                         goto err_out_unmap;
7375                 }
7376         }
7377
7378         if (CHIP_NUM(bp) == CHIP_NUM_5709 && CHIP_REV(bp) != CHIP_REV_Ax) {
7379                 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX))
7380                         bp->flags |= BNX2_FLAG_MSIX_CAP;
7381         }
7382
7383         if (CHIP_ID(bp) != CHIP_ID_5706_A0 && CHIP_ID(bp) != CHIP_ID_5706_A1) {
7384                 if (pci_find_capability(pdev, PCI_CAP_ID_MSI))
7385                         bp->flags |= BNX2_FLAG_MSI_CAP;
7386         }
7387
7388         /* 5708 cannot support DMA addresses > 40-bit.  */
7389         if (CHIP_NUM(bp) == CHIP_NUM_5708)
7390                 persist_dma_mask = dma_mask = DMA_40BIT_MASK;
7391         else
7392                 persist_dma_mask = dma_mask = DMA_64BIT_MASK;
7393
7394         /* Configure DMA attributes. */
7395         if (pci_set_dma_mask(pdev, dma_mask) == 0) {
7396                 dev->features |= NETIF_F_HIGHDMA;
7397                 rc = pci_set_consistent_dma_mask(pdev, persist_dma_mask);
7398                 if (rc) {
7399                         dev_err(&pdev->dev,
7400                                 "pci_set_consistent_dma_mask failed, aborting.\n");
7401                         goto err_out_unmap;
7402                 }
7403         } else if ((rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK)) != 0) {
7404                 dev_err(&pdev->dev, "System does not support DMA, aborting.\n");
7405                 goto err_out_unmap;
7406         }
7407
7408         if (!(bp->flags & BNX2_FLAG_PCIE))
7409                 bnx2_get_pci_speed(bp);
7410
7411         /* 5706A0 may falsely detect SERR and PERR. */
7412         if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
7413                 reg = REG_RD(bp, PCI_COMMAND);
7414                 reg &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY);
7415                 REG_WR(bp, PCI_COMMAND, reg);
7416         }
7417         else if ((CHIP_ID(bp) == CHIP_ID_5706_A1) &&
7418                 !(bp->flags & BNX2_FLAG_PCIX)) {
7419
7420                 dev_err(&pdev->dev,
7421                         "5706 A1 can only be used in a PCIX bus, aborting.\n");
7422                 goto err_out_unmap;
7423         }
7424
7425         bnx2_init_nvram(bp);
7426
7427         reg = bnx2_reg_rd_ind(bp, BNX2_SHM_HDR_SIGNATURE);
7428
7429         if ((reg & BNX2_SHM_HDR_SIGNATURE_SIG_MASK) ==
7430             BNX2_SHM_HDR_SIGNATURE_SIG) {
7431                 u32 off = PCI_FUNC(pdev->devfn) << 2;
7432
7433                 bp->shmem_base = bnx2_reg_rd_ind(bp, BNX2_SHM_HDR_ADDR_0 + off);
7434         } else
7435                 bp->shmem_base = HOST_VIEW_SHMEM_BASE;
7436
7437         /* Get the permanent MAC address.  First we need to make sure the
7438          * firmware is actually running.
7439          */
7440         reg = bnx2_shmem_rd(bp, BNX2_DEV_INFO_SIGNATURE);
7441
7442         if ((reg & BNX2_DEV_INFO_SIGNATURE_MAGIC_MASK) !=
7443             BNX2_DEV_INFO_SIGNATURE_MAGIC) {
7444                 dev_err(&pdev->dev, "Firmware not running, aborting.\n");
7445                 rc = -ENODEV;
7446                 goto err_out_unmap;
7447         }
7448
7449         reg = bnx2_shmem_rd(bp, BNX2_DEV_INFO_BC_REV);
7450         for (i = 0, j = 0; i < 3; i++) {
7451                 u8 num, k, skip0;
7452
7453                 num = (u8) (reg >> (24 - (i * 8)));
7454                 for (k = 100, skip0 = 1; k >= 1; num %= k, k /= 10) {
7455                         if (num >= k || !skip0 || k == 1) {
7456                                 bp->fw_version[j++] = (num / k) + '0';
7457                                 skip0 = 0;
7458                         }
7459                 }
7460                 if (i != 2)
7461                         bp->fw_version[j++] = '.';
7462         }
7463         reg = bnx2_shmem_rd(bp, BNX2_PORT_FEATURE);
7464         if (reg & BNX2_PORT_FEATURE_WOL_ENABLED)
7465                 bp->wol = 1;
7466
7467         if (reg & BNX2_PORT_FEATURE_ASF_ENABLED) {
7468                 bp->flags |= BNX2_FLAG_ASF_ENABLE;
7469
7470                 for (i = 0; i < 30; i++) {
7471                         reg = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
7472                         if (reg & BNX2_CONDITION_MFW_RUN_MASK)
7473                                 break;
7474                         msleep(10);
7475                 }
7476         }
7477         reg = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
7478         reg &= BNX2_CONDITION_MFW_RUN_MASK;
7479         if (reg != BNX2_CONDITION_MFW_RUN_UNKNOWN &&
7480             reg != BNX2_CONDITION_MFW_RUN_NONE) {
7481                 u32 addr = bnx2_shmem_rd(bp, BNX2_MFW_VER_PTR);
7482
7483                 bp->fw_version[j++] = ' ';
7484                 for (i = 0; i < 3; i++) {
7485                         reg = bnx2_reg_rd_ind(bp, addr + i * 4);
7486                         reg = swab32(reg);
7487                         memcpy(&bp->fw_version[j], &reg, 4);
7488                         j += 4;
7489                 }
7490         }
7491
7492         reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_MAC_UPPER);
7493         bp->mac_addr[0] = (u8) (reg >> 8);
7494         bp->mac_addr[1] = (u8) reg;
7495
7496         reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_MAC_LOWER);
7497         bp->mac_addr[2] = (u8) (reg >> 24);
7498         bp->mac_addr[3] = (u8) (reg >> 16);
7499         bp->mac_addr[4] = (u8) (reg >> 8);
7500         bp->mac_addr[5] = (u8) reg;
7501
7502         bp->tx_ring_size = MAX_TX_DESC_CNT;
7503         bnx2_set_rx_ring_size(bp, 255);
7504
7505         bp->rx_csum = 1;
7506
7507         bp->tx_quick_cons_trip_int = 20;
7508         bp->tx_quick_cons_trip = 20;
7509         bp->tx_ticks_int = 80;
7510         bp->tx_ticks = 80;
7511
7512         bp->rx_quick_cons_trip_int = 6;
7513         bp->rx_quick_cons_trip = 6;
7514         bp->rx_ticks_int = 18;
7515         bp->rx_ticks = 18;
7516
7517         bp->stats_ticks = USEC_PER_SEC & BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
7518
7519         bp->timer_interval =  HZ;
7520         bp->current_interval =  HZ;
7521
7522         bp->phy_addr = 1;
7523
7524         /* Disable WOL support if we are running on a SERDES chip. */
7525         if (CHIP_NUM(bp) == CHIP_NUM_5709)
7526                 bnx2_get_5709_media(bp);
7527         else if (CHIP_BOND_ID(bp) & CHIP_BOND_ID_SERDES_BIT)
7528                 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7529
7530         bp->phy_port = PORT_TP;
7531         if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
7532                 bp->phy_port = PORT_FIBRE;
7533                 reg = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG);
7534                 if (!(reg & BNX2_SHARED_HW_CFG_GIG_LINK_ON_VAUX)) {
7535                         bp->flags |= BNX2_FLAG_NO_WOL;
7536                         bp->wol = 0;
7537                 }
7538                 if (CHIP_NUM(bp) == CHIP_NUM_5706) {
7539                         /* Don't do parallel detect on this board because of
7540                          * some board problems.  The link will not go down
7541                          * if we do parallel detect.
7542                          */
7543                         if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
7544                             pdev->subsystem_device == 0x310c)
7545                                 bp->phy_flags |= BNX2_PHY_FLAG_NO_PARALLEL;
7546                 } else {
7547                         bp->phy_addr = 2;
7548                         if (reg & BNX2_SHARED_HW_CFG_PHY_2_5G)
7549                                 bp->phy_flags |= BNX2_PHY_FLAG_2_5G_CAPABLE;
7550                 }
7551         } else if (CHIP_NUM(bp) == CHIP_NUM_5706 ||
7552                    CHIP_NUM(bp) == CHIP_NUM_5708)
7553                 bp->phy_flags |= BNX2_PHY_FLAG_CRC_FIX;
7554         else if (CHIP_NUM(bp) == CHIP_NUM_5709 &&
7555                  (CHIP_REV(bp) == CHIP_REV_Ax ||
7556                   CHIP_REV(bp) == CHIP_REV_Bx))
7557                 bp->phy_flags |= BNX2_PHY_FLAG_DIS_EARLY_DAC;
7558
7559         bnx2_init_fw_cap(bp);
7560
7561         if ((CHIP_ID(bp) == CHIP_ID_5708_A0) ||
7562             (CHIP_ID(bp) == CHIP_ID_5708_B0) ||
7563             (CHIP_ID(bp) == CHIP_ID_5708_B1)) {
7564                 bp->flags |= BNX2_FLAG_NO_WOL;
7565                 bp->wol = 0;
7566         }
7567
7568         if (CHIP_ID(bp) == CHIP_ID_5706_A0) {
7569                 bp->tx_quick_cons_trip_int =
7570                         bp->tx_quick_cons_trip;
7571                 bp->tx_ticks_int = bp->tx_ticks;
7572                 bp->rx_quick_cons_trip_int =
7573                         bp->rx_quick_cons_trip;
7574                 bp->rx_ticks_int = bp->rx_ticks;
7575                 bp->comp_prod_trip_int = bp->comp_prod_trip;
7576                 bp->com_ticks_int = bp->com_ticks;
7577                 bp->cmd_ticks_int = bp->cmd_ticks;
7578         }
7579
7580         /* Disable MSI on 5706 if AMD 8132 bridge is found.
7581          *
7582          * MSI is defined to be 32-bit write.  The 5706 does 64-bit MSI writes
7583          * with byte enables disabled on the unused 32-bit word.  This is legal
7584          * but causes problems on the AMD 8132 which will eventually stop
7585          * responding after a while.
7586          *
7587          * AMD believes this incompatibility is unique to the 5706, and
7588          * prefers to locally disable MSI rather than globally disabling it.
7589          */
7590         if (CHIP_NUM(bp) == CHIP_NUM_5706 && disable_msi == 0) {
7591                 struct pci_dev *amd_8132 = NULL;
7592
7593                 while ((amd_8132 = pci_get_device(PCI_VENDOR_ID_AMD,
7594                                                   PCI_DEVICE_ID_AMD_8132_BRIDGE,
7595                                                   amd_8132))) {
7596
7597                         if (amd_8132->revision >= 0x10 &&
7598                             amd_8132->revision <= 0x13) {
7599                                 disable_msi = 1;
7600                                 pci_dev_put(amd_8132);
7601                                 break;
7602                         }
7603                 }
7604         }
7605
7606         bnx2_set_default_link(bp);
7607         bp->req_flow_ctrl = FLOW_CTRL_RX | FLOW_CTRL_TX;
7608
7609         init_timer(&bp->timer);
7610         bp->timer.expires = RUN_AT(bp->timer_interval);
7611         bp->timer.data = (unsigned long) bp;
7612         bp->timer.function = bnx2_timer;
7613
7614         return 0;
7615
7616 err_out_unmap:
7617         if (bp->regview) {
7618                 iounmap(bp->regview);
7619                 bp->regview = NULL;
7620         }
7621
7622 err_out_release:
7623         pci_release_regions(pdev);
7624
7625 err_out_disable:
7626         pci_disable_device(pdev);
7627         pci_set_drvdata(pdev, NULL);
7628
7629 err_out:
7630         return rc;
7631 }
7632
7633 static char * __devinit
7634 bnx2_bus_string(struct bnx2 *bp, char *str)
7635 {
7636         char *s = str;
7637
7638         if (bp->flags & BNX2_FLAG_PCIE) {
7639                 s += sprintf(s, "PCI Express");
7640         } else {
7641                 s += sprintf(s, "PCI");
7642                 if (bp->flags & BNX2_FLAG_PCIX)
7643                         s += sprintf(s, "-X");
7644                 if (bp->flags & BNX2_FLAG_PCI_32BIT)
7645                         s += sprintf(s, " 32-bit");
7646                 else
7647                         s += sprintf(s, " 64-bit");
7648                 s += sprintf(s, " %dMHz", bp->bus_speed_mhz);
7649         }
7650         return str;
7651 }
7652
7653 static void __devinit
7654 bnx2_init_napi(struct bnx2 *bp)
7655 {
7656         int i;
7657
7658         for (i = 0; i < BNX2_MAX_MSIX_VEC; i++) {
7659                 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
7660                 int (*poll)(struct napi_struct *, int);
7661
7662                 if (i == 0)
7663                         poll = bnx2_poll;
7664                 else
7665                         poll = bnx2_poll_msix;
7666
7667                 netif_napi_add(bp->dev, &bp->bnx2_napi[i].napi, poll, 64);
7668                 bnapi->bp = bp;
7669         }
7670 }
7671
7672 static int __devinit
7673 bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
7674 {
7675         static int version_printed = 0;
7676         struct net_device *dev = NULL;
7677         struct bnx2 *bp;
7678         int rc;
7679         char str[40];
7680         DECLARE_MAC_BUF(mac);
7681
7682         if (version_printed++ == 0)
7683                 printk(KERN_INFO "%s", version);
7684
7685         /* dev zeroed in init_etherdev */
7686         dev = alloc_etherdev_mq(sizeof(*bp), TX_MAX_RINGS);
7687
7688         if (!dev)
7689                 return -ENOMEM;
7690
7691         rc = bnx2_init_board(pdev, dev);
7692         if (rc < 0) {
7693                 free_netdev(dev);
7694                 return rc;
7695         }
7696
7697         dev->open = bnx2_open;
7698         dev->hard_start_xmit = bnx2_start_xmit;
7699         dev->stop = bnx2_close;
7700         dev->get_stats = bnx2_get_stats;
7701         dev->set_rx_mode = bnx2_set_rx_mode;
7702         dev->do_ioctl = bnx2_ioctl;
7703         dev->set_mac_address = bnx2_change_mac_addr;
7704         dev->change_mtu = bnx2_change_mtu;
7705         dev->tx_timeout = bnx2_tx_timeout;
7706         dev->watchdog_timeo = TX_TIMEOUT;
7707 #ifdef BCM_VLAN
7708         dev->vlan_rx_register = bnx2_vlan_rx_register;
7709 #endif
7710         dev->ethtool_ops = &bnx2_ethtool_ops;
7711
7712         bp = netdev_priv(dev);
7713         bnx2_init_napi(bp);
7714
7715 #if defined(HAVE_POLL_CONTROLLER) || defined(CONFIG_NET_POLL_CONTROLLER)
7716         dev->poll_controller = poll_bnx2;
7717 #endif
7718
7719         pci_set_drvdata(pdev, dev);
7720
7721         memcpy(dev->dev_addr, bp->mac_addr, 6);
7722         memcpy(dev->perm_addr, bp->mac_addr, 6);
7723         bp->name = board_info[ent->driver_data].name;
7724
7725         dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
7726         if (CHIP_NUM(bp) == CHIP_NUM_5709)
7727                 dev->features |= NETIF_F_IPV6_CSUM;
7728
7729 #ifdef BCM_VLAN
7730         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
7731 #endif
7732         dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
7733         if (CHIP_NUM(bp) == CHIP_NUM_5709)
7734                 dev->features |= NETIF_F_TSO6;
7735
7736         if ((rc = register_netdev(dev))) {
7737                 dev_err(&pdev->dev, "Cannot register net device\n");
7738                 if (bp->regview)
7739                         iounmap(bp->regview);
7740                 pci_release_regions(pdev);
7741                 pci_disable_device(pdev);
7742                 pci_set_drvdata(pdev, NULL);
7743                 free_netdev(dev);
7744                 return rc;
7745         }
7746
7747         printk(KERN_INFO "%s: %s (%c%d) %s found at mem %lx, "
7748                 "IRQ %d, node addr %s\n",
7749                 dev->name,
7750                 bp->name,
7751                 ((CHIP_ID(bp) & 0xf000) >> 12) + 'A',
7752                 ((CHIP_ID(bp) & 0x0ff0) >> 4),
7753                 bnx2_bus_string(bp, str),
7754                 dev->base_addr,
7755                 bp->pdev->irq, print_mac(mac, dev->dev_addr));
7756
7757         return 0;
7758 }
7759
7760 static void __devexit
7761 bnx2_remove_one(struct pci_dev *pdev)
7762 {
7763         struct net_device *dev = pci_get_drvdata(pdev);
7764         struct bnx2 *bp = netdev_priv(dev);
7765
7766         flush_scheduled_work();
7767
7768         unregister_netdev(dev);
7769
7770         if (bp->regview)
7771                 iounmap(bp->regview);
7772
7773         free_netdev(dev);
7774         pci_release_regions(pdev);
7775         pci_disable_device(pdev);
7776         pci_set_drvdata(pdev, NULL);
7777 }
7778
7779 static int
7780 bnx2_suspend(struct pci_dev *pdev, pm_message_t state)
7781 {
7782         struct net_device *dev = pci_get_drvdata(pdev);
7783         struct bnx2 *bp = netdev_priv(dev);
7784         u32 reset_code;
7785
7786         /* PCI register 4 needs to be saved whether netif_running() or not.
7787          * MSI address and data need to be saved if using MSI and
7788          * netif_running().
7789          */
7790         pci_save_state(pdev);
7791         if (!netif_running(dev))
7792                 return 0;
7793
7794         flush_scheduled_work();
7795         bnx2_netif_stop(bp);
7796         netif_device_detach(dev);
7797         del_timer_sync(&bp->timer);
7798         if (bp->flags & BNX2_FLAG_NO_WOL)
7799                 reset_code = BNX2_DRV_MSG_CODE_UNLOAD_LNK_DN;
7800         else if (bp->wol)
7801                 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_WOL;
7802         else
7803                 reset_code = BNX2_DRV_MSG_CODE_SUSPEND_NO_WOL;
7804         bnx2_reset_chip(bp, reset_code);
7805         bnx2_free_skbs(bp);
7806         bnx2_set_power_state(bp, pci_choose_state(pdev, state));
7807         return 0;
7808 }
7809
7810 static int
7811 bnx2_resume(struct pci_dev *pdev)
7812 {
7813         struct net_device *dev = pci_get_drvdata(pdev);
7814         struct bnx2 *bp = netdev_priv(dev);
7815
7816         pci_restore_state(pdev);
7817         if (!netif_running(dev))
7818                 return 0;
7819
7820         bnx2_set_power_state(bp, PCI_D0);
7821         netif_device_attach(dev);
7822         bnx2_init_nic(bp, 1);
7823         bnx2_netif_start(bp);
7824         return 0;
7825 }
7826
7827 /**
7828  * bnx2_io_error_detected - called when PCI error is detected
7829  * @pdev: Pointer to PCI device
7830  * @state: The current pci connection state
7831  *
7832  * This function is called after a PCI bus error affecting
7833  * this device has been detected.
7834  */
7835 static pci_ers_result_t bnx2_io_error_detected(struct pci_dev *pdev,
7836                                                pci_channel_state_t state)
7837 {
7838         struct net_device *dev = pci_get_drvdata(pdev);
7839         struct bnx2 *bp = netdev_priv(dev);
7840
7841         rtnl_lock();
7842         netif_device_detach(dev);
7843
7844         if (netif_running(dev)) {
7845                 bnx2_netif_stop(bp);
7846                 del_timer_sync(&bp->timer);
7847                 bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
7848         }
7849
7850         pci_disable_device(pdev);
7851         rtnl_unlock();
7852
7853         /* Request a slot slot reset. */
7854         return PCI_ERS_RESULT_NEED_RESET;
7855 }
7856
7857 /**
7858  * bnx2_io_slot_reset - called after the pci bus has been reset.
7859  * @pdev: Pointer to PCI device
7860  *
7861  * Restart the card from scratch, as if from a cold-boot.
7862  */
7863 static pci_ers_result_t bnx2_io_slot_reset(struct pci_dev *pdev)
7864 {
7865         struct net_device *dev = pci_get_drvdata(pdev);
7866         struct bnx2 *bp = netdev_priv(dev);
7867
7868         rtnl_lock();
7869         if (pci_enable_device(pdev)) {
7870                 dev_err(&pdev->dev,
7871                         "Cannot re-enable PCI device after reset.\n");
7872                 rtnl_unlock();
7873                 return PCI_ERS_RESULT_DISCONNECT;
7874         }
7875         pci_set_master(pdev);
7876         pci_restore_state(pdev);
7877
7878         if (netif_running(dev)) {
7879                 bnx2_set_power_state(bp, PCI_D0);
7880                 bnx2_init_nic(bp, 1);
7881         }
7882
7883         rtnl_unlock();
7884         return PCI_ERS_RESULT_RECOVERED;
7885 }
7886
7887 /**
7888  * bnx2_io_resume - called when traffic can start flowing again.
7889  * @pdev: Pointer to PCI device
7890  *
7891  * This callback is called when the error recovery driver tells us that
7892  * its OK to resume normal operation.
7893  */
7894 static void bnx2_io_resume(struct pci_dev *pdev)
7895 {
7896         struct net_device *dev = pci_get_drvdata(pdev);
7897         struct bnx2 *bp = netdev_priv(dev);
7898
7899         rtnl_lock();
7900         if (netif_running(dev))
7901                 bnx2_netif_start(bp);
7902
7903         netif_device_attach(dev);
7904         rtnl_unlock();
7905 }
7906
7907 static struct pci_error_handlers bnx2_err_handler = {
7908         .error_detected = bnx2_io_error_detected,
7909         .slot_reset     = bnx2_io_slot_reset,
7910         .resume         = bnx2_io_resume,
7911 };
7912
7913 static struct pci_driver bnx2_pci_driver = {
7914         .name           = DRV_MODULE_NAME,
7915         .id_table       = bnx2_pci_tbl,
7916         .probe          = bnx2_init_one,
7917         .remove         = __devexit_p(bnx2_remove_one),
7918         .suspend        = bnx2_suspend,
7919         .resume         = bnx2_resume,
7920         .err_handler    = &bnx2_err_handler,
7921 };
7922
7923 static int __init bnx2_init(void)
7924 {
7925         return pci_register_driver(&bnx2_pci_driver);
7926 }
7927
7928 static void __exit bnx2_cleanup(void)
7929 {
7930         pci_unregister_driver(&bnx2_pci_driver);
7931 }
7932
7933 module_init(bnx2_init);
7934 module_exit(bnx2_cleanup);
7935
7936
7937