git.oblomov.eu Git - linux-2.6/blob - drivers/net/tg3.c

   1 /*
   2  * tg3.c: Broadcom Tigon3 ethernet driver.
   3  *
   4  * Copyright (C) 2001, 2002, 2003, 2004 David S. Miller (davem@redhat.com)
   5  * Copyright (C) 2001, 2002, 2003 Jeff Garzik (jgarzik@pobox.com)
   6  * Copyright (C) 2004 Sun Microsystems Inc.
   7  * Copyright (C) 2005 Broadcom Corporation.
   8  *
   9  * Firmware is:
  10  *      Derived from proprietary unpublished source code,
  11  *      Copyright (C) 2000-2003 Broadcom Corporation.
  12  *
  13  *      Permission is hereby granted for the distribution of this firmware
  14  *      data in hexadecimal or equivalent format, provided this copyright
  15  *      notice is accompanying it.
  16  */
  17
  18 #include <linux/config.h>
  19
  20 #include <linux/module.h>
  21 #include <linux/moduleparam.h>
  22 #include <linux/kernel.h>
  23 #include <linux/types.h>
  24 #include <linux/compiler.h>
  25 #include <linux/slab.h>
  26 #include <linux/delay.h>
  27 #include <linux/init.h>
  28 #include <linux/ioport.h>
  29 #include <linux/pci.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/etherdevice.h>
  32 #include <linux/skbuff.h>
  33 #include <linux/ethtool.h>
  34 #include <linux/mii.h>
  35 #include <linux/if_vlan.h>
  36 #include <linux/ip.h>
  37 #include <linux/tcp.h>
  38 #include <linux/workqueue.h>
  39
  40 #include <net/checksum.h>
  41
  42 #include <asm/system.h>
  43 #include <asm/io.h>
  44 #include <asm/byteorder.h>
  45 #include <asm/uaccess.h>
  46
  47 #ifdef CONFIG_SPARC64
  48 #include <asm/idprom.h>
  49 #include <asm/oplib.h>
  50 #include <asm/pbm.h>
  51 #endif
  52
  53 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
  54 #define TG3_VLAN_TAG_USED 1
  55 #else
  56 #define TG3_VLAN_TAG_USED 0
  57 #endif
  58
  59 #ifdef NETIF_F_TSO
  60 #define TG3_TSO_SUPPORT 1
  61 #else
  62 #define TG3_TSO_SUPPORT 0
  63 #endif
  64
  65 #include "tg3.h"
  66
  67 #define DRV_MODULE_NAME         "tg3"
  68 #define PFX DRV_MODULE_NAME     ": "
  69 #define DRV_MODULE_VERSION      "3.34"
  70 #define DRV_MODULE_RELDATE      "July 25, 2005"
  71
  72 #define TG3_DEF_MAC_MODE        0
  73 #define TG3_DEF_RX_MODE         0
  74 #define TG3_DEF_TX_MODE         0
  75 #define TG3_DEF_MSG_ENABLE        \
  76         (NETIF_MSG_DRV          | \
  77          NETIF_MSG_PROBE        | \
  78          NETIF_MSG_LINK         | \
  79          NETIF_MSG_TIMER        | \
  80          NETIF_MSG_IFDOWN       | \
  81          NETIF_MSG_IFUP         | \
  82          NETIF_MSG_RX_ERR       | \
  83          NETIF_MSG_TX_ERR)
  84
  85 /* length of time before we decide the hardware is borked,
  86  * and dev->tx_timeout() should be called to fix the problem
  87  */
  88 #define TG3_TX_TIMEOUT                  (5 * HZ)
  89
  90 /* hardware minimum and maximum for a single frame's data payload */
  91 #define TG3_MIN_MTU                     60
  92 #define TG3_MAX_MTU(tp) \
  93         ((tp->tg3_flags2 & TG3_FLG2_JUMBO_CAPABLE) ? 9000 : 1500)
  94
  95 /* These numbers seem to be hard coded in the NIC firmware somehow.
  96  * You can't change the ring sizes, but you can change where you place
  97  * them in the NIC onboard memory.
  98  */
  99 #define TG3_RX_RING_SIZE                512
 100 #define TG3_DEF_RX_RING_PENDING         200
 101 #define TG3_RX_JUMBO_RING_SIZE          256
 102 #define TG3_DEF_RX_JUMBO_RING_PENDING   100
 103
 104 /* Do not place this n-ring entries value into the tp struct itself,
 105  * we really want to expose these constants to GCC so that modulo et
 106  * al.  operations are done with shifts and masks instead of with
 107  * hw multiply/modulo instructions.  Another solution would be to
 108  * replace things like '% foo' with '& (foo - 1)'.
 109  */
 110 #define TG3_RX_RCB_RING_SIZE(tp)        \
 111         ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) ?  512 : 1024)
 112
 113 #define TG3_TX_RING_SIZE                512
 114 #define TG3_DEF_TX_RING_PENDING         (TG3_TX_RING_SIZE - 1)
 115
 116 #define TG3_RX_RING_BYTES       (sizeof(struct tg3_rx_buffer_desc) * \
 117                                  TG3_RX_RING_SIZE)
 118 #define TG3_RX_JUMBO_RING_BYTES (sizeof(struct tg3_rx_buffer_desc) * \
 119                                  TG3_RX_JUMBO_RING_SIZE)
 120 #define TG3_RX_RCB_RING_BYTES(tp) (sizeof(struct tg3_rx_buffer_desc) * \
 121                                    TG3_RX_RCB_RING_SIZE(tp))
 122 #define TG3_TX_RING_BYTES       (sizeof(struct tg3_tx_buffer_desc) * \
 123                                  TG3_TX_RING_SIZE)
 124 #define TX_RING_GAP(TP) \
 125         (TG3_TX_RING_SIZE - (TP)->tx_pending)
 126 #define TX_BUFFS_AVAIL(TP)                                              \
 127         (((TP)->tx_cons <= (TP)->tx_prod) ?                             \
 128           (TP)->tx_cons + (TP)->tx_pending - (TP)->tx_prod :            \
 129           (TP)->tx_cons - (TP)->tx_prod - TX_RING_GAP(TP))
 130 #define NEXT_TX(N)              (((N) + 1) & (TG3_TX_RING_SIZE - 1))
 131
 132 #define RX_PKT_BUF_SZ           (1536 + tp->rx_offset + 64)
 133 #define RX_JUMBO_PKT_BUF_SZ     (9046 + tp->rx_offset + 64)
 134
 135 /* minimum number of free TX descriptors required to wake up TX process */
 136 #define TG3_TX_WAKEUP_THRESH            (TG3_TX_RING_SIZE / 4)
 137
 138 /* number of ETHTOOL_GSTATS u64's */
 139 #define TG3_NUM_STATS           (sizeof(struct tg3_ethtool_stats)/sizeof(u64))
 140
 141 #define TG3_NUM_TEST            6
 142
 143 static char version[] __devinitdata =
 144         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 145
 146 MODULE_AUTHOR("David S. Miller (davem@redhat.com) and Jeff Garzik (jgarzik@pobox.com)");
 147 MODULE_DESCRIPTION("Broadcom Tigon3 ethernet driver");
 148 MODULE_LICENSE("GPL");
 149 MODULE_VERSION(DRV_MODULE_VERSION);
 150
 151 static int tg3_debug = -1;      /* -1 == use TG3_DEF_MSG_ENABLE as value */
 152 module_param(tg3_debug, int, 0);
 153 MODULE_PARM_DESC(tg3_debug, "Tigon3 bitmapped debugging message enable value");
 154
 155 static struct pci_device_id tg3_pci_tbl[] = {
 156         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5700,
 157           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 158         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5701,
 159           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 160         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702,
 161           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 162         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703,
 163           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 164         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704,
 165           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 166         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702FE,
 167           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 168         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705,
 169           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 170         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705_2,
 171           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 172         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M,
 173           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 174         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M_2,
 175           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 176         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702X,
 177           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 178         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703X,
 179           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 180         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S,
 181           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 182         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702A3,
 183           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 184         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703A3,
 185           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 186         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5782,
 187           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 188         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5788,
 189           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 190         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5789,
 191           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 192         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901,
 193           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 194         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901_2,
 195           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 196         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S_2,
 197           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 198         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705F,
 199           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 200         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5720,
 201           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 202         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5721,
 203           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 204         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750,
 205           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 206         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751,
 207           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 208         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750M,
 209           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 210         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751M,
 211           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 212         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751F,
 213           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 214         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752,
 215           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 216         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752M,
 217           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 218         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753,
 219           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 220         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753M,
 221           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 222         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753F,
 223           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 224         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780,
 225           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 226         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S,
 227           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 228         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5781,
 229           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 230         { PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9DXX,
 231           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 232         { PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9MXX,
 233           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 234         { PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1000,
 235           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 236         { PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1001,
 237           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 238         { PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1003,
 239           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 240         { PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC9100,
 241           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 242         { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_TIGON3,
 243           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 244         { 0, }
 245 };
 246
 247 MODULE_DEVICE_TABLE(pci, tg3_pci_tbl);
 248
 249 static struct {
 250         const char string[ETH_GSTRING_LEN];
 251 } ethtool_stats_keys[TG3_NUM_STATS] = {
 252         { "rx_octets" },
 253         { "rx_fragments" },
 254         { "rx_ucast_packets" },
 255         { "rx_mcast_packets" },
 256         { "rx_bcast_packets" },
 257         { "rx_fcs_errors" },
 258         { "rx_align_errors" },
 259         { "rx_xon_pause_rcvd" },
 260         { "rx_xoff_pause_rcvd" },
 261         { "rx_mac_ctrl_rcvd" },
 262         { "rx_xoff_entered" },
 263         { "rx_frame_too_long_errors" },
 264         { "rx_jabbers" },
 265         { "rx_undersize_packets" },
 266         { "rx_in_length_errors" },
 267         { "rx_out_length_errors" },
 268         { "rx_64_or_less_octet_packets" },
 269         { "rx_65_to_127_octet_packets" },
 270         { "rx_128_to_255_octet_packets" },
 271         { "rx_256_to_511_octet_packets" },
 272         { "rx_512_to_1023_octet_packets" },
 273         { "rx_1024_to_1522_octet_packets" },
 274         { "rx_1523_to_2047_octet_packets" },
 275         { "rx_2048_to_4095_octet_packets" },
 276         { "rx_4096_to_8191_octet_packets" },
 277         { "rx_8192_to_9022_octet_packets" },
 278
 279         { "tx_octets" },
 280         { "tx_collisions" },
 281
 282         { "tx_xon_sent" },
 283         { "tx_xoff_sent" },
 284         { "tx_flow_control" },
 285         { "tx_mac_errors" },
 286         { "tx_single_collisions" },
 287         { "tx_mult_collisions" },
 288         { "tx_deferred" },
 289         { "tx_excessive_collisions" },
 290         { "tx_late_collisions" },
 291         { "tx_collide_2times" },
 292         { "tx_collide_3times" },
 293         { "tx_collide_4times" },
 294         { "tx_collide_5times" },
 295         { "tx_collide_6times" },
 296         { "tx_collide_7times" },
 297         { "tx_collide_8times" },
 298         { "tx_collide_9times" },
 299         { "tx_collide_10times" },
 300         { "tx_collide_11times" },
 301         { "tx_collide_12times" },
 302         { "tx_collide_13times" },
 303         { "tx_collide_14times" },
 304         { "tx_collide_15times" },
 305         { "tx_ucast_packets" },
 306         { "tx_mcast_packets" },
 307         { "tx_bcast_packets" },
 308         { "tx_carrier_sense_errors" },
 309         { "tx_discards" },
 310         { "tx_errors" },
 311
 312         { "dma_writeq_full" },
 313         { "dma_write_prioq_full" },
 314         { "rxbds_empty" },
 315         { "rx_discards" },
 316         { "rx_errors" },
 317         { "rx_threshold_hit" },
 318
 319         { "dma_readq_full" },
 320         { "dma_read_prioq_full" },
 321         { "tx_comp_queue_full" },
 322
 323         { "ring_set_send_prod_index" },
 324         { "ring_status_update" },
 325         { "nic_irqs" },
 326         { "nic_avoided_irqs" },
 327         { "nic_tx_threshold_hit" }
 328 };
 329
 330 static struct {
 331         const char string[ETH_GSTRING_LEN];
 332 } ethtool_test_keys[TG3_NUM_TEST] = {
 333         { "nvram test     (online) " },
 334         { "link test      (online) " },
 335         { "register test  (offline)" },
 336         { "memory test    (offline)" },
 337         { "loopback test  (offline)" },
 338         { "interrupt test (offline)" },
 339 };
 340
 341 static void tg3_write_indirect_reg32(struct tg3 *tp, u32 off, u32 val)
 342 {
 343         if ((tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG) != 0) {
 344                 spin_lock_bh(&tp->indirect_lock);
 345                 pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
 346                 pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
 347                 spin_unlock_bh(&tp->indirect_lock);
 348         } else {
 349                 writel(val, tp->regs + off);
 350                 if ((tp->tg3_flags & TG3_FLAG_5701_REG_WRITE_BUG) != 0)
 351                         readl(tp->regs + off);
 352         }
 353 }
 354
 355 static void _tw32_flush(struct tg3 *tp, u32 off, u32 val)
 356 {
 357         if ((tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG) != 0) {
 358                 spin_lock_bh(&tp->indirect_lock);
 359                 pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
 360                 pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
 361                 spin_unlock_bh(&tp->indirect_lock);
 362         } else {
 363                 void __iomem *dest = tp->regs + off;
 364                 writel(val, dest);
 365                 readl(dest);    /* always flush PCI write */
 366         }
 367 }
 368
 369 static inline void _tw32_rx_mbox(struct tg3 *tp, u32 off, u32 val)
 370 {
 371         void __iomem *mbox = tp->regs + off;
 372         writel(val, mbox);
 373         if (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)
 374                 readl(mbox);
 375 }
 376
 377 static inline void _tw32_tx_mbox(struct tg3 *tp, u32 off, u32 val)
 378 {
 379         void __iomem *mbox = tp->regs + off;
 380         writel(val, mbox);
 381         if (tp->tg3_flags & TG3_FLAG_TXD_MBOX_HWBUG)
 382                 writel(val, mbox);
 383         if (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)
 384                 readl(mbox);
 385 }
 386
 387 #define tw32_mailbox(reg, val)  writel(((val) & 0xffffffff), tp->regs + (reg))
 388 #define tw32_rx_mbox(reg, val)  _tw32_rx_mbox(tp, reg, val)
 389 #define tw32_tx_mbox(reg, val)  _tw32_tx_mbox(tp, reg, val)
 390
 391 #define tw32(reg,val)           tg3_write_indirect_reg32(tp,(reg),(val))
 392 #define tw32_f(reg,val)         _tw32_flush(tp,(reg),(val))
 393 #define tw16(reg,val)           writew(((val) & 0xffff), tp->regs + (reg))
 394 #define tw8(reg,val)            writeb(((val) & 0xff), tp->regs + (reg))
 395 #define tr32(reg)               readl(tp->regs + (reg))
 396 #define tr16(reg)               readw(tp->regs + (reg))
 397 #define tr8(reg)                readb(tp->regs + (reg))
 398
 399 static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
 400 {
 401         spin_lock_bh(&tp->indirect_lock);
 402         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
 403         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
 404
 405         /* Always leave this as zero. */
 406         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
 407         spin_unlock_bh(&tp->indirect_lock);
 408 }
 409
 410 static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
 411 {
 412         spin_lock_bh(&tp->indirect_lock);
 413         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
 414         pci_read_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
 415
 416         /* Always leave this as zero. */
 417         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
 418         spin_unlock_bh(&tp->indirect_lock);
 419 }
 420
 421 static void tg3_disable_ints(struct tg3 *tp)
 422 {
 423         tw32(TG3PCI_MISC_HOST_CTRL,
 424              (tp->misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT));
 425         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
 426         tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
 427 }
 428
 429 static inline void tg3_cond_int(struct tg3 *tp)
 430 {
 431         if (tp->hw_status->status & SD_STATUS_UPDATED)
 432                 tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
 433 }
 434
 435 static void tg3_enable_ints(struct tg3 *tp)
 436 {
 437         tp->irq_sync = 0;
 438         wmb();
 439
 440         tw32(TG3PCI_MISC_HOST_CTRL,
 441              (tp->misc_host_ctrl & ~MISC_HOST_CTRL_MASK_PCI_INT));
 442         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
 443                      (tp->last_tag << 24));
 444         tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
 445         tg3_cond_int(tp);
 446 }
 447
 448 static inline unsigned int tg3_has_work(struct tg3 *tp)
 449 {
 450         struct tg3_hw_status *sblk = tp->hw_status;
 451         unsigned int work_exists = 0;
 452
 453         /* check for phy events */
 454         if (!(tp->tg3_flags &
 455               (TG3_FLAG_USE_LINKCHG_REG |
 456                TG3_FLAG_POLL_SERDES))) {
 457                 if (sblk->status & SD_STATUS_LINK_CHG)
 458                         work_exists = 1;
 459         }
 460         /* check for RX/TX work to do */
 461         if (sblk->idx[0].tx_consumer != tp->tx_cons ||
 462             sblk->idx[0].rx_producer != tp->rx_rcb_ptr)
 463                 work_exists = 1;
 464
 465         return work_exists;
 466 }
 467
 468 /* tg3_restart_ints
 469  *  similar to tg3_enable_ints, but it accurately determines whether there
 470  *  is new work pending and can return without flushing the PIO write
 471  *  which reenables interrupts
 472  */
 473 static void tg3_restart_ints(struct tg3 *tp)
 474 {
 475         tw32(TG3PCI_MISC_HOST_CTRL,
 476                 (tp->misc_host_ctrl & ~MISC_HOST_CTRL_MASK_PCI_INT));
 477         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
 478                      tp->last_tag << 24);
 479         mmiowb();
 480
 481         /* When doing tagged status, this work check is unnecessary.
 482          * The last_tag we write above tells the chip which piece of
 483          * work we've completed.
 484          */
 485         if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) &&
 486             tg3_has_work(tp))
 487                 tw32(HOSTCC_MODE, tp->coalesce_mode |
 488                      (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
 489 }
 490
 491 static inline void tg3_netif_stop(struct tg3 *tp)
 492 {
 493         tp->dev->trans_start = jiffies; /* prevent tx timeout */
 494         netif_poll_disable(tp->dev);
 495         netif_tx_disable(tp->dev);
 496 }
 497
 498 static inline void tg3_netif_start(struct tg3 *tp)
 499 {
 500         netif_wake_queue(tp->dev);
 501         /* NOTE: unconditional netif_wake_queue is only appropriate
 502          * so long as all callers are assured to have free tx slots
 503          * (such as after tg3_init_hw)
 504          */
 505         netif_poll_enable(tp->dev);
 506         tp->hw_status->status |= SD_STATUS_UPDATED;
 507         tg3_enable_ints(tp);
 508 }
 509
 510 static void tg3_switch_clocks(struct tg3 *tp)
 511 {
 512         u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL);
 513         u32 orig_clock_ctrl;
 514
 515         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
 516                 return;
 517
 518         orig_clock_ctrl = clock_ctrl;
 519         clock_ctrl &= (CLOCK_CTRL_FORCE_CLKRUN |
 520                        CLOCK_CTRL_CLKRUN_OENABLE |
 521                        0x1f);
 522         tp->pci_clock_ctrl = clock_ctrl;
 523
 524         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
 525                 if (orig_clock_ctrl & CLOCK_CTRL_625_CORE) {
 526                         tw32_f(TG3PCI_CLOCK_CTRL,
 527                                clock_ctrl | CLOCK_CTRL_625_CORE);
 528                         udelay(40);
 529                 }
 530         } else if ((orig_clock_ctrl & CLOCK_CTRL_44MHZ_CORE) != 0) {
 531                 tw32_f(TG3PCI_CLOCK_CTRL,
 532                      clock_ctrl |
 533                      (CLOCK_CTRL_44MHZ_CORE | CLOCK_CTRL_ALTCLK));
 534                 udelay(40);
 535                 tw32_f(TG3PCI_CLOCK_CTRL,
 536                      clock_ctrl | (CLOCK_CTRL_ALTCLK));
 537                 udelay(40);
 538         }
 539         tw32_f(TG3PCI_CLOCK_CTRL, clock_ctrl);
 540         udelay(40);
 541 }
 542
 543 #define PHY_BUSY_LOOPS  5000
 544
 545 static int tg3_readphy(struct tg3 *tp, int reg, u32 *val)
 546 {
 547         u32 frame_val;
 548         unsigned int loops;
 549         int ret;
 550
 551         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
 552                 tw32_f(MAC_MI_MODE,
 553                      (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
 554                 udelay(80);
 555         }
 556
 557         *val = 0x0;
 558
 559         frame_val  = ((PHY_ADDR << MI_COM_PHY_ADDR_SHIFT) &
 560                       MI_COM_PHY_ADDR_MASK);
 561         frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
 562                       MI_COM_REG_ADDR_MASK);
 563         frame_val |= (MI_COM_CMD_READ | MI_COM_START);
 564
 565         tw32_f(MAC_MI_COM, frame_val);
 566
 567         loops = PHY_BUSY_LOOPS;
 568         while (loops != 0) {
 569                 udelay(10);
 570                 frame_val = tr32(MAC_MI_COM);
 571
 572                 if ((frame_val & MI_COM_BUSY) == 0) {
 573                         udelay(5);
 574                         frame_val = tr32(MAC_MI_COM);
 575                         break;
 576                 }
 577                 loops -= 1;
 578         }
 579
 580         ret = -EBUSY;
 581         if (loops != 0) {
 582                 *val = frame_val & MI_COM_DATA_MASK;
 583                 ret = 0;
 584         }
 585
 586         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
 587                 tw32_f(MAC_MI_MODE, tp->mi_mode);
 588                 udelay(80);
 589         }
 590
 591         return ret;
 592 }
 593
 594 static int tg3_writephy(struct tg3 *tp, int reg, u32 val)
 595 {
 596         u32 frame_val;
 597         unsigned int loops;
 598         int ret;
 599
 600         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
 601                 tw32_f(MAC_MI_MODE,
 602                      (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
 603                 udelay(80);
 604         }
 605
 606         frame_val  = ((PHY_ADDR << MI_COM_PHY_ADDR_SHIFT) &
 607                       MI_COM_PHY_ADDR_MASK);
 608         frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
 609                       MI_COM_REG_ADDR_MASK);
 610         frame_val |= (val & MI_COM_DATA_MASK);
 611         frame_val |= (MI_COM_CMD_WRITE | MI_COM_START);
 612
 613         tw32_f(MAC_MI_COM, frame_val);
 614
 615         loops = PHY_BUSY_LOOPS;
 616         while (loops != 0) {
 617                 udelay(10);
 618                 frame_val = tr32(MAC_MI_COM);
 619                 if ((frame_val & MI_COM_BUSY) == 0) {
 620                         udelay(5);
 621                         frame_val = tr32(MAC_MI_COM);
 622                         break;
 623                 }
 624                 loops -= 1;
 625         }
 626
 627         ret = -EBUSY;
 628         if (loops != 0)
 629                 ret = 0;
 630
 631         if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
 632                 tw32_f(MAC_MI_MODE, tp->mi_mode);
 633                 udelay(80);
 634         }
 635
 636         return ret;
 637 }
 638
 639 static void tg3_phy_set_wirespeed(struct tg3 *tp)
 640 {
 641         u32 val;
 642
 643         if (tp->tg3_flags2 & TG3_FLG2_NO_ETH_WIRE_SPEED)
 644                 return;
 645
 646         if (!tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x7007) &&
 647             !tg3_readphy(tp, MII_TG3_AUX_CTRL, &val))
 648                 tg3_writephy(tp, MII_TG3_AUX_CTRL,
 649                              (val | (1 << 15) | (1 << 4)));
 650 }
 651
 652 static int tg3_bmcr_reset(struct tg3 *tp)
 653 {
 654         u32 phy_control;
 655         int limit, err;
 656
 657         /* OK, reset it, and poll the BMCR_RESET bit until it
 658          * clears or we time out.
 659          */
 660         phy_control = BMCR_RESET;
 661         err = tg3_writephy(tp, MII_BMCR, phy_control);
 662         if (err != 0)
 663                 return -EBUSY;
 664
 665         limit = 5000;
 666         while (limit--) {
 667                 err = tg3_readphy(tp, MII_BMCR, &phy_control);
 668                 if (err != 0)
 669                         return -EBUSY;
 670
 671                 if ((phy_control & BMCR_RESET) == 0) {
 672                         udelay(40);
 673                         break;
 674                 }
 675                 udelay(10);
 676         }
 677         if (limit <= 0)
 678                 return -EBUSY;
 679
 680         return 0;
 681 }
 682
 683 static int tg3_wait_macro_done(struct tg3 *tp)
 684 {
 685         int limit = 100;
 686
 687         while (limit--) {
 688                 u32 tmp32;
 689
 690                 if (!tg3_readphy(tp, 0x16, &tmp32)) {
 691                         if ((tmp32 & 0x1000) == 0)
 692                                 break;
 693                 }
 694         }
 695         if (limit <= 0)
 696                 return -EBUSY;
 697
 698         return 0;
 699 }
 700
 701 static int tg3_phy_write_and_check_testpat(struct tg3 *tp, int *resetp)
 702 {
 703         static const u32 test_pat[4][6] = {
 704         { 0x00005555, 0x00000005, 0x00002aaa, 0x0000000a, 0x00003456, 0x00000003 },
 705         { 0x00002aaa, 0x0000000a, 0x00003333, 0x00000003, 0x0000789a, 0x00000005 },
 706         { 0x00005a5a, 0x00000005, 0x00002a6a, 0x0000000a, 0x00001bcd, 0x00000003 },
 707         { 0x00002a5a, 0x0000000a, 0x000033c3, 0x00000003, 0x00002ef1, 0x00000005 }
 708         };
 709         int chan;
 710
 711         for (chan = 0; chan < 4; chan++) {
 712                 int i;
 713
 714                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
 715                              (chan * 0x2000) | 0x0200);
 716                 tg3_writephy(tp, 0x16, 0x0002);
 717
 718                 for (i = 0; i < 6; i++)
 719                         tg3_writephy(tp, MII_TG3_DSP_RW_PORT,
 720                                      test_pat[chan][i]);
 721
 722                 tg3_writephy(tp, 0x16, 0x0202);
 723                 if (tg3_wait_macro_done(tp)) {
 724                         *resetp = 1;
 725                         return -EBUSY;
 726                 }
 727
 728                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
 729                              (chan * 0x2000) | 0x0200);
 730                 tg3_writephy(tp, 0x16, 0x0082);
 731                 if (tg3_wait_macro_done(tp)) {
 732                         *resetp = 1;
 733                         return -EBUSY;
 734                 }
 735
 736                 tg3_writephy(tp, 0x16, 0x0802);
 737                 if (tg3_wait_macro_done(tp)) {
 738                         *resetp = 1;
 739                         return -EBUSY;
 740                 }
 741
 742                 for (i = 0; i < 6; i += 2) {
 743                         u32 low, high;
 744
 745                         if (tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &low) ||
 746                             tg3_readphy(tp, MII_TG3_DSP_RW_PORT, &high) ||
 747                             tg3_wait_macro_done(tp)) {
 748                                 *resetp = 1;
 749                                 return -EBUSY;
 750                         }
 751                         low &= 0x7fff;
 752                         high &= 0x000f;
 753                         if (low != test_pat[chan][i] ||
 754                             high != test_pat[chan][i+1]) {
 755                                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000b);
 756                                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x4001);
 757                                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x4005);
 758
 759                                 return -EBUSY;
 760                         }
 761                 }
 762         }
 763
 764         return 0;
 765 }
 766
 767 static int tg3_phy_reset_chanpat(struct tg3 *tp)
 768 {
 769         int chan;
 770
 771         for (chan = 0; chan < 4; chan++) {
 772                 int i;
 773
 774                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS,
 775                              (chan * 0x2000) | 0x0200);
 776                 tg3_writephy(tp, 0x16, 0x0002);
 777                 for (i = 0; i < 6; i++)
 778                         tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x000);
 779                 tg3_writephy(tp, 0x16, 0x0202);
 780                 if (tg3_wait_macro_done(tp))
 781                         return -EBUSY;
 782         }
 783
 784         return 0;
 785 }
 786
 787 static int tg3_phy_reset_5703_4_5(struct tg3 *tp)
 788 {
 789         u32 reg32, phy9_orig;
 790         int retries, do_phy_reset, err;
 791
 792         retries = 10;
 793         do_phy_reset = 1;
 794         do {
 795                 if (do_phy_reset) {
 796                         err = tg3_bmcr_reset(tp);
 797                         if (err)
 798                                 return err;
 799                         do_phy_reset = 0;
 800                 }
 801
 802                 /* Disable transmitter and interrupt.  */
 803                 if (tg3_readphy(tp, MII_TG3_EXT_CTRL, &reg32))
 804                         continue;
 805
 806                 reg32 |= 0x3000;
 807                 tg3_writephy(tp, MII_TG3_EXT_CTRL, reg32);
 808
 809                 /* Set full-duplex, 1000 mbps.  */
 810                 tg3_writephy(tp, MII_BMCR,
 811                              BMCR_FULLDPLX | TG3_BMCR_SPEED1000);
 812
 813                 /* Set to master mode.  */
 814                 if (tg3_readphy(tp, MII_TG3_CTRL, &phy9_orig))
 815                         continue;
 816
 817                 tg3_writephy(tp, MII_TG3_CTRL,
 818                              (MII_TG3_CTRL_AS_MASTER |
 819                               MII_TG3_CTRL_ENABLE_AS_MASTER));
 820
 821                 /* Enable SM_DSP_CLOCK and 6dB.  */
 822                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
 823
 824                 /* Block the PHY control access.  */
 825                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8005);
 826                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0800);
 827
 828                 err = tg3_phy_write_and_check_testpat(tp, &do_phy_reset);
 829                 if (!err)
 830                         break;
 831         } while (--retries);
 832
 833         err = tg3_phy_reset_chanpat(tp);
 834         if (err)
 835                 return err;
 836
 837         tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8005);
 838         tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0000);
 839
 840         tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8200);
 841         tg3_writephy(tp, 0x16, 0x0000);
 842
 843         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
 844             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
 845                 /* Set Extended packet length bit for jumbo frames */
 846                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4400);
 847         }
 848         else {
 849                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
 850         }
 851
 852         tg3_writephy(tp, MII_TG3_CTRL, phy9_orig);
 853
 854         if (!tg3_readphy(tp, MII_TG3_EXT_CTRL, &reg32)) {
 855                 reg32 &= ~0x3000;
 856                 tg3_writephy(tp, MII_TG3_EXT_CTRL, reg32);
 857         } else if (!err)
 858                 err = -EBUSY;
 859
 860         return err;
 861 }
 862
 863 /* This will reset the tigon3 PHY if there is no valid
 864  * link unless the FORCE argument is non-zero.
 865  */
 866 static int tg3_phy_reset(struct tg3 *tp)
 867 {
 868         u32 phy_status;
 869         int err;
 870
 871         err  = tg3_readphy(tp, MII_BMSR, &phy_status);
 872         err |= tg3_readphy(tp, MII_BMSR, &phy_status);
 873         if (err != 0)
 874                 return -EBUSY;
 875
 876         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
 877             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
 878             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
 879                 err = tg3_phy_reset_5703_4_5(tp);
 880                 if (err)
 881                         return err;
 882                 goto out;
 883         }
 884
 885         err = tg3_bmcr_reset(tp);
 886         if (err)
 887                 return err;
 888
 889 out:
 890         if (tp->tg3_flags2 & TG3_FLG2_PHY_ADC_BUG) {
 891                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
 892                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x201f);
 893                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x2aaa);
 894                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
 895                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0323);
 896                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
 897         }
 898         if (tp->tg3_flags2 & TG3_FLG2_PHY_5704_A0_BUG) {
 899                 tg3_writephy(tp, 0x1c, 0x8d68);
 900                 tg3_writephy(tp, 0x1c, 0x8d68);
 901         }
 902         if (tp->tg3_flags2 & TG3_FLG2_PHY_BER_BUG) {
 903                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0c00);
 904                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x000a);
 905                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x310b);
 906                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x201f);
 907                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x9506);
 908                 tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x401f);
 909                 tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x14e2);
 910                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0400);
 911         }
 912         /* Set Extended packet length bit (bit 14) on all chips that */
 913         /* support jumbo frames */
 914         if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
 915                 /* Cannot do read-modify-write on 5401 */
 916                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4c20);
 917         } else if (tp->tg3_flags2 & TG3_FLG2_JUMBO_CAPABLE) {
 918                 u32 phy_reg;
 919
 920                 /* Set bit 14 with read-modify-write to preserve other bits */
 921                 if (!tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x0007) &&
 922                     !tg3_readphy(tp, MII_TG3_AUX_CTRL, &phy_reg))
 923                         tg3_writephy(tp, MII_TG3_AUX_CTRL, phy_reg | 0x4000);
 924         }
 925
 926         /* Set phy register 0x10 bit 0 to high fifo elasticity to support
 927          * jumbo frames transmission.
 928          */
 929         if (tp->tg3_flags2 & TG3_FLG2_JUMBO_CAPABLE) {
 930                 u32 phy_reg;
 931
 932                 if (!tg3_readphy(tp, MII_TG3_EXT_CTRL, &phy_reg))
 933                     tg3_writephy(tp, MII_TG3_EXT_CTRL,
 934                                  phy_reg | MII_TG3_EXT_CTRL_FIFO_ELASTIC);
 935         }
 936
 937         tg3_phy_set_wirespeed(tp);
 938         return 0;
 939 }
 940
 941 static void tg3_frob_aux_power(struct tg3 *tp)
 942 {
 943         struct tg3 *tp_peer = tp;
 944
 945         if ((tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) != 0)
 946                 return;
 947
 948         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
 949                 tp_peer = pci_get_drvdata(tp->pdev_peer);
 950                 if (!tp_peer)
 951                         BUG();
 952         }
 953
 954
 955         if ((tp->tg3_flags & TG3_FLAG_WOL_ENABLE) != 0 ||
 956             (tp_peer->tg3_flags & TG3_FLAG_WOL_ENABLE) != 0) {
 957                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
 958                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
 959                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
 960                              (GRC_LCLCTRL_GPIO_OE0 |
 961                               GRC_LCLCTRL_GPIO_OE1 |
 962                               GRC_LCLCTRL_GPIO_OE2 |
 963                               GRC_LCLCTRL_GPIO_OUTPUT0 |
 964                               GRC_LCLCTRL_GPIO_OUTPUT1));
 965                         udelay(100);
 966                 } else {
 967                         u32 no_gpio2;
 968                         u32 grc_local_ctrl;
 969
 970                         if (tp_peer != tp &&
 971                             (tp_peer->tg3_flags & TG3_FLAG_INIT_COMPLETE) != 0)
 972                                 return;
 973
 974                         /* On 5753 and variants, GPIO2 cannot be used. */
 975                         no_gpio2 = tp->nic_sram_data_cfg &
 976                                     NIC_SRAM_DATA_CFG_NO_GPIO2;
 977
 978                         grc_local_ctrl = GRC_LCLCTRL_GPIO_OE0 |
 979                                          GRC_LCLCTRL_GPIO_OE1 |
 980                                          GRC_LCLCTRL_GPIO_OE2 |
 981                                          GRC_LCLCTRL_GPIO_OUTPUT1 |
 982                                          GRC_LCLCTRL_GPIO_OUTPUT2;
 983                         if (no_gpio2) {
 984                                 grc_local_ctrl &= ~(GRC_LCLCTRL_GPIO_OE2 |
 985                                                     GRC_LCLCTRL_GPIO_OUTPUT2);
 986                         }
 987                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
 988                                                 grc_local_ctrl);
 989                         udelay(100);
 990
 991                         grc_local_ctrl |= GRC_LCLCTRL_GPIO_OUTPUT0;
 992
 993                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
 994                                                 grc_local_ctrl);
 995                         udelay(100);
 996
 997                         if (!no_gpio2) {
 998                                 grc_local_ctrl &= ~GRC_LCLCTRL_GPIO_OUTPUT2;
 999                                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1000                                        grc_local_ctrl);
1001                                 udelay(100);
1002                         }
1003                 }
1004         } else {
1005                 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
1006                     GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) {
1007                         if (tp_peer != tp &&
1008                             (tp_peer->tg3_flags & TG3_FLAG_INIT_COMPLETE) != 0)
1009                                 return;
1010
1011                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1012                              (GRC_LCLCTRL_GPIO_OE1 |
1013                               GRC_LCLCTRL_GPIO_OUTPUT1));
1014                         udelay(100);
1015
1016                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1017                              (GRC_LCLCTRL_GPIO_OE1));
1018                         udelay(100);
1019
1020                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
1021                              (GRC_LCLCTRL_GPIO_OE1 |
1022                               GRC_LCLCTRL_GPIO_OUTPUT1));
1023                         udelay(100);
1024                 }
1025         }
1026 }
1027
1028 static int tg3_setup_phy(struct tg3 *, int);
1029
1030 #define RESET_KIND_SHUTDOWN     0
1031 #define RESET_KIND_INIT         1
1032 #define RESET_KIND_SUSPEND      2
1033
1034 static void tg3_write_sig_post_reset(struct tg3 *, int);
1035 static int tg3_halt_cpu(struct tg3 *, u32);
1036
1037 static int tg3_set_power_state(struct tg3 *tp, int state)
1038 {
1039         u32 misc_host_ctrl;
1040         u16 power_control, power_caps;
1041         int pm = tp->pm_cap;
1042
1043         /* Make sure register accesses (indirect or otherwise)
1044          * will function correctly.
1045          */
1046         pci_write_config_dword(tp->pdev,
1047                                TG3PCI_MISC_HOST_CTRL,
1048                                tp->misc_host_ctrl);
1049
1050         pci_read_config_word(tp->pdev,
1051                              pm + PCI_PM_CTRL,
1052                              &power_control);
1053         power_control |= PCI_PM_CTRL_PME_STATUS;
1054         power_control &= ~(PCI_PM_CTRL_STATE_MASK);
1055         switch (state) {
1056         case 0:
1057                 power_control |= 0;
1058                 pci_write_config_word(tp->pdev,
1059                                       pm + PCI_PM_CTRL,
1060                                       power_control);
1061                 udelay(100);    /* Delay after power state change */
1062
1063                 /* Switch out of Vaux if it is not a LOM */
1064                 if (!(tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT)) {
1065                         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
1066                         udelay(100);
1067                 }
1068
1069                 return 0;
1070
1071         case 1:
1072                 power_control |= 1;
1073                 break;
1074
1075         case 2:
1076                 power_control |= 2;
1077                 break;
1078
1079         case 3:
1080                 power_control |= 3;
1081                 break;
1082
1083         default:
1084                 printk(KERN_WARNING PFX "%s: Invalid power state (%d) "
1085                        "requested.\n",
1086                        tp->dev->name, state);
1087                 return -EINVAL;
1088         };
1089
1090         power_control |= PCI_PM_CTRL_PME_ENABLE;
1091
1092         misc_host_ctrl = tr32(TG3PCI_MISC_HOST_CTRL);
1093         tw32(TG3PCI_MISC_HOST_CTRL,
1094              misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT);
1095
1096         if (tp->link_config.phy_is_low_power == 0) {
1097                 tp->link_config.phy_is_low_power = 1;
1098                 tp->link_config.orig_speed = tp->link_config.speed;
1099                 tp->link_config.orig_duplex = tp->link_config.duplex;
1100                 tp->link_config.orig_autoneg = tp->link_config.autoneg;
1101         }
1102
1103         if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)) {
1104                 tp->link_config.speed = SPEED_10;
1105                 tp->link_config.duplex = DUPLEX_HALF;
1106                 tp->link_config.autoneg = AUTONEG_ENABLE;
1107                 tg3_setup_phy(tp, 0);
1108         }
1109
1110         pci_read_config_word(tp->pdev, pm + PCI_PM_PMC, &power_caps);
1111
1112         if (tp->tg3_flags & TG3_FLAG_WOL_ENABLE) {
1113                 u32 mac_mode;
1114
1115                 if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
1116                         tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x5a);
1117                         udelay(40);
1118
1119                         mac_mode = MAC_MODE_PORT_MODE_MII;
1120
1121                         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 ||
1122                             !(tp->tg3_flags & TG3_FLAG_WOL_SPEED_100MB))
1123                                 mac_mode |= MAC_MODE_LINK_POLARITY;
1124                 } else {
1125                         mac_mode = MAC_MODE_PORT_MODE_TBI;
1126                 }
1127
1128                 if (!(tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
1129                         tw32(MAC_LED_CTRL, tp->led_ctrl);
1130
1131                 if (((power_caps & PCI_PM_CAP_PME_D3cold) &&
1132                      (tp->tg3_flags & TG3_FLAG_WOL_ENABLE)))
1133                         mac_mode |= MAC_MODE_MAGIC_PKT_ENABLE;
1134
1135                 tw32_f(MAC_MODE, mac_mode);
1136                 udelay(100);
1137
1138                 tw32_f(MAC_RX_MODE, RX_MODE_ENABLE);
1139                 udelay(10);
1140         }
1141
1142         if (!(tp->tg3_flags & TG3_FLAG_WOL_SPEED_100MB) &&
1143             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1144              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
1145                 u32 base_val;
1146
1147                 base_val = tp->pci_clock_ctrl;
1148                 base_val |= (CLOCK_CTRL_RXCLK_DISABLE |
1149                              CLOCK_CTRL_TXCLK_DISABLE);
1150
1151                 tw32_f(TG3PCI_CLOCK_CTRL, base_val |
1152                      CLOCK_CTRL_ALTCLK |
1153                      CLOCK_CTRL_PWRDOWN_PLL133);
1154                 udelay(40);
1155         } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
1156                 /* do nothing */
1157         } else if (!((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
1158                      (tp->tg3_flags & TG3_FLAG_ENABLE_ASF))) {
1159                 u32 newbits1, newbits2;
1160
1161                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1162                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
1163                         newbits1 = (CLOCK_CTRL_RXCLK_DISABLE |
1164                                     CLOCK_CTRL_TXCLK_DISABLE |
1165                                     CLOCK_CTRL_ALTCLK);
1166                         newbits2 = newbits1 | CLOCK_CTRL_44MHZ_CORE;
1167                 } else if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
1168                         newbits1 = CLOCK_CTRL_625_CORE;
1169                         newbits2 = newbits1 | CLOCK_CTRL_ALTCLK;
1170                 } else {
1171                         newbits1 = CLOCK_CTRL_ALTCLK;
1172                         newbits2 = newbits1 | CLOCK_CTRL_44MHZ_CORE;
1173                 }
1174
1175                 tw32_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl | newbits1);
1176                 udelay(40);
1177
1178                 tw32_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl | newbits2);
1179                 udelay(40);
1180
1181                 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
1182                         u32 newbits3;
1183
1184                         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1185                             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
1186                                 newbits3 = (CLOCK_CTRL_RXCLK_DISABLE |
1187                                             CLOCK_CTRL_TXCLK_DISABLE |
1188                                             CLOCK_CTRL_44MHZ_CORE);
1189                         } else {
1190                                 newbits3 = CLOCK_CTRL_44MHZ_CORE;
1191                         }
1192
1193                         tw32_f(TG3PCI_CLOCK_CTRL,
1194                                          tp->pci_clock_ctrl | newbits3);
1195                         udelay(40);
1196                 }
1197         }
1198
1199         tg3_frob_aux_power(tp);
1200
1201         /* Workaround for unstable PLL clock */
1202         if ((GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5750_AX) ||
1203             (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5750_BX)) {
1204                 u32 val = tr32(0x7d00);
1205
1206                 val &= ~((1 << 16) | (1 << 4) | (1 << 2) | (1 << 1) | 1);
1207                 tw32(0x7d00, val);
1208                 if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
1209                         tg3_halt_cpu(tp, RX_CPU_BASE);
1210         }
1211
1212         /* Finally, set the new power state. */
1213         pci_write_config_word(tp->pdev, pm + PCI_PM_CTRL, power_control);
1214         udelay(100);    /* Delay after power state change */
1215
1216         tg3_write_sig_post_reset(tp, RESET_KIND_SHUTDOWN);
1217
1218         return 0;
1219 }
1220
1221 static void tg3_link_report(struct tg3 *tp)
1222 {
1223         if (!netif_carrier_ok(tp->dev)) {
1224                 printk(KERN_INFO PFX "%s: Link is down.\n", tp->dev->name);
1225         } else {
1226                 printk(KERN_INFO PFX "%s: Link is up at %d Mbps, %s duplex.\n",
1227                        tp->dev->name,
1228                        (tp->link_config.active_speed == SPEED_1000 ?
1229                         1000 :
1230                         (tp->link_config.active_speed == SPEED_100 ?
1231                          100 : 10)),
1232                        (tp->link_config.active_duplex == DUPLEX_FULL ?
1233                         "full" : "half"));
1234
1235                 printk(KERN_INFO PFX "%s: Flow control is %s for TX and "
1236                        "%s for RX.\n",
1237                        tp->dev->name,
1238                        (tp->tg3_flags & TG3_FLAG_TX_PAUSE) ? "on" : "off",
1239                        (tp->tg3_flags & TG3_FLAG_RX_PAUSE) ? "on" : "off");
1240         }
1241 }
1242
1243 static void tg3_setup_flow_control(struct tg3 *tp, u32 local_adv, u32 remote_adv)
1244 {
1245         u32 new_tg3_flags = 0;
1246         u32 old_rx_mode = tp->rx_mode;
1247         u32 old_tx_mode = tp->tx_mode;
1248
1249         if (tp->tg3_flags & TG3_FLAG_PAUSE_AUTONEG) {
1250
1251                 /* Convert 1000BaseX flow control bits to 1000BaseT
1252                  * bits before resolving flow control.
1253                  */
1254                 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
1255                         local_adv &= ~(ADVERTISE_PAUSE_CAP |
1256                                        ADVERTISE_PAUSE_ASYM);
1257                         remote_adv &= ~(LPA_PAUSE_CAP | LPA_PAUSE_ASYM);
1258
1259                         if (local_adv & ADVERTISE_1000XPAUSE)
1260                                 local_adv |= ADVERTISE_PAUSE_CAP;
1261                         if (local_adv & ADVERTISE_1000XPSE_ASYM)
1262                                 local_adv |= ADVERTISE_PAUSE_ASYM;
1263                         if (remote_adv & LPA_1000XPAUSE)
1264                                 remote_adv |= LPA_PAUSE_CAP;
1265                         if (remote_adv & LPA_1000XPAUSE_ASYM)
1266                                 remote_adv |= LPA_PAUSE_ASYM;
1267                 }
1268
1269                 if (local_adv & ADVERTISE_PAUSE_CAP) {
1270                         if (local_adv & ADVERTISE_PAUSE_ASYM) {
1271                                 if (remote_adv & LPA_PAUSE_CAP)
1272                                         new_tg3_flags |=
1273                                                 (TG3_FLAG_RX_PAUSE |
1274                                                 TG3_FLAG_TX_PAUSE);
1275                                 else if (remote_adv & LPA_PAUSE_ASYM)
1276                                         new_tg3_flags |=
1277                                                 (TG3_FLAG_RX_PAUSE);
1278                         } else {
1279                                 if (remote_adv & LPA_PAUSE_CAP)
1280                                         new_tg3_flags |=
1281                                                 (TG3_FLAG_RX_PAUSE |
1282                                                 TG3_FLAG_TX_PAUSE);
1283                         }
1284                 } else if (local_adv & ADVERTISE_PAUSE_ASYM) {
1285                         if ((remote_adv & LPA_PAUSE_CAP) &&
1286                         (remote_adv & LPA_PAUSE_ASYM))
1287                                 new_tg3_flags |= TG3_FLAG_TX_PAUSE;
1288                 }
1289
1290                 tp->tg3_flags &= ~(TG3_FLAG_RX_PAUSE | TG3_FLAG_TX_PAUSE);
1291                 tp->tg3_flags |= new_tg3_flags;
1292         } else {
1293                 new_tg3_flags = tp->tg3_flags;
1294         }
1295
1296         if (new_tg3_flags & TG3_FLAG_RX_PAUSE)
1297                 tp->rx_mode |= RX_MODE_FLOW_CTRL_ENABLE;
1298         else
1299                 tp->rx_mode &= ~RX_MODE_FLOW_CTRL_ENABLE;
1300
1301         if (old_rx_mode != tp->rx_mode) {
1302                 tw32_f(MAC_RX_MODE, tp->rx_mode);
1303         }
1304
1305         if (new_tg3_flags & TG3_FLAG_TX_PAUSE)
1306                 tp->tx_mode |= TX_MODE_FLOW_CTRL_ENABLE;
1307         else
1308                 tp->tx_mode &= ~TX_MODE_FLOW_CTRL_ENABLE;
1309
1310         if (old_tx_mode != tp->tx_mode) {
1311                 tw32_f(MAC_TX_MODE, tp->tx_mode);
1312         }
1313 }
1314
1315 static void tg3_aux_stat_to_speed_duplex(struct tg3 *tp, u32 val, u16 *speed, u8 *duplex)
1316 {
1317         switch (val & MII_TG3_AUX_STAT_SPDMASK) {
1318         case MII_TG3_AUX_STAT_10HALF:
1319                 *speed = SPEED_10;
1320                 *duplex = DUPLEX_HALF;
1321                 break;
1322
1323         case MII_TG3_AUX_STAT_10FULL:
1324                 *speed = SPEED_10;
1325                 *duplex = DUPLEX_FULL;
1326                 break;
1327
1328         case MII_TG3_AUX_STAT_100HALF:
1329                 *speed = SPEED_100;
1330                 *duplex = DUPLEX_HALF;
1331                 break;
1332
1333         case MII_TG3_AUX_STAT_100FULL:
1334                 *speed = SPEED_100;
1335                 *duplex = DUPLEX_FULL;
1336                 break;
1337
1338         case MII_TG3_AUX_STAT_1000HALF:
1339                 *speed = SPEED_1000;
1340                 *duplex = DUPLEX_HALF;
1341                 break;
1342
1343         case MII_TG3_AUX_STAT_1000FULL:
1344                 *speed = SPEED_1000;
1345                 *duplex = DUPLEX_FULL;
1346                 break;
1347
1348         default:
1349                 *speed = SPEED_INVALID;
1350                 *duplex = DUPLEX_INVALID;
1351                 break;
1352         };
1353 }
1354
1355 static void tg3_phy_copper_begin(struct tg3 *tp)
1356 {
1357         u32 new_adv;
1358         int i;
1359
1360         if (tp->link_config.phy_is_low_power) {
1361                 /* Entering low power mode.  Disable gigabit and
1362                  * 100baseT advertisements.
1363                  */
1364                 tg3_writephy(tp, MII_TG3_CTRL, 0);
1365
1366                 new_adv = (ADVERTISE_10HALF | ADVERTISE_10FULL |
1367                            ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
1368                 if (tp->tg3_flags & TG3_FLAG_WOL_SPEED_100MB)
1369                         new_adv |= (ADVERTISE_100HALF | ADVERTISE_100FULL);
1370
1371                 tg3_writephy(tp, MII_ADVERTISE, new_adv);
1372         } else if (tp->link_config.speed == SPEED_INVALID) {
1373                 tp->link_config.advertising =
1374                         (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
1375                          ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
1376                          ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full |
1377                          ADVERTISED_Autoneg | ADVERTISED_MII);
1378
1379                 if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
1380                         tp->link_config.advertising &=
1381                                 ~(ADVERTISED_1000baseT_Half |
1382                                   ADVERTISED_1000baseT_Full);
1383
1384                 new_adv = (ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
1385                 if (tp->link_config.advertising & ADVERTISED_10baseT_Half)
1386                         new_adv |= ADVERTISE_10HALF;
1387                 if (tp->link_config.advertising & ADVERTISED_10baseT_Full)
1388                         new_adv |= ADVERTISE_10FULL;
1389                 if (tp->link_config.advertising & ADVERTISED_100baseT_Half)
1390                         new_adv |= ADVERTISE_100HALF;
1391                 if (tp->link_config.advertising & ADVERTISED_100baseT_Full)
1392                         new_adv |= ADVERTISE_100FULL;
1393                 tg3_writephy(tp, MII_ADVERTISE, new_adv);
1394
1395                 if (tp->link_config.advertising &
1396                     (ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full)) {
1397                         new_adv = 0;
1398                         if (tp->link_config.advertising & ADVERTISED_1000baseT_Half)
1399                                 new_adv |= MII_TG3_CTRL_ADV_1000_HALF;
1400                         if (tp->link_config.advertising & ADVERTISED_1000baseT_Full)
1401                                 new_adv |= MII_TG3_CTRL_ADV_1000_FULL;
1402                         if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY) &&
1403                             (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
1404                              tp->pci_chip_rev_id == CHIPREV_ID_5701_B0))
1405                                 new_adv |= (MII_TG3_CTRL_AS_MASTER |
1406                                             MII_TG3_CTRL_ENABLE_AS_MASTER);
1407                         tg3_writephy(tp, MII_TG3_CTRL, new_adv);
1408                 } else {
1409                         tg3_writephy(tp, MII_TG3_CTRL, 0);
1410                 }
1411         } else {
1412                 /* Asking for a specific link mode. */
1413                 if (tp->link_config.speed == SPEED_1000) {
1414                         new_adv = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP;
1415                         tg3_writephy(tp, MII_ADVERTISE, new_adv);
1416
1417                         if (tp->link_config.duplex == DUPLEX_FULL)
1418                                 new_adv = MII_TG3_CTRL_ADV_1000_FULL;
1419                         else
1420                                 new_adv = MII_TG3_CTRL_ADV_1000_HALF;
1421                         if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
1422                             tp->pci_chip_rev_id == CHIPREV_ID_5701_B0)
1423                                 new_adv |= (MII_TG3_CTRL_AS_MASTER |
1424                                             MII_TG3_CTRL_ENABLE_AS_MASTER);
1425                         tg3_writephy(tp, MII_TG3_CTRL, new_adv);
1426                 } else {
1427                         tg3_writephy(tp, MII_TG3_CTRL, 0);
1428
1429                         new_adv = ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP;
1430                         if (tp->link_config.speed == SPEED_100) {
1431                                 if (tp->link_config.duplex == DUPLEX_FULL)
1432                                         new_adv |= ADVERTISE_100FULL;
1433                                 else
1434                                         new_adv |= ADVERTISE_100HALF;
1435                         } else {
1436                                 if (tp->link_config.duplex == DUPLEX_FULL)
1437                                         new_adv |= ADVERTISE_10FULL;
1438                                 else
1439                                         new_adv |= ADVERTISE_10HALF;
1440                         }
1441                         tg3_writephy(tp, MII_ADVERTISE, new_adv);
1442                 }
1443         }
1444
1445         if (tp->link_config.autoneg == AUTONEG_DISABLE &&
1446             tp->link_config.speed != SPEED_INVALID) {
1447                 u32 bmcr, orig_bmcr;
1448
1449                 tp->link_config.active_speed = tp->link_config.speed;
1450                 tp->link_config.active_duplex = tp->link_config.duplex;
1451
1452                 bmcr = 0;
1453                 switch (tp->link_config.speed) {
1454                 default:
1455                 case SPEED_10:
1456                         break;
1457
1458                 case SPEED_100:
1459                         bmcr |= BMCR_SPEED100;
1460                         break;
1461
1462                 case SPEED_1000:
1463                         bmcr |= TG3_BMCR_SPEED1000;
1464                         break;
1465                 };
1466
1467                 if (tp->link_config.duplex == DUPLEX_FULL)
1468                         bmcr |= BMCR_FULLDPLX;
1469
1470                 if (!tg3_readphy(tp, MII_BMCR, &orig_bmcr) &&
1471                     (bmcr != orig_bmcr)) {
1472                         tg3_writephy(tp, MII_BMCR, BMCR_LOOPBACK);
1473                         for (i = 0; i < 1500; i++) {
1474                                 u32 tmp;
1475
1476                                 udelay(10);
1477                                 if (tg3_readphy(tp, MII_BMSR, &tmp) ||
1478                                     tg3_readphy(tp, MII_BMSR, &tmp))
1479                                         continue;
1480                                 if (!(tmp & BMSR_LSTATUS)) {
1481                                         udelay(40);
1482                                         break;
1483                                 }
1484                         }
1485                         tg3_writephy(tp, MII_BMCR, bmcr);
1486                         udelay(40);
1487                 }
1488         } else {
1489                 tg3_writephy(tp, MII_BMCR,
1490                              BMCR_ANENABLE | BMCR_ANRESTART);
1491         }
1492 }
1493
1494 static int tg3_init_5401phy_dsp(struct tg3 *tp)
1495 {
1496         int err;
1497
1498         /* Turn off tap power management. */
1499         /* Set Extended packet length bit */
1500         err  = tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4c20);
1501
1502         err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x0012);
1503         err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x1804);
1504
1505         err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x0013);
1506         err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x1204);
1507
1508         err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8006);
1509         err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0132);
1510
1511         err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x8006);
1512         err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0232);
1513
1514         err |= tg3_writephy(tp, MII_TG3_DSP_ADDRESS, 0x201f);
1515         err |= tg3_writephy(tp, MII_TG3_DSP_RW_PORT, 0x0a20);
1516
1517         udelay(40);
1518
1519         return err;
1520 }
1521
1522 static int tg3_copper_is_advertising_all(struct tg3 *tp)
1523 {
1524         u32 adv_reg, all_mask;
1525
1526         if (tg3_readphy(tp, MII_ADVERTISE, &adv_reg))
1527                 return 0;
1528
1529         all_mask = (ADVERTISE_10HALF | ADVERTISE_10FULL |
1530                     ADVERTISE_100HALF | ADVERTISE_100FULL);
1531         if ((adv_reg & all_mask) != all_mask)
1532                 return 0;
1533         if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY)) {
1534                 u32 tg3_ctrl;
1535
1536                 if (tg3_readphy(tp, MII_TG3_CTRL, &tg3_ctrl))
1537                         return 0;
1538
1539                 all_mask = (MII_TG3_CTRL_ADV_1000_HALF |
1540                             MII_TG3_CTRL_ADV_1000_FULL);
1541                 if ((tg3_ctrl & all_mask) != all_mask)
1542                         return 0;
1543         }
1544         return 1;
1545 }
1546
1547 static int tg3_setup_copper_phy(struct tg3 *tp, int force_reset)
1548 {
1549         int current_link_up;
1550         u32 bmsr, dummy;
1551         u16 current_speed;
1552         u8 current_duplex;
1553         int i, err;
1554
1555         tw32(MAC_EVENT, 0);
1556
1557         tw32_f(MAC_STATUS,
1558              (MAC_STATUS_SYNC_CHANGED |
1559               MAC_STATUS_CFG_CHANGED |
1560               MAC_STATUS_MI_COMPLETION |
1561               MAC_STATUS_LNKSTATE_CHANGED));
1562         udelay(40);
1563
1564         tp->mi_mode = MAC_MI_MODE_BASE;
1565         tw32_f(MAC_MI_MODE, tp->mi_mode);
1566         udelay(80);
1567
1568         tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x02);
1569
1570         /* Some third-party PHYs need to be reset on link going
1571          * down.
1572          */
1573         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
1574              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
1575              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) &&
1576             netif_carrier_ok(tp->dev)) {
1577                 tg3_readphy(tp, MII_BMSR, &bmsr);
1578                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
1579                     !(bmsr & BMSR_LSTATUS))
1580                         force_reset = 1;
1581         }
1582         if (force_reset)
1583                 tg3_phy_reset(tp);
1584
1585         if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
1586                 tg3_readphy(tp, MII_BMSR, &bmsr);
1587                 if (tg3_readphy(tp, MII_BMSR, &bmsr) ||
1588                     !(tp->tg3_flags & TG3_FLAG_INIT_COMPLETE))
1589                         bmsr = 0;
1590
1591                 if (!(bmsr & BMSR_LSTATUS)) {
1592                         err = tg3_init_5401phy_dsp(tp);
1593                         if (err)
1594                                 return err;
1595
1596                         tg3_readphy(tp, MII_BMSR, &bmsr);
1597                         for (i = 0; i < 1000; i++) {
1598                                 udelay(10);
1599                                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
1600                                     (bmsr & BMSR_LSTATUS)) {
1601                                         udelay(40);
1602                                         break;
1603                                 }
1604                         }
1605
1606                         if ((tp->phy_id & PHY_ID_REV_MASK) == PHY_REV_BCM5401_B0 &&
1607                             !(bmsr & BMSR_LSTATUS) &&
1608                             tp->link_config.active_speed == SPEED_1000) {
1609                                 err = tg3_phy_reset(tp);
1610                                 if (!err)
1611                                         err = tg3_init_5401phy_dsp(tp);
1612                                 if (err)
1613                                         return err;
1614                         }
1615                 }
1616         } else if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
1617                    tp->pci_chip_rev_id == CHIPREV_ID_5701_B0) {
1618                 /* 5701 {A0,B0} CRC bug workaround */
1619                 tg3_writephy(tp, 0x15, 0x0a75);
1620                 tg3_writephy(tp, 0x1c, 0x8c68);
1621                 tg3_writephy(tp, 0x1c, 0x8d68);
1622                 tg3_writephy(tp, 0x1c, 0x8c68);
1623         }
1624
1625         /* Clear pending interrupts... */
1626         tg3_readphy(tp, MII_TG3_ISTAT, &dummy);
1627         tg3_readphy(tp, MII_TG3_ISTAT, &dummy);
1628
1629         if (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT)
1630                 tg3_writephy(tp, MII_TG3_IMASK, ~MII_TG3_INT_LINKCHG);
1631         else
1632                 tg3_writephy(tp, MII_TG3_IMASK, ~0);
1633
1634         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
1635             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
1636                 if (tp->led_ctrl == LED_CTRL_MODE_PHY_1)
1637                         tg3_writephy(tp, MII_TG3_EXT_CTRL,
1638                                      MII_TG3_EXT_CTRL_LNK3_LED_MODE);
1639                 else
1640                         tg3_writephy(tp, MII_TG3_EXT_CTRL, 0);
1641         }
1642
1643         current_link_up = 0;
1644         current_speed = SPEED_INVALID;
1645         current_duplex = DUPLEX_INVALID;
1646
1647         if (tp->tg3_flags2 & TG3_FLG2_CAPACITIVE_COUPLING) {
1648                 u32 val;
1649
1650                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4007);
1651                 tg3_readphy(tp, MII_TG3_AUX_CTRL, &val);
1652                 if (!(val & (1 << 10))) {
1653                         val |= (1 << 10);
1654                         tg3_writephy(tp, MII_TG3_AUX_CTRL, val);
1655                         goto relink;
1656                 }
1657         }
1658
1659         bmsr = 0;
1660         for (i = 0; i < 100; i++) {
1661                 tg3_readphy(tp, MII_BMSR, &bmsr);
1662                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
1663                     (bmsr & BMSR_LSTATUS))
1664                         break;
1665                 udelay(40);
1666         }
1667
1668         if (bmsr & BMSR_LSTATUS) {
1669                 u32 aux_stat, bmcr;
1670
1671                 tg3_readphy(tp, MII_TG3_AUX_STAT, &aux_stat);
1672                 for (i = 0; i < 2000; i++) {
1673                         udelay(10);
1674                         if (!tg3_readphy(tp, MII_TG3_AUX_STAT, &aux_stat) &&
1675                             aux_stat)
1676                                 break;
1677                 }
1678
1679                 tg3_aux_stat_to_speed_duplex(tp, aux_stat,
1680                                              &current_speed,
1681                                              &current_duplex);
1682
1683                 bmcr = 0;
1684                 for (i = 0; i < 200; i++) {
1685                         tg3_readphy(tp, MII_BMCR, &bmcr);
1686                         if (tg3_readphy(tp, MII_BMCR, &bmcr))
1687                                 continue;
1688                         if (bmcr && bmcr != 0x7fff)
1689                                 break;
1690                         udelay(10);
1691                 }
1692
1693                 if (tp->link_config.autoneg == AUTONEG_ENABLE) {
1694                         if (bmcr & BMCR_ANENABLE) {
1695                                 current_link_up = 1;
1696
1697                                 /* Force autoneg restart if we are exiting
1698                                  * low power mode.
1699                                  */
1700                                 if (!tg3_copper_is_advertising_all(tp))
1701                                         current_link_up = 0;
1702                         } else {
1703                                 current_link_up = 0;
1704                         }
1705                 } else {
1706                         if (!(bmcr & BMCR_ANENABLE) &&
1707                             tp->link_config.speed == current_speed &&
1708                             tp->link_config.duplex == current_duplex) {
1709                                 current_link_up = 1;
1710                         } else {
1711                                 current_link_up = 0;
1712                         }
1713                 }
1714
1715                 tp->link_config.active_speed = current_speed;
1716                 tp->link_config.active_duplex = current_duplex;
1717         }
1718
1719         if (current_link_up == 1 &&
1720             (tp->link_config.active_duplex == DUPLEX_FULL) &&
1721             (tp->link_config.autoneg == AUTONEG_ENABLE)) {
1722                 u32 local_adv, remote_adv;
1723
1724                 if (tg3_readphy(tp, MII_ADVERTISE, &local_adv))
1725                         local_adv = 0;
1726                 local_adv &= (ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
1727
1728                 if (tg3_readphy(tp, MII_LPA, &remote_adv))
1729                         remote_adv = 0;
1730
1731                 remote_adv &= (LPA_PAUSE_CAP | LPA_PAUSE_ASYM);
1732
1733                 /* If we are not advertising full pause capability,
1734                  * something is wrong.  Bring the link down and reconfigure.
1735                  */
1736                 if (local_adv != ADVERTISE_PAUSE_CAP) {
1737                         current_link_up = 0;
1738                 } else {
1739                         tg3_setup_flow_control(tp, local_adv, remote_adv);
1740                 }
1741         }
1742 relink:
1743         if (current_link_up == 0) {
1744                 u32 tmp;
1745
1746                 tg3_phy_copper_begin(tp);
1747
1748                 tg3_readphy(tp, MII_BMSR, &tmp);
1749                 if (!tg3_readphy(tp, MII_BMSR, &tmp) &&
1750                     (tmp & BMSR_LSTATUS))
1751                         current_link_up = 1;
1752         }
1753
1754         tp->mac_mode &= ~MAC_MODE_PORT_MODE_MASK;
1755         if (current_link_up == 1) {
1756                 if (tp->link_config.active_speed == SPEED_100 ||
1757                     tp->link_config.active_speed == SPEED_10)
1758                         tp->mac_mode |= MAC_MODE_PORT_MODE_MII;
1759                 else
1760                         tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
1761         } else
1762                 tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
1763
1764         tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX;
1765         if (tp->link_config.active_duplex == DUPLEX_HALF)
1766                 tp->mac_mode |= MAC_MODE_HALF_DUPLEX;
1767
1768         tp->mac_mode &= ~MAC_MODE_LINK_POLARITY;
1769         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) {
1770                 if ((tp->led_ctrl == LED_CTRL_MODE_PHY_2) ||
1771                     (current_link_up == 1 &&
1772                      tp->link_config.active_speed == SPEED_10))
1773                         tp->mac_mode |= MAC_MODE_LINK_POLARITY;
1774         } else {
1775                 if (current_link_up == 1)
1776                         tp->mac_mode |= MAC_MODE_LINK_POLARITY;
1777         }
1778
1779         /* ??? Without this setting Netgear GA302T PHY does not
1780          * ??? send/receive packets...
1781          */
1782         if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5411 &&
1783             tp->pci_chip_rev_id == CHIPREV_ID_5700_ALTIMA) {
1784                 tp->mi_mode |= MAC_MI_MODE_AUTO_POLL;
1785                 tw32_f(MAC_MI_MODE, tp->mi_mode);
1786                 udelay(80);
1787         }
1788
1789         tw32_f(MAC_MODE, tp->mac_mode);
1790         udelay(40);
1791
1792         if (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) {
1793                 /* Polled via timer. */
1794                 tw32_f(MAC_EVENT, 0);
1795         } else {
1796                 tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
1797         }
1798         udelay(40);
1799
1800         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 &&
1801             current_link_up == 1 &&
1802             tp->link_config.active_speed == SPEED_1000 &&
1803             ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) ||
1804              (tp->tg3_flags & TG3_FLAG_PCI_HIGH_SPEED))) {
1805                 udelay(120);
1806                 tw32_f(MAC_STATUS,
1807                      (MAC_STATUS_SYNC_CHANGED |
1808                       MAC_STATUS_CFG_CHANGED));
1809                 udelay(40);
1810                 tg3_write_mem(tp,
1811                               NIC_SRAM_FIRMWARE_MBOX,
1812                               NIC_SRAM_FIRMWARE_MBOX_MAGIC2);
1813         }
1814
1815         if (current_link_up != netif_carrier_ok(tp->dev)) {
1816                 if (current_link_up)
1817                         netif_carrier_on(tp->dev);
1818                 else
1819                         netif_carrier_off(tp->dev);
1820                 tg3_link_report(tp);
1821         }
1822
1823         return 0;
1824 }
1825
1826 struct tg3_fiber_aneginfo {
1827         int state;
1828 #define ANEG_STATE_UNKNOWN              0
1829 #define ANEG_STATE_AN_ENABLE            1
1830 #define ANEG_STATE_RESTART_INIT         2
1831 #define ANEG_STATE_RESTART              3
1832 #define ANEG_STATE_DISABLE_LINK_OK      4
1833 #define ANEG_STATE_ABILITY_DETECT_INIT  5
1834 #define ANEG_STATE_ABILITY_DETECT       6
1835 #define ANEG_STATE_ACK_DETECT_INIT      7
1836 #define ANEG_STATE_ACK_DETECT           8
1837 #define ANEG_STATE_COMPLETE_ACK_INIT    9
1838 #define ANEG_STATE_COMPLETE_ACK         10
1839 #define ANEG_STATE_IDLE_DETECT_INIT     11
1840 #define ANEG_STATE_IDLE_DETECT          12
1841 #define ANEG_STATE_LINK_OK              13
1842 #define ANEG_STATE_NEXT_PAGE_WAIT_INIT  14
1843 #define ANEG_STATE_NEXT_PAGE_WAIT       15
1844
1845         u32 flags;
1846 #define MR_AN_ENABLE            0x00000001
1847 #define MR_RESTART_AN           0x00000002
1848 #define MR_AN_COMPLETE          0x00000004
1849 #define MR_PAGE_RX              0x00000008
1850 #define MR_NP_LOADED            0x00000010
1851 #define MR_TOGGLE_TX            0x00000020
1852 #define MR_LP_ADV_FULL_DUPLEX   0x00000040
1853 #define MR_LP_ADV_HALF_DUPLEX   0x00000080
1854 #define MR_LP_ADV_SYM_PAUSE     0x00000100
1855 #define MR_LP_ADV_ASYM_PAUSE    0x00000200
1856 #define MR_LP_ADV_REMOTE_FAULT1 0x00000400
1857 #define MR_LP_ADV_REMOTE_FAULT2 0x00000800
1858 #define MR_LP_ADV_NEXT_PAGE     0x00001000
1859 #define MR_TOGGLE_RX            0x00002000
1860 #define MR_NP_RX                0x00004000
1861
1862 #define MR_LINK_OK              0x80000000
1863
1864         unsigned long link_time, cur_time;
1865
1866         u32 ability_match_cfg;
1867         int ability_match_count;
1868
1869         char ability_match, idle_match, ack_match;
1870
1871         u32 txconfig, rxconfig;
1872 #define ANEG_CFG_NP             0x00000080
1873 #define ANEG_CFG_ACK            0x00000040
1874 #define ANEG_CFG_RF2            0x00000020
1875 #define ANEG_CFG_RF1            0x00000010
1876 #define ANEG_CFG_PS2            0x00000001
1877 #define ANEG_CFG_PS1            0x00008000
1878 #define ANEG_CFG_HD             0x00004000
1879 #define ANEG_CFG_FD             0x00002000
1880 #define ANEG_CFG_INVAL          0x00001f06
1881
1882 };
1883 #define ANEG_OK         0
1884 #define ANEG_DONE       1
1885 #define ANEG_TIMER_ENAB 2
1886 #define ANEG_FAILED     -1
1887
1888 #define ANEG_STATE_SETTLE_TIME  10000
1889
1890 static int tg3_fiber_aneg_smachine(struct tg3 *tp,
1891                                    struct tg3_fiber_aneginfo *ap)
1892 {
1893         unsigned long delta;
1894         u32 rx_cfg_reg;
1895         int ret;
1896
1897         if (ap->state == ANEG_STATE_UNKNOWN) {
1898                 ap->rxconfig = 0;
1899                 ap->link_time = 0;
1900                 ap->cur_time = 0;
1901                 ap->ability_match_cfg = 0;
1902                 ap->ability_match_count = 0;
1903                 ap->ability_match = 0;
1904                 ap->idle_match = 0;
1905                 ap->ack_match = 0;
1906         }
1907         ap->cur_time++;
1908
1909         if (tr32(MAC_STATUS) & MAC_STATUS_RCVD_CFG) {
1910                 rx_cfg_reg = tr32(MAC_RX_AUTO_NEG);
1911
1912                 if (rx_cfg_reg != ap->ability_match_cfg) {
1913                         ap->ability_match_cfg = rx_cfg_reg;
1914                         ap->ability_match = 0;
1915                         ap->ability_match_count = 0;
1916                 } else {
1917                         if (++ap->ability_match_count > 1) {
1918                                 ap->ability_match = 1;
1919                                 ap->ability_match_cfg = rx_cfg_reg;
1920                         }
1921                 }
1922                 if (rx_cfg_reg & ANEG_CFG_ACK)
1923                         ap->ack_match = 1;
1924                 else
1925                         ap->ack_match = 0;
1926
1927                 ap->idle_match = 0;
1928         } else {
1929                 ap->idle_match = 1;
1930                 ap->ability_match_cfg = 0;
1931                 ap->ability_match_count = 0;
1932                 ap->ability_match = 0;
1933                 ap->ack_match = 0;
1934
1935                 rx_cfg_reg = 0;
1936         }
1937
1938         ap->rxconfig = rx_cfg_reg;
1939         ret = ANEG_OK;
1940
1941         switch(ap->state) {
1942         case ANEG_STATE_UNKNOWN:
1943                 if (ap->flags & (MR_AN_ENABLE | MR_RESTART_AN))
1944                         ap->state = ANEG_STATE_AN_ENABLE;
1945
1946                 /* fallthru */
1947         case ANEG_STATE_AN_ENABLE:
1948                 ap->flags &= ~(MR_AN_COMPLETE | MR_PAGE_RX);
1949                 if (ap->flags & MR_AN_ENABLE) {
1950                         ap->link_time = 0;
1951                         ap->cur_time = 0;
1952                         ap->ability_match_cfg = 0;
1953                         ap->ability_match_count = 0;
1954                         ap->ability_match = 0;
1955                         ap->idle_match = 0;
1956                         ap->ack_match = 0;
1957
1958                         ap->state = ANEG_STATE_RESTART_INIT;
1959                 } else {
1960                         ap->state = ANEG_STATE_DISABLE_LINK_OK;
1961                 }
1962                 break;
1963
1964         case ANEG_STATE_RESTART_INIT:
1965                 ap->link_time = ap->cur_time;
1966                 ap->flags &= ~(MR_NP_LOADED);
1967                 ap->txconfig = 0;
1968                 tw32(MAC_TX_AUTO_NEG, 0);
1969                 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
1970                 tw32_f(MAC_MODE, tp->mac_mode);
1971                 udelay(40);
1972
1973                 ret = ANEG_TIMER_ENAB;
1974                 ap->state = ANEG_STATE_RESTART;
1975
1976                 /* fallthru */
1977         case ANEG_STATE_RESTART:
1978                 delta = ap->cur_time - ap->link_time;
1979                 if (delta > ANEG_STATE_SETTLE_TIME) {
1980                         ap->state = ANEG_STATE_ABILITY_DETECT_INIT;
1981                 } else {
1982                         ret = ANEG_TIMER_ENAB;
1983                 }
1984                 break;
1985
1986         case ANEG_STATE_DISABLE_LINK_OK:
1987                 ret = ANEG_DONE;
1988                 break;
1989
1990         case ANEG_STATE_ABILITY_DETECT_INIT:
1991                 ap->flags &= ~(MR_TOGGLE_TX);
1992                 ap->txconfig = (ANEG_CFG_FD | ANEG_CFG_PS1);
1993                 tw32(MAC_TX_AUTO_NEG, ap->txconfig);
1994                 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
1995                 tw32_f(MAC_MODE, tp->mac_mode);
1996                 udelay(40);
1997
1998                 ap->state = ANEG_STATE_ABILITY_DETECT;
1999                 break;
2000
2001         case ANEG_STATE_ABILITY_DETECT:
2002                 if (ap->ability_match != 0 && ap->rxconfig != 0) {
2003                         ap->state = ANEG_STATE_ACK_DETECT_INIT;
2004                 }
2005                 break;
2006
2007         case ANEG_STATE_ACK_DETECT_INIT:
2008                 ap->txconfig |= ANEG_CFG_ACK;
2009                 tw32(MAC_TX_AUTO_NEG, ap->txconfig);
2010                 tp->mac_mode |= MAC_MODE_SEND_CONFIGS;
2011                 tw32_f(MAC_MODE, tp->mac_mode);
2012                 udelay(40);
2013
2014                 ap->state = ANEG_STATE_ACK_DETECT;
2015
2016                 /* fallthru */
2017         case ANEG_STATE_ACK_DETECT:
2018                 if (ap->ack_match != 0) {
2019                         if ((ap->rxconfig & ~ANEG_CFG_ACK) ==
2020                             (ap->ability_match_cfg & ~ANEG_CFG_ACK)) {
2021                                 ap->state = ANEG_STATE_COMPLETE_ACK_INIT;
2022                         } else {
2023                                 ap->state = ANEG_STATE_AN_ENABLE;
2024                         }
2025                 } else if (ap->ability_match != 0 &&
2026                            ap->rxconfig == 0) {
2027                         ap->state = ANEG_STATE_AN_ENABLE;
2028                 }
2029                 break;
2030
2031         case ANEG_STATE_COMPLETE_ACK_INIT:
2032                 if (ap->rxconfig & ANEG_CFG_INVAL) {
2033                         ret = ANEG_FAILED;
2034                         break;
2035                 }
2036                 ap->flags &= ~(MR_LP_ADV_FULL_DUPLEX |
2037                                MR_LP_ADV_HALF_DUPLEX |
2038                                MR_LP_ADV_SYM_PAUSE |
2039                                MR_LP_ADV_ASYM_PAUSE |
2040                                MR_LP_ADV_REMOTE_FAULT1 |
2041                                MR_LP_ADV_REMOTE_FAULT2 |
2042                                MR_LP_ADV_NEXT_PAGE |
2043                                MR_TOGGLE_RX |
2044                                MR_NP_RX);
2045                 if (ap->rxconfig & ANEG_CFG_FD)
2046                         ap->flags |= MR_LP_ADV_FULL_DUPLEX;
2047                 if (ap->rxconfig & ANEG_CFG_HD)
2048                         ap->flags |= MR_LP_ADV_HALF_DUPLEX;
2049                 if (ap->rxconfig & ANEG_CFG_PS1)
2050                         ap->flags |= MR_LP_ADV_SYM_PAUSE;
2051                 if (ap->rxconfig & ANEG_CFG_PS2)
2052                         ap->flags |= MR_LP_ADV_ASYM_PAUSE;
2053                 if (ap->rxconfig & ANEG_CFG_RF1)
2054                         ap->flags |= MR_LP_ADV_REMOTE_FAULT1;
2055                 if (ap->rxconfig & ANEG_CFG_RF2)
2056                         ap->flags |= MR_LP_ADV_REMOTE_FAULT2;
2057                 if (ap->rxconfig & ANEG_CFG_NP)
2058                         ap->flags |= MR_LP_ADV_NEXT_PAGE;
2059
2060                 ap->link_time = ap->cur_time;
2061
2062                 ap->flags ^= (MR_TOGGLE_TX);
2063                 if (ap->rxconfig & 0x0008)
2064                         ap->flags |= MR_TOGGLE_RX;
2065                 if (ap->rxconfig & ANEG_CFG_NP)
2066                         ap->flags |= MR_NP_RX;
2067                 ap->flags |= MR_PAGE_RX;
2068
2069                 ap->state = ANEG_STATE_COMPLETE_ACK;
2070                 ret = ANEG_TIMER_ENAB;
2071                 break;
2072
2073         case ANEG_STATE_COMPLETE_ACK:
2074                 if (ap->ability_match != 0 &&
2075                     ap->rxconfig == 0) {
2076                         ap->state = ANEG_STATE_AN_ENABLE;
2077                         break;
2078                 }
2079                 delta = ap->cur_time - ap->link_time;
2080                 if (delta > ANEG_STATE_SETTLE_TIME) {
2081                         if (!(ap->flags & (MR_LP_ADV_NEXT_PAGE))) {
2082                                 ap->state = ANEG_STATE_IDLE_DETECT_INIT;
2083                         } else {
2084                                 if ((ap->txconfig & ANEG_CFG_NP) == 0 &&
2085                                     !(ap->flags & MR_NP_RX)) {
2086                                         ap->state = ANEG_STATE_IDLE_DETECT_INIT;
2087                                 } else {
2088                                         ret = ANEG_FAILED;
2089                                 }
2090                         }
2091                 }
2092                 break;
2093
2094         case ANEG_STATE_IDLE_DETECT_INIT:
2095                 ap->link_time = ap->cur_time;
2096                 tp->mac_mode &= ~MAC_MODE_SEND_CONFIGS;
2097                 tw32_f(MAC_MODE, tp->mac_mode);
2098                 udelay(40);
2099
2100                 ap->state = ANEG_STATE_IDLE_DETECT;
2101                 ret = ANEG_TIMER_ENAB;
2102                 break;
2103
2104         case ANEG_STATE_IDLE_DETECT:
2105                 if (ap->ability_match != 0 &&
2106                     ap->rxconfig == 0) {
2107                         ap->state = ANEG_STATE_AN_ENABLE;
2108                         break;
2109                 }
2110                 delta = ap->cur_time - ap->link_time;
2111                 if (delta > ANEG_STATE_SETTLE_TIME) {
2112                         /* XXX another gem from the Broadcom driver :( */
2113                         ap->state = ANEG_STATE_LINK_OK;
2114                 }
2115                 break;
2116
2117         case ANEG_STATE_LINK_OK:
2118                 ap->flags |= (MR_AN_COMPLETE | MR_LINK_OK);
2119                 ret = ANEG_DONE;
2120                 break;
2121
2122         case ANEG_STATE_NEXT_PAGE_WAIT_INIT:
2123                 /* ??? unimplemented */
2124                 break;
2125
2126         case ANEG_STATE_NEXT_PAGE_WAIT:
2127                 /* ??? unimplemented */
2128                 break;
2129
2130         default:
2131                 ret = ANEG_FAILED;
2132                 break;
2133         };
2134
2135         return ret;
2136 }
2137
2138 static int fiber_autoneg(struct tg3 *tp, u32 *flags)
2139 {
2140         int res = 0;
2141         struct tg3_fiber_aneginfo aninfo;
2142         int status = ANEG_FAILED;
2143         unsigned int tick;
2144         u32 tmp;
2145
2146         tw32_f(MAC_TX_AUTO_NEG, 0);
2147
2148         tmp = tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK;
2149         tw32_f(MAC_MODE, tmp | MAC_MODE_PORT_MODE_GMII);
2150         udelay(40);
2151
2152         tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_SEND_CONFIGS);
2153         udelay(40);
2154
2155         memset(&aninfo, 0, sizeof(aninfo));
2156         aninfo.flags |= MR_AN_ENABLE;
2157         aninfo.state = ANEG_STATE_UNKNOWN;
2158         aninfo.cur_time = 0;
2159         tick = 0;
2160         while (++tick < 195000) {
2161                 status = tg3_fiber_aneg_smachine(tp, &aninfo);
2162                 if (status == ANEG_DONE || status == ANEG_FAILED)
2163                         break;
2164
2165                 udelay(1);
2166         }
2167
2168         tp->mac_mode &= ~MAC_MODE_SEND_CONFIGS;
2169         tw32_f(MAC_MODE, tp->mac_mode);
2170         udelay(40);
2171
2172         *flags = aninfo.flags;
2173
2174         if (status == ANEG_DONE &&
2175             (aninfo.flags & (MR_AN_COMPLETE | MR_LINK_OK |
2176                              MR_LP_ADV_FULL_DUPLEX)))
2177                 res = 1;
2178
2179         return res;
2180 }
2181
2182 static void tg3_init_bcm8002(struct tg3 *tp)
2183 {
2184         u32 mac_status = tr32(MAC_STATUS);
2185         int i;
2186
2187         /* Reset when initting first time or we have a link. */
2188         if ((tp->tg3_flags & TG3_FLAG_INIT_COMPLETE) &&
2189             !(mac_status & MAC_STATUS_PCS_SYNCED))
2190                 return;
2191
2192         /* Set PLL lock range. */
2193         tg3_writephy(tp, 0x16, 0x8007);
2194
2195         /* SW reset */
2196         tg3_writephy(tp, MII_BMCR, BMCR_RESET);
2197
2198         /* Wait for reset to complete. */
2199         /* XXX schedule_timeout() ... */
2200         for (i = 0; i < 500; i++)
2201                 udelay(10);
2202
2203         /* Config mode; select PMA/Ch 1 regs. */
2204         tg3_writephy(tp, 0x10, 0x8411);
2205
2206         /* Enable auto-lock and comdet, select txclk for tx. */
2207         tg3_writephy(tp, 0x11, 0x0a10);
2208
2209         tg3_writephy(tp, 0x18, 0x00a0);
2210         tg3_writephy(tp, 0x16, 0x41ff);
2211
2212         /* Assert and deassert POR. */
2213         tg3_writephy(tp, 0x13, 0x0400);
2214         udelay(40);
2215         tg3_writephy(tp, 0x13, 0x0000);
2216
2217         tg3_writephy(tp, 0x11, 0x0a50);
2218         udelay(40);
2219         tg3_writephy(tp, 0x11, 0x0a10);
2220
2221         /* Wait for signal to stabilize */
2222         /* XXX schedule_timeout() ... */
2223         for (i = 0; i < 15000; i++)
2224                 udelay(10);
2225
2226         /* Deselect the channel register so we can read the PHYID
2227          * later.
2228          */
2229         tg3_writephy(tp, 0x10, 0x8011);
2230 }
2231
2232 static int tg3_setup_fiber_hw_autoneg(struct tg3 *tp, u32 mac_status)
2233 {
2234         u32 sg_dig_ctrl, sg_dig_status;
2235         u32 serdes_cfg, expected_sg_dig_ctrl;
2236         int workaround, port_a;
2237         int current_link_up;
2238
2239         serdes_cfg = 0;
2240         expected_sg_dig_ctrl = 0;
2241         workaround = 0;
2242         port_a = 1;
2243         current_link_up = 0;
2244
2245         if (tp->pci_chip_rev_id != CHIPREV_ID_5704_A0 &&
2246             tp->pci_chip_rev_id != CHIPREV_ID_5704_A1) {
2247                 workaround = 1;
2248                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
2249                         port_a = 0;
2250
2251                 /* preserve bits 0-11,13,14 for signal pre-emphasis */
2252                 /* preserve bits 20-23 for voltage regulator */
2253                 serdes_cfg = tr32(MAC_SERDES_CFG) & 0x00f06fff;
2254         }
2255
2256         sg_dig_ctrl = tr32(SG_DIG_CTRL);
2257
2258         if (tp->link_config.autoneg != AUTONEG_ENABLE) {
2259                 if (sg_dig_ctrl & (1 << 31)) {
2260                         if (workaround) {
2261                                 u32 val = serdes_cfg;
2262
2263                                 if (port_a)
2264                                         val |= 0xc010000;
2265                                 else
2266                                         val |= 0x4010000;
2267                                 tw32_f(MAC_SERDES_CFG, val);
2268                         }
2269                         tw32_f(SG_DIG_CTRL, 0x01388400);
2270                 }
2271                 if (mac_status & MAC_STATUS_PCS_SYNCED) {
2272                         tg3_setup_flow_control(tp, 0, 0);
2273                         current_link_up = 1;
2274                 }
2275                 goto out;
2276         }
2277
2278         /* Want auto-negotiation.  */
2279         expected_sg_dig_ctrl = 0x81388400;
2280
2281         /* Pause capability */
2282         expected_sg_dig_ctrl |= (1 << 11);
2283
2284         /* Asymettric pause */
2285         expected_sg_dig_ctrl |= (1 << 12);
2286
2287         if (sg_dig_ctrl != expected_sg_dig_ctrl) {
2288                 if (workaround)
2289                         tw32_f(MAC_SERDES_CFG, serdes_cfg | 0xc011000);
2290                 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl | (1 << 30));
2291                 udelay(5);
2292                 tw32_f(SG_DIG_CTRL, expected_sg_dig_ctrl);
2293
2294                 tp->tg3_flags2 |= TG3_FLG2_PHY_JUST_INITTED;
2295         } else if (mac_status & (MAC_STATUS_PCS_SYNCED |
2296                                  MAC_STATUS_SIGNAL_DET)) {
2297                 int i;
2298
2299                 /* Giver time to negotiate (~200ms) */
2300                 for (i = 0; i < 40000; i++) {
2301                         sg_dig_status = tr32(SG_DIG_STATUS);
2302                         if (sg_dig_status & (0x3))
2303                                 break;
2304                         udelay(5);
2305                 }
2306                 mac_status = tr32(MAC_STATUS);
2307
2308                 if ((sg_dig_status & (1 << 1)) &&
2309                     (mac_status & MAC_STATUS_PCS_SYNCED)) {
2310                         u32 local_adv, remote_adv;
2311
2312                         local_adv = ADVERTISE_PAUSE_CAP;
2313                         remote_adv = 0;
2314                         if (sg_dig_status & (1 << 19))
2315                                 remote_adv |= LPA_PAUSE_CAP;
2316                         if (sg_dig_status & (1 << 20))
2317                                 remote_adv |= LPA_PAUSE_ASYM;
2318
2319                         tg3_setup_flow_control(tp, local_adv, remote_adv);
2320                         current_link_up = 1;
2321                         tp->tg3_flags2 &= ~TG3_FLG2_PHY_JUST_INITTED;
2322                 } else if (!(sg_dig_status & (1 << 1))) {
2323                         if (tp->tg3_flags2 & TG3_FLG2_PHY_JUST_INITTED)
2324                                 tp->tg3_flags2 &= ~TG3_FLG2_PHY_JUST_INITTED;
2325                         else {
2326                                 if (workaround) {
2327                                         u32 val = serdes_cfg;
2328
2329                                         if (port_a)
2330                                                 val |= 0xc010000;
2331                                         else
2332                                                 val |= 0x4010000;
2333
2334                                         tw32_f(MAC_SERDES_CFG, val);
2335                                 }
2336
2337                                 tw32_f(SG_DIG_CTRL, 0x01388400);
2338                                 udelay(40);
2339
2340                                 /* Link parallel detection - link is up */
2341                                 /* only if we have PCS_SYNC and not */
2342                                 /* receiving config code words */
2343                                 mac_status = tr32(MAC_STATUS);
2344                                 if ((mac_status & MAC_STATUS_PCS_SYNCED) &&
2345                                     !(mac_status & MAC_STATUS_RCVD_CFG)) {
2346                                         tg3_setup_flow_control(tp, 0, 0);
2347                                         current_link_up = 1;
2348                                 }
2349                         }
2350                 }
2351         }
2352
2353 out:
2354         return current_link_up;
2355 }
2356
2357 static int tg3_setup_fiber_by_hand(struct tg3 *tp, u32 mac_status)
2358 {
2359         int current_link_up = 0;
2360
2361         if (!(mac_status & MAC_STATUS_PCS_SYNCED)) {
2362                 tp->tg3_flags &= ~TG3_FLAG_GOT_SERDES_FLOWCTL;
2363                 goto out;
2364         }
2365
2366         if (tp->link_config.autoneg == AUTONEG_ENABLE) {
2367                 u32 flags;
2368                 int i;
2369
2370                 if (fiber_autoneg(tp, &flags)) {
2371                         u32 local_adv, remote_adv;
2372
2373                         local_adv = ADVERTISE_PAUSE_CAP;
2374                         remote_adv = 0;
2375                         if (flags & MR_LP_ADV_SYM_PAUSE)
2376                                 remote_adv |= LPA_PAUSE_CAP;
2377                         if (flags & MR_LP_ADV_ASYM_PAUSE)
2378                                 remote_adv |= LPA_PAUSE_ASYM;
2379
2380                         tg3_setup_flow_control(tp, local_adv, remote_adv);
2381
2382                         tp->tg3_flags |= TG3_FLAG_GOT_SERDES_FLOWCTL;
2383                         current_link_up = 1;
2384                 }
2385                 for (i = 0; i < 30; i++) {
2386                         udelay(20);
2387                         tw32_f(MAC_STATUS,
2388                                (MAC_STATUS_SYNC_CHANGED |
2389                                 MAC_STATUS_CFG_CHANGED));
2390                         udelay(40);
2391                         if ((tr32(MAC_STATUS) &
2392                              (MAC_STATUS_SYNC_CHANGED |
2393                               MAC_STATUS_CFG_CHANGED)) == 0)
2394                                 break;
2395                 }
2396
2397                 mac_status = tr32(MAC_STATUS);
2398                 if (current_link_up == 0 &&
2399                     (mac_status & MAC_STATUS_PCS_SYNCED) &&
2400                     !(mac_status & MAC_STATUS_RCVD_CFG))
2401                         current_link_up = 1;
2402         } else {
2403                 /* Forcing 1000FD link up. */
2404                 current_link_up = 1;
2405                 tp->tg3_flags |= TG3_FLAG_GOT_SERDES_FLOWCTL;
2406
2407                 tw32_f(MAC_MODE, (tp->mac_mode | MAC_MODE_SEND_CONFIGS));
2408                 udelay(40);
2409         }
2410
2411 out:
2412         return current_link_up;
2413 }
2414
2415 static int tg3_setup_fiber_phy(struct tg3 *tp, int force_reset)
2416 {
2417         u32 orig_pause_cfg;
2418         u16 orig_active_speed;
2419         u8 orig_active_duplex;
2420         u32 mac_status;
2421         int current_link_up;
2422         int i;
2423
2424         orig_pause_cfg =
2425                 (tp->tg3_flags & (TG3_FLAG_RX_PAUSE |
2426                                   TG3_FLAG_TX_PAUSE));
2427         orig_active_speed = tp->link_config.active_speed;
2428         orig_active_duplex = tp->link_config.active_duplex;
2429
2430         if (!(tp->tg3_flags2 & TG3_FLG2_HW_AUTONEG) &&
2431             netif_carrier_ok(tp->dev) &&
2432             (tp->tg3_flags & TG3_FLAG_INIT_COMPLETE)) {
2433                 mac_status = tr32(MAC_STATUS);
2434                 mac_status &= (MAC_STATUS_PCS_SYNCED |
2435                                MAC_STATUS_SIGNAL_DET |
2436                                MAC_STATUS_CFG_CHANGED |
2437                                MAC_STATUS_RCVD_CFG);
2438                 if (mac_status == (MAC_STATUS_PCS_SYNCED |
2439                                    MAC_STATUS_SIGNAL_DET)) {
2440                         tw32_f(MAC_STATUS, (MAC_STATUS_SYNC_CHANGED |
2441                                             MAC_STATUS_CFG_CHANGED));
2442                         return 0;
2443                 }
2444         }
2445
2446         tw32_f(MAC_TX_AUTO_NEG, 0);
2447
2448         tp->mac_mode &= ~(MAC_MODE_PORT_MODE_MASK | MAC_MODE_HALF_DUPLEX);
2449         tp->mac_mode |= MAC_MODE_PORT_MODE_TBI;
2450         tw32_f(MAC_MODE, tp->mac_mode);
2451         udelay(40);
2452
2453         if (tp->phy_id == PHY_ID_BCM8002)
2454                 tg3_init_bcm8002(tp);
2455
2456         /* Enable link change event even when serdes polling.  */
2457         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
2458         udelay(40);
2459
2460         current_link_up = 0;
2461         mac_status = tr32(MAC_STATUS);
2462
2463         if (tp->tg3_flags2 & TG3_FLG2_HW_AUTONEG)
2464                 current_link_up = tg3_setup_fiber_hw_autoneg(tp, mac_status);
2465         else
2466                 current_link_up = tg3_setup_fiber_by_hand(tp, mac_status);
2467
2468         tp->mac_mode &= ~MAC_MODE_LINK_POLARITY;
2469         tw32_f(MAC_MODE, tp->mac_mode);
2470         udelay(40);
2471
2472         tp->hw_status->status =
2473                 (SD_STATUS_UPDATED |
2474                  (tp->hw_status->status & ~SD_STATUS_LINK_CHG));
2475
2476         for (i = 0; i < 100; i++) {
2477                 tw32_f(MAC_STATUS, (MAC_STATUS_SYNC_CHANGED |
2478                                     MAC_STATUS_CFG_CHANGED));
2479                 udelay(5);
2480                 if ((tr32(MAC_STATUS) & (MAC_STATUS_SYNC_CHANGED |
2481                                          MAC_STATUS_CFG_CHANGED)) == 0)
2482                         break;
2483         }
2484
2485         mac_status = tr32(MAC_STATUS);
2486         if ((mac_status & MAC_STATUS_PCS_SYNCED) == 0) {
2487                 current_link_up = 0;
2488                 if (tp->link_config.autoneg == AUTONEG_ENABLE) {
2489                         tw32_f(MAC_MODE, (tp->mac_mode |
2490                                           MAC_MODE_SEND_CONFIGS));
2491                         udelay(1);
2492                         tw32_f(MAC_MODE, tp->mac_mode);
2493                 }
2494         }
2495
2496         if (current_link_up == 1) {
2497                 tp->link_config.active_speed = SPEED_1000;
2498                 tp->link_config.active_duplex = DUPLEX_FULL;
2499                 tw32(MAC_LED_CTRL, (tp->led_ctrl |
2500                                     LED_CTRL_LNKLED_OVERRIDE |
2501                                     LED_CTRL_1000MBPS_ON));
2502         } else {
2503                 tp->link_config.active_speed = SPEED_INVALID;
2504                 tp->link_config.active_duplex = DUPLEX_INVALID;
2505                 tw32(MAC_LED_CTRL, (tp->led_ctrl |
2506                                     LED_CTRL_LNKLED_OVERRIDE |
2507                                     LED_CTRL_TRAFFIC_OVERRIDE));
2508         }
2509
2510         if (current_link_up != netif_carrier_ok(tp->dev)) {
2511                 if (current_link_up)
2512                         netif_carrier_on(tp->dev);
2513                 else
2514                         netif_carrier_off(tp->dev);
2515                 tg3_link_report(tp);
2516         } else {
2517                 u32 now_pause_cfg =
2518                         tp->tg3_flags & (TG3_FLAG_RX_PAUSE |
2519                                          TG3_FLAG_TX_PAUSE);
2520                 if (orig_pause_cfg != now_pause_cfg ||
2521                     orig_active_speed != tp->link_config.active_speed ||
2522                     orig_active_duplex != tp->link_config.active_duplex)
2523                         tg3_link_report(tp);
2524         }
2525
2526         return 0;
2527 }
2528
2529 static int tg3_setup_fiber_mii_phy(struct tg3 *tp, int force_reset)
2530 {
2531         int current_link_up, err = 0;
2532         u32 bmsr, bmcr;
2533         u16 current_speed;
2534         u8 current_duplex;
2535
2536         tp->mac_mode |= MAC_MODE_PORT_MODE_GMII;
2537         tw32_f(MAC_MODE, tp->mac_mode);
2538         udelay(40);
2539
2540         tw32(MAC_EVENT, 0);
2541
2542         tw32_f(MAC_STATUS,
2543              (MAC_STATUS_SYNC_CHANGED |
2544               MAC_STATUS_CFG_CHANGED |
2545               MAC_STATUS_MI_COMPLETION |
2546               MAC_STATUS_LNKSTATE_CHANGED));
2547         udelay(40);
2548
2549         if (force_reset)
2550                 tg3_phy_reset(tp);
2551
2552         current_link_up = 0;
2553         current_speed = SPEED_INVALID;
2554         current_duplex = DUPLEX_INVALID;
2555
2556         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
2557         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
2558
2559         err |= tg3_readphy(tp, MII_BMCR, &bmcr);
2560
2561         if ((tp->link_config.autoneg == AUTONEG_ENABLE) && !force_reset &&
2562             (tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT)) {
2563                 /* do nothing, just check for link up at the end */
2564         } else if (tp->link_config.autoneg == AUTONEG_ENABLE) {
2565                 u32 adv, new_adv;
2566
2567                 err |= tg3_readphy(tp, MII_ADVERTISE, &adv);
2568                 new_adv = adv & ~(ADVERTISE_1000XFULL | ADVERTISE_1000XHALF |
2569                                   ADVERTISE_1000XPAUSE |
2570                                   ADVERTISE_1000XPSE_ASYM |
2571                                   ADVERTISE_SLCT);
2572
2573                 /* Always advertise symmetric PAUSE just like copper */
2574                 new_adv |= ADVERTISE_1000XPAUSE;
2575
2576                 if (tp->link_config.advertising & ADVERTISED_1000baseT_Half)
2577                         new_adv |= ADVERTISE_1000XHALF;
2578                 if (tp->link_config.advertising & ADVERTISED_1000baseT_Full)
2579                         new_adv |= ADVERTISE_1000XFULL;
2580
2581                 if ((new_adv != adv) || !(bmcr & BMCR_ANENABLE)) {
2582                         tg3_writephy(tp, MII_ADVERTISE, new_adv);
2583                         bmcr |= BMCR_ANENABLE | BMCR_ANRESTART;
2584                         tg3_writephy(tp, MII_BMCR, bmcr);
2585
2586                         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
2587                         tp->tg3_flags2 |= TG3_FLG2_PHY_JUST_INITTED;
2588                         tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2589
2590                         return err;
2591                 }
2592         } else {
2593                 u32 new_bmcr;
2594
2595                 bmcr &= ~BMCR_SPEED1000;
2596                 new_bmcr = bmcr & ~(BMCR_ANENABLE | BMCR_FULLDPLX);
2597
2598                 if (tp->link_config.duplex == DUPLEX_FULL)
2599                         new_bmcr |= BMCR_FULLDPLX;
2600
2601                 if (new_bmcr != bmcr) {
2602                         /* BMCR_SPEED1000 is a reserved bit that needs
2603                          * to be set on write.
2604                          */
2605                         new_bmcr |= BMCR_SPEED1000;
2606
2607                         /* Force a linkdown */
2608                         if (netif_carrier_ok(tp->dev)) {
2609                                 u32 adv;
2610
2611                                 err |= tg3_readphy(tp, MII_ADVERTISE, &adv);
2612                                 adv &= ~(ADVERTISE_1000XFULL |
2613                                          ADVERTISE_1000XHALF |
2614                                          ADVERTISE_SLCT);
2615                                 tg3_writephy(tp, MII_ADVERTISE, adv);
2616                                 tg3_writephy(tp, MII_BMCR, bmcr |
2617                                                            BMCR_ANRESTART |
2618                                                            BMCR_ANENABLE);
2619                                 udelay(10);
2620                                 netif_carrier_off(tp->dev);
2621                         }
2622                         tg3_writephy(tp, MII_BMCR, new_bmcr);
2623                         bmcr = new_bmcr;
2624                         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
2625                         err |= tg3_readphy(tp, MII_BMSR, &bmsr);
2626                         tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2627                 }
2628         }
2629
2630         if (bmsr & BMSR_LSTATUS) {
2631                 current_speed = SPEED_1000;
2632                 current_link_up = 1;
2633                 if (bmcr & BMCR_FULLDPLX)
2634                         current_duplex = DUPLEX_FULL;
2635                 else
2636                         current_duplex = DUPLEX_HALF;
2637
2638                 if (bmcr & BMCR_ANENABLE) {
2639                         u32 local_adv, remote_adv, common;
2640
2641                         err |= tg3_readphy(tp, MII_ADVERTISE, &local_adv);
2642                         err |= tg3_readphy(tp, MII_LPA, &remote_adv);
2643                         common = local_adv & remote_adv;
2644                         if (common & (ADVERTISE_1000XHALF |
2645                                       ADVERTISE_1000XFULL)) {
2646                                 if (common & ADVERTISE_1000XFULL)
2647                                         current_duplex = DUPLEX_FULL;
2648                                 else
2649                                         current_duplex = DUPLEX_HALF;
2650
2651                                 tg3_setup_flow_control(tp, local_adv,
2652                                                        remote_adv);
2653                         }
2654                         else
2655                                 current_link_up = 0;
2656                 }
2657         }
2658
2659         tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX;
2660         if (tp->link_config.active_duplex == DUPLEX_HALF)
2661                 tp->mac_mode |= MAC_MODE_HALF_DUPLEX;
2662
2663         tw32_f(MAC_MODE, tp->mac_mode);
2664         udelay(40);
2665
2666         tw32_f(MAC_EVENT, MAC_EVENT_LNKSTATE_CHANGED);
2667
2668         tp->link_config.active_speed = current_speed;
2669         tp->link_config.active_duplex = current_duplex;
2670
2671         if (current_link_up != netif_carrier_ok(tp->dev)) {
2672                 if (current_link_up)
2673                         netif_carrier_on(tp->dev);
2674                 else {
2675                         netif_carrier_off(tp->dev);
2676                         tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2677                 }
2678                 tg3_link_report(tp);
2679         }
2680         return err;
2681 }
2682
2683 static void tg3_serdes_parallel_detect(struct tg3 *tp)
2684 {
2685         if (tp->tg3_flags2 & TG3_FLG2_PHY_JUST_INITTED) {
2686                 /* Give autoneg time to complete. */
2687                 tp->tg3_flags2 &= ~TG3_FLG2_PHY_JUST_INITTED;
2688                 return;
2689         }
2690         if (!netif_carrier_ok(tp->dev) &&
2691             (tp->link_config.autoneg == AUTONEG_ENABLE)) {
2692                 u32 bmcr;
2693
2694                 tg3_readphy(tp, MII_BMCR, &bmcr);
2695                 if (bmcr & BMCR_ANENABLE) {
2696                         u32 phy1, phy2;
2697
2698                         /* Select shadow register 0x1f */
2699                         tg3_writephy(tp, 0x1c, 0x7c00);
2700                         tg3_readphy(tp, 0x1c, &phy1);
2701
2702                         /* Select expansion interrupt status register */
2703                         tg3_writephy(tp, 0x17, 0x0f01);
2704                         tg3_readphy(tp, 0x15, &phy2);
2705                         tg3_readphy(tp, 0x15, &phy2);
2706
2707                         if ((phy1 & 0x10) && !(phy2 & 0x20)) {
2708                                 /* We have signal detect and not receiving
2709                                  * config code words, link is up by parallel
2710                                  * detection.
2711                                  */
2712
2713                                 bmcr &= ~BMCR_ANENABLE;
2714                                 bmcr |= BMCR_SPEED1000 | BMCR_FULLDPLX;
2715                                 tg3_writephy(tp, MII_BMCR, bmcr);
2716                                 tp->tg3_flags2 |= TG3_FLG2_PARALLEL_DETECT;
2717                         }
2718                 }
2719         }
2720         else if (netif_carrier_ok(tp->dev) &&
2721                  (tp->link_config.autoneg == AUTONEG_ENABLE) &&
2722                  (tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT)) {
2723                 u32 phy2;
2724
2725                 /* Select expansion interrupt status register */
2726                 tg3_writephy(tp, 0x17, 0x0f01);
2727                 tg3_readphy(tp, 0x15, &phy2);
2728                 if (phy2 & 0x20) {
2729                         u32 bmcr;
2730
2731                         /* Config code words received, turn on autoneg. */
2732                         tg3_readphy(tp, MII_BMCR, &bmcr);
2733                         tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANENABLE);
2734
2735                         tp->tg3_flags2 &= ~TG3_FLG2_PARALLEL_DETECT;
2736
2737                 }
2738         }
2739 }
2740
2741 static int tg3_setup_phy(struct tg3 *tp, int force_reset)
2742 {
2743         int err;
2744
2745         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
2746                 err = tg3_setup_fiber_phy(tp, force_reset);
2747         } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
2748                 err = tg3_setup_fiber_mii_phy(tp, force_reset);
2749         } else {
2750                 err = tg3_setup_copper_phy(tp, force_reset);
2751         }
2752
2753         if (tp->link_config.active_speed == SPEED_1000 &&
2754             tp->link_config.active_duplex == DUPLEX_HALF)
2755                 tw32(MAC_TX_LENGTHS,
2756                      ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
2757                       (6 << TX_LENGTHS_IPG_SHIFT) |
2758                       (0xff << TX_LENGTHS_SLOT_TIME_SHIFT)));
2759         else
2760                 tw32(MAC_TX_LENGTHS,
2761                      ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
2762                       (6 << TX_LENGTHS_IPG_SHIFT) |
2763                       (32 << TX_LENGTHS_SLOT_TIME_SHIFT)));
2764
2765         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
2766                 if (netif_carrier_ok(tp->dev)) {
2767                         tw32(HOSTCC_STAT_COAL_TICKS,
2768                              tp->coal.stats_block_coalesce_usecs);
2769                 } else {
2770                         tw32(HOSTCC_STAT_COAL_TICKS, 0);
2771                 }
2772         }
2773
2774         return err;
2775 }
2776
2777 /* Tigon3 never reports partial packet sends.  So we do not
2778  * need special logic to handle SKBs that have not had all
2779  * of their frags sent yet, like SunGEM does.
2780  */
2781 static void tg3_tx(struct tg3 *tp)
2782 {
2783         u32 hw_idx = tp->hw_status->idx[0].tx_consumer;
2784         u32 sw_idx = tp->tx_cons;
2785
2786         while (sw_idx != hw_idx) {
2787                 struct tx_ring_info *ri = &tp->tx_buffers[sw_idx];
2788                 struct sk_buff *skb = ri->skb;
2789                 int i;
2790
2791                 if (unlikely(skb == NULL))
2792                         BUG();
2793
2794                 pci_unmap_single(tp->pdev,
2795                                  pci_unmap_addr(ri, mapping),
2796                                  skb_headlen(skb),
2797                                  PCI_DMA_TODEVICE);
2798
2799                 ri->skb = NULL;
2800
2801                 sw_idx = NEXT_TX(sw_idx);
2802
2803                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2804                         if (unlikely(sw_idx == hw_idx))
2805                                 BUG();
2806
2807                         ri = &tp->tx_buffers[sw_idx];
2808                         if (unlikely(ri->skb != NULL))
2809                                 BUG();
2810
2811                         pci_unmap_page(tp->pdev,
2812                                        pci_unmap_addr(ri, mapping),
2813                                        skb_shinfo(skb)->frags[i].size,
2814                                        PCI_DMA_TODEVICE);
2815
2816                         sw_idx = NEXT_TX(sw_idx);
2817                 }
2818
2819                 dev_kfree_skb(skb);
2820         }
2821
2822         tp->tx_cons = sw_idx;
2823
2824         if (netif_queue_stopped(tp->dev) &&
2825             (TX_BUFFS_AVAIL(tp) > TG3_TX_WAKEUP_THRESH))
2826                 netif_wake_queue(tp->dev);
2827 }
2828
2829 /* Returns size of skb allocated or < 0 on error.
2830  *
2831  * We only need to fill in the address because the other members
2832  * of the RX descriptor are invariant, see tg3_init_rings.
2833  *
2834  * Note the purposeful assymetry of cpu vs. chip accesses.  For
2835  * posting buffers we only dirty the first cache line of the RX
2836  * descriptor (containing the address).  Whereas for the RX status
2837  * buffers the cpu only reads the last cacheline of the RX descriptor
2838  * (to fetch the error flags, vlan tag, checksum, and opaque cookie).
2839  */
2840 static int tg3_alloc_rx_skb(struct tg3 *tp, u32 opaque_key,
2841                             int src_idx, u32 dest_idx_unmasked)
2842 {
2843         struct tg3_rx_buffer_desc *desc;
2844         struct ring_info *map, *src_map;
2845         struct sk_buff *skb;
2846         dma_addr_t mapping;
2847         int skb_size, dest_idx;
2848
2849         src_map = NULL;
2850         switch (opaque_key) {
2851         case RXD_OPAQUE_RING_STD:
2852                 dest_idx = dest_idx_unmasked % TG3_RX_RING_SIZE;
2853                 desc = &tp->rx_std[dest_idx];
2854                 map = &tp->rx_std_buffers[dest_idx];
2855                 if (src_idx >= 0)
2856                         src_map = &tp->rx_std_buffers[src_idx];
2857                 skb_size = tp->rx_pkt_buf_sz;
2858                 break;
2859
2860         case RXD_OPAQUE_RING_JUMBO:
2861                 dest_idx = dest_idx_unmasked % TG3_RX_JUMBO_RING_SIZE;
2862                 desc = &tp->rx_jumbo[dest_idx];
2863                 map = &tp->rx_jumbo_buffers[dest_idx];
2864                 if (src_idx >= 0)
2865                         src_map = &tp->rx_jumbo_buffers[src_idx];
2866                 skb_size = RX_JUMBO_PKT_BUF_SZ;
2867                 break;
2868
2869         default:
2870                 return -EINVAL;
2871         };
2872
2873         /* Do not overwrite any of the map or rp information
2874          * until we are sure we can commit to a new buffer.
2875          *
2876          * Callers depend upon this behavior and assume that
2877          * we leave everything unchanged if we fail.
2878          */
2879         skb = dev_alloc_skb(skb_size);
2880         if (skb == NULL)
2881                 return -ENOMEM;
2882
2883         skb->dev = tp->dev;
2884         skb_reserve(skb, tp->rx_offset);
2885
2886         mapping = pci_map_single(tp->pdev, skb->data,
2887                                  skb_size - tp->rx_offset,
2888                                  PCI_DMA_FROMDEVICE);
2889
2890         map->skb = skb;
2891         pci_unmap_addr_set(map, mapping, mapping);
2892
2893         if (src_map != NULL)
2894                 src_map->skb = NULL;
2895
2896         desc->addr_hi = ((u64)mapping >> 32);
2897         desc->addr_lo = ((u64)mapping & 0xffffffff);
2898
2899         return skb_size;
2900 }
2901
2902 /* We only need to move over in the address because the other
2903  * members of the RX descriptor are invariant.  See notes above
2904  * tg3_alloc_rx_skb for full details.
2905  */
2906 static void tg3_recycle_rx(struct tg3 *tp, u32 opaque_key,
2907                            int src_idx, u32 dest_idx_unmasked)
2908 {
2909         struct tg3_rx_buffer_desc *src_desc, *dest_desc;
2910         struct ring_info *src_map, *dest_map;
2911         int dest_idx;
2912
2913         switch (opaque_key) {
2914         case RXD_OPAQUE_RING_STD:
2915                 dest_idx = dest_idx_unmasked % TG3_RX_RING_SIZE;
2916                 dest_desc = &tp->rx_std[dest_idx];
2917                 dest_map = &tp->rx_std_buffers[dest_idx];
2918                 src_desc = &tp->rx_std[src_idx];
2919                 src_map = &tp->rx_std_buffers[src_idx];
2920                 break;
2921
2922         case RXD_OPAQUE_RING_JUMBO:
2923                 dest_idx = dest_idx_unmasked % TG3_RX_JUMBO_RING_SIZE;
2924                 dest_desc = &tp->rx_jumbo[dest_idx];
2925                 dest_map = &tp->rx_jumbo_buffers[dest_idx];
2926                 src_desc = &tp->rx_jumbo[src_idx];
2927                 src_map = &tp->rx_jumbo_buffers[src_idx];
2928                 break;
2929
2930         default:
2931                 return;
2932         };
2933
2934         dest_map->skb = src_map->skb;
2935         pci_unmap_addr_set(dest_map, mapping,
2936                            pci_unmap_addr(src_map, mapping));
2937         dest_desc->addr_hi = src_desc->addr_hi;
2938         dest_desc->addr_lo = src_desc->addr_lo;
2939
2940         src_map->skb = NULL;
2941 }
2942
2943 #if TG3_VLAN_TAG_USED
2944 static int tg3_vlan_rx(struct tg3 *tp, struct sk_buff *skb, u16 vlan_tag)
2945 {
2946         return vlan_hwaccel_receive_skb(skb, tp->vlgrp, vlan_tag);
2947 }
2948 #endif
2949
2950 /* The RX ring scheme is composed of multiple rings which post fresh
2951  * buffers to the chip, and one special ring the chip uses to report
2952  * status back to the host.
2953  *
2954  * The special ring reports the status of received packets to the
2955  * host.  The chip does not write into the original descriptor the
2956  * RX buffer was obtained from.  The chip simply takes the original
2957  * descriptor as provided by the host, updates the status and length
2958  * field, then writes this into the next status ring entry.
2959  *
2960  * Each ring the host uses to post buffers to the chip is described
2961  * by a TG3_BDINFO entry in the chips SRAM area.  When a packet arrives,
2962  * it is first placed into the on-chip ram.  When the packet's length
2963  * is known, it walks down the TG3_BDINFO entries to select the ring.
2964  * Each TG3_BDINFO specifies a MAXLEN field and the first TG3_BDINFO
2965  * which is within the range of the new packet's length is chosen.
2966  *
2967  * The "separate ring for rx status" scheme may sound queer, but it makes
2968  * sense from a cache coherency perspective.  If only the host writes
2969  * to the buffer post rings, and only the chip writes to the rx status
2970  * rings, then cache lines never move beyond shared-modified state.
2971  * If both the host and chip were to write into the same ring, cache line
2972  * eviction could occur since both entities want it in an exclusive state.
2973  */
2974 static int tg3_rx(struct tg3 *tp, int budget)
2975 {
2976         u32 work_mask;
2977         u32 sw_idx = tp->rx_rcb_ptr;
2978         u16 hw_idx;
2979         int received;
2980
2981         hw_idx = tp->hw_status->idx[0].rx_producer;
2982         /*
2983          * We need to order the read of hw_idx and the read of
2984          * the opaque cookie.
2985          */
2986         rmb();
2987         work_mask = 0;
2988         received = 0;
2989         while (sw_idx != hw_idx && budget > 0) {
2990                 struct tg3_rx_buffer_desc *desc = &tp->rx_rcb[sw_idx];
2991                 unsigned int len;
2992                 struct sk_buff *skb;
2993                 dma_addr_t dma_addr;
2994                 u32 opaque_key, desc_idx, *post_ptr;
2995
2996                 desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
2997                 opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
2998                 if (opaque_key == RXD_OPAQUE_RING_STD) {
2999                         dma_addr = pci_unmap_addr(&tp->rx_std_buffers[desc_idx],
3000                                                   mapping);
3001                         skb = tp->rx_std_buffers[desc_idx].skb;
3002                         post_ptr = &tp->rx_std_ptr;
3003                 } else if (opaque_key == RXD_OPAQUE_RING_JUMBO) {
3004                         dma_addr = pci_unmap_addr(&tp->rx_jumbo_buffers[desc_idx],
3005                                                   mapping);
3006                         skb = tp->rx_jumbo_buffers[desc_idx].skb;
3007                         post_ptr = &tp->rx_jumbo_ptr;
3008                 }
3009                 else {
3010                         goto next_pkt_nopost;
3011                 }
3012
3013                 work_mask |= opaque_key;
3014
3015                 if ((desc->err_vlan & RXD_ERR_MASK) != 0 &&
3016                     (desc->err_vlan != RXD_ERR_ODD_NIBBLE_RCVD_MII)) {
3017                 drop_it:
3018                         tg3_recycle_rx(tp, opaque_key,
3019                                        desc_idx, *post_ptr);
3020                 drop_it_no_recycle:
3021                         /* Other statistics kept track of by card. */
3022                         tp->net_stats.rx_dropped++;
3023                         goto next_pkt;
3024                 }
3025
3026                 len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT) - 4; /* omit crc */
3027
3028                 if (len > RX_COPY_THRESHOLD
3029                         && tp->rx_offset == 2
3030                         /* rx_offset != 2 iff this is a 5701 card running
3031                          * in PCI-X mode [see tg3_get_invariants()] */
3032                 ) {
3033                         int skb_size;
3034
3035                         skb_size = tg3_alloc_rx_skb(tp, opaque_key,
3036                                                     desc_idx, *post_ptr);
3037                         if (skb_size < 0)
3038                                 goto drop_it;
3039
3040                         pci_unmap_single(tp->pdev, dma_addr,
3041                                          skb_size - tp->rx_offset,
3042                                          PCI_DMA_FROMDEVICE);
3043
3044                         skb_put(skb, len);
3045                 } else {
3046                         struct sk_buff *copy_skb;
3047
3048                         tg3_recycle_rx(tp, opaque_key,
3049                                        desc_idx, *post_ptr);
3050
3051                         copy_skb = dev_alloc_skb(len + 2);
3052                         if (copy_skb == NULL)
3053                                 goto drop_it_no_recycle;
3054
3055                         copy_skb->dev = tp->dev;
3056                         skb_reserve(copy_skb, 2);
3057                         skb_put(copy_skb, len);
3058                         pci_dma_sync_single_for_cpu(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
3059                         memcpy(copy_skb->data, skb->data, len);
3060                         pci_dma_sync_single_for_device(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
3061
3062                         /* We'll reuse the original ring buffer. */
3063                         skb = copy_skb;
3064                 }
3065
3066                 if ((tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) &&
3067                     (desc->type_flags & RXD_FLAG_TCPUDP_CSUM) &&
3068                     (((desc->ip_tcp_csum & RXD_TCPCSUM_MASK)
3069                       >> RXD_TCPCSUM_SHIFT) == 0xffff))
3070                         skb->ip_summed = CHECKSUM_UNNECESSARY;
3071                 else
3072                         skb->ip_summed = CHECKSUM_NONE;
3073
3074                 skb->protocol = eth_type_trans(skb, tp->dev);
3075 #if TG3_VLAN_TAG_USED
3076                 if (tp->vlgrp != NULL &&
3077                     desc->type_flags & RXD_FLAG_VLAN) {
3078                         tg3_vlan_rx(tp, skb,
3079                                     desc->err_vlan & RXD_VLAN_MASK);
3080                 } else
3081 #endif
3082                         netif_receive_skb(skb);
3083
3084                 tp->dev->last_rx = jiffies;
3085                 received++;
3086                 budget--;
3087
3088 next_pkt:
3089                 (*post_ptr)++;
3090 next_pkt_nopost:
3091                 sw_idx++;
3092                 sw_idx %= TG3_RX_RCB_RING_SIZE(tp);
3093
3094                 /* Refresh hw_idx to see if there is new work */
3095                 if (sw_idx == hw_idx) {
3096                         hw_idx = tp->hw_status->idx[0].rx_producer;
3097                         rmb();
3098                 }
3099         }
3100
3101         /* ACK the status ring. */
3102         tp->rx_rcb_ptr = sw_idx;
3103         tw32_rx_mbox(MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW, sw_idx);
3104
3105         /* Refill RX ring(s). */
3106         if (work_mask & RXD_OPAQUE_RING_STD) {
3107                 sw_idx = tp->rx_std_ptr % TG3_RX_RING_SIZE;
3108                 tw32_rx_mbox(MAILBOX_RCV_STD_PROD_IDX + TG3_64BIT_REG_LOW,
3109                              sw_idx);
3110         }
3111         if (work_mask & RXD_OPAQUE_RING_JUMBO) {
3112                 sw_idx = tp->rx_jumbo_ptr % TG3_RX_JUMBO_RING_SIZE;
3113                 tw32_rx_mbox(MAILBOX_RCV_JUMBO_PROD_IDX + TG3_64BIT_REG_LOW,
3114                              sw_idx);
3115         }
3116         mmiowb();
3117
3118         return received;
3119 }
3120
3121 static int tg3_poll(struct net_device *netdev, int *budget)
3122 {
3123         struct tg3 *tp = netdev_priv(netdev);
3124         struct tg3_hw_status *sblk = tp->hw_status;
3125         int done;
3126
3127         /* handle link change and other phy events */
3128         if (!(tp->tg3_flags &
3129               (TG3_FLAG_USE_LINKCHG_REG |
3130                TG3_FLAG_POLL_SERDES))) {
3131                 if (sblk->status & SD_STATUS_LINK_CHG) {
3132                         sblk->status = SD_STATUS_UPDATED |
3133                                 (sblk->status & ~SD_STATUS_LINK_CHG);
3134                         spin_lock(&tp->lock);
3135                         tg3_setup_phy(tp, 0);
3136                         spin_unlock(&tp->lock);
3137                 }
3138         }
3139
3140         /* run TX completion thread */
3141         if (sblk->idx[0].tx_consumer != tp->tx_cons) {
3142                 spin_lock(&tp->tx_lock);
3143                 tg3_tx(tp);
3144                 spin_unlock(&tp->tx_lock);
3145         }
3146
3147         /* run RX thread, within the bounds set by NAPI.
3148          * All RX "locking" is done by ensuring outside
3149          * code synchronizes with dev->poll()
3150          */
3151         if (sblk->idx[0].rx_producer != tp->rx_rcb_ptr) {
3152                 int orig_budget = *budget;
3153                 int work_done;
3154
3155                 if (orig_budget > netdev->quota)
3156                         orig_budget = netdev->quota;
3157
3158                 work_done = tg3_rx(tp, orig_budget);
3159
3160                 *budget -= work_done;
3161                 netdev->quota -= work_done;
3162         }
3163
3164         if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
3165                 tp->last_tag = sblk->status_tag;
3166         rmb();
3167         sblk->status &= ~SD_STATUS_UPDATED;
3168
3169         /* if no more work, tell net stack and NIC we're done */
3170         done = !tg3_has_work(tp);
3171         if (done) {
3172                 spin_lock(&tp->lock);
3173                 netif_rx_complete(netdev);
3174                 tg3_restart_ints(tp);
3175                 spin_unlock(&tp->lock);
3176         }
3177
3178         return (done ? 0 : 1);
3179 }
3180
3181 static void tg3_irq_quiesce(struct tg3 *tp)
3182 {
3183         BUG_ON(tp->irq_sync);
3184
3185         tp->irq_sync = 1;
3186         smp_mb();
3187
3188         synchronize_irq(tp->pdev->irq);
3189 }
3190
3191 static inline int tg3_irq_sync(struct tg3 *tp)
3192 {
3193         return tp->irq_sync;
3194 }
3195
3196 /* Fully shutdown all tg3 driver activity elsewhere in the system.
3197  * If irq_sync is non-zero, then the IRQ handler must be synchronized
3198  * with as well.  Most of the time, this is not necessary except when
3199  * shutting down the device.
3200  */
3201 static inline void tg3_full_lock(struct tg3 *tp, int irq_sync)
3202 {
3203         if (irq_sync)
3204                 tg3_irq_quiesce(tp);
3205         spin_lock_bh(&tp->lock);
3206         spin_lock(&tp->tx_lock);
3207 }
3208
3209 static inline void tg3_full_unlock(struct tg3 *tp)
3210 {
3211         spin_unlock(&tp->tx_lock);
3212         spin_unlock_bh(&tp->lock);
3213 }
3214
3215 /* MSI ISR - No need to check for interrupt sharing and no need to
3216  * flush status block and interrupt mailbox. PCI ordering rules
3217  * guarantee that MSI will arrive after the status block.
3218  */
3219 static irqreturn_t tg3_msi(int irq, void *dev_id, struct pt_regs *regs)
3220 {
3221         struct net_device *dev = dev_id;
3222         struct tg3 *tp = netdev_priv(dev);
3223         struct tg3_hw_status *sblk = tp->hw_status;
3224
3225         /*
3226          * Writing any value to intr-mbox-0 clears PCI INTA# and
3227          * chip-internal interrupt pending events.
3228          * Writing non-zero to intr-mbox-0 additional tells the
3229          * NIC to stop sending us irqs, engaging "in-intr-handler"
3230          * event coalescing.
3231          */
3232         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
3233         tp->last_tag = sblk->status_tag;
3234         rmb();
3235         if (tg3_irq_sync(tp))
3236                 goto out;
3237         sblk->status &= ~SD_STATUS_UPDATED;
3238         if (likely(tg3_has_work(tp)))
3239                 netif_rx_schedule(dev);         /* schedule NAPI poll */
3240         else {
3241                 /* No work, re-enable interrupts.  */
3242                 tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
3243                              tp->last_tag << 24);
3244         }
3245 out:
3246         return IRQ_RETVAL(1);
3247 }
3248
3249 static irqreturn_t tg3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
3250 {
3251         struct net_device *dev = dev_id;
3252         struct tg3 *tp = netdev_priv(dev);
3253         struct tg3_hw_status *sblk = tp->hw_status;
3254         unsigned int handled = 1;
3255
3256         /* In INTx mode, it is possible for the interrupt to arrive at
3257          * the CPU before the status block posted prior to the interrupt.
3258          * Reading the PCI State register will confirm whether the
3259          * interrupt is ours and will flush the status block.
3260          */
3261         if ((sblk->status & SD_STATUS_UPDATED) ||
3262             !(tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
3263                 /*
3264                  * Writing any value to intr-mbox-0 clears PCI INTA# and
3265                  * chip-internal interrupt pending events.
3266                  * Writing non-zero to intr-mbox-0 additional tells the
3267                  * NIC to stop sending us irqs, engaging "in-intr-handler"
3268                  * event coalescing.
3269                  */
3270                 tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
3271                              0x00000001);
3272                 if (tg3_irq_sync(tp))
3273                         goto out;
3274                 sblk->status &= ~SD_STATUS_UPDATED;
3275                 if (likely(tg3_has_work(tp)))
3276                         netif_rx_schedule(dev);         /* schedule NAPI poll */
3277                 else {
3278                         /* No work, shared interrupt perhaps?  re-enable
3279                          * interrupts, and flush that PCI write
3280                          */
3281                         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
3282                                 0x00000000);
3283                         tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
3284                 }
3285         } else {        /* shared interrupt */
3286                 handled = 0;
3287         }
3288 out:
3289         return IRQ_RETVAL(handled);
3290 }
3291
3292 static irqreturn_t tg3_interrupt_tagged(int irq, void *dev_id, struct pt_regs *regs)
3293 {
3294         struct net_device *dev = dev_id;
3295         struct tg3 *tp = netdev_priv(dev);
3296         struct tg3_hw_status *sblk = tp->hw_status;
3297         unsigned int handled = 1;
3298
3299         /* In INTx mode, it is possible for the interrupt to arrive at
3300          * the CPU before the status block posted prior to the interrupt.
3301          * Reading the PCI State register will confirm whether the
3302          * interrupt is ours and will flush the status block.
3303          */
3304         if ((sblk->status & SD_STATUS_UPDATED) ||
3305             !(tr32(TG3PCI_PCISTATE) & PCISTATE_INT_NOT_ACTIVE)) {
3306                 /*
3307                  * writing any value to intr-mbox-0 clears PCI INTA# and
3308                  * chip-internal interrupt pending events.
3309                  * writing non-zero to intr-mbox-0 additional tells the
3310                  * NIC to stop sending us irqs, engaging "in-intr-handler"
3311                  * event coalescing.
3312                  */
3313                 tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
3314                              0x00000001);
3315                 tp->last_tag = sblk->status_tag;
3316                 rmb();
3317                 if (tg3_irq_sync(tp))
3318                         goto out;
3319                 sblk->status &= ~SD_STATUS_UPDATED;
3320                 if (likely(tg3_has_work(tp)))
3321                         netif_rx_schedule(dev);         /* schedule NAPI poll */
3322                 else {
3323                         /* no work, shared interrupt perhaps?  re-enable
3324                          * interrupts, and flush that PCI write
3325                          */
3326                         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
3327                                      tp->last_tag << 24);
3328                         tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
3329                 }
3330         } else {        /* shared interrupt */
3331                 handled = 0;
3332         }
3333 out:
3334         return IRQ_RETVAL(handled);
3335 }
3336
3337 /* ISR for interrupt test */
3338 static irqreturn_t tg3_test_isr(int irq, void *dev_id,
3339                 struct pt_regs *regs)
3340 {
3341         struct net_device *dev = dev_id;
3342         struct tg3 *tp = netdev_priv(dev);
3343         struct tg3_hw_status *sblk = tp->hw_status;
3344
3345         if (sblk->status & SD_STATUS_UPDATED) {
3346                 tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
3347                              0x00000001);
3348                 return IRQ_RETVAL(1);
3349         }
3350         return IRQ_RETVAL(0);
3351 }
3352
3353 static int tg3_init_hw(struct tg3 *);
3354 static int tg3_halt(struct tg3 *, int, int);
3355
3356 #ifdef CONFIG_NET_POLL_CONTROLLER
3357 static void tg3_poll_controller(struct net_device *dev)
3358 {
3359         struct tg3 *tp = netdev_priv(dev);
3360
3361         tg3_interrupt(tp->pdev->irq, dev, NULL);
3362 }
3363 #endif
3364
3365 static void tg3_reset_task(void *_data)
3366 {
3367         struct tg3 *tp = _data;
3368         unsigned int restart_timer;
3369
3370         tg3_netif_stop(tp);
3371
3372         tg3_full_lock(tp, 1);
3373
3374         restart_timer = tp->tg3_flags2 & TG3_FLG2_RESTART_TIMER;
3375         tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER;
3376
3377         tg3_halt(tp, RESET_KIND_SHUTDOWN, 0);
3378         tg3_init_hw(tp);
3379
3380         tg3_netif_start(tp);
3381
3382         tg3_full_unlock(tp);
3383
3384         if (restart_timer)
3385                 mod_timer(&tp->timer, jiffies + 1);
3386 }
3387
3388 static void tg3_tx_timeout(struct net_device *dev)
3389 {
3390         struct tg3 *tp = netdev_priv(dev);
3391
3392         printk(KERN_ERR PFX "%s: transmit timed out, resetting\n",
3393                dev->name);
3394
3395         schedule_work(&tp->reset_task);
3396 }
3397
3398 static void tg3_set_txd(struct tg3 *, int, dma_addr_t, int, u32, u32);
3399
3400 static int tigon3_4gb_hwbug_workaround(struct tg3 *tp, struct sk_buff *skb,
3401                                        u32 guilty_entry, int guilty_len,
3402                                        u32 last_plus_one, u32 *start, u32 mss)
3403 {
3404         struct sk_buff *new_skb = skb_copy(skb, GFP_ATOMIC);
3405         dma_addr_t new_addr;
3406         u32 entry = *start;
3407         int i;
3408
3409         if (!new_skb) {
3410                 dev_kfree_skb(skb);
3411                 return -1;
3412         }
3413
3414         /* New SKB is guaranteed to be linear. */
3415         entry = *start;
3416         new_addr = pci_map_single(tp->pdev, new_skb->data, new_skb->len,
3417                                   PCI_DMA_TODEVICE);
3418         tg3_set_txd(tp, entry, new_addr, new_skb->len,
3419                     (skb->ip_summed == CHECKSUM_HW) ?
3420                     TXD_FLAG_TCPUDP_CSUM : 0, 1 | (mss << 1));
3421         *start = NEXT_TX(entry);
3422
3423         /* Now clean up the sw ring entries. */
3424         i = 0;
3425         while (entry != last_plus_one) {
3426                 int len;
3427
3428                 if (i == 0)
3429                         len = skb_headlen(skb);
3430                 else
3431                         len = skb_shinfo(skb)->frags[i-1].size;
3432                 pci_unmap_single(tp->pdev,
3433                                  pci_unmap_addr(&tp->tx_buffers[entry], mapping),
3434                                  len, PCI_DMA_TODEVICE);
3435                 if (i == 0) {
3436                         tp->tx_buffers[entry].skb = new_skb;
3437                         pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, new_addr);
3438                 } else {
3439                         tp->tx_buffers[entry].skb = NULL;
3440                 }
3441                 entry = NEXT_TX(entry);
3442                 i++;
3443         }
3444
3445         dev_kfree_skb(skb);
3446
3447         return 0;
3448 }
3449
3450 static void tg3_set_txd(struct tg3 *tp, int entry,
3451                         dma_addr_t mapping, int len, u32 flags,
3452                         u32 mss_and_is_end)
3453 {
3454         struct tg3_tx_buffer_desc *txd = &tp->tx_ring[entry];
3455         int is_end = (mss_and_is_end & 0x1);
3456         u32 mss = (mss_and_is_end >> 1);
3457         u32 vlan_tag = 0;
3458
3459         if (is_end)
3460                 flags |= TXD_FLAG_END;
3461         if (flags & TXD_FLAG_VLAN) {
3462                 vlan_tag = flags >> 16;
3463                 flags &= 0xffff;
3464         }
3465         vlan_tag |= (mss << TXD_MSS_SHIFT);
3466
3467         txd->addr_hi = ((u64) mapping >> 32);
3468         txd->addr_lo = ((u64) mapping & 0xffffffff);
3469         txd->len_flags = (len << TXD_LEN_SHIFT) | flags;
3470         txd->vlan_tag = vlan_tag << TXD_VLAN_TAG_SHIFT;
3471 }
3472
3473 static inline int tg3_4g_overflow_test(dma_addr_t mapping, int len)
3474 {
3475         u32 base = (u32) mapping & 0xffffffff;
3476
3477         return ((base > 0xffffdcc0) &&
3478                 (base + len + 8 < base));
3479 }
3480
3481 static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
3482 {
3483         struct tg3 *tp = netdev_priv(dev);
3484         dma_addr_t mapping;
3485         unsigned int i;
3486         u32 len, entry, base_flags, mss;
3487         int would_hit_hwbug;
3488
3489         len = skb_headlen(skb);
3490
3491         /* No BH disabling for tx_lock here.  We are running in BH disabled
3492          * context and TX reclaim runs via tp->poll inside of a software
3493          * interrupt.  Furthermore, IRQ processing runs lockless so we have
3494          * no IRQ context deadlocks to worry about either.  Rejoice!
3495          */
3496         if (!spin_trylock(&tp->tx_lock))
3497                 return NETDEV_TX_LOCKED;
3498
3499         /* This is a hard error, log it. */
3500         if (unlikely(TX_BUFFS_AVAIL(tp) <= (skb_shinfo(skb)->nr_frags + 1))) {
3501                 netif_stop_queue(dev);
3502                 spin_unlock(&tp->tx_lock);
3503                 printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!\n",
3504                        dev->name);
3505                 return NETDEV_TX_BUSY;
3506         }
3507
3508         entry = tp->tx_prod;
3509         base_flags = 0;
3510         if (skb->ip_summed == CHECKSUM_HW)
3511                 base_flags |= TXD_FLAG_TCPUDP_CSUM;
3512 #if TG3_TSO_SUPPORT != 0
3513         mss = 0;
3514         if (skb->len > (tp->dev->mtu + ETH_HLEN) &&
3515             (mss = skb_shinfo(skb)->tso_size) != 0) {
3516                 int tcp_opt_len, ip_tcp_len;
3517
3518                 if (skb_header_cloned(skb) &&
3519                     pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
3520                         dev_kfree_skb(skb);
3521                         goto out_unlock;
3522                 }
3523
3524                 tcp_opt_len = ((skb->h.th->doff - 5) * 4);
3525                 ip_tcp_len = (skb->nh.iph->ihl * 4) + sizeof(struct tcphdr);
3526
3527                 base_flags |= (TXD_FLAG_CPU_PRE_DMA |
3528                                TXD_FLAG_CPU_POST_DMA);
3529
3530                 skb->nh.iph->check = 0;
3531                 skb->nh.iph->tot_len = ntohs(mss + ip_tcp_len + tcp_opt_len);
3532                 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
3533                         skb->h.th->check = 0;
3534                         base_flags &= ~TXD_FLAG_TCPUDP_CSUM;
3535                 }
3536                 else {
3537                         skb->h.th->check =
3538                                 ~csum_tcpudp_magic(skb->nh.iph->saddr,
3539                                                    skb->nh.iph->daddr,
3540                                                    0, IPPROTO_TCP, 0);
3541                 }
3542
3543                 if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO) ||
3544                     (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705)) {
3545                         if (tcp_opt_len || skb->nh.iph->ihl > 5) {
3546                                 int tsflags;
3547
3548                                 tsflags = ((skb->nh.iph->ihl - 5) +
3549                                            (tcp_opt_len >> 2));
3550                                 mss |= (tsflags << 11);
3551                         }
3552                 } else {
3553                         if (tcp_opt_len || skb->nh.iph->ihl > 5) {
3554                                 int tsflags;
3555
3556                                 tsflags = ((skb->nh.iph->ihl - 5) +
3557                                            (tcp_opt_len >> 2));
3558                                 base_flags |= tsflags << 12;
3559                         }
3560                 }
3561         }
3562 #else
3563         mss = 0;
3564 #endif
3565 #if TG3_VLAN_TAG_USED
3566         if (tp->vlgrp != NULL && vlan_tx_tag_present(skb))
3567                 base_flags |= (TXD_FLAG_VLAN |
3568                                (vlan_tx_tag_get(skb) << 16));
3569 #endif
3570
3571         /* Queue skb data, a.k.a. the main skb fragment. */
3572         mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
3573
3574         tp->tx_buffers[entry].skb = skb;
3575         pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
3576
3577         would_hit_hwbug = 0;
3578
3579         if (tg3_4g_overflow_test(mapping, len))
3580                 would_hit_hwbug = entry + 1;
3581
3582         tg3_set_txd(tp, entry, mapping, len, base_flags,
3583                     (skb_shinfo(skb)->nr_frags == 0) | (mss << 1));
3584
3585         entry = NEXT_TX(entry);
3586
3587         /* Now loop through additional data fragments, and queue them. */
3588         if (skb_shinfo(skb)->nr_frags > 0) {
3589                 unsigned int i, last;
3590
3591                 last = skb_shinfo(skb)->nr_frags - 1;
3592                 for (i = 0; i <= last; i++) {
3593                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
3594
3595                         len = frag->size;
3596                         mapping = pci_map_page(tp->pdev,
3597                                                frag->page,
3598                                                frag->page_offset,
3599                                                len, PCI_DMA_TODEVICE);
3600
3601                         tp->tx_buffers[entry].skb = NULL;
3602                         pci_unmap_addr_set(&tp->tx_buffers[entry], mapping, mapping);
3603
3604                         if (tg3_4g_overflow_test(mapping, len)) {
3605                                 /* Only one should match. */
3606                                 if (would_hit_hwbug)
3607                                         BUG();
3608                                 would_hit_hwbug = entry + 1;
3609                         }
3610
3611                         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
3612                                 tg3_set_txd(tp, entry, mapping, len,
3613                                             base_flags, (i == last)|(mss << 1));
3614                         else
3615                                 tg3_set_txd(tp, entry, mapping, len,
3616                                             base_flags, (i == last));
3617
3618                         entry = NEXT_TX(entry);
3619                 }
3620         }
3621
3622         if (would_hit_hwbug) {
3623                 u32 last_plus_one = entry;
3624                 u32 start;
3625                 unsigned int len = 0;
3626
3627                 would_hit_hwbug -= 1;
3628                 entry = entry - 1 - skb_shinfo(skb)->nr_frags;
3629                 entry &= (TG3_TX_RING_SIZE - 1);
3630                 start = entry;
3631                 i = 0;
3632                 while (entry != last_plus_one) {
3633                         if (i == 0)
3634                                 len = skb_headlen(skb);
3635                         else
3636                                 len = skb_shinfo(skb)->frags[i-1].size;
3637
3638                         if (entry == would_hit_hwbug)
3639                                 break;
3640
3641                         i++;
3642                         entry = NEXT_TX(entry);
3643
3644                 }
3645
3646                 /* If the workaround fails due to memory/mapping
3647                  * failure, silently drop this packet.
3648                  */
3649                 if (tigon3_4gb_hwbug_workaround(tp, skb,
3650                                                 entry, len,
3651                                                 last_plus_one,
3652                                                 &start, mss))
3653                         goto out_unlock;
3654
3655                 entry = start;
3656         }
3657
3658         /* Packets are ready, update Tx producer idx local and on card. */
3659         tw32_tx_mbox((MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW), entry);
3660
3661         tp->tx_prod = entry;
3662         if (TX_BUFFS_AVAIL(tp) <= (MAX_SKB_FRAGS + 1))
3663                 netif_stop_queue(dev);
3664
3665 out_unlock:
3666         mmiowb();
3667         spin_unlock(&tp->tx_lock);
3668
3669         dev->trans_start = jiffies;
3670
3671         return NETDEV_TX_OK;
3672 }
3673
3674 static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
3675                                int new_mtu)
3676 {
3677         dev->mtu = new_mtu;
3678
3679         if (new_mtu > ETH_DATA_LEN) {
3680                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
3681                         tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
3682                         ethtool_op_set_tso(dev, 0);
3683                 }
3684                 else
3685                         tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
3686         } else {
3687                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
3688                         tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
3689                 tp->tg3_flags &= ~TG3_FLAG_JUMBO_RING_ENABLE;
3690         }
3691 }
3692
3693 static int tg3_change_mtu(struct net_device *dev, int new_mtu)
3694 {
3695         struct tg3 *tp = netdev_priv(dev);
3696
3697         if (new_mtu < TG3_MIN_MTU || new_mtu > TG3_MAX_MTU(tp))
3698                 return -EINVAL;
3699
3700         if (!netif_running(dev)) {
3701                 /* We'll just catch it later when the
3702                  * device is up'd.
3703                  */
3704                 tg3_set_mtu(dev, tp, new_mtu);
3705                 return 0;
3706         }
3707
3708         tg3_netif_stop(tp);
3709
3710         tg3_full_lock(tp, 1);
3711
3712         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
3713
3714         tg3_set_mtu(dev, tp, new_mtu);
3715
3716         tg3_init_hw(tp);
3717
3718         tg3_netif_start(tp);
3719
3720         tg3_full_unlock(tp);
3721
3722         return 0;
3723 }
3724
3725 /* Free up pending packets in all rx/tx rings.
3726  *
3727  * The chip has been shut down and the driver detached from
3728  * the networking, so no interrupts or new tx packets will
3729  * end up in the driver.  tp->{tx,}lock is not held and we are not
3730  * in an interrupt context and thus may sleep.
3731  */
3732 static void tg3_free_rings(struct tg3 *tp)
3733 {
3734         struct ring_info *rxp;
3735         int i;
3736
3737         for (i = 0; i < TG3_RX_RING_SIZE; i++) {
3738                 rxp = &tp->rx_std_buffers[i];
3739
3740                 if (rxp->skb == NULL)
3741                         continue;
3742                 pci_unmap_single(tp->pdev,
3743                                  pci_unmap_addr(rxp, mapping),
3744                                  tp->rx_pkt_buf_sz - tp->rx_offset,
3745                                  PCI_DMA_FROMDEVICE);
3746                 dev_kfree_skb_any(rxp->skb);
3747                 rxp->skb = NULL;
3748         }
3749
3750         for (i = 0; i < TG3_RX_JUMBO_RING_SIZE; i++) {
3751                 rxp = &tp->rx_jumbo_buffers[i];
3752
3753                 if (rxp->skb == NULL)
3754                         continue;
3755                 pci_unmap_single(tp->pdev,
3756                                  pci_unmap_addr(rxp, mapping),
3757                                  RX_JUMBO_PKT_BUF_SZ - tp->rx_offset,
3758                                  PCI_DMA_FROMDEVICE);
3759                 dev_kfree_skb_any(rxp->skb);
3760                 rxp->skb = NULL;
3761         }
3762
3763         for (i = 0; i < TG3_TX_RING_SIZE; ) {
3764                 struct tx_ring_info *txp;
3765                 struct sk_buff *skb;
3766                 int j;
3767
3768                 txp = &tp->tx_buffers[i];
3769                 skb = txp->skb;
3770
3771                 if (skb == NULL) {
3772                         i++;
3773                         continue;
3774                 }
3775
3776                 pci_unmap_single(tp->pdev,
3777                                  pci_unmap_addr(txp, mapping),
3778                                  skb_headlen(skb),
3779                                  PCI_DMA_TODEVICE);
3780                 txp->skb = NULL;
3781
3782                 i++;
3783
3784                 for (j = 0; j < skb_shinfo(skb)->nr_frags; j++) {
3785                         txp = &tp->tx_buffers[i & (TG3_TX_RING_SIZE - 1)];
3786                         pci_unmap_page(tp->pdev,
3787                                        pci_unmap_addr(txp, mapping),
3788                                        skb_shinfo(skb)->frags[j].size,
3789                                        PCI_DMA_TODEVICE);
3790                         i++;
3791                 }
3792
3793                 dev_kfree_skb_any(skb);
3794         }
3795 }
3796
3797 /* Initialize tx/rx rings for packet processing.
3798  *
3799  * The chip has been shut down and the driver detached from
3800  * the networking, so no interrupts or new tx packets will
3801  * end up in the driver.  tp->{tx,}lock are held and thus
3802  * we may not sleep.
3803  */
3804 static void tg3_init_rings(struct tg3 *tp)
3805 {
3806         u32 i;
3807
3808         /* Free up all the SKBs. */
3809         tg3_free_rings(tp);
3810
3811         /* Zero out all descriptors. */
3812         memset(tp->rx_std, 0, TG3_RX_RING_BYTES);
3813         memset(tp->rx_jumbo, 0, TG3_RX_JUMBO_RING_BYTES);
3814         memset(tp->rx_rcb, 0, TG3_RX_RCB_RING_BYTES(tp));
3815         memset(tp->tx_ring, 0, TG3_TX_RING_BYTES);
3816
3817         tp->rx_pkt_buf_sz = RX_PKT_BUF_SZ;
3818         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) &&
3819             (tp->dev->mtu > ETH_DATA_LEN))
3820                 tp->rx_pkt_buf_sz = RX_JUMBO_PKT_BUF_SZ;
3821
3822         /* Initialize invariants of the rings, we only set this
3823          * stuff once.  This works because the card does not
3824          * write into the rx buffer posting rings.
3825          */
3826         for (i = 0; i < TG3_RX_RING_SIZE; i++) {
3827                 struct tg3_rx_buffer_desc *rxd;
3828
3829                 rxd = &tp->rx_std[i];
3830                 rxd->idx_len = (tp->rx_pkt_buf_sz - tp->rx_offset - 64)
3831                         << RXD_LEN_SHIFT;
3832                 rxd->type_flags = (RXD_FLAG_END << RXD_FLAGS_SHIFT);
3833                 rxd->opaque = (RXD_OPAQUE_RING_STD |
3834                                (i << RXD_OPAQUE_INDEX_SHIFT));
3835         }
3836
3837         if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) {
3838                 for (i = 0; i < TG3_RX_JUMBO_RING_SIZE; i++) {
3839                         struct tg3_rx_buffer_desc *rxd;
3840
3841                         rxd = &tp->rx_jumbo[i];
3842                         rxd->idx_len = (RX_JUMBO_PKT_BUF_SZ - tp->rx_offset - 64)
3843                                 << RXD_LEN_SHIFT;
3844                         rxd->type_flags = (RXD_FLAG_END << RXD_FLAGS_SHIFT) |
3845                                 RXD_FLAG_JUMBO;
3846                         rxd->opaque = (RXD_OPAQUE_RING_JUMBO |
3847                                (i << RXD_OPAQUE_INDEX_SHIFT));
3848                 }
3849         }
3850
3851         /* Now allocate fresh SKBs for each rx ring. */
3852         for (i = 0; i < tp->rx_pending; i++) {
3853                 if (tg3_alloc_rx_skb(tp, RXD_OPAQUE_RING_STD,
3854                                      -1, i) < 0)
3855                         break;
3856         }
3857
3858         if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) {
3859                 for (i = 0; i < tp->rx_jumbo_pending; i++) {
3860                         if (tg3_alloc_rx_skb(tp, RXD_OPAQUE_RING_JUMBO,
3861                                              -1, i) < 0)
3862                                 break;
3863                 }
3864         }
3865 }
3866
3867 /*
3868  * Must not be invoked with interrupt sources disabled and
3869  * the hardware shutdown down.
3870  */
3871 static void tg3_free_consistent(struct tg3 *tp)
3872 {
3873         if (tp->rx_std_buffers) {
3874                 kfree(tp->rx_std_buffers);
3875                 tp->rx_std_buffers = NULL;
3876         }
3877         if (tp->rx_std) {
3878                 pci_free_consistent(tp->pdev, TG3_RX_RING_BYTES,
3879                                     tp->rx_std, tp->rx_std_mapping);
3880                 tp->rx_std = NULL;
3881         }
3882         if (tp->rx_jumbo) {
3883                 pci_free_consistent(tp->pdev, TG3_RX_JUMBO_RING_BYTES,
3884                                     tp->rx_jumbo, tp->rx_jumbo_mapping);
3885                 tp->rx_jumbo = NULL;
3886         }
3887         if (tp->rx_rcb) {
3888                 pci_free_consistent(tp->pdev, TG3_RX_RCB_RING_BYTES(tp),
3889                                     tp->rx_rcb, tp->rx_rcb_mapping);
3890                 tp->rx_rcb = NULL;
3891         }
3892         if (tp->tx_ring) {
3893                 pci_free_consistent(tp->pdev, TG3_TX_RING_BYTES,
3894                         tp->tx_ring, tp->tx_desc_mapping);
3895                 tp->tx_ring = NULL;
3896         }
3897         if (tp->hw_status) {
3898                 pci_free_consistent(tp->pdev, TG3_HW_STATUS_SIZE,
3899                                     tp->hw_status, tp->status_mapping);
3900                 tp->hw_status = NULL;
3901         }
3902         if (tp->hw_stats) {
3903                 pci_free_consistent(tp->pdev, sizeof(struct tg3_hw_stats),
3904                                     tp->hw_stats, tp->stats_mapping);
3905                 tp->hw_stats = NULL;
3906         }
3907 }
3908
3909 /*
3910  * Must not be invoked with interrupt sources disabled and
3911  * the hardware shutdown down.  Can sleep.
3912  */
3913 static int tg3_alloc_consistent(struct tg3 *tp)
3914 {
3915         tp->rx_std_buffers = kmalloc((sizeof(struct ring_info) *
3916                                       (TG3_RX_RING_SIZE +
3917                                        TG3_RX_JUMBO_RING_SIZE)) +
3918                                      (sizeof(struct tx_ring_info) *
3919                                       TG3_TX_RING_SIZE),
3920                                      GFP_KERNEL);
3921         if (!tp->rx_std_buffers)
3922                 return -ENOMEM;
3923
3924         memset(tp->rx_std_buffers, 0,
3925                (sizeof(struct ring_info) *
3926                 (TG3_RX_RING_SIZE +
3927                  TG3_RX_JUMBO_RING_SIZE)) +
3928                (sizeof(struct tx_ring_info) *
3929                 TG3_TX_RING_SIZE));
3930
3931         tp->rx_jumbo_buffers = &tp->rx_std_buffers[TG3_RX_RING_SIZE];
3932         tp->tx_buffers = (struct tx_ring_info *)
3933                 &tp->rx_jumbo_buffers[TG3_RX_JUMBO_RING_SIZE];
3934
3935         tp->rx_std = pci_alloc_consistent(tp->pdev, TG3_RX_RING_BYTES,
3936                                           &tp->rx_std_mapping);
3937         if (!tp->rx_std)
3938                 goto err_out;
3939
3940         tp->rx_jumbo = pci_alloc_consistent(tp->pdev, TG3_RX_JUMBO_RING_BYTES,
3941                                             &tp->rx_jumbo_mapping);
3942
3943         if (!tp->rx_jumbo)
3944                 goto err_out;
3945
3946         tp->rx_rcb = pci_alloc_consistent(tp->pdev, TG3_RX_RCB_RING_BYTES(tp),
3947                                           &tp->rx_rcb_mapping);
3948         if (!tp->rx_rcb)
3949                 goto err_out;
3950
3951         tp->tx_ring = pci_alloc_consistent(tp->pdev, TG3_TX_RING_BYTES,
3952                                            &tp->tx_desc_mapping);
3953         if (!tp->tx_ring)
3954                 goto err_out;
3955
3956         tp->hw_status = pci_alloc_consistent(tp->pdev,
3957                                              TG3_HW_STATUS_SIZE,
3958                                              &tp->status_mapping);
3959         if (!tp->hw_status)
3960                 goto err_out;
3961
3962         tp->hw_stats = pci_alloc_consistent(tp->pdev,
3963                                             sizeof(struct tg3_hw_stats),
3964                                             &tp->stats_mapping);
3965         if (!tp->hw_stats)
3966                 goto err_out;
3967
3968         memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
3969         memset(tp->hw_stats, 0, sizeof(struct tg3_hw_stats));
3970
3971         return 0;
3972
3973 err_out:
3974         tg3_free_consistent(tp);
3975         return -ENOMEM;
3976 }
3977
3978 #define MAX_WAIT_CNT 1000
3979
3980 /* To stop a block, clear the enable bit and poll till it
3981  * clears.  tp->lock is held.
3982  */
3983 static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit, int silent)
3984 {
3985         unsigned int i;
3986         u32 val;
3987
3988         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
3989                 switch (ofs) {
3990                 case RCVLSC_MODE:
3991                 case DMAC_MODE:
3992                 case MBFREE_MODE:
3993                 case BUFMGR_MODE:
3994                 case MEMARB_MODE:
3995                         /* We can't enable/disable these bits of the
3996                          * 5705/5750, just say success.
3997                          */
3998                         return 0;
3999
4000                 default:
4001                         break;
4002                 };
4003         }
4004
4005         val = tr32(ofs);
4006         val &= ~enable_bit;
4007         tw32_f(ofs, val);
4008
4009         for (i = 0; i < MAX_WAIT_CNT; i++) {
4010                 udelay(100);
4011                 val = tr32(ofs);
4012                 if ((val & enable_bit) == 0)
4013                         break;
4014         }
4015
4016         if (i == MAX_WAIT_CNT && !silent) {
4017                 printk(KERN_ERR PFX "tg3_stop_block timed out, "
4018                        "ofs=%lx enable_bit=%x\n",
4019                        ofs, enable_bit);
4020                 return -ENODEV;
4021         }
4022
4023         return 0;
4024 }
4025
4026 /* tp->lock is held. */
4027 static int tg3_abort_hw(struct tg3 *tp, int silent)
4028 {
4029         int i, err;
4030
4031         tg3_disable_ints(tp);
4032
4033         tp->rx_mode &= ~RX_MODE_ENABLE;
4034         tw32_f(MAC_RX_MODE, tp->rx_mode);
4035         udelay(10);
4036
4037         err  = tg3_stop_block(tp, RCVBDI_MODE, RCVBDI_MODE_ENABLE, silent);
4038         err |= tg3_stop_block(tp, RCVLPC_MODE, RCVLPC_MODE_ENABLE, silent);
4039         err |= tg3_stop_block(tp, RCVLSC_MODE, RCVLSC_MODE_ENABLE, silent);
4040         err |= tg3_stop_block(tp, RCVDBDI_MODE, RCVDBDI_MODE_ENABLE, silent);
4041         err |= tg3_stop_block(tp, RCVDCC_MODE, RCVDCC_MODE_ENABLE, silent);
4042         err |= tg3_stop_block(tp, RCVCC_MODE, RCVCC_MODE_ENABLE, silent);
4043
4044         err |= tg3_stop_block(tp, SNDBDS_MODE, SNDBDS_MODE_ENABLE, silent);
4045         err |= tg3_stop_block(tp, SNDBDI_MODE, SNDBDI_MODE_ENABLE, silent);
4046         err |= tg3_stop_block(tp, SNDDATAI_MODE, SNDDATAI_MODE_ENABLE, silent);
4047         err |= tg3_stop_block(tp, RDMAC_MODE, RDMAC_MODE_ENABLE, silent);
4048         err |= tg3_stop_block(tp, SNDDATAC_MODE, SNDDATAC_MODE_ENABLE, silent);
4049         err |= tg3_stop_block(tp, DMAC_MODE, DMAC_MODE_ENABLE, silent);
4050         err |= tg3_stop_block(tp, SNDBDC_MODE, SNDBDC_MODE_ENABLE, silent);
4051
4052         tp->mac_mode &= ~MAC_MODE_TDE_ENABLE;
4053         tw32_f(MAC_MODE, tp->mac_mode);
4054         udelay(40);
4055
4056         tp->tx_mode &= ~TX_MODE_ENABLE;
4057         tw32_f(MAC_TX_MODE, tp->tx_mode);
4058
4059         for (i = 0; i < MAX_WAIT_CNT; i++) {
4060                 udelay(100);
4061                 if (!(tr32(MAC_TX_MODE) & TX_MODE_ENABLE))
4062                         break;
4063         }
4064         if (i >= MAX_WAIT_CNT) {
4065                 printk(KERN_ERR PFX "tg3_abort_hw timed out for %s, "
4066                        "TX_MODE_ENABLE will not clear MAC_TX_MODE=%08x\n",
4067                        tp->dev->name, tr32(MAC_TX_MODE));
4068                 err |= -ENODEV;
4069         }
4070
4071         err |= tg3_stop_block(tp, HOSTCC_MODE, HOSTCC_MODE_ENABLE, silent);
4072         err |= tg3_stop_block(tp, WDMAC_MODE, WDMAC_MODE_ENABLE, silent);
4073         err |= tg3_stop_block(tp, MBFREE_MODE, MBFREE_MODE_ENABLE, silent);
4074
4075         tw32(FTQ_RESET, 0xffffffff);
4076         tw32(FTQ_RESET, 0x00000000);
4077
4078         err |= tg3_stop_block(tp, BUFMGR_MODE, BUFMGR_MODE_ENABLE, silent);
4079         err |= tg3_stop_block(tp, MEMARB_MODE, MEMARB_MODE_ENABLE, silent);
4080
4081         if (tp->hw_status)
4082                 memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
4083         if (tp->hw_stats)
4084                 memset(tp->hw_stats, 0, sizeof(struct tg3_hw_stats));
4085
4086         return err;
4087 }
4088
4089 /* tp->lock is held. */
4090 static int tg3_nvram_lock(struct tg3 *tp)
4091 {
4092         if (tp->tg3_flags & TG3_FLAG_NVRAM) {
4093                 int i;
4094
4095                 tw32(NVRAM_SWARB, SWARB_REQ_SET1);
4096                 for (i = 0; i < 8000; i++) {
4097                         if (tr32(NVRAM_SWARB) & SWARB_GNT1)
4098                                 break;
4099                         udelay(20);
4100                 }
4101                 if (i == 8000)
4102                         return -ENODEV;
4103         }
4104         return 0;
4105 }
4106
4107 /* tp->lock is held. */
4108 static void tg3_nvram_unlock(struct tg3 *tp)
4109 {
4110         if (tp->tg3_flags & TG3_FLAG_NVRAM)
4111                 tw32_f(NVRAM_SWARB, SWARB_REQ_CLR1);
4112 }
4113
4114 /* tp->lock is held. */
4115 static void tg3_enable_nvram_access(struct tg3 *tp)
4116 {
4117         if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
4118             !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM)) {
4119                 u32 nvaccess = tr32(NVRAM_ACCESS);
4120
4121                 tw32(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
4122         }
4123 }
4124
4125 /* tp->lock is held. */
4126 static void tg3_disable_nvram_access(struct tg3 *tp)
4127 {
4128         if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
4129             !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM)) {
4130                 u32 nvaccess = tr32(NVRAM_ACCESS);
4131
4132                 tw32(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
4133         }
4134 }
4135
4136 /* tp->lock is held. */
4137 static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind)
4138 {
4139         if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X))
4140                 tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX,
4141                               NIC_SRAM_FIRMWARE_MBOX_MAGIC1);
4142
4143         if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) {
4144                 switch (kind) {
4145                 case RESET_KIND_INIT:
4146                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4147                                       DRV_STATE_START);
4148                         break;
4149
4150                 case RESET_KIND_SHUTDOWN:
4151                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4152                                       DRV_STATE_UNLOAD);
4153                         break;
4154
4155                 case RESET_KIND_SUSPEND:
4156                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4157                                       DRV_STATE_SUSPEND);
4158                         break;
4159
4160                 default:
4161                         break;
4162                 };
4163         }
4164 }
4165
4166 /* tp->lock is held. */
4167 static void tg3_write_sig_post_reset(struct tg3 *tp, int kind)
4168 {
4169         if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) {
4170                 switch (kind) {
4171                 case RESET_KIND_INIT:
4172                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4173                                       DRV_STATE_START_DONE);
4174                         break;
4175
4176                 case RESET_KIND_SHUTDOWN:
4177                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4178                                       DRV_STATE_UNLOAD_DONE);
4179                         break;
4180
4181                 default:
4182                         break;
4183                 };
4184         }
4185 }
4186
4187 /* tp->lock is held. */
4188 static void tg3_write_sig_legacy(struct tg3 *tp, int kind)
4189 {
4190         if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
4191                 switch (kind) {
4192                 case RESET_KIND_INIT:
4193                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4194                                       DRV_STATE_START);
4195                         break;
4196
4197                 case RESET_KIND_SHUTDOWN:
4198                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4199                                       DRV_STATE_UNLOAD);
4200                         break;
4201
4202                 case RESET_KIND_SUSPEND:
4203                         tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
4204                                       DRV_STATE_SUSPEND);
4205                         break;
4206
4207                 default:
4208                         break;
4209                 };
4210         }
4211 }
4212
4213 static void tg3_stop_fw(struct tg3 *);
4214
4215 /* tp->lock is held. */
4216 static int tg3_chip_reset(struct tg3 *tp)
4217 {
4218         u32 val;
4219         u32 flags_save;
4220         int i;
4221
4222         if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X))
4223                 tg3_nvram_lock(tp);
4224
4225         /*
4226          * We must avoid the readl() that normally takes place.
4227          * It locks machines, causes machine checks, and other
4228          * fun things.  So, temporarily disable the 5701
4229          * hardware workaround, while we do the reset.
4230          */
4231         flags_save = tp->tg3_flags;
4232         tp->tg3_flags &= ~TG3_FLAG_5701_REG_WRITE_BUG;
4233
4234         /* do the reset */
4235         val = GRC_MISC_CFG_CORECLK_RESET;
4236
4237         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
4238                 if (tr32(0x7e2c) == 0x60) {
4239                         tw32(0x7e2c, 0x20);
4240                 }
4241                 if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0) {
4242                         tw32(GRC_MISC_CFG, (1 << 29));
4243                         val |= (1 << 29);
4244                 }
4245         }
4246
4247         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
4248                 val |= GRC_MISC_CFG_KEEP_GPHY_POWER;
4249         tw32(GRC_MISC_CFG, val);
4250
4251         /* restore 5701 hardware bug workaround flag */
4252         tp->tg3_flags = flags_save;
4253
4254         /* Unfortunately, we have to delay before the PCI read back.
4255          * Some 575X chips even will not respond to a PCI cfg access
4256          * when the reset command is given to the chip.
4257          *
4258          * How do these hardware designers expect things to work
4259          * properly if the PCI write is posted for a long period
4260          * of time?  It is always necessary to have some method by
4261          * which a register read back can occur to push the write
4262          * out which does the reset.
4263          *
4264          * For most tg3 variants the trick below was working.
4265          * Ho hum...
4266          */
4267         udelay(120);
4268
4269         /* Flush PCI posted writes.  The normal MMIO registers
4270          * are inaccessible at this time so this is the only
4271          * way to make this reliably (actually, this is no longer
4272          * the case, see above).  I tried to use indirect
4273          * register read/write but this upset some 5701 variants.
4274          */
4275         pci_read_config_dword(tp->pdev, PCI_COMMAND, &val);
4276
4277         udelay(120);
4278
4279         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
4280                 if (tp->pci_chip_rev_id == CHIPREV_ID_5750_A0) {
4281                         int i;
4282                         u32 cfg_val;
4283
4284                         /* Wait for link training to complete.  */
4285                         for (i = 0; i < 5000; i++)
4286                                 udelay(100);
4287
4288                         pci_read_config_dword(tp->pdev, 0xc4, &cfg_val);
4289                         pci_write_config_dword(tp->pdev, 0xc4,
4290                                                cfg_val | (1 << 15));
4291                 }
4292                 /* Set PCIE max payload size and clear error status.  */
4293                 pci_write_config_dword(tp->pdev, 0xd8, 0xf5000);
4294         }
4295
4296         /* Re-enable indirect register accesses. */
4297         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
4298                                tp->misc_host_ctrl);
4299
4300         /* Set MAX PCI retry to zero. */
4301         val = (PCISTATE_ROM_ENABLE | PCISTATE_ROM_RETRY_ENABLE);
4302         if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0 &&
4303             (tp->tg3_flags & TG3_FLAG_PCIX_MODE))
4304                 val |= PCISTATE_RETRY_SAME_DMA;
4305         pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, val);
4306
4307         pci_restore_state(tp->pdev);
4308
4309         /* Make sure PCI-X relaxed ordering bit is clear. */
4310         pci_read_config_dword(tp->pdev, TG3PCI_X_CAPS, &val);
4311         val &= ~PCIX_CAPS_RELAXED_ORDERING;
4312         pci_write_config_dword(tp->pdev, TG3PCI_X_CAPS, val);
4313
4314         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
4315                 u32 val;
4316
4317                 /* Chip reset on 5780 will reset MSI enable bit,
4318                  * so need to restore it.
4319                  */
4320                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
4321                         u16 ctrl;
4322
4323                         pci_read_config_word(tp->pdev,
4324                                              tp->msi_cap + PCI_MSI_FLAGS,
4325                                              &ctrl);
4326                         pci_write_config_word(tp->pdev,
4327                                               tp->msi_cap + PCI_MSI_FLAGS,
4328                                               ctrl | PCI_MSI_FLAGS_ENABLE);
4329                         val = tr32(MSGINT_MODE);
4330                         tw32(MSGINT_MODE, val | MSGINT_MODE_ENABLE);
4331                 }
4332
4333                 val = tr32(MEMARB_MODE);
4334                 tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
4335
4336         } else
4337                 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
4338
4339         if (tp->pci_chip_rev_id == CHIPREV_ID_5750_A3) {
4340                 tg3_stop_fw(tp);
4341                 tw32(0x5000, 0x400);
4342         }
4343
4344         tw32(GRC_MODE, tp->grc_mode);
4345
4346         if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A0) {
4347                 u32 val = tr32(0xc4);
4348
4349                 tw32(0xc4, val | (1 << 15));
4350         }
4351
4352         if ((tp->nic_sram_data_cfg & NIC_SRAM_DATA_CFG_MINI_PCI) != 0 &&
4353             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
4354                 tp->pci_clock_ctrl |= CLOCK_CTRL_CLKRUN_OENABLE;
4355                 if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A0)
4356                         tp->pci_clock_ctrl |= CLOCK_CTRL_FORCE_CLKRUN;
4357                 tw32(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl);
4358         }
4359
4360         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
4361                 tp->mac_mode = MAC_MODE_PORT_MODE_TBI;
4362                 tw32_f(MAC_MODE, tp->mac_mode);
4363         } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
4364                 tp->mac_mode = MAC_MODE_PORT_MODE_GMII;
4365                 tw32_f(MAC_MODE, tp->mac_mode);
4366         } else
4367                 tw32_f(MAC_MODE, 0);
4368         udelay(40);
4369
4370         if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X)) {
4371                 /* Wait for firmware initialization to complete. */
4372                 for (i = 0; i < 100000; i++) {
4373                         tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
4374                         if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
4375                                 break;
4376                         udelay(10);
4377                 }
4378                 if (i >= 100000) {
4379                         printk(KERN_ERR PFX "tg3_reset_hw timed out for %s, "
4380                                "firmware will not restart magic=%08x\n",
4381                                tp->dev->name, val);
4382                         return -ENODEV;
4383                 }
4384         }
4385
4386         if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
4387             tp->pci_chip_rev_id != CHIPREV_ID_5750_A0) {
4388                 u32 val = tr32(0x7c00);
4389
4390                 tw32(0x7c00, val | (1 << 25));
4391         }
4392
4393         /* Reprobe ASF enable state.  */
4394         tp->tg3_flags &= ~TG3_FLAG_ENABLE_ASF;
4395         tp->tg3_flags2 &= ~TG3_FLG2_ASF_NEW_HANDSHAKE;
4396         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
4397         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
4398                 u32 nic_cfg;
4399
4400                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
4401                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
4402                         tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
4403                         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
4404                                 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
4405                 }
4406         }
4407
4408         return 0;
4409 }
4410
4411 /* tp->lock is held. */
4412 static void tg3_stop_fw(struct tg3 *tp)
4413 {
4414         if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
4415                 u32 val;
4416                 int i;
4417
4418                 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_PAUSE_FW);
4419                 val = tr32(GRC_RX_CPU_EVENT);
4420                 val |= (1 << 14);
4421                 tw32(GRC_RX_CPU_EVENT, val);
4422
4423                 /* Wait for RX cpu to ACK the event.  */
4424                 for (i = 0; i < 100; i++) {
4425                         if (!(tr32(GRC_RX_CPU_EVENT) & (1 << 14)))
4426                                 break;
4427                         udelay(1);
4428                 }
4429         }
4430 }
4431
4432 /* tp->lock is held. */
4433 static int tg3_halt(struct tg3 *tp, int kind, int silent)
4434 {
4435         int err;
4436
4437         tg3_stop_fw(tp);
4438
4439         tg3_write_sig_pre_reset(tp, kind);
4440
4441         tg3_abort_hw(tp, silent);
4442         err = tg3_chip_reset(tp);
4443
4444         tg3_write_sig_legacy(tp, kind);
4445         tg3_write_sig_post_reset(tp, kind);
4446
4447         if (err)
4448                 return err;
4449
4450         return 0;
4451 }
4452
4453 #define TG3_FW_RELEASE_MAJOR    0x0
4454 #define TG3_FW_RELASE_MINOR     0x0
4455 #define TG3_FW_RELEASE_FIX      0x0
4456 #define TG3_FW_START_ADDR       0x08000000
4457 #define TG3_FW_TEXT_ADDR        0x08000000
4458 #define TG3_FW_TEXT_LEN         0x9c0
4459 #define TG3_FW_RODATA_ADDR      0x080009c0
4460 #define TG3_FW_RODATA_LEN       0x60
4461 #define TG3_FW_DATA_ADDR        0x08000a40
4462 #define TG3_FW_DATA_LEN         0x20
4463 #define TG3_FW_SBSS_ADDR        0x08000a60
4464 #define TG3_FW_SBSS_LEN         0xc
4465 #define TG3_FW_BSS_ADDR         0x08000a70
4466 #define TG3_FW_BSS_LEN          0x10
4467
4468 static u32 tg3FwText[(TG3_FW_TEXT_LEN / sizeof(u32)) + 1] = {
4469         0x00000000, 0x10000003, 0x00000000, 0x0000000d, 0x0000000d, 0x3c1d0800,
4470         0x37bd3ffc, 0x03a0f021, 0x3c100800, 0x26100000, 0x0e000018, 0x00000000,
4471         0x0000000d, 0x3c1d0800, 0x37bd3ffc, 0x03a0f021, 0x3c100800, 0x26100034,
4472         0x0e00021c, 0x00000000, 0x0000000d, 0x00000000, 0x00000000, 0x00000000,
4473         0x27bdffe0, 0x3c1cc000, 0xafbf0018, 0xaf80680c, 0x0e00004c, 0x241b2105,
4474         0x97850000, 0x97870002, 0x9782002c, 0x9783002e, 0x3c040800, 0x248409c0,
4475         0xafa00014, 0x00021400, 0x00621825, 0x00052c00, 0xafa30010, 0x8f860010,
4476         0x00e52825, 0x0e000060, 0x24070102, 0x3c02ac00, 0x34420100, 0x3c03ac01,
4477         0x34630100, 0xaf820490, 0x3c02ffff, 0xaf820494, 0xaf830498, 0xaf82049c,
4478         0x24020001, 0xaf825ce0, 0x0e00003f, 0xaf825d00, 0x0e000140, 0x00000000,
4479         0x8fbf0018, 0x03e00008, 0x27bd0020, 0x2402ffff, 0xaf825404, 0x8f835400,
4480         0x34630400, 0xaf835400, 0xaf825404, 0x3c020800, 0x24420034, 0xaf82541c,
4481         0x03e00008, 0xaf805400, 0x00000000, 0x00000000, 0x3c020800, 0x34423000,
4482         0x3c030800, 0x34633000, 0x3c040800, 0x348437ff, 0x3c010800, 0xac220a64,
4483         0x24020040, 0x3c010800, 0xac220a68, 0x3c010800, 0xac200a60, 0xac600000,
4484         0x24630004, 0x0083102b, 0x5040fffd, 0xac600000, 0x03e00008, 0x00000000,
4485         0x00804821, 0x8faa0010, 0x3c020800, 0x8c420a60, 0x3c040800, 0x8c840a68,
4486         0x8fab0014, 0x24430001, 0x0044102b, 0x3c010800, 0xac230a60, 0x14400003,
4487         0x00004021, 0x3c010800, 0xac200a60, 0x3c020800, 0x8c420a60, 0x3c030800,
4488         0x8c630a64, 0x91240000, 0x00021140, 0x00431021, 0x00481021, 0x25080001,
4489         0xa0440000, 0x29020008, 0x1440fff4, 0x25290001, 0x3c020800, 0x8c420a60,
4490         0x3c030800, 0x8c630a64, 0x8f84680c, 0x00021140, 0x00431021, 0xac440008,
4491         0xac45000c, 0xac460010, 0xac470014, 0xac4a0018, 0x03e00008, 0xac4b001c,
4492         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4493         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4494         0, 0, 0, 0, 0, 0,
4495         0x02000008, 0x00000000, 0x0a0001e3, 0x3c0a0001, 0x0a0001e3, 0x3c0a0002,
4496         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
4497         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
4498         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
4499         0x0a0001e3, 0x3c0a0007, 0x0a0001e3, 0x3c0a0008, 0x0a0001e3, 0x3c0a0009,
4500         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x3c0a000b,
4501         0x0a0001e3, 0x3c0a000c, 0x0a0001e3, 0x3c0a000d, 0x0a0001e3, 0x00000000,
4502         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x3c0a000e, 0x0a0001e3, 0x00000000,
4503         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
4504         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000, 0x0a0001e3, 0x00000000,
4505         0x0a0001e3, 0x00000000, 0x0a0001e3, 0x3c0a0013, 0x0a0001e3, 0x3c0a0014,
4506         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4507         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4508         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4509         0x27bdffe0, 0x00001821, 0x00001021, 0xafbf0018, 0xafb10014, 0xafb00010,
4510         0x3c010800, 0x00220821, 0xac200a70, 0x3c010800, 0x00220821, 0xac200a74,
4511         0x3c010800, 0x00220821, 0xac200a78, 0x24630001, 0x1860fff5, 0x2442000c,
4512         0x24110001, 0x8f906810, 0x32020004, 0x14400005, 0x24040001, 0x3c020800,
4513         0x8c420a78, 0x18400003, 0x00002021, 0x0e000182, 0x00000000, 0x32020001,
4514         0x10400003, 0x00000000, 0x0e000169, 0x00000000, 0x0a000153, 0xaf915028,
4515         0x8fbf0018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020, 0x3c050800,
4516         0x8ca50a70, 0x3c060800, 0x8cc60a80, 0x3c070800, 0x8ce70a78, 0x27bdffe0,
4517         0x3c040800, 0x248409d0, 0xafbf0018, 0xafa00010, 0x0e000060, 0xafa00014,
4518         0x0e00017b, 0x00002021, 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x24020001,
4519         0x8f836810, 0x00821004, 0x00021027, 0x00621824, 0x03e00008, 0xaf836810,
4520         0x27bdffd8, 0xafbf0024, 0x1080002e, 0xafb00020, 0x8f825cec, 0xafa20018,
4521         0x8f825cec, 0x3c100800, 0x26100a78, 0xafa2001c, 0x34028000, 0xaf825cec,
4522         0x8e020000, 0x18400016, 0x00000000, 0x3c020800, 0x94420a74, 0x8fa3001c,
4523         0x000221c0, 0xac830004, 0x8fa2001c, 0x3c010800, 0x0e000201, 0xac220a74,
4524         0x10400005, 0x00000000, 0x8e020000, 0x24420001, 0x0a0001df, 0xae020000,
4525         0x3c020800, 0x8c420a70, 0x00021c02, 0x000321c0, 0x0a0001c5, 0xafa2001c,
4526         0x0e000201, 0x00000000, 0x1040001f, 0x00000000, 0x8e020000, 0x8fa3001c,
4527         0x24420001, 0x3c010800, 0xac230a70, 0x3c010800, 0xac230a74, 0x0a0001df,
4528         0xae020000, 0x3c100800, 0x26100a78, 0x8e020000, 0x18400028, 0x00000000,
4529         0x0e000201, 0x00000000, 0x14400024, 0x00000000, 0x8e020000, 0x3c030800,
4530         0x8c630a70, 0x2442ffff, 0xafa3001c, 0x18400006, 0xae020000, 0x00031402,
4531         0x000221c0, 0x8c820004, 0x3c010800, 0xac220a70, 0x97a2001e, 0x2442ff00,
4532         0x2c420300, 0x1440000b, 0x24024000, 0x3c040800, 0x248409dc, 0xafa00010,
4533         0xafa00014, 0x8fa6001c, 0x24050008, 0x0e000060, 0x00003821, 0x0a0001df,
4534         0x00000000, 0xaf825cf8, 0x3c020800, 0x8c420a40, 0x8fa3001c, 0x24420001,
4535         0xaf835cf8, 0x3c010800, 0xac220a40, 0x8fbf0024, 0x8fb00020, 0x03e00008,
4536         0x27bd0028, 0x27bdffe0, 0x3c040800, 0x248409e8, 0x00002821, 0x00003021,
4537         0x00003821, 0xafbf0018, 0xafa00010, 0x0e000060, 0xafa00014, 0x8fbf0018,
4538         0x03e00008, 0x27bd0020, 0x8f82680c, 0x8f85680c, 0x00021827, 0x0003182b,
4539         0x00031823, 0x00431024, 0x00441021, 0x00a2282b, 0x10a00006, 0x00000000,
4540         0x00401821, 0x8f82680c, 0x0043102b, 0x1440fffd, 0x00000000, 0x03e00008,
4541         0x00000000, 0x3c040800, 0x8c840000, 0x3c030800, 0x8c630a40, 0x0064102b,
4542         0x54400002, 0x00831023, 0x00641023, 0x2c420008, 0x03e00008, 0x38420001,
4543         0x27bdffe0, 0x00802821, 0x3c040800, 0x24840a00, 0x00003021, 0x00003821,
4544         0xafbf0018, 0xafa00010, 0x0e000060, 0xafa00014, 0x0a000216, 0x00000000,
4545         0x8fbf0018, 0x03e00008, 0x27bd0020, 0x00000000, 0x27bdffe0, 0x3c1cc000,
4546         0xafbf0018, 0x0e00004c, 0xaf80680c, 0x3c040800, 0x24840a10, 0x03802821,
4547         0x00003021, 0x00003821, 0xafa00010, 0x0e000060, 0xafa00014, 0x2402ffff,
4548         0xaf825404, 0x3c0200aa, 0x0e000234, 0xaf825434, 0x8fbf0018, 0x03e00008,
4549         0x27bd0020, 0x00000000, 0x00000000, 0x00000000, 0x27bdffe8, 0xafb00010,
4550         0x24100001, 0xafbf0014, 0x3c01c003, 0xac200000, 0x8f826810, 0x30422000,
4551         0x10400003, 0x00000000, 0x0e000246, 0x00000000, 0x0a00023a, 0xaf905428,
4552         0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x27bdfff8, 0x8f845d0c,
4553         0x3c0200ff, 0x3c030800, 0x8c630a50, 0x3442fff8, 0x00821024, 0x1043001e,
4554         0x3c0500ff, 0x34a5fff8, 0x3c06c003, 0x3c074000, 0x00851824, 0x8c620010,
4555         0x3c010800, 0xac230a50, 0x30420008, 0x10400005, 0x00871025, 0x8cc20000,
4556         0x24420001, 0xacc20000, 0x00871025, 0xaf825d0c, 0x8fa20000, 0x24420001,
4557         0xafa20000, 0x8fa20000, 0x8fa20000, 0x24420001, 0xafa20000, 0x8fa20000,
4558         0x8f845d0c, 0x3c030800, 0x8c630a50, 0x00851024, 0x1443ffe8, 0x00851824,
4559         0x27bd0008, 0x03e00008, 0x00000000, 0x00000000, 0x00000000
4560 };
4561
4562 static u32 tg3FwRodata[(TG3_FW_RODATA_LEN / sizeof(u32)) + 1] = {
4563         0x35373031, 0x726c7341, 0x00000000, 0x00000000, 0x53774576, 0x656e7430,
4564         0x00000000, 0x726c7045, 0x76656e74, 0x31000000, 0x556e6b6e, 0x45766e74,
4565         0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x66617461, 0x6c457272,
4566         0x00000000, 0x00000000, 0x4d61696e, 0x43707542, 0x00000000, 0x00000000,
4567         0x00000000
4568 };
4569
4570 #if 0 /* All zeros, don't eat up space with it. */
4571 u32 tg3FwData[(TG3_FW_DATA_LEN / sizeof(u32)) + 1] = {
4572         0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4573         0x00000000, 0x00000000, 0x00000000, 0x00000000
4574 };
4575 #endif
4576
4577 #define RX_CPU_SCRATCH_BASE     0x30000
4578 #define RX_CPU_SCRATCH_SIZE     0x04000
4579 #define TX_CPU_SCRATCH_BASE     0x34000
4580 #define TX_CPU_SCRATCH_SIZE     0x04000
4581
4582 /* tp->lock is held. */
4583 static int tg3_halt_cpu(struct tg3 *tp, u32 offset)
4584 {
4585         int i;
4586
4587         if (offset == TX_CPU_BASE &&
4588             (tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
4589                 BUG();
4590
4591         if (offset == RX_CPU_BASE) {
4592                 for (i = 0; i < 10000; i++) {
4593                         tw32(offset + CPU_STATE, 0xffffffff);
4594                         tw32(offset + CPU_MODE,  CPU_MODE_HALT);
4595                         if (tr32(offset + CPU_MODE) & CPU_MODE_HALT)
4596                                 break;
4597                 }
4598
4599                 tw32(offset + CPU_STATE, 0xffffffff);
4600                 tw32_f(offset + CPU_MODE,  CPU_MODE_HALT);
4601                 udelay(10);
4602         } else {
4603                 for (i = 0; i < 10000; i++) {
4604                         tw32(offset + CPU_STATE, 0xffffffff);
4605                         tw32(offset + CPU_MODE,  CPU_MODE_HALT);
4606                         if (tr32(offset + CPU_MODE) & CPU_MODE_HALT)
4607                                 break;
4608                 }
4609         }
4610
4611         if (i >= 10000) {
4612                 printk(KERN_ERR PFX "tg3_reset_cpu timed out for %s, "
4613                        "and %s CPU\n",
4614                        tp->dev->name,
4615                        (offset == RX_CPU_BASE ? "RX" : "TX"));
4616                 return -ENODEV;
4617         }
4618         return 0;
4619 }
4620
4621 struct fw_info {
4622         unsigned int text_base;
4623         unsigned int text_len;
4624         u32 *text_data;
4625         unsigned int rodata_base;
4626         unsigned int rodata_len;
4627         u32 *rodata_data;
4628         unsigned int data_base;
4629         unsigned int data_len;
4630         u32 *data_data;
4631 };
4632
4633 /* tp->lock is held. */
4634 static int tg3_load_firmware_cpu(struct tg3 *tp, u32 cpu_base, u32 cpu_scratch_base,
4635                                  int cpu_scratch_size, struct fw_info *info)
4636 {
4637         int err, i;
4638         u32 orig_tg3_flags = tp->tg3_flags;
4639         void (*write_op)(struct tg3 *, u32, u32);
4640
4641         if (cpu_base == TX_CPU_BASE &&
4642             (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
4643                 printk(KERN_ERR PFX "tg3_load_firmware_cpu: Trying to load "
4644                        "TX cpu firmware on %s which is 5705.\n",
4645                        tp->dev->name);
4646                 return -EINVAL;
4647         }
4648
4649         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
4650                 write_op = tg3_write_mem;
4651         else
4652                 write_op = tg3_write_indirect_reg32;
4653
4654         /* Force use of PCI config space for indirect register
4655          * write calls.
4656          */
4657         tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
4658
4659         /* It is possible that bootcode is still loading at this point.
4660          * Get the nvram lock first before halting the cpu.
4661          */
4662         tg3_nvram_lock(tp);
4663         err = tg3_halt_cpu(tp, cpu_base);
4664         tg3_nvram_unlock(tp);
4665         if (err)
4666                 goto out;
4667
4668         for (i = 0; i < cpu_scratch_size; i += sizeof(u32))
4669                 write_op(tp, cpu_scratch_base + i, 0);
4670         tw32(cpu_base + CPU_STATE, 0xffffffff);
4671         tw32(cpu_base + CPU_MODE, tr32(cpu_base+CPU_MODE)|CPU_MODE_HALT);
4672         for (i = 0; i < (info->text_len / sizeof(u32)); i++)
4673                 write_op(tp, (cpu_scratch_base +
4674                               (info->text_base & 0xffff) +
4675                               (i * sizeof(u32))),
4676                          (info->text_data ?
4677                           info->text_data[i] : 0));
4678         for (i = 0; i < (info->rodata_len / sizeof(u32)); i++)
4679                 write_op(tp, (cpu_scratch_base +
4680                               (info->rodata_base & 0xffff) +
4681                               (i * sizeof(u32))),
4682                          (info->rodata_data ?
4683                           info->rodata_data[i] : 0));
4684         for (i = 0; i < (info->data_len / sizeof(u32)); i++)
4685                 write_op(tp, (cpu_scratch_base +
4686                               (info->data_base & 0xffff) +
4687                               (i * sizeof(u32))),
4688                          (info->data_data ?
4689                           info->data_data[i] : 0));
4690
4691         err = 0;
4692
4693 out:
4694         tp->tg3_flags = orig_tg3_flags;
4695         return err;
4696 }
4697
4698 /* tp->lock is held. */
4699 static int tg3_load_5701_a0_firmware_fix(struct tg3 *tp)
4700 {
4701         struct fw_info info;
4702         int err, i;
4703
4704         info.text_base = TG3_FW_TEXT_ADDR;
4705         info.text_len = TG3_FW_TEXT_LEN;
4706         info.text_data = &tg3FwText[0];
4707         info.rodata_base = TG3_FW_RODATA_ADDR;
4708         info.rodata_len = TG3_FW_RODATA_LEN;
4709         info.rodata_data = &tg3FwRodata[0];
4710         info.data_base = TG3_FW_DATA_ADDR;
4711         info.data_len = TG3_FW_DATA_LEN;
4712         info.data_data = NULL;
4713
4714         err = tg3_load_firmware_cpu(tp, RX_CPU_BASE,
4715                                     RX_CPU_SCRATCH_BASE, RX_CPU_SCRATCH_SIZE,
4716                                     &info);
4717         if (err)
4718                 return err;
4719
4720         err = tg3_load_firmware_cpu(tp, TX_CPU_BASE,
4721                                     TX_CPU_SCRATCH_BASE, TX_CPU_SCRATCH_SIZE,
4722                                     &info);
4723         if (err)
4724                 return err;
4725
4726         /* Now startup only the RX cpu. */
4727         tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
4728         tw32_f(RX_CPU_BASE + CPU_PC,    TG3_FW_TEXT_ADDR);
4729
4730         for (i = 0; i < 5; i++) {
4731                 if (tr32(RX_CPU_BASE + CPU_PC) == TG3_FW_TEXT_ADDR)
4732                         break;
4733                 tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
4734                 tw32(RX_CPU_BASE + CPU_MODE,  CPU_MODE_HALT);
4735                 tw32_f(RX_CPU_BASE + CPU_PC,    TG3_FW_TEXT_ADDR);
4736                 udelay(1000);
4737         }
4738         if (i >= 5) {
4739                 printk(KERN_ERR PFX "tg3_load_firmware fails for %s "
4740                        "to set RX CPU PC, is %08x should be %08x\n",
4741                        tp->dev->name, tr32(RX_CPU_BASE + CPU_PC),
4742                        TG3_FW_TEXT_ADDR);
4743                 return -ENODEV;
4744         }
4745         tw32(RX_CPU_BASE + CPU_STATE, 0xffffffff);
4746         tw32_f(RX_CPU_BASE + CPU_MODE,  0x00000000);
4747
4748         return 0;
4749 }
4750
4751 #if TG3_TSO_SUPPORT != 0
4752
4753 #define TG3_TSO_FW_RELEASE_MAJOR        0x1
4754 #define TG3_TSO_FW_RELASE_MINOR         0x6
4755 #define TG3_TSO_FW_RELEASE_FIX          0x0
4756 #define TG3_TSO_FW_START_ADDR           0x08000000
4757 #define TG3_TSO_FW_TEXT_ADDR            0x08000000
4758 #define TG3_TSO_FW_TEXT_LEN             0x1aa0
4759 #define TG3_TSO_FW_RODATA_ADDR          0x08001aa0
4760 #define TG3_TSO_FW_RODATA_LEN           0x60
4761 #define TG3_TSO_FW_DATA_ADDR            0x08001b20
4762 #define TG3_TSO_FW_DATA_LEN             0x30
4763 #define TG3_TSO_FW_SBSS_ADDR            0x08001b50
4764 #define TG3_TSO_FW_SBSS_LEN             0x2c
4765 #define TG3_TSO_FW_BSS_ADDR             0x08001b80
4766 #define TG3_TSO_FW_BSS_LEN              0x894
4767
4768 static u32 tg3TsoFwText[(TG3_TSO_FW_TEXT_LEN / 4) + 1] = {
4769         0x0e000003, 0x00000000, 0x08001b24, 0x00000000, 0x10000003, 0x00000000,
4770         0x0000000d, 0x0000000d, 0x3c1d0800, 0x37bd4000, 0x03a0f021, 0x3c100800,
4771         0x26100000, 0x0e000010, 0x00000000, 0x0000000d, 0x27bdffe0, 0x3c04fefe,
4772         0xafbf0018, 0x0e0005d8, 0x34840002, 0x0e000668, 0x00000000, 0x3c030800,
4773         0x90631b68, 0x24020002, 0x3c040800, 0x24841aac, 0x14620003, 0x24050001,
4774         0x3c040800, 0x24841aa0, 0x24060006, 0x00003821, 0xafa00010, 0x0e00067c,
4775         0xafa00014, 0x8f625c50, 0x34420001, 0xaf625c50, 0x8f625c90, 0x34420001,
4776         0xaf625c90, 0x2402ffff, 0x0e000034, 0xaf625404, 0x8fbf0018, 0x03e00008,
4777         0x27bd0020, 0x00000000, 0x00000000, 0x00000000, 0x27bdffe0, 0xafbf001c,
4778         0xafb20018, 0xafb10014, 0x0e00005b, 0xafb00010, 0x24120002, 0x24110001,
4779         0x8f706820, 0x32020100, 0x10400003, 0x00000000, 0x0e0000bb, 0x00000000,
4780         0x8f706820, 0x32022000, 0x10400004, 0x32020001, 0x0e0001f0, 0x24040001,
4781         0x32020001, 0x10400003, 0x00000000, 0x0e0000a3, 0x00000000, 0x3c020800,
4782         0x90421b98, 0x14520003, 0x00000000, 0x0e0004c0, 0x00000000, 0x0a00003c,
4783         0xaf715028, 0x8fbf001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x03e00008,
4784         0x27bd0020, 0x27bdffe0, 0x3c040800, 0x24841ac0, 0x00002821, 0x00003021,
4785         0x00003821, 0xafbf0018, 0xafa00010, 0x0e00067c, 0xafa00014, 0x3c040800,
4786         0x248423d8, 0xa4800000, 0x3c010800, 0xa0201b98, 0x3c010800, 0xac201b9c,
4787         0x3c010800, 0xac201ba0, 0x3c010800, 0xac201ba4, 0x3c010800, 0xac201bac,
4788         0x3c010800, 0xac201bb8, 0x3c010800, 0xac201bbc, 0x8f624434, 0x3c010800,
4789         0xac221b88, 0x8f624438, 0x3c010800, 0xac221b8c, 0x8f624410, 0xac80f7a8,
4790         0x3c010800, 0xac201b84, 0x3c010800, 0xac2023e0, 0x3c010800, 0xac2023c8,
4791         0x3c010800, 0xac2023cc, 0x3c010800, 0xac202400, 0x3c010800, 0xac221b90,
4792         0x8f620068, 0x24030007, 0x00021702, 0x10430005, 0x00000000, 0x8f620068,
4793         0x00021702, 0x14400004, 0x24020001, 0x3c010800, 0x0a000097, 0xac20240c,
4794         0xac820034, 0x3c040800, 0x24841acc, 0x3c050800, 0x8ca5240c, 0x00003021,
4795         0x00003821, 0xafa00010, 0x0e00067c, 0xafa00014, 0x8fbf0018, 0x03e00008,
4796         0x27bd0020, 0x27bdffe0, 0x3c040800, 0x24841ad8, 0x00002821, 0x00003021,
4797         0x00003821, 0xafbf0018, 0xafa00010, 0x0e00067c, 0xafa00014, 0x0e00005b,
4798         0x00000000, 0x0e0000b4, 0x00002021, 0x8fbf0018, 0x03e00008, 0x27bd0020,
4799         0x24020001, 0x8f636820, 0x00821004, 0x00021027, 0x00621824, 0x03e00008,
4800         0xaf636820, 0x27bdffd0, 0xafbf002c, 0xafb60028, 0xafb50024, 0xafb40020,
4801         0xafb3001c, 0xafb20018, 0xafb10014, 0xafb00010, 0x8f675c5c, 0x3c030800,
4802         0x24631bbc, 0x8c620000, 0x14470005, 0x3c0200ff, 0x3c020800, 0x90421b98,
4803         0x14400119, 0x3c0200ff, 0x3442fff8, 0x00e28824, 0xac670000, 0x00111902,
4804         0x306300ff, 0x30e20003, 0x000211c0, 0x00622825, 0x00a04021, 0x00071602,
4805         0x3c030800, 0x90631b98, 0x3044000f, 0x14600036, 0x00804821, 0x24020001,
4806         0x3c010800, 0xa0221b98, 0x00051100, 0x00821025, 0x3c010800, 0xac201b9c,
4807         0x3c010800, 0xac201ba0, 0x3c010800, 0xac201ba4, 0x3c010800, 0xac201bac,
4808         0x3c010800, 0xac201bb8, 0x3c010800, 0xac201bb0, 0x3c010800, 0xac201bb4,
4809         0x3c010800, 0xa42223d8, 0x9622000c, 0x30437fff, 0x3c010800, 0xa4222410,
4810         0x30428000, 0x3c010800, 0xa4231bc6, 0x10400005, 0x24020001, 0x3c010800,
4811         0xac2223f4, 0x0a000102, 0x2406003e, 0x24060036, 0x3c010800, 0xac2023f4,
4812         0x9622000a, 0x3c030800, 0x94631bc6, 0x3c010800, 0xac2023f0, 0x3c010800,
4813         0xac2023f8, 0x00021302, 0x00021080, 0x00c21021, 0x00621821, 0x3c010800,
4814         0xa42223d0, 0x3c010800, 0x0a000115, 0xa4231b96, 0x9622000c, 0x3c010800,
4815         0xa42223ec, 0x3c040800, 0x24841b9c, 0x8c820000, 0x00021100, 0x3c010800,
4816         0x00220821, 0xac311bc8, 0x8c820000, 0x00021100, 0x3c010800, 0x00220821,
4817         0xac271bcc, 0x8c820000, 0x25030001, 0x306601ff, 0x00021100, 0x3c010800,
4818         0x00220821, 0xac261bd0, 0x8c820000, 0x00021100, 0x3c010800, 0x00220821,
4819         0xac291bd4, 0x96230008, 0x3c020800, 0x8c421bac, 0x00432821, 0x3c010800,
4820         0xac251bac, 0x9622000a, 0x30420004, 0x14400018, 0x00061100, 0x8f630c14,
4821         0x3063000f, 0x2c620002, 0x1440000b, 0x3c02c000, 0x8f630c14, 0x3c020800,
4822         0x8c421b40, 0x3063000f, 0x24420001, 0x3c010800, 0xac221b40, 0x2c620002,
4823         0x1040fff7, 0x3c02c000, 0x00e21825, 0xaf635c5c, 0x8f625c50, 0x30420002,
4824         0x10400014, 0x00000000, 0x0a000147, 0x00000000, 0x3c030800, 0x8c631b80,
4825         0x3c040800, 0x94841b94, 0x01221025, 0x3c010800, 0xa42223da, 0x24020001,
4826         0x3c010800, 0xac221bb8, 0x24630001, 0x0085202a, 0x3c010800, 0x10800003,
4827         0xac231b80, 0x3c010800, 0xa4251b94, 0x3c060800, 0x24c61b9c, 0x8cc20000,
4828         0x24420001, 0xacc20000, 0x28420080, 0x14400005, 0x00000000, 0x0e000656,
4829         0x24040002, 0x0a0001e6, 0x00000000, 0x3c020800, 0x8c421bb8, 0x10400078,
4830         0x24020001, 0x3c050800, 0x90a51b98, 0x14a20072, 0x00000000, 0x3c150800,
4831         0x96b51b96, 0x3c040800, 0x8c841bac, 0x32a3ffff, 0x0083102a, 0x1440006c,
4832         0x00000000, 0x14830003, 0x00000000, 0x3c010800, 0xac2523f0, 0x1060005c,
4833         0x00009021, 0x24d60004, 0x0060a021, 0x24d30014, 0x8ec20000, 0x00028100,
4834         0x3c110800, 0x02308821, 0x0e000625, 0x8e311bc8, 0x00402821, 0x10a00054,
4835         0x00000000, 0x9628000a, 0x31020040, 0x10400005, 0x2407180c, 0x8e22000c,
4836         0x2407188c, 0x00021400, 0xaca20018, 0x3c030800, 0x00701821, 0x8c631bd0,
4837         0x3c020800, 0x00501021, 0x8c421bd4, 0x00031d00, 0x00021400, 0x00621825,
4838         0xaca30014, 0x8ec30004, 0x96220008, 0x00432023, 0x3242ffff, 0x3083ffff,
4839         0x00431021, 0x0282102a, 0x14400002, 0x02b23023, 0x00803021, 0x8e620000,
4840         0x30c4ffff, 0x00441021, 0xae620000, 0x8e220000, 0xaca20000, 0x8e220004,
4841         0x8e63fff4, 0x00431021, 0xaca20004, 0xa4a6000e, 0x8e62fff4, 0x00441021,
4842         0xae62fff4, 0x96230008, 0x0043102a, 0x14400005, 0x02469021, 0x8e62fff0,
4843         0xae60fff4, 0x24420001, 0xae62fff0, 0xaca00008, 0x3242ffff, 0x14540008,
4844         0x24020305, 0x31020080, 0x54400001, 0x34e70010, 0x24020905, 0xa4a2000c,
4845         0x0a0001cb, 0x34e70020, 0xa4a2000c, 0x3c020800, 0x8c4223f0, 0x10400003,
4846         0x3c024b65, 0x0a0001d3, 0x34427654, 0x3c02b49a, 0x344289ab, 0xaca2001c,
4847         0x30e2ffff, 0xaca20010, 0x0e0005a2, 0x00a02021, 0x3242ffff, 0x0054102b,
4848         0x1440ffa9, 0x00000000, 0x24020002, 0x3c010800, 0x0a0001e6, 0xa0221b98,
4849         0x8ec2083c, 0x24420001, 0x0a0001e6, 0xaec2083c, 0x0e0004c0, 0x00000000,
4850         0x8fbf002c, 0x8fb60028, 0x8fb50024, 0x8fb40020, 0x8fb3001c, 0x8fb20018,
4851         0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0030, 0x27bdffd0, 0xafbf0028,
4852         0xafb30024, 0xafb20020, 0xafb1001c, 0xafb00018, 0x8f725c9c, 0x3c0200ff,
4853         0x3442fff8, 0x3c070800, 0x24e71bb4, 0x02428824, 0x9623000e, 0x8ce20000,
4854         0x00431021, 0xace20000, 0x8e220010, 0x30420020, 0x14400011, 0x00809821,
4855         0x0e00063b, 0x02202021, 0x3c02c000, 0x02421825, 0xaf635c9c, 0x8f625c90,
4856         0x30420002, 0x1040011e, 0x00000000, 0xaf635c9c, 0x8f625c90, 0x30420002,
4857         0x10400119, 0x00000000, 0x0a00020d, 0x00000000, 0x8e240008, 0x8e230014,
4858         0x00041402, 0x000231c0, 0x00031502, 0x304201ff, 0x2442ffff, 0x3042007f,
4859         0x00031942, 0x30637800, 0x00021100, 0x24424000, 0x00624821, 0x9522000a,
4860         0x3084ffff, 0x30420008, 0x104000b0, 0x000429c0, 0x3c020800, 0x8c422400,
4861         0x14400024, 0x24c50008, 0x94c20014, 0x3c010800, 0xa42223d0, 0x8cc40010,
4862         0x00041402, 0x3c010800, 0xa42223d2, 0x3c010800, 0xa42423d4, 0x94c2000e,
4863         0x3083ffff, 0x00431023, 0x3c010800, 0xac222408, 0x94c2001a, 0x3c010800,
4864         0xac262400, 0x3c010800, 0xac322404, 0x3c010800, 0xac2223fc, 0x3c02c000,
4865         0x02421825, 0xaf635c9c, 0x8f625c90, 0x30420002, 0x104000e5, 0x00000000,
4866         0xaf635c9c, 0x8f625c90, 0x30420002, 0x104000e0, 0x00000000, 0x0a000246,
4867         0x00000000, 0x94c2000e, 0x3c030800, 0x946323d4, 0x00434023, 0x3103ffff,
4868         0x2c620008, 0x1040001c, 0x00000000, 0x94c20014, 0x24420028, 0x00a22821,
4869         0x00031042, 0x1840000b, 0x00002021, 0x24e60848, 0x00403821, 0x94a30000,
4870         0x8cc20000, 0x24840001, 0x00431021, 0xacc20000, 0x0087102a, 0x1440fff9,
4871         0x24a50002, 0x31020001, 0x1040001f, 0x3c024000, 0x3c040800, 0x248423fc,
4872         0xa0a00001, 0x94a30000, 0x8c820000, 0x00431021, 0x0a000285, 0xac820000,
4873         0x8f626800, 0x3c030010, 0x00431024, 0x10400009, 0x00000000, 0x94c2001a,
4874         0x3c030800, 0x8c6323fc, 0x00431021, 0x3c010800, 0xac2223fc, 0x0a000286,
4875         0x3c024000, 0x94c2001a, 0x94c4001c, 0x3c030800, 0x8c6323fc, 0x00441023,
4876         0x00621821, 0x3c010800, 0xac2323fc, 0x3c024000, 0x02421825, 0xaf635c9c,
4877         0x8f625c90, 0x30420002, 0x1440fffc, 0x00000000, 0x9522000a, 0x30420010,
4878         0x1040009b, 0x00000000, 0x3c030800, 0x946323d4, 0x3c070800, 0x24e72400,
4879         0x8ce40000, 0x8f626800, 0x24630030, 0x00832821, 0x3c030010, 0x00431024,
4880         0x1440000a, 0x00000000, 0x94a20004, 0x3c040800, 0x8c842408, 0x3c030800,
4881         0x8c6323fc, 0x00441023, 0x00621821, 0x3c010800, 0xac2323fc, 0x3c040800,
4882         0x8c8423fc, 0x00041c02, 0x3082ffff, 0x00622021, 0x00041402, 0x00822021,
4883         0x00041027, 0xa4a20006, 0x3c030800, 0x8c632404, 0x3c0200ff, 0x3442fff8,
4884         0x00628824, 0x96220008, 0x24050001, 0x24034000, 0x000231c0, 0x00801021,
4885         0xa4c2001a, 0xa4c0001c, 0xace00000, 0x3c010800, 0xac251b60, 0xaf635cb8,
4886         0x8f625cb0, 0x30420002, 0x10400003, 0x00000000, 0x3c010800, 0xac201b60,
4887         0x8e220008, 0xaf625cb8, 0x8f625cb0, 0x30420002, 0x10400003, 0x00000000,
4888         0x3c010800, 0xac201b60, 0x3c020800, 0x8c421b60, 0x1040ffec, 0x00000000,
4889         0x3c040800, 0x0e00063b, 0x8c842404, 0x0a00032a, 0x00000000, 0x3c030800,
4890         0x90631b98, 0x24020002, 0x14620003, 0x3c034b65, 0x0a0002e1, 0x00008021,
4891         0x8e22001c, 0x34637654, 0x10430002, 0x24100002, 0x24100001, 0x00c02021,
4892         0x0e000350, 0x02003021, 0x24020003, 0x3c010800, 0xa0221b98, 0x24020002,
4893         0x1202000a, 0x24020001, 0x3c030800, 0x8c6323f0, 0x10620006, 0x00000000,
4894         0x3c020800, 0x944223d8, 0x00021400, 0x0a00031f, 0xae220014, 0x3c040800,
4895         0x248423da, 0x94820000, 0x00021400, 0xae220014, 0x3c020800, 0x8c421bbc,
4896         0x3c03c000, 0x3c010800, 0xa0201b98, 0x00431025, 0xaf625c5c, 0x8f625c50,
4897         0x30420002, 0x10400009, 0x00000000, 0x2484f7e2, 0x8c820000, 0x00431025,
4898         0xaf625c5c, 0x8f625c50, 0x30420002, 0x1440fffa, 0x00000000, 0x3c020800,
4899         0x24421b84, 0x8c430000, 0x24630001, 0xac430000, 0x8f630c14, 0x3063000f,
4900         0x2c620002, 0x1440000c, 0x3c024000, 0x8f630c14, 0x3c020800, 0x8c421b40,
4901         0x3063000f, 0x24420001, 0x3c010800, 0xac221b40, 0x2c620002, 0x1040fff7,
4902         0x00000000, 0x3c024000, 0x02421825, 0xaf635c9c, 0x8f625c90, 0x30420002,
4903         0x1440fffc, 0x00000000, 0x12600003, 0x00000000, 0x0e0004c0, 0x00000000,
4904         0x8fbf0028, 0x8fb30024, 0x8fb20020, 0x8fb1001c, 0x8fb00018, 0x03e00008,
4905         0x27bd0030, 0x8f634450, 0x3c040800, 0x24841b88, 0x8c820000, 0x00031c02,
4906         0x0043102b, 0x14400007, 0x3c038000, 0x8c840004, 0x8f624450, 0x00021c02,
4907         0x0083102b, 0x1040fffc, 0x3c038000, 0xaf634444, 0x8f624444, 0x00431024,
4908         0x1440fffd, 0x00000000, 0x8f624448, 0x03e00008, 0x3042ffff, 0x3c024000,
4909         0x00822025, 0xaf645c38, 0x8f625c30, 0x30420002, 0x1440fffc, 0x00000000,
4910         0x03e00008, 0x00000000, 0x27bdffe0, 0x00805821, 0x14c00011, 0x256e0008,
4911         0x3c020800, 0x8c4223f4, 0x10400007, 0x24020016, 0x3c010800, 0xa42223d2,
4912         0x2402002a, 0x3c010800, 0x0a000364, 0xa42223d4, 0x8d670010, 0x00071402,
4913         0x3c010800, 0xa42223d2, 0x3c010800, 0xa42723d4, 0x3c040800, 0x948423d4,
4914         0x3c030800, 0x946323d2, 0x95cf0006, 0x3c020800, 0x944223d0, 0x00832023,
4915         0x01e2c023, 0x3065ffff, 0x24a20028, 0x01c24821, 0x3082ffff, 0x14c0001a,
4916         0x01226021, 0x9582000c, 0x3042003f, 0x3c010800, 0xa42223d6, 0x95820004,
4917         0x95830006, 0x3c010800, 0xac2023e4, 0x3c010800, 0xac2023e8, 0x00021400,
4918         0x00431025, 0x3c010800, 0xac221bc0, 0x95220004, 0x3c010800, 0xa4221bc4,
4919         0x95230002, 0x01e51023, 0x0043102a, 0x10400010, 0x24020001, 0x3c010800,
4920         0x0a000398, 0xac2223f8, 0x3c030800, 0x8c6323e8, 0x3c020800, 0x94421bc4,
4921         0x00431021, 0xa5220004, 0x3c020800, 0x94421bc0, 0xa5820004, 0x3c020800,
4922         0x8c421bc0, 0xa5820006, 0x3c020800, 0x8c4223f0, 0x3c0d0800, 0x8dad23e4,
4923         0x3c0a0800, 0x144000e5, 0x8d4a23e8, 0x3c020800, 0x94421bc4, 0x004a1821,
4924         0x3063ffff, 0x0062182b, 0x24020002, 0x10c2000d, 0x01435023, 0x3c020800,
4925         0x944223d6, 0x30420009, 0x10400008, 0x00000000, 0x9582000c, 0x3042fff6,
4926         0xa582000c, 0x3c020800, 0x944223d6, 0x30420009, 0x01a26823, 0x3c020800,
4927         0x8c4223f8, 0x1040004a, 0x01203821, 0x3c020800, 0x944223d2, 0x00004021,
4928         0xa520000a, 0x01e21023, 0xa5220002, 0x3082ffff, 0x00021042, 0x18400008,
4929         0x00003021, 0x00401821, 0x94e20000, 0x25080001, 0x00c23021, 0x0103102a,
4930         0x1440fffb, 0x24e70002, 0x00061c02, 0x30c2ffff, 0x00623021, 0x00061402,
4931         0x00c23021, 0x00c02821, 0x00061027, 0xa522000a, 0x00003021, 0x2527000c,
4932         0x00004021, 0x94e20000, 0x25080001, 0x00c23021, 0x2d020004, 0x1440fffb,
4933         0x24e70002, 0x95220002, 0x00004021, 0x91230009, 0x00442023, 0x01803821,
4934         0x3082ffff, 0xa4e00010, 0x00621821, 0x00021042, 0x18400010, 0x00c33021,
4935         0x00404821, 0x94e20000, 0x24e70002, 0x00c23021, 0x30e2007f, 0x14400006,
4936         0x25080001, 0x8d630000, 0x3c02007f, 0x3442ff80, 0x00625824, 0x25670008,
4937         0x0109102a, 0x1440fff3, 0x00000000, 0x30820001, 0x10400005, 0x00061c02,
4938         0xa0e00001, 0x94e20000, 0x00c23021, 0x00061c02, 0x30c2ffff, 0x00623021,
4939         0x00061402, 0x00c23021, 0x0a00047d, 0x30c6ffff, 0x24020002, 0x14c20081,
4940         0x00000000, 0x3c020800, 0x8c42240c, 0x14400007, 0x00000000, 0x3c020800,
4941         0x944223d2, 0x95230002, 0x01e21023, 0x10620077, 0x00000000, 0x3c020800,
4942         0x944223d2, 0x01e21023, 0xa5220002, 0x3c020800, 0x8c42240c, 0x1040001a,
4943         0x31e3ffff, 0x8dc70010, 0x3c020800, 0x94421b96, 0x00e04021, 0x00072c02,
4944         0x00aa2021, 0x00431023, 0x00823823, 0x00072402, 0x30e2ffff, 0x00823821,
4945         0x00071027, 0xa522000a, 0x3102ffff, 0x3c040800, 0x948423d4, 0x00453023,
4946         0x00e02821, 0x00641823, 0x006d1821, 0x00c33021, 0x00061c02, 0x30c2ffff,
4947         0x0a00047d, 0x00623021, 0x01203821, 0x00004021, 0x3082ffff, 0x00021042,
4948         0x18400008, 0x00003021, 0x00401821, 0x94e20000, 0x25080001, 0x00c23021,
4949         0x0103102a, 0x1440fffb, 0x24e70002, 0x00061c02, 0x30c2ffff, 0x00623021,
4950         0x00061402, 0x00c23021, 0x00c02821, 0x00061027, 0xa522000a, 0x00003021,
4951         0x2527000c, 0x00004021, 0x94e20000, 0x25080001, 0x00c23021, 0x2d020004,
4952         0x1440fffb, 0x24e70002, 0x95220002, 0x00004021, 0x91230009, 0x00442023,
4953         0x01803821, 0x3082ffff, 0xa4e00010, 0x3c040800, 0x948423d4, 0x00621821,
4954         0x00c33021, 0x00061c02, 0x30c2ffff, 0x00623021, 0x00061c02, 0x3c020800,
4955         0x944223d0, 0x00c34821, 0x00441023, 0x00021fc2, 0x00431021, 0x00021043,
4956         0x18400010, 0x00003021, 0x00402021, 0x94e20000, 0x24e70002, 0x00c23021,
4957         0x30e2007f, 0x14400006, 0x25080001, 0x8d630000, 0x3c02007f, 0x3442ff80,
4958         0x00625824, 0x25670008, 0x0104102a, 0x1440fff3, 0x00000000, 0x3c020800,
4959         0x944223ec, 0x00c23021, 0x3122ffff, 0x00c23021, 0x00061c02, 0x30c2ffff,
4960         0x00623021, 0x00061402, 0x00c23021, 0x00c04021, 0x00061027, 0xa5820010,
4961         0xadc00014, 0x0a00049d, 0xadc00000, 0x8dc70010, 0x00e04021, 0x11400007,
4962         0x00072c02, 0x00aa3021, 0x00061402, 0x30c3ffff, 0x00433021, 0x00061402,
4963         0x00c22821, 0x00051027, 0xa522000a, 0x3c030800, 0x946323d4, 0x3102ffff,
4964         0x01e21021, 0x00433023, 0x00cd3021, 0x00061c02, 0x30c2ffff, 0x00623021,
4965         0x00061402, 0x00c23021, 0x00c04021, 0x00061027, 0xa5820010, 0x3102ffff,
4966         0x00051c00, 0x00431025, 0xadc20010, 0x3c020800, 0x8c4223f4, 0x10400005,
4967         0x2de205eb, 0x14400002, 0x25e2fff2, 0x34028870, 0xa5c20034, 0x3c030800,
4968         0x246323e8, 0x8c620000, 0x24420001, 0xac620000, 0x3c040800, 0x8c8423e4,
4969         0x3c020800, 0x8c421bc0, 0x3303ffff, 0x00832021, 0x00431821, 0x0062102b,
4970         0x3c010800, 0xac2423e4, 0x10400003, 0x2482ffff, 0x3c010800, 0xac2223e4,
4971         0x3c010800, 0xac231bc0, 0x03e00008, 0x27bd0020, 0x27bdffb8, 0x3c050800,
4972         0x24a51b96, 0xafbf0044, 0xafbe0040, 0xafb7003c, 0xafb60038, 0xafb50034,
4973         0xafb40030, 0xafb3002c, 0xafb20028, 0xafb10024, 0xafb00020, 0x94a90000,
4974         0x3c020800, 0x944223d0, 0x3c030800, 0x8c631bb0, 0x3c040800, 0x8c841bac,
4975         0x01221023, 0x0064182a, 0xa7a9001e, 0x106000be, 0xa7a20016, 0x24be0022,
4976         0x97b6001e, 0x24b3001a, 0x24b70016, 0x8fc20000, 0x14400008, 0x00000000,
4977         0x8fc2fff8, 0x97a30016, 0x8fc4fff4, 0x00431021, 0x0082202a, 0x148000b0,
4978         0x00000000, 0x97d50818, 0x32a2ffff, 0x104000a3, 0x00009021, 0x0040a021,
4979         0x00008821, 0x0e000625, 0x00000000, 0x00403021, 0x14c00007, 0x00000000,
4980         0x3c020800, 0x8c4223dc, 0x24420001, 0x3c010800, 0x0a000596, 0xac2223dc,
4981         0x3c100800, 0x02118021, 0x8e101bc8, 0x9608000a, 0x31020040, 0x10400005,
4982         0x2407180c, 0x8e02000c, 0x2407188c, 0x00021400, 0xacc20018, 0x31020080,
4983         0x54400001, 0x34e70010, 0x3c020800, 0x00511021, 0x8c421bd0, 0x3c030800,
4984         0x00711821, 0x8c631bd4, 0x00021500, 0x00031c00, 0x00431025, 0xacc20014,
4985         0x96040008, 0x3242ffff, 0x00821021, 0x0282102a, 0x14400002, 0x02b22823,
4986         0x00802821, 0x8e020000, 0x02459021, 0xacc20000, 0x8e020004, 0x00c02021,
4987         0x26310010, 0xac820004, 0x30e2ffff, 0xac800008, 0xa485000e, 0xac820010,
4988         0x24020305, 0x0e0005a2, 0xa482000c, 0x3242ffff, 0x0054102b, 0x1440ffc5,
4989         0x3242ffff, 0x0a00058e, 0x00000000, 0x8e620000, 0x8e63fffc, 0x0043102a,
4990         0x10400067, 0x00000000, 0x8e62fff0, 0x00028900, 0x3c100800, 0x02118021,
4991         0x0e000625, 0x8e101bc8, 0x00403021, 0x14c00005, 0x00000000, 0x8e62082c,
4992         0x24420001, 0x0a000596, 0xae62082c, 0x9608000a, 0x31020040, 0x10400005,
4993         0x2407180c, 0x8e02000c, 0x2407188c, 0x00021400, 0xacc20018, 0x3c020800,
4994         0x00511021, 0x8c421bd0, 0x3c030800, 0x00711821, 0x8c631bd4, 0x00021500,
4995         0x00031c00, 0x00431025, 0xacc20014, 0x8e63fff4, 0x96020008, 0x00432023,
4996         0x3242ffff, 0x3083ffff, 0x00431021, 0x02c2102a, 0x10400003, 0x00802821,
4997         0x97a9001e, 0x01322823, 0x8e620000, 0x30a4ffff, 0x00441021, 0xae620000,
4998         0xa4c5000e, 0x8e020000, 0xacc20000, 0x8e020004, 0x8e63fff4, 0x00431021,
4999         0xacc20004, 0x8e63fff4, 0x96020008, 0x00641821, 0x0062102a, 0x14400006,
5000         0x02459021, 0x8e62fff0, 0xae60fff4, 0x24420001, 0x0a000571, 0xae62fff0,
5001         0xae63fff4, 0xacc00008, 0x3242ffff, 0x10560003, 0x31020004, 0x10400006,
5002         0x24020305, 0x31020080, 0x54400001, 0x34e70010, 0x34e70020, 0x24020905,
5003         0xa4c2000c, 0x8ee30000, 0x8ee20004, 0x14620007, 0x3c02b49a, 0x8ee20860,
5004         0x54400001, 0x34e70400, 0x3c024b65, 0x0a000588, 0x34427654, 0x344289ab,
5005         0xacc2001c, 0x30e2ffff, 0xacc20010, 0x0e0005a2, 0x00c02021, 0x3242ffff,
5006         0x0056102b, 0x1440ff9b, 0x00000000, 0x8e620000, 0x8e63fffc, 0x0043102a,
5007         0x1440ff48, 0x00000000, 0x8fbf0044, 0x8fbe0040, 0x8fb7003c, 0x8fb60038,
5008         0x8fb50034, 0x8fb40030, 0x8fb3002c, 0x8fb20028, 0x8fb10024, 0x8fb00020,
5009         0x03e00008, 0x27bd0048, 0x27bdffe8, 0xafbf0014, 0xafb00010, 0x8f624450,
5010         0x8f634410, 0x0a0005b1, 0x00808021, 0x8f626820, 0x30422000, 0x10400003,
5011         0x00000000, 0x0e0001f0, 0x00002021, 0x8f624450, 0x8f634410, 0x3042ffff,
5012         0x0043102b, 0x1440fff5, 0x00000000, 0x8f630c14, 0x3063000f, 0x2c620002,
5013         0x1440000b, 0x00000000, 0x8f630c14, 0x3c020800, 0x8c421b40, 0x3063000f,
5014         0x24420001, 0x3c010800, 0xac221b40, 0x2c620002, 0x1040fff7, 0x00000000,
5015         0xaf705c18, 0x8f625c10, 0x30420002, 0x10400009, 0x00000000, 0x8f626820,
5016         0x30422000, 0x1040fff8, 0x00000000, 0x0e0001f0, 0x00002021, 0x0a0005c4,
5017         0x00000000, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x00000000,
5018         0x00000000, 0x00000000, 0x27bdffe8, 0x3c1bc000, 0xafbf0014, 0xafb00010,
5019         0xaf60680c, 0x8f626804, 0x34420082, 0xaf626804, 0x8f634000, 0x24020b50,
5020         0x3c010800, 0xac221b54, 0x24020b78, 0x3c010800, 0xac221b64, 0x34630002,
5021         0xaf634000, 0x0e000605, 0x00808021, 0x3c010800, 0xa0221b68, 0x304200ff,
5022         0x24030002, 0x14430005, 0x00000000, 0x3c020800, 0x8c421b54, 0x0a0005f8,
5023         0xac5000c0, 0x3c020800, 0x8c421b54, 0xac5000bc, 0x8f624434, 0x8f634438,
5024         0x8f644410, 0x3c010800, 0xac221b5c, 0x3c010800, 0xac231b6c, 0x3c010800,
5025         0xac241b58, 0x8fbf0014, 0x8fb00010, 0x03e00008, 0x27bd0018, 0x3c040800,
5026         0x8c870000, 0x3c03aa55, 0x3463aa55, 0x3c06c003, 0xac830000, 0x8cc20000,
5027         0x14430007, 0x24050002, 0x3c0355aa, 0x346355aa, 0xac830000, 0x8cc20000,
5028         0x50430001, 0x24050001, 0x3c020800, 0xac470000, 0x03e00008, 0x00a01021,
5029         0x27bdfff8, 0x18800009, 0x00002821, 0x8f63680c, 0x8f62680c, 0x1043fffe,
5030         0x00000000, 0x24a50001, 0x00a4102a, 0x1440fff9, 0x00000000, 0x03e00008,
5031         0x27bd0008, 0x8f634450, 0x3c020800, 0x8c421b5c, 0x00031c02, 0x0043102b,
5032         0x14400008, 0x3c038000, 0x3c040800, 0x8c841b6c, 0x8f624450, 0x00021c02,
5033         0x0083102b, 0x1040fffc, 0x3c038000, 0xaf634444, 0x8f624444, 0x00431024,
5034         0x1440fffd, 0x00000000, 0x8f624448, 0x03e00008, 0x3042ffff, 0x3082ffff,
5035         0x2442e000, 0x2c422001, 0x14400003, 0x3c024000, 0x0a000648, 0x2402ffff,
5036         0x00822025, 0xaf645c38, 0x8f625c30, 0x30420002, 0x1440fffc, 0x00001021,
5037         0x03e00008, 0x00000000, 0x8f624450, 0x3c030800, 0x8c631b58, 0x0a000651,
5038         0x3042ffff, 0x8f624450, 0x3042ffff, 0x0043102b, 0x1440fffc, 0x00000000,
5039         0x03e00008, 0x00000000, 0x27bdffe0, 0x00802821, 0x3c040800, 0x24841af0,
5040         0x00003021, 0x00003821, 0xafbf0018, 0xafa00010, 0x0e00067c, 0xafa00014,
5041         0x0a000660, 0x00000000, 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x00000000,
5042         0x00000000, 0x00000000, 0x3c020800, 0x34423000, 0x3c030800, 0x34633000,
5043         0x3c040800, 0x348437ff, 0x3c010800, 0xac221b74, 0x24020040, 0x3c010800,
5044         0xac221b78, 0x3c010800, 0xac201b70, 0xac600000, 0x24630004, 0x0083102b,
5045         0x5040fffd, 0xac600000, 0x03e00008, 0x00000000, 0x00804821, 0x8faa0010,
5046         0x3c020800, 0x8c421b70, 0x3c040800, 0x8c841b78, 0x8fab0014, 0x24430001,
5047         0x0044102b, 0x3c010800, 0xac231b70, 0x14400003, 0x00004021, 0x3c010800,
5048         0xac201b70, 0x3c020800, 0x8c421b70, 0x3c030800, 0x8c631b74, 0x91240000,
5049         0x00021140, 0x00431021, 0x00481021, 0x25080001, 0xa0440000, 0x29020008,
5050         0x1440fff4, 0x25290001, 0x3c020800, 0x8c421b70, 0x3c030800, 0x8c631b74,
5051         0x8f64680c, 0x00021140, 0x00431021, 0xac440008, 0xac45000c, 0xac460010,
5052         0xac470014, 0xac4a0018, 0x03e00008, 0xac4b001c, 0x00000000, 0x00000000,
5053 };
5054
5055 static u32 tg3TsoFwRodata[] = {
5056         0x4d61696e, 0x43707542, 0x00000000, 0x4d61696e, 0x43707541, 0x00000000,
5057         0x00000000, 0x00000000, 0x73746b6f, 0x66666c64, 0x496e0000, 0x73746b6f,
5058         0x66662a2a, 0x00000000, 0x53774576, 0x656e7430, 0x00000000, 0x00000000,
5059         0x00000000, 0x00000000, 0x66617461, 0x6c457272, 0x00000000, 0x00000000,
5060         0x00000000,
5061 };
5062
5063 static u32 tg3TsoFwData[] = {
5064         0x00000000, 0x73746b6f, 0x66666c64, 0x5f76312e, 0x362e3000, 0x00000000,
5065         0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
5066         0x00000000,
5067 };
5068
5069 /* 5705 needs a special version of the TSO firmware.  */
5070 #define TG3_TSO5_FW_RELEASE_MAJOR       0x1
5071 #define TG3_TSO5_FW_RELASE_MINOR        0x2
5072 #define TG3_TSO5_FW_RELEASE_FIX         0x0
5073 #define TG3_TSO5_FW_START_ADDR          0x00010000
5074 #define TG3_TSO5_FW_TEXT_ADDR           0x00010000
5075 #define TG3_TSO5_FW_TEXT_LEN            0xe90
5076 #define TG3_TSO5_FW_RODATA_ADDR         0x00010e90
5077 #define TG3_TSO5_FW_RODATA_LEN          0x50
5078 #define TG3_TSO5_FW_DATA_ADDR           0x00010f00
5079 #define TG3_TSO5_FW_DATA_LEN            0x20
5080 #define TG3_TSO5_FW_SBSS_ADDR           0x00010f20
5081 #define TG3_TSO5_FW_SBSS_LEN            0x28
5082 #define TG3_TSO5_FW_BSS_ADDR            0x00010f50
5083 #define TG3_TSO5_FW_BSS_LEN             0x88
5084
5085 static u32 tg3Tso5FwText[(TG3_TSO5_FW_TEXT_LEN / 4) + 1] = {
5086         0x0c004003, 0x00000000, 0x00010f04, 0x00000000, 0x10000003, 0x00000000,
5087         0x0000000d, 0x0000000d, 0x3c1d0001, 0x37bde000, 0x03a0f021, 0x3c100001,
5088         0x26100000, 0x0c004010, 0x00000000, 0x0000000d, 0x27bdffe0, 0x3c04fefe,
5089         0xafbf0018, 0x0c0042e8, 0x34840002, 0x0c004364, 0x00000000, 0x3c030001,
5090         0x90630f34, 0x24020002, 0x3c040001, 0x24840e9c, 0x14620003, 0x24050001,
5091         0x3c040001, 0x24840e90, 0x24060002, 0x00003821, 0xafa00010, 0x0c004378,
5092         0xafa00014, 0x0c00402c, 0x00000000, 0x8fbf0018, 0x03e00008, 0x27bd0020,
5093         0x00000000, 0x00000000, 0x27bdffe0, 0xafbf001c, 0xafb20018, 0xafb10014,
5094         0x0c0042d4, 0xafb00010, 0x3c128000, 0x24110001, 0x8f706810, 0x32020400,
5095         0x10400007, 0x00000000, 0x8f641008, 0x00921024, 0x14400003, 0x00000000,
5096         0x0c004064, 0x00000000, 0x3c020001, 0x90420f56, 0x10510003, 0x32020200,
5097         0x1040fff1, 0x00000000, 0x0c0041b4, 0x00000000, 0x08004034, 0x00000000,
5098         0x8fbf001c, 0x8fb20018, 0x8fb10014, 0x8fb00010, 0x03e00008, 0x27bd0020,
5099         0x27bdffe0, 0x3c040001, 0x24840eb0, 0x00002821, 0x00003021, 0x00003821,
5100         0xafbf0018, 0xafa00010, 0x0c004378, 0xafa00014, 0x0000d021, 0x24020130,
5101         0xaf625000, 0x3c010001, 0xa4200f50, 0x3c010001, 0xa0200f57, 0x8fbf0018,
5102         0x03e00008, 0x27bd0020, 0x00000000, 0x00000000, 0x3c030001, 0x24630f60,
5103         0x90620000, 0x27bdfff0, 0x14400003, 0x0080c021, 0x08004073, 0x00004821,
5104         0x3c022000, 0x03021024, 0x10400003, 0x24090002, 0x08004073, 0xa0600000,
5105         0x24090001, 0x00181040, 0x30431f80, 0x346f8008, 0x1520004b, 0x25eb0028,
5106         0x3c040001, 0x00832021, 0x8c848010, 0x3c050001, 0x24a50f7a, 0x00041402,
5107         0xa0a20000, 0x3c010001, 0xa0240f7b, 0x3c020001, 0x00431021, 0x94428014,
5108         0x3c010001, 0xa0220f7c, 0x3c0c0001, 0x01836021, 0x8d8c8018, 0x304200ff,
5109         0x24420008, 0x000220c3, 0x24020001, 0x3c010001, 0xa0220f60, 0x0124102b,
5110         0x1040000c, 0x00003821, 0x24a6000e, 0x01602821, 0x8ca20000, 0x8ca30004,
5111         0x24a50008, 0x24e70001, 0xacc20000, 0xacc30004, 0x00e4102b, 0x1440fff8,
5112         0x24c60008, 0x00003821, 0x3c080001, 0x25080f7b, 0x91060000, 0x3c020001,
5113         0x90420f7c, 0x2503000d, 0x00c32821, 0x00461023, 0x00021fc2, 0x00431021,
5114         0x00021043, 0x1840000c, 0x00002021, 0x91020001, 0x00461023, 0x00021fc2,
5115         0x00431021, 0x00021843, 0x94a20000, 0x24e70001, 0x00822021, 0x00e3102a,
5116         0x1440fffb, 0x24a50002, 0x00041c02, 0x3082ffff, 0x00622021, 0x00041402,
5117         0x00822021, 0x3c02ffff, 0x01821024, 0x3083ffff, 0x00431025, 0x3c010001,
5118         0x080040fa, 0xac220f80, 0x3c050001, 0x24a50f7c, 0x90a20000, 0x3c0c0001,
5119         0x01836021, 0x8d8c8018, 0x000220c2, 0x1080000e, 0x00003821, 0x01603021,
5120         0x24a5000c, 0x8ca20000, 0x8ca30004, 0x24a50008, 0x24e70001, 0xacc20000,
5121         0xacc30004, 0x00e4102b, 0x1440fff8, 0x24c60008, 0x3c050001, 0x24a50f7c,
5122         0x90a20000, 0x30430007, 0x24020004, 0x10620011, 0x28620005, 0x10400005,
5123         0x24020002, 0x10620008, 0x000710c0, 0x080040fa, 0x00000000, 0x24020006,
5124         0x1062000e, 0x000710c0, 0x080040fa, 0x00000000, 0x00a21821, 0x9463000c,
5125         0x004b1021, 0x080040fa, 0xa4430000, 0x000710c0, 0x00a21821, 0x8c63000c,
5126         0x004b1021, 0x080040fa, 0xac430000, 0x00a21821, 0x8c63000c, 0x004b2021,
5127         0x00a21021, 0xac830000, 0x94420010, 0xa4820004, 0x95e70006, 0x3c020001,
5128         0x90420f7c, 0x3c030001, 0x90630f7a, 0x00e2c823, 0x3c020001, 0x90420f7b,
5129         0x24630028, 0x01e34021, 0x24420028, 0x15200012, 0x01e23021, 0x94c2000c,
5130         0x3c010001, 0xa4220f78, 0x94c20004, 0x94c30006, 0x3c010001, 0xa4200f76,
5131         0x3c010001, 0xa4200f72, 0x00021400, 0x00431025, 0x3c010001, 0xac220f6c,
5132         0x95020004, 0x3c010001, 0x08004124, 0xa4220f70, 0x3c020001, 0x94420f70,
5133         0x3c030001, 0x94630f72, 0x00431021, 0xa5020004, 0x3c020001, 0x94420f6c,
5134         0xa4c20004, 0x3c020001, 0x8c420f6c, 0xa4c20006, 0x3c040001, 0x94840f72,
5135         0x3c020001, 0x94420f70, 0x3c0a0001, 0x954a0f76, 0x00441821, 0x3063ffff,
5136         0x0062182a, 0x24020002, 0x1122000b, 0x00832023, 0x3c030001, 0x94630f78,
5137         0x30620009, 0x10400006, 0x3062fff6, 0xa4c2000c, 0x3c020001, 0x94420f78,
5138         0x30420009, 0x01425023, 0x24020001, 0x1122001b, 0x29220002, 0x50400005,
5139         0x24020002, 0x11200007, 0x31a2ffff, 0x08004197, 0x00000000, 0x1122001d,
5140         0x24020016, 0x08004197, 0x31a2ffff, 0x3c0e0001, 0x95ce0f80, 0x10800005,
5141         0x01806821, 0x01c42021, 0x00041c02, 0x3082ffff, 0x00627021, 0x000e1027,
5142         0xa502000a, 0x3c030001, 0x90630f7b, 0x31a2ffff, 0x00e21021, 0x0800418d,
5143         0x00432023, 0x3c020001, 0x94420f80, 0x00442021, 0x00041c02, 0x3082ffff,
5144         0x00622021, 0x00807021, 0x00041027, 0x08004185, 0xa502000a, 0x3c050001,
5145         0x24a50f7a, 0x90a30000, 0x14620002, 0x24e2fff2, 0xa5e20034, 0x90a20000,
5146         0x00e21023, 0xa5020002, 0x3c030001, 0x94630f80, 0x3c020001, 0x94420f5a,
5147         0x30e5ffff, 0x00641821, 0x00451023, 0x00622023, 0x00041c02, 0x3082ffff,
5148         0x00622021, 0x00041027, 0xa502000a, 0x3c030001, 0x90630f7c, 0x24620001,
5149         0x14a20005, 0x00807021, 0x01631021, 0x90420000, 0x08004185, 0x00026200,
5150         0x24620002, 0x14a20003, 0x306200fe, 0x004b1021, 0x944c0000, 0x3c020001,
5151         0x94420f82, 0x3183ffff, 0x3c040001, 0x90840f7b, 0x00431021, 0x00e21021,
5152         0x00442023, 0x008a2021, 0x00041c02, 0x3082ffff, 0x00622021, 0x00041402,
5153         0x00822021, 0x00806821, 0x00041027, 0xa4c20010, 0x31a2ffff, 0x000e1c00,
5154         0x00431025, 0x3c040001, 0x24840f72, 0xade20010, 0x94820000, 0x3c050001,
5155         0x94a50f76, 0x3c030001, 0x8c630f6c, 0x24420001, 0x00b92821, 0xa4820000,
5156         0x3322ffff, 0x00622021, 0x0083182b, 0x3c010001, 0xa4250f76, 0x10600003,
5157         0x24a2ffff, 0x3c010001, 0xa4220f76, 0x3c024000, 0x03021025, 0x3c010001,
5158         0xac240f6c, 0xaf621008, 0x03e00008, 0x27bd0010, 0x3c030001, 0x90630f56,
5159         0x27bdffe8, 0x24020001, 0xafbf0014, 0x10620026, 0xafb00010, 0x8f620cf4,
5160         0x2442ffff, 0x3042007f, 0x00021100, 0x8c434000, 0x3c010001, 0xac230f64,
5161         0x8c434008, 0x24444000, 0x8c5c4004, 0x30620040, 0x14400002, 0x24020088,
5162         0x24020008, 0x3c010001, 0xa4220f68, 0x30620004, 0x10400005, 0x24020001,
5163         0x3c010001, 0xa0220f57, 0x080041d5, 0x00031402, 0x3c010001, 0xa0200f57,
5164         0x00031402, 0x3c010001, 0xa4220f54, 0x9483000c, 0x24020001, 0x3c010001,
5165         0xa4200f50, 0x3c010001, 0xa0220f56, 0x3c010001, 0xa4230f62, 0x24020001,
5166         0x1342001e, 0x00000000, 0x13400005, 0x24020003, 0x13420067, 0x00000000,
5167         0x080042cf, 0x00000000, 0x3c020001, 0x94420f62, 0x241a0001, 0x3c010001,
5168         0xa4200f5e, 0x3c010001, 0xa4200f52, 0x304407ff, 0x00021bc2, 0x00031823,
5169         0x3063003e, 0x34630036, 0x00021242, 0x3042003c, 0x00621821, 0x3c010001,
5170         0xa4240f58, 0x00832021, 0x24630030, 0x3c010001, 0xa4240f5a, 0x3c010001,
5171         0xa4230f5c, 0x3c060001, 0x24c60f52, 0x94c50000, 0x94c30002, 0x3c040001,
5172         0x94840f5a, 0x00651021, 0x0044102a, 0x10400013, 0x3c108000, 0x00a31021,
5173         0xa4c20000, 0x3c02a000, 0xaf620cf4, 0x3c010001, 0xa0200f56, 0x8f641008,
5174         0x00901024, 0x14400003, 0x00000000, 0x0c004064, 0x00000000, 0x8f620cf4,
5175         0x00501024, 0x104000b7, 0x00000000, 0x0800420f, 0x00000000, 0x3c030001,
5176         0x94630f50, 0x00851023, 0xa4c40000, 0x00621821, 0x3042ffff, 0x3c010001,
5177         0xa4230f50, 0xaf620ce8, 0x3c020001, 0x94420f68, 0x34420024, 0xaf620cec,
5178         0x94c30002, 0x3c020001, 0x94420f50, 0x14620012, 0x3c028000, 0x3c108000,
5179         0x3c02a000, 0xaf620cf4, 0x3c010001, 0xa0200f56, 0x8f641008, 0x00901024,
5180         0x14400003, 0x00000000, 0x0c004064, 0x00000000, 0x8f620cf4, 0x00501024,
5181         0x1440fff7, 0x00000000, 0x080042cf, 0x241a0003, 0xaf620cf4, 0x3c108000,
5182         0x8f641008, 0x00901024, 0x14400003, 0x00000000, 0x0c004064, 0x00000000,
5183         0x8f620cf4, 0x00501024, 0x1440fff7, 0x00000000, 0x080042cf, 0x241a0003,
5184         0x3c070001, 0x24e70f50, 0x94e20000, 0x03821021, 0xaf620ce0, 0x3c020001,
5185         0x8c420f64, 0xaf620ce4, 0x3c050001, 0x94a50f54, 0x94e30000, 0x3c040001,
5186         0x94840f58, 0x3c020001, 0x94420f5e, 0x00a32823, 0x00822023, 0x30a6ffff,
5187         0x3083ffff, 0x00c3102b, 0x14400043, 0x00000000, 0x3c020001, 0x94420f5c,
5188         0x00021400, 0x00621025, 0xaf620ce8, 0x94e20000, 0x3c030001, 0x94630f54,
5189         0x00441021, 0xa4e20000, 0x3042ffff, 0x14430021, 0x3c020008, 0x3c020001,
5190         0x90420f57, 0x10400006, 0x3c03000c, 0x3c020001, 0x94420f68, 0x34630624,
5191         0x0800427c, 0x0000d021, 0x3c020001, 0x94420f68, 0x3c030008, 0x34630624,
5192         0x00431025, 0xaf620cec, 0x3c108000, 0x3c02a000, 0xaf620cf4, 0x3c010001,
5193         0xa0200f56, 0x8f641008, 0x00901024, 0x14400003, 0x00000000, 0x0c004064,
5194         0x00000000, 0x8f620cf4, 0x00501024, 0x10400015, 0x00000000, 0x08004283,
5195         0x00000000, 0x3c030001, 0x94630f68, 0x34420624, 0x3c108000, 0x00621825,
5196         0x3c028000, 0xaf630cec, 0xaf620cf4, 0x8f641008, 0x00901024, 0x14400003,
5197         0x00000000, 0x0c004064, 0x00000000, 0x8f620cf4, 0x00501024, 0x1440fff7,
5198         0x00000000, 0x3c010001, 0x080042cf, 0xa4200f5e, 0x3c020001, 0x94420f5c,
5199         0x00021400, 0x00c21025, 0xaf620ce8, 0x3c020001, 0x90420f57, 0x10400009,
5200         0x3c03000c, 0x3c020001, 0x94420f68, 0x34630624, 0x0000d021, 0x00431025,
5201         0xaf620cec, 0x080042c1, 0x3c108000, 0x3c020001, 0x94420f68, 0x3c030008,
5202         0x34630604, 0x00431025, 0xaf620cec, 0x3c020001, 0x94420f5e, 0x00451021,
5203         0x3c010001, 0xa4220f5e, 0x3c108000, 0x3c02a000, 0xaf620cf4, 0x3c010001,
5204         0xa0200f56, 0x8f641008, 0x00901024, 0x14400003, 0x00000000, 0x0c004064,
5205         0x00000000, 0x8f620cf4, 0x00501024, 0x1440fff7, 0x00000000, 0x8fbf0014,
5206         0x8fb00010, 0x03e00008, 0x27bd0018, 0x00000000, 0x27bdffe0, 0x3c040001,
5207         0x24840ec0, 0x00002821, 0x00003021, 0x00003821, 0xafbf0018, 0xafa00010,
5208         0x0c004378, 0xafa00014, 0x0000d021, 0x24020130, 0xaf625000, 0x3c010001,
5209         0xa4200f50, 0x3c010001, 0xa0200f57, 0x8fbf0018, 0x03e00008, 0x27bd0020,
5210         0x27bdffe8, 0x3c1bc000, 0xafbf0014, 0xafb00010, 0xaf60680c, 0x8f626804,
5211         0x34420082, 0xaf626804, 0x8f634000, 0x24020b50, 0x3c010001, 0xac220f20,
5212         0x24020b78, 0x3c010001, 0xac220f30, 0x34630002, 0xaf634000, 0x0c004315,
5213         0x00808021, 0x3c010001, 0xa0220f34, 0x304200ff, 0x24030002, 0x14430005,
5214         0x00000000, 0x3c020001, 0x8c420f20, 0x08004308, 0xac5000c0, 0x3c020001,
5215         0x8c420f20, 0xac5000bc, 0x8f624434, 0x8f634438, 0x8f644410, 0x3c010001,
5216         0xac220f28, 0x3c010001, 0xac230f38, 0x3c010001, 0xac240f24, 0x8fbf0014,
5217         0x8fb00010, 0x03e00008, 0x27bd0018, 0x03e00008, 0x24020001, 0x27bdfff8,
5218         0x18800009, 0x00002821, 0x8f63680c, 0x8f62680c, 0x1043fffe, 0x00000000,
5219         0x24a50001, 0x00a4102a, 0x1440fff9, 0x00000000, 0x03e00008, 0x27bd0008,
5220         0x8f634450, 0x3c020001, 0x8c420f28, 0x00031c02, 0x0043102b, 0x14400008,
5221         0x3c038000, 0x3c040001, 0x8c840f38, 0x8f624450, 0x00021c02, 0x0083102b,
5222         0x1040fffc, 0x3c038000, 0xaf634444, 0x8f624444, 0x00431024, 0x1440fffd,
5223         0x00000000, 0x8f624448, 0x03e00008, 0x3042ffff, 0x3082ffff, 0x2442e000,
5224         0x2c422001, 0x14400003, 0x3c024000, 0x08004347, 0x2402ffff, 0x00822025,
5225         0xaf645c38, 0x8f625c30, 0x30420002, 0x1440fffc, 0x00001021, 0x03e00008,
5226         0x00000000, 0x8f624450, 0x3c030001, 0x8c630f24, 0x08004350, 0x3042ffff,
5227         0x8f624450, 0x3042ffff, 0x0043102b, 0x1440fffc, 0x00000000, 0x03e00008,
5228         0x00000000, 0x27bdffe0, 0x00802821, 0x3c040001, 0x24840ed0, 0x00003021,
5229         0x00003821, 0xafbf0018, 0xafa00010, 0x0c004378, 0xafa00014, 0x0800435f,
5230         0x00000000, 0x8fbf0018, 0x03e00008, 0x27bd0020, 0x3c020001, 0x3442d600,
5231         0x3c030001, 0x3463d600, 0x3c040001, 0x3484ddff, 0x3c010001, 0xac220f40,
5232         0x24020040, 0x3c010001, 0xac220f44, 0x3c010001, 0xac200f3c, 0xac600000,
5233         0x24630004, 0x0083102b, 0x5040fffd, 0xac600000, 0x03e00008, 0x00000000,
5234         0x00804821, 0x8faa0010, 0x3c020001, 0x8c420f3c, 0x3c040001, 0x8c840f44,
5235         0x8fab0014, 0x24430001, 0x0044102b, 0x3c010001, 0xac230f3c, 0x14400003,
5236         0x00004021, 0x3c010001, 0xac200f3c, 0x3c020001, 0x8c420f3c, 0x3c030001,
5237         0x8c630f40, 0x91240000, 0x00021140, 0x00431021, 0x00481021, 0x25080001,
5238         0xa0440000, 0x29020008, 0x1440fff4, 0x25290001, 0x3c020001, 0x8c420f3c,
5239         0x3c030001, 0x8c630f40, 0x8f64680c, 0x00021140, 0x00431021, 0xac440008,
5240         0xac45000c, 0xac460010, 0xac470014, 0xac4a0018, 0x03e00008, 0xac4b001c,
5241         0x00000000, 0x00000000, 0x00000000,
5242 };
5243
5244 static u32 tg3Tso5FwRodata[(TG3_TSO5_FW_RODATA_LEN / 4) + 1] = {
5245         0x4d61696e, 0x43707542, 0x00000000, 0x4d61696e, 0x43707541, 0x00000000,
5246         0x00000000, 0x00000000, 0x73746b6f, 0x66666c64, 0x00000000, 0x00000000,
5247         0x73746b6f, 0x66666c64, 0x00000000, 0x00000000, 0x66617461, 0x6c457272,
5248         0x00000000, 0x00000000, 0x00000000,
5249 };
5250
5251 static u32 tg3Tso5FwData[(TG3_TSO5_FW_DATA_LEN / 4) + 1] = {
5252         0x00000000, 0x73746b6f, 0x66666c64, 0x5f76312e, 0x322e3000, 0x00000000,
5253         0x00000000, 0x00000000, 0x00000000,
5254 };
5255
5256 /* tp->lock is held. */
5257 static int tg3_load_tso_firmware(struct tg3 *tp)
5258 {
5259         struct fw_info info;
5260         unsigned long cpu_base, cpu_scratch_base, cpu_scratch_size;
5261         int err, i;
5262
5263         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
5264                 return 0;
5265
5266         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) {
5267                 info.text_base = TG3_TSO5_FW_TEXT_ADDR;
5268                 info.text_len = TG3_TSO5_FW_TEXT_LEN;
5269                 info.text_data = &tg3Tso5FwText[0];
5270                 info.rodata_base = TG3_TSO5_FW_RODATA_ADDR;
5271                 info.rodata_len = TG3_TSO5_FW_RODATA_LEN;
5272                 info.rodata_data = &tg3Tso5FwRodata[0];
5273                 info.data_base = TG3_TSO5_FW_DATA_ADDR;
5274                 info.data_len = TG3_TSO5_FW_DATA_LEN;
5275                 info.data_data = &tg3Tso5FwData[0];
5276                 cpu_base = RX_CPU_BASE;
5277                 cpu_scratch_base = NIC_SRAM_MBUF_POOL_BASE5705;
5278                 cpu_scratch_size = (info.text_len +
5279                                     info.rodata_len +
5280                                     info.data_len +
5281                                     TG3_TSO5_FW_SBSS_LEN +
5282                                     TG3_TSO5_FW_BSS_LEN);
5283         } else {
5284                 info.text_base = TG3_TSO_FW_TEXT_ADDR;
5285                 info.text_len = TG3_TSO_FW_TEXT_LEN;
5286                 info.text_data = &tg3TsoFwText[0];
5287                 info.rodata_base = TG3_TSO_FW_RODATA_ADDR;
5288                 info.rodata_len = TG3_TSO_FW_RODATA_LEN;
5289                 info.rodata_data = &tg3TsoFwRodata[0];
5290                 info.data_base = TG3_TSO_FW_DATA_ADDR;
5291                 info.data_len = TG3_TSO_FW_DATA_LEN;
5292                 info.data_data = &tg3TsoFwData[0];
5293                 cpu_base = TX_CPU_BASE;
5294                 cpu_scratch_base = TX_CPU_SCRATCH_BASE;
5295                 cpu_scratch_size = TX_CPU_SCRATCH_SIZE;
5296         }
5297
5298         err = tg3_load_firmware_cpu(tp, cpu_base,
5299                                     cpu_scratch_base, cpu_scratch_size,
5300                                     &info);
5301         if (err)
5302                 return err;
5303
5304         /* Now startup the cpu. */
5305         tw32(cpu_base + CPU_STATE, 0xffffffff);
5306         tw32_f(cpu_base + CPU_PC,    info.text_base);
5307
5308         for (i = 0; i < 5; i++) {
5309                 if (tr32(cpu_base + CPU_PC) == info.text_base)
5310                         break;
5311                 tw32(cpu_base + CPU_STATE, 0xffffffff);
5312                 tw32(cpu_base + CPU_MODE,  CPU_MODE_HALT);
5313                 tw32_f(cpu_base + CPU_PC,    info.text_base);
5314                 udelay(1000);
5315         }
5316         if (i >= 5) {
5317                 printk(KERN_ERR PFX "tg3_load_tso_firmware fails for %s "
5318                        "to set CPU PC, is %08x should be %08x\n",
5319                        tp->dev->name, tr32(cpu_base + CPU_PC),
5320                        info.text_base);
5321                 return -ENODEV;
5322         }
5323         tw32(cpu_base + CPU_STATE, 0xffffffff);
5324         tw32_f(cpu_base + CPU_MODE,  0x00000000);
5325         return 0;
5326 }
5327
5328 #endif /* TG3_TSO_SUPPORT != 0 */
5329
5330 /* tp->lock is held. */
5331 static void __tg3_set_mac_addr(struct tg3 *tp)
5332 {
5333         u32 addr_high, addr_low;
5334         int i;
5335
5336         addr_high = ((tp->dev->dev_addr[0] << 8) |
5337                      tp->dev->dev_addr[1]);
5338         addr_low = ((tp->dev->dev_addr[2] << 24) |
5339                     (tp->dev->dev_addr[3] << 16) |
5340                     (tp->dev->dev_addr[4] <<  8) |
5341                     (tp->dev->dev_addr[5] <<  0));
5342         for (i = 0; i < 4; i++) {
5343                 tw32(MAC_ADDR_0_HIGH + (i * 8), addr_high);
5344                 tw32(MAC_ADDR_0_LOW + (i * 8), addr_low);
5345         }
5346
5347         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
5348             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
5349                 for (i = 0; i < 12; i++) {
5350                         tw32(MAC_EXTADDR_0_HIGH + (i * 8), addr_high);
5351                         tw32(MAC_EXTADDR_0_LOW + (i * 8), addr_low);
5352                 }
5353         }
5354
5355         addr_high = (tp->dev->dev_addr[0] +
5356                      tp->dev->dev_addr[1] +
5357                      tp->dev->dev_addr[2] +
5358                      tp->dev->dev_addr[3] +
5359                      tp->dev->dev_addr[4] +
5360                      tp->dev->dev_addr[5]) &
5361                 TX_BACKOFF_SEED_MASK;
5362         tw32(MAC_TX_BACKOFF_SEED, addr_high);
5363 }
5364
5365 static int tg3_set_mac_addr(struct net_device *dev, void *p)
5366 {
5367         struct tg3 *tp = netdev_priv(dev);
5368         struct sockaddr *addr = p;
5369
5370         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
5371
5372         spin_lock_bh(&tp->lock);
5373         __tg3_set_mac_addr(tp);
5374         spin_unlock_bh(&tp->lock);
5375
5376         return 0;
5377 }
5378
5379 /* tp->lock is held. */
5380 static void tg3_set_bdinfo(struct tg3 *tp, u32 bdinfo_addr,
5381                            dma_addr_t mapping, u32 maxlen_flags,
5382                            u32 nic_addr)
5383 {
5384         tg3_write_mem(tp,
5385                       (bdinfo_addr + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH),
5386                       ((u64) mapping >> 32));
5387         tg3_write_mem(tp,
5388                       (bdinfo_addr + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW),
5389                       ((u64) mapping & 0xffffffff));
5390         tg3_write_mem(tp,
5391                       (bdinfo_addr + TG3_BDINFO_MAXLEN_FLAGS),
5392                        maxlen_flags);
5393
5394         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
5395                 tg3_write_mem(tp,
5396                               (bdinfo_addr + TG3_BDINFO_NIC_ADDR),
5397                               nic_addr);
5398 }
5399
5400 static void __tg3_set_rx_mode(struct net_device *);
5401 static void __tg3_set_coalesce(struct tg3 *tp, struct ethtool_coalesce *ec)
5402 {
5403         tw32(HOSTCC_RXCOL_TICKS, ec->rx_coalesce_usecs);
5404         tw32(HOSTCC_TXCOL_TICKS, ec->tx_coalesce_usecs);
5405         tw32(HOSTCC_RXMAX_FRAMES, ec->rx_max_coalesced_frames);
5406         tw32(HOSTCC_TXMAX_FRAMES, ec->tx_max_coalesced_frames);
5407         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5408                 tw32(HOSTCC_RXCOAL_TICK_INT, ec->rx_coalesce_usecs_irq);
5409                 tw32(HOSTCC_TXCOAL_TICK_INT, ec->tx_coalesce_usecs_irq);
5410         }
5411         tw32(HOSTCC_RXCOAL_MAXF_INT, ec->rx_max_coalesced_frames_irq);
5412         tw32(HOSTCC_TXCOAL_MAXF_INT, ec->tx_max_coalesced_frames_irq);
5413         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5414                 u32 val = ec->stats_block_coalesce_usecs;
5415
5416                 if (!netif_carrier_ok(tp->dev))
5417                         val = 0;
5418
5419                 tw32(HOSTCC_STAT_COAL_TICKS, val);
5420         }
5421 }
5422
5423 /* tp->lock is held. */
5424 static int tg3_reset_hw(struct tg3 *tp)
5425 {
5426         u32 val, rdmac_mode;
5427         int i, err, limit;
5428
5429         tg3_disable_ints(tp);
5430
5431         tg3_stop_fw(tp);
5432
5433         tg3_write_sig_pre_reset(tp, RESET_KIND_INIT);
5434
5435         if (tp->tg3_flags & TG3_FLAG_INIT_COMPLETE) {
5436                 tg3_abort_hw(tp, 1);
5437         }
5438
5439         err = tg3_chip_reset(tp);
5440         if (err)
5441                 return err;
5442
5443         tg3_write_sig_legacy(tp, RESET_KIND_INIT);
5444
5445         /* This works around an issue with Athlon chipsets on
5446          * B3 tigon3 silicon.  This bit has no effect on any
5447          * other revision.  But do not set this on PCI Express
5448          * chips.
5449          */
5450         if (!(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
5451                 tp->pci_clock_ctrl |= CLOCK_CTRL_DELAY_PCI_GRANT;
5452         tw32_f(TG3PCI_CLOCK_CTRL, tp->pci_clock_ctrl);
5453
5454         if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0 &&
5455             (tp->tg3_flags & TG3_FLAG_PCIX_MODE)) {
5456                 val = tr32(TG3PCI_PCISTATE);
5457                 val |= PCISTATE_RETRY_SAME_DMA;
5458                 tw32(TG3PCI_PCISTATE, val);
5459         }
5460
5461         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5704_BX) {
5462                 /* Enable some hw fixes.  */
5463                 val = tr32(TG3PCI_MSI_DATA);
5464                 val |= (1 << 26) | (1 << 28) | (1 << 29);
5465                 tw32(TG3PCI_MSI_DATA, val);
5466         }
5467
5468         /* Descriptor ring init may make accesses to the
5469          * NIC SRAM area to setup the TX descriptors, so we
5470          * can only do this after the hardware has been
5471          * successfully reset.
5472          */
5473         tg3_init_rings(tp);
5474
5475         /* This value is determined during the probe time DMA
5476          * engine test, tg3_test_dma.
5477          */
5478         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
5479
5480         tp->grc_mode &= ~(GRC_MODE_HOST_SENDBDS |
5481                           GRC_MODE_4X_NIC_SEND_RINGS |
5482                           GRC_MODE_NO_TX_PHDR_CSUM |
5483                           GRC_MODE_NO_RX_PHDR_CSUM);
5484         tp->grc_mode |= GRC_MODE_HOST_SENDBDS;
5485         if (tp->tg3_flags & TG3_FLAG_NO_TX_PSEUDO_CSUM)
5486                 tp->grc_mode |= GRC_MODE_NO_TX_PHDR_CSUM;
5487         if (tp->tg3_flags & TG3_FLAG_NO_RX_PSEUDO_CSUM)
5488                 tp->grc_mode |= GRC_MODE_NO_RX_PHDR_CSUM;
5489
5490         tw32(GRC_MODE,
5491              tp->grc_mode |
5492              (GRC_MODE_IRQ_ON_MAC_ATTN | GRC_MODE_HOST_STACKUP));
5493
5494         /* Setup the timer prescalar register.  Clock is always 66Mhz. */
5495         val = tr32(GRC_MISC_CFG);
5496         val &= ~0xff;
5497         val |= (65 << GRC_MISC_CFG_PRESCALAR_SHIFT);
5498         tw32(GRC_MISC_CFG, val);
5499
5500         /* Initialize MBUF/DESC pool. */
5501         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
5502                 /* Do nothing.  */
5503         } else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705) {
5504                 tw32(BUFMGR_MB_POOL_ADDR, NIC_SRAM_MBUF_POOL_BASE);
5505                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
5506                         tw32(BUFMGR_MB_POOL_SIZE, NIC_SRAM_MBUF_POOL_SIZE64);
5507                 else
5508                         tw32(BUFMGR_MB_POOL_SIZE, NIC_SRAM_MBUF_POOL_SIZE96);
5509                 tw32(BUFMGR_DMA_DESC_POOL_ADDR, NIC_SRAM_DMA_DESC_POOL_BASE);
5510                 tw32(BUFMGR_DMA_DESC_POOL_SIZE, NIC_SRAM_DMA_DESC_POOL_SIZE);
5511         }
5512 #if TG3_TSO_SUPPORT != 0
5513         else if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) {
5514                 int fw_len;
5515
5516                 fw_len = (TG3_TSO5_FW_TEXT_LEN +
5517                           TG3_TSO5_FW_RODATA_LEN +
5518                           TG3_TSO5_FW_DATA_LEN +
5519                           TG3_TSO5_FW_SBSS_LEN +
5520                           TG3_TSO5_FW_BSS_LEN);
5521                 fw_len = (fw_len + (0x80 - 1)) & ~(0x80 - 1);
5522                 tw32(BUFMGR_MB_POOL_ADDR,
5523                      NIC_SRAM_MBUF_POOL_BASE5705 + fw_len);
5524                 tw32(BUFMGR_MB_POOL_SIZE,
5525                      NIC_SRAM_MBUF_POOL_SIZE5705 - fw_len - 0xa00);
5526         }
5527 #endif
5528
5529         if (tp->dev->mtu <= ETH_DATA_LEN) {
5530                 tw32(BUFMGR_MB_RDMA_LOW_WATER,
5531                      tp->bufmgr_config.mbuf_read_dma_low_water);
5532                 tw32(BUFMGR_MB_MACRX_LOW_WATER,
5533                      tp->bufmgr_config.mbuf_mac_rx_low_water);
5534                 tw32(BUFMGR_MB_HIGH_WATER,
5535                      tp->bufmgr_config.mbuf_high_water);
5536         } else {
5537                 tw32(BUFMGR_MB_RDMA_LOW_WATER,
5538                      tp->bufmgr_config.mbuf_read_dma_low_water_jumbo);
5539                 tw32(BUFMGR_MB_MACRX_LOW_WATER,
5540                      tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo);
5541                 tw32(BUFMGR_MB_HIGH_WATER,
5542                      tp->bufmgr_config.mbuf_high_water_jumbo);
5543         }
5544         tw32(BUFMGR_DMA_LOW_WATER,
5545              tp->bufmgr_config.dma_low_water);
5546         tw32(BUFMGR_DMA_HIGH_WATER,
5547              tp->bufmgr_config.dma_high_water);
5548
5549         tw32(BUFMGR_MODE, BUFMGR_MODE_ENABLE | BUFMGR_MODE_ATTN_ENABLE);
5550         for (i = 0; i < 2000; i++) {
5551                 if (tr32(BUFMGR_MODE) & BUFMGR_MODE_ENABLE)
5552                         break;
5553                 udelay(10);
5554         }
5555         if (i >= 2000) {
5556                 printk(KERN_ERR PFX "tg3_reset_hw cannot enable BUFMGR for %s.\n",
5557                        tp->dev->name);
5558                 return -ENODEV;
5559         }
5560
5561         /* Setup replenish threshold. */
5562         tw32(RCVBDI_STD_THRESH, tp->rx_pending / 8);
5563
5564         /* Initialize TG3_BDINFO's at:
5565          *  RCVDBDI_STD_BD:     standard eth size rx ring
5566          *  RCVDBDI_JUMBO_BD:   jumbo frame rx ring
5567          *  RCVDBDI_MINI_BD:    small frame rx ring (??? does not work)
5568          *
5569          * like so:
5570          *  TG3_BDINFO_HOST_ADDR:       high/low parts of DMA address of ring
5571          *  TG3_BDINFO_MAXLEN_FLAGS:    (rx max buffer size << 16) |
5572          *                              ring attribute flags
5573          *  TG3_BDINFO_NIC_ADDR:        location of descriptors in nic SRAM
5574          *
5575          * Standard receive ring @ NIC_SRAM_RX_BUFFER_DESC, 512 entries.
5576          * Jumbo receive ring @ NIC_SRAM_RX_JUMBO_BUFFER_DESC, 256 entries.
5577          *
5578          * The size of each ring is fixed in the firmware, but the location is
5579          * configurable.
5580          */
5581         tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH,
5582              ((u64) tp->rx_std_mapping >> 32));
5583         tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
5584              ((u64) tp->rx_std_mapping & 0xffffffff));
5585         tw32(RCVDBDI_STD_BD + TG3_BDINFO_NIC_ADDR,
5586              NIC_SRAM_RX_BUFFER_DESC);
5587
5588         /* Don't even try to program the JUMBO/MINI buffer descriptor
5589          * configs on 5705.
5590          */
5591         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
5592                 tw32(RCVDBDI_STD_BD + TG3_BDINFO_MAXLEN_FLAGS,
5593                      RX_STD_MAX_SIZE_5705 << BDINFO_FLAGS_MAXLEN_SHIFT);
5594         } else {
5595                 tw32(RCVDBDI_STD_BD + TG3_BDINFO_MAXLEN_FLAGS,
5596                      RX_STD_MAX_SIZE << BDINFO_FLAGS_MAXLEN_SHIFT);
5597
5598                 tw32(RCVDBDI_MINI_BD + TG3_BDINFO_MAXLEN_FLAGS,
5599                      BDINFO_FLAGS_DISABLED);
5600
5601                 /* Setup replenish threshold. */
5602                 tw32(RCVBDI_JUMBO_THRESH, tp->rx_jumbo_pending / 8);
5603
5604                 if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) {
5605                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_HIGH,
5606                              ((u64) tp->rx_jumbo_mapping >> 32));
5607                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
5608                              ((u64) tp->rx_jumbo_mapping & 0xffffffff));
5609                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
5610                              RX_JUMBO_MAX_SIZE << BDINFO_FLAGS_MAXLEN_SHIFT);
5611                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_NIC_ADDR,
5612                              NIC_SRAM_RX_JUMBO_BUFFER_DESC);
5613                 } else {
5614                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
5615                              BDINFO_FLAGS_DISABLED);
5616                 }
5617
5618         }
5619
5620         /* There is only one send ring on 5705/5750, no need to explicitly
5621          * disable the others.
5622          */
5623         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5624                 /* Clear out send RCB ring in SRAM. */
5625                 for (i = NIC_SRAM_SEND_RCB; i < NIC_SRAM_RCV_RET_RCB; i += TG3_BDINFO_SIZE)
5626                         tg3_write_mem(tp, i + TG3_BDINFO_MAXLEN_FLAGS,
5627                                       BDINFO_FLAGS_DISABLED);
5628         }
5629
5630         tp->tx_prod = 0;
5631         tp->tx_cons = 0;
5632         tw32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW, 0);
5633         tw32_tx_mbox(MAILBOX_SNDNIC_PROD_IDX_0 + TG3_64BIT_REG_LOW, 0);
5634
5635         tg3_set_bdinfo(tp, NIC_SRAM_SEND_RCB,
5636                        tp->tx_desc_mapping,
5637                        (TG3_TX_RING_SIZE <<
5638                         BDINFO_FLAGS_MAXLEN_SHIFT),
5639                        NIC_SRAM_TX_BUFFER_DESC);
5640
5641         /* There is only one receive return ring on 5705/5750, no need
5642          * to explicitly disable the others.
5643          */
5644         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5645                 for (i = NIC_SRAM_RCV_RET_RCB; i < NIC_SRAM_STATS_BLK;
5646                      i += TG3_BDINFO_SIZE) {
5647                         tg3_write_mem(tp, i + TG3_BDINFO_MAXLEN_FLAGS,
5648                                       BDINFO_FLAGS_DISABLED);
5649                 }
5650         }
5651
5652         tp->rx_rcb_ptr = 0;
5653         tw32_rx_mbox(MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW, 0);
5654
5655         tg3_set_bdinfo(tp, NIC_SRAM_RCV_RET_RCB,
5656                        tp->rx_rcb_mapping,
5657                        (TG3_RX_RCB_RING_SIZE(tp) <<
5658                         BDINFO_FLAGS_MAXLEN_SHIFT),
5659                        0);
5660
5661         tp->rx_std_ptr = tp->rx_pending;
5662         tw32_rx_mbox(MAILBOX_RCV_STD_PROD_IDX + TG3_64BIT_REG_LOW,
5663                      tp->rx_std_ptr);
5664
5665         tp->rx_jumbo_ptr = (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE) ?
5666                                                 tp->rx_jumbo_pending : 0;
5667         tw32_rx_mbox(MAILBOX_RCV_JUMBO_PROD_IDX + TG3_64BIT_REG_LOW,
5668                      tp->rx_jumbo_ptr);
5669
5670         /* Initialize MAC address and backoff seed. */
5671         __tg3_set_mac_addr(tp);
5672
5673         /* MTU + ethernet header + FCS + optional VLAN tag */
5674         tw32(MAC_RX_MTU_SIZE, tp->dev->mtu + ETH_HLEN + 8);
5675
5676         /* The slot time is changed by tg3_setup_phy if we
5677          * run at gigabit with half duplex.
5678          */
5679         tw32(MAC_TX_LENGTHS,
5680              (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
5681              (6 << TX_LENGTHS_IPG_SHIFT) |
5682              (32 << TX_LENGTHS_SLOT_TIME_SHIFT));
5683
5684         /* Receive rules. */
5685         tw32(MAC_RCV_RULE_CFG, RCV_RULE_CFG_DEFAULT_CLASS);
5686         tw32(RCVLPC_CONFIG, 0x0181);
5687
5688         /* Calculate RDMAC_MODE setting early, we need it to determine
5689          * the RCVLPC_STATE_ENABLE mask.
5690          */
5691         rdmac_mode = (RDMAC_MODE_ENABLE | RDMAC_MODE_TGTABORT_ENAB |
5692                       RDMAC_MODE_MSTABORT_ENAB | RDMAC_MODE_PARITYERR_ENAB |
5693                       RDMAC_MODE_ADDROFLOW_ENAB | RDMAC_MODE_FIFOOFLOW_ENAB |
5694                       RDMAC_MODE_FIFOURUN_ENAB | RDMAC_MODE_FIFOOREAD_ENAB |
5695                       RDMAC_MODE_LNGREAD_ENAB);
5696         if (tp->tg3_flags & TG3_FLAG_SPLIT_MODE)
5697                 rdmac_mode |= RDMAC_MODE_SPLIT_ENABLE;
5698
5699         /* If statement applies to 5705 and 5750 PCI devices only */
5700         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
5701              tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) ||
5702             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)) {
5703                 if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE &&
5704                     (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 ||
5705                      tp->pci_chip_rev_id == CHIPREV_ID_5705_A2)) {
5706                         rdmac_mode |= RDMAC_MODE_FIFO_SIZE_128;
5707                 } else if (!(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH) &&
5708                            !(tp->tg3_flags2 & TG3_FLG2_IS_5788)) {
5709                         rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
5710                 }
5711         }
5712
5713         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)
5714                 rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
5715
5716 #if TG3_TSO_SUPPORT != 0
5717         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
5718                 rdmac_mode |= (1 << 27);
5719 #endif
5720
5721         /* Receive/send statistics. */
5722         if ((rdmac_mode & RDMAC_MODE_FIFO_SIZE_128) &&
5723             (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
5724                 val = tr32(RCVLPC_STATS_ENABLE);
5725                 val &= ~RCVLPC_STATSENAB_LNGBRST_RFIX;
5726                 tw32(RCVLPC_STATS_ENABLE, val);
5727         } else {
5728                 tw32(RCVLPC_STATS_ENABLE, 0xffffff);
5729         }
5730         tw32(RCVLPC_STATSCTRL, RCVLPC_STATSCTRL_ENABLE);
5731         tw32(SNDDATAI_STATSENAB, 0xffffff);
5732         tw32(SNDDATAI_STATSCTRL,
5733              (SNDDATAI_SCTRL_ENABLE |
5734               SNDDATAI_SCTRL_FASTUPD));
5735
5736         /* Setup host coalescing engine. */
5737         tw32(HOSTCC_MODE, 0);
5738         for (i = 0; i < 2000; i++) {
5739                 if (!(tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE))
5740                         break;
5741                 udelay(10);
5742         }
5743
5744         __tg3_set_coalesce(tp, &tp->coal);
5745
5746         /* set status block DMA address */
5747         tw32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH,
5748              ((u64) tp->status_mapping >> 32));
5749         tw32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW,
5750              ((u64) tp->status_mapping & 0xffffffff));
5751
5752         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5753                 /* Status/statistics block address.  See tg3_timer,
5754                  * the tg3_periodic_fetch_stats call there, and
5755                  * tg3_get_stats to see how this works for 5705/5750 chips.
5756                  */
5757                 tw32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH,
5758                      ((u64) tp->stats_mapping >> 32));
5759                 tw32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW,
5760                      ((u64) tp->stats_mapping & 0xffffffff));
5761                 tw32(HOSTCC_STATS_BLK_NIC_ADDR, NIC_SRAM_STATS_BLK);
5762                 tw32(HOSTCC_STATUS_BLK_NIC_ADDR, NIC_SRAM_STATUS_BLK);
5763         }
5764
5765         tw32(HOSTCC_MODE, HOSTCC_MODE_ENABLE | tp->coalesce_mode);
5766
5767         tw32(RCVCC_MODE, RCVCC_MODE_ENABLE | RCVCC_MODE_ATTN_ENABLE);
5768         tw32(RCVLPC_MODE, RCVLPC_MODE_ENABLE);
5769         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
5770                 tw32(RCVLSC_MODE, RCVLSC_MODE_ENABLE | RCVLSC_MODE_ATTN_ENABLE);
5771
5772         /* Clear statistics/status block in chip, and status block in ram. */
5773         for (i = NIC_SRAM_STATS_BLK;
5774              i < NIC_SRAM_STATUS_BLK + TG3_HW_STATUS_SIZE;
5775              i += sizeof(u32)) {
5776                 tg3_write_mem(tp, i, 0);
5777                 udelay(40);
5778         }
5779         memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
5780
5781         tp->mac_mode = MAC_MODE_TXSTAT_ENABLE | MAC_MODE_RXSTAT_ENABLE |
5782                 MAC_MODE_TDE_ENABLE | MAC_MODE_RDE_ENABLE | MAC_MODE_FHDE_ENABLE;
5783         tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_RXSTAT_CLEAR | MAC_MODE_TXSTAT_CLEAR);
5784         udelay(40);
5785
5786         /* tp->grc_local_ctrl is partially set up during tg3_get_invariants().
5787          * If TG3_FLAG_EEPROM_WRITE_PROT is set, we should read the
5788          * register to preserve the GPIO settings for LOMs. The GPIOs,
5789          * whether used as inputs or outputs, are set by boot code after
5790          * reset.
5791          */
5792         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
5793                 u32 gpio_mask;
5794
5795                 gpio_mask = GRC_LCLCTRL_GPIO_OE0 | GRC_LCLCTRL_GPIO_OE2 |
5796                             GRC_LCLCTRL_GPIO_OUTPUT0 | GRC_LCLCTRL_GPIO_OUTPUT2;
5797
5798                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
5799                         gpio_mask |= GRC_LCLCTRL_GPIO_OE3 |
5800                                      GRC_LCLCTRL_GPIO_OUTPUT3;
5801
5802                 tp->grc_local_ctrl |= tr32(GRC_LOCAL_CTRL) & gpio_mask;
5803
5804                 /* GPIO1 must be driven high for eeprom write protect */
5805                 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
5806                                        GRC_LCLCTRL_GPIO_OUTPUT1);
5807         }
5808         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
5809         udelay(100);
5810
5811         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0);
5812         tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
5813         tp->last_tag = 0;
5814
5815         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
5816                 tw32_f(DMAC_MODE, DMAC_MODE_ENABLE);
5817                 udelay(40);
5818         }
5819
5820         val = (WDMAC_MODE_ENABLE | WDMAC_MODE_TGTABORT_ENAB |
5821                WDMAC_MODE_MSTABORT_ENAB | WDMAC_MODE_PARITYERR_ENAB |
5822                WDMAC_MODE_ADDROFLOW_ENAB | WDMAC_MODE_FIFOOFLOW_ENAB |
5823                WDMAC_MODE_FIFOURUN_ENAB | WDMAC_MODE_FIFOOREAD_ENAB |
5824                WDMAC_MODE_LNGREAD_ENAB);
5825
5826         /* If statement applies to 5705 and 5750 PCI devices only */
5827         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
5828              tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) ||
5829             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
5830                 if ((tp->tg3_flags & TG3_FLG2_TSO_CAPABLE) &&
5831                     (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 ||
5832                      tp->pci_chip_rev_id == CHIPREV_ID_5705_A2)) {
5833                         /* nothing */
5834                 } else if (!(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH) &&
5835                            !(tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
5836                            !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)) {
5837                         val |= WDMAC_MODE_RX_ACCEL;
5838                 }
5839         }
5840
5841         tw32_f(WDMAC_MODE, val);
5842         udelay(40);
5843
5844         if ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) != 0) {
5845                 val = tr32(TG3PCI_X_CAPS);
5846                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703) {
5847                         val &= ~PCIX_CAPS_BURST_MASK;
5848                         val |= (PCIX_CAPS_MAX_BURST_CPIOB << PCIX_CAPS_BURST_SHIFT);
5849                 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
5850                         val &= ~(PCIX_CAPS_SPLIT_MASK | PCIX_CAPS_BURST_MASK);
5851                         val |= (PCIX_CAPS_MAX_BURST_CPIOB << PCIX_CAPS_BURST_SHIFT);
5852                         if (tp->tg3_flags & TG3_FLAG_SPLIT_MODE)
5853                                 val |= (tp->split_mode_max_reqs <<
5854                                         PCIX_CAPS_SPLIT_SHIFT);
5855                 }
5856                 tw32(TG3PCI_X_CAPS, val);
5857         }
5858
5859         tw32_f(RDMAC_MODE, rdmac_mode);
5860         udelay(40);
5861
5862         tw32(RCVDCC_MODE, RCVDCC_MODE_ENABLE | RCVDCC_MODE_ATTN_ENABLE);
5863         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
5864                 tw32(MBFREE_MODE, MBFREE_MODE_ENABLE);
5865         tw32(SNDDATAC_MODE, SNDDATAC_MODE_ENABLE);
5866         tw32(SNDBDC_MODE, SNDBDC_MODE_ENABLE | SNDBDC_MODE_ATTN_ENABLE);
5867         tw32(RCVBDI_MODE, RCVBDI_MODE_ENABLE | RCVBDI_MODE_RCB_ATTN_ENAB);
5868         tw32(RCVDBDI_MODE, RCVDBDI_MODE_ENABLE | RCVDBDI_MODE_INV_RING_SZ);
5869         tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE);
5870 #if TG3_TSO_SUPPORT != 0
5871         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
5872                 tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE | 0x8);
5873 #endif
5874         tw32(SNDBDI_MODE, SNDBDI_MODE_ENABLE | SNDBDI_MODE_ATTN_ENABLE);
5875         tw32(SNDBDS_MODE, SNDBDS_MODE_ENABLE | SNDBDS_MODE_ATTN_ENABLE);
5876
5877         if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0) {
5878                 err = tg3_load_5701_a0_firmware_fix(tp);
5879                 if (err)
5880                         return err;
5881         }
5882
5883 #if TG3_TSO_SUPPORT != 0
5884         if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) {
5885                 err = tg3_load_tso_firmware(tp);
5886                 if (err)
5887                         return err;
5888         }
5889 #endif
5890
5891         tp->tx_mode = TX_MODE_ENABLE;
5892         tw32_f(MAC_TX_MODE, tp->tx_mode);
5893         udelay(100);
5894
5895         tp->rx_mode = RX_MODE_ENABLE;
5896         tw32_f(MAC_RX_MODE, tp->rx_mode);
5897         udelay(10);
5898
5899         if (tp->link_config.phy_is_low_power) {
5900                 tp->link_config.phy_is_low_power = 0;
5901                 tp->link_config.speed = tp->link_config.orig_speed;
5902                 tp->link_config.duplex = tp->link_config.orig_duplex;
5903                 tp->link_config.autoneg = tp->link_config.orig_autoneg;
5904         }
5905
5906         tp->mi_mode = MAC_MI_MODE_BASE;
5907         tw32_f(MAC_MI_MODE, tp->mi_mode);
5908         udelay(80);
5909
5910         tw32(MAC_LED_CTRL, tp->led_ctrl);
5911
5912         tw32(MAC_MI_STAT, MAC_MI_STAT_LNKSTAT_ATTN_ENAB);
5913         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
5914                 tw32_f(MAC_RX_MODE, RX_MODE_RESET);
5915                 udelay(10);
5916         }
5917         tw32_f(MAC_RX_MODE, tp->rx_mode);
5918         udelay(10);
5919
5920         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
5921                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) &&
5922                         !(tp->tg3_flags2 & TG3_FLG2_SERDES_PREEMPHASIS)) {
5923                         /* Set drive transmission level to 1.2V  */
5924                         /* only if the signal pre-emphasis bit is not set  */
5925                         val = tr32(MAC_SERDES_CFG);
5926                         val &= 0xfffff000;
5927                         val |= 0x880;
5928                         tw32(MAC_SERDES_CFG, val);
5929                 }
5930                 if (tp->pci_chip_rev_id == CHIPREV_ID_5703_A1)
5931                         tw32(MAC_SERDES_CFG, 0x616000);
5932         }
5933
5934         /* Prevent chip from dropping frames when flow control
5935          * is enabled.
5936          */
5937         tw32_f(MAC_LOW_WMARK_MAX_RX_FRAME, 2);
5938
5939         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
5940             (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
5941                 /* Use hardware link auto-negotiation */
5942                 tp->tg3_flags2 |= TG3_FLG2_HW_AUTONEG;
5943         }
5944
5945         err = tg3_setup_phy(tp, 1);
5946         if (err)
5947                 return err;
5948
5949         if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
5950                 u32 tmp;
5951
5952                 /* Clear CRC stats. */
5953                 if (!tg3_readphy(tp, 0x1e, &tmp)) {
5954                         tg3_writephy(tp, 0x1e, tmp | 0x8000);
5955                         tg3_readphy(tp, 0x14, &tmp);
5956                 }
5957         }
5958
5959         __tg3_set_rx_mode(tp->dev);
5960
5961         /* Initialize receive rules. */
5962         tw32(MAC_RCV_RULE_0,  0xc2000000 & RCV_RULE_DISABLE_MASK);
5963         tw32(MAC_RCV_VALUE_0, 0xffffffff & RCV_RULE_DISABLE_MASK);
5964         tw32(MAC_RCV_RULE_1,  0x86000004 & RCV_RULE_DISABLE_MASK);
5965         tw32(MAC_RCV_VALUE_1, 0xffffffff & RCV_RULE_DISABLE_MASK);
5966
5967         if ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
5968             (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5780))
5969                 limit = 8;
5970         else
5971                 limit = 16;
5972         if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF)
5973                 limit -= 4;
5974         switch (limit) {
5975         case 16:
5976                 tw32(MAC_RCV_RULE_15,  0); tw32(MAC_RCV_VALUE_15,  0);
5977         case 15:
5978                 tw32(MAC_RCV_RULE_14,  0); tw32(MAC_RCV_VALUE_14,  0);
5979         case 14:
5980                 tw32(MAC_RCV_RULE_13,  0); tw32(MAC_RCV_VALUE_13,  0);
5981         case 13:
5982                 tw32(MAC_RCV_RULE_12,  0); tw32(MAC_RCV_VALUE_12,  0);
5983         case 12:
5984                 tw32(MAC_RCV_RULE_11,  0); tw32(MAC_RCV_VALUE_11,  0);
5985         case 11:
5986                 tw32(MAC_RCV_RULE_10,  0); tw32(MAC_RCV_VALUE_10,  0);
5987         case 10:
5988                 tw32(MAC_RCV_RULE_9,  0); tw32(MAC_RCV_VALUE_9,  0);
5989         case 9:
5990                 tw32(MAC_RCV_RULE_8,  0); tw32(MAC_RCV_VALUE_8,  0);
5991         case 8:
5992                 tw32(MAC_RCV_RULE_7,  0); tw32(MAC_RCV_VALUE_7,  0);
5993         case 7:
5994                 tw32(MAC_RCV_RULE_6,  0); tw32(MAC_RCV_VALUE_6,  0);
5995         case 6:
5996                 tw32(MAC_RCV_RULE_5,  0); tw32(MAC_RCV_VALUE_5,  0);
5997         case 5:
5998                 tw32(MAC_RCV_RULE_4,  0); tw32(MAC_RCV_VALUE_4,  0);
5999         case 4:
6000                 /* tw32(MAC_RCV_RULE_3,  0); tw32(MAC_RCV_VALUE_3,  0); */
6001         case 3:
6002                 /* tw32(MAC_RCV_RULE_2,  0); tw32(MAC_RCV_VALUE_2,  0); */
6003         case 2:
6004         case 1:
6005
6006         default:
6007                 break;
6008         };
6009
6010         tg3_write_sig_post_reset(tp, RESET_KIND_INIT);
6011
6012         return 0;
6013 }
6014
6015 /* Called at device open time to get the chip ready for
6016  * packet processing.  Invoked with tp->lock held.
6017  */
6018 static int tg3_init_hw(struct tg3 *tp)
6019 {
6020         int err;
6021
6022         /* Force the chip into D0. */
6023         err = tg3_set_power_state(tp, 0);
6024         if (err)
6025                 goto out;
6026
6027         tg3_switch_clocks(tp);
6028
6029         tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
6030
6031         err = tg3_reset_hw(tp);
6032
6033 out:
6034         return err;
6035 }
6036
6037 #define TG3_STAT_ADD32(PSTAT, REG) \
6038 do {    u32 __val = tr32(REG); \
6039         (PSTAT)->low += __val; \
6040         if ((PSTAT)->low < __val) \
6041                 (PSTAT)->high += 1; \
6042 } while (0)
6043
6044 static void tg3_periodic_fetch_stats(struct tg3 *tp)
6045 {
6046         struct tg3_hw_stats *sp = tp->hw_stats;
6047
6048         if (!netif_carrier_ok(tp->dev))
6049                 return;
6050
6051         TG3_STAT_ADD32(&sp->tx_octets, MAC_TX_STATS_OCTETS);
6052         TG3_STAT_ADD32(&sp->tx_collisions, MAC_TX_STATS_COLLISIONS);
6053         TG3_STAT_ADD32(&sp->tx_xon_sent, MAC_TX_STATS_XON_SENT);
6054         TG3_STAT_ADD32(&sp->tx_xoff_sent, MAC_TX_STATS_XOFF_SENT);
6055         TG3_STAT_ADD32(&sp->tx_mac_errors, MAC_TX_STATS_MAC_ERRORS);
6056         TG3_STAT_ADD32(&sp->tx_single_collisions, MAC_TX_STATS_SINGLE_COLLISIONS);
6057         TG3_STAT_ADD32(&sp->tx_mult_collisions, MAC_TX_STATS_MULT_COLLISIONS);
6058         TG3_STAT_ADD32(&sp->tx_deferred, MAC_TX_STATS_DEFERRED);
6059         TG3_STAT_ADD32(&sp->tx_excessive_collisions, MAC_TX_STATS_EXCESSIVE_COL);
6060         TG3_STAT_ADD32(&sp->tx_late_collisions, MAC_TX_STATS_LATE_COL);
6061         TG3_STAT_ADD32(&sp->tx_ucast_packets, MAC_TX_STATS_UCAST);
6062         TG3_STAT_ADD32(&sp->tx_mcast_packets, MAC_TX_STATS_MCAST);
6063         TG3_STAT_ADD32(&sp->tx_bcast_packets, MAC_TX_STATS_BCAST);
6064
6065         TG3_STAT_ADD32(&sp->rx_octets, MAC_RX_STATS_OCTETS);
6066         TG3_STAT_ADD32(&sp->rx_fragments, MAC_RX_STATS_FRAGMENTS);
6067         TG3_STAT_ADD32(&sp->rx_ucast_packets, MAC_RX_STATS_UCAST);
6068         TG3_STAT_ADD32(&sp->rx_mcast_packets, MAC_RX_STATS_MCAST);
6069         TG3_STAT_ADD32(&sp->rx_bcast_packets, MAC_RX_STATS_BCAST);
6070         TG3_STAT_ADD32(&sp->rx_fcs_errors, MAC_RX_STATS_FCS_ERRORS);
6071         TG3_STAT_ADD32(&sp->rx_align_errors, MAC_RX_STATS_ALIGN_ERRORS);
6072         TG3_STAT_ADD32(&sp->rx_xon_pause_rcvd, MAC_RX_STATS_XON_PAUSE_RECVD);
6073         TG3_STAT_ADD32(&sp->rx_xoff_pause_rcvd, MAC_RX_STATS_XOFF_PAUSE_RECVD);
6074         TG3_STAT_ADD32(&sp->rx_mac_ctrl_rcvd, MAC_RX_STATS_MAC_CTRL_RECVD);
6075         TG3_STAT_ADD32(&sp->rx_xoff_entered, MAC_RX_STATS_XOFF_ENTERED);
6076         TG3_STAT_ADD32(&sp->rx_frame_too_long_errors, MAC_RX_STATS_FRAME_TOO_LONG);
6077         TG3_STAT_ADD32(&sp->rx_jabbers, MAC_RX_STATS_JABBERS);
6078         TG3_STAT_ADD32(&sp->rx_undersize_packets, MAC_RX_STATS_UNDERSIZE);
6079 }
6080
6081 static void tg3_timer(unsigned long __opaque)
6082 {
6083         struct tg3 *tp = (struct tg3 *) __opaque;
6084
6085         spin_lock(&tp->lock);
6086
6087         if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)) {
6088                 /* All of this garbage is because when using non-tagged
6089                  * IRQ status the mailbox/status_block protocol the chip
6090                  * uses with the cpu is race prone.
6091                  */
6092                 if (tp->hw_status->status & SD_STATUS_UPDATED) {
6093                         tw32(GRC_LOCAL_CTRL,
6094                              tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
6095                 } else {
6096                         tw32(HOSTCC_MODE, tp->coalesce_mode |
6097                              (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
6098                 }
6099
6100                 if (!(tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
6101                         tp->tg3_flags2 |= TG3_FLG2_RESTART_TIMER;
6102                         spin_unlock(&tp->lock);
6103                         schedule_work(&tp->reset_task);
6104                         return;
6105                 }
6106         }
6107
6108         /* This part only runs once per second. */
6109         if (!--tp->timer_counter) {
6110                 if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
6111                         tg3_periodic_fetch_stats(tp);
6112
6113                 if (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) {
6114                         u32 mac_stat;
6115                         int phy_event;
6116
6117                         mac_stat = tr32(MAC_STATUS);
6118
6119                         phy_event = 0;
6120                         if (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT) {
6121                                 if (mac_stat & MAC_STATUS_MI_INTERRUPT)
6122                                         phy_event = 1;
6123                         } else if (mac_stat & MAC_STATUS_LNKSTATE_CHANGED)
6124                                 phy_event = 1;
6125
6126                         if (phy_event)
6127                                 tg3_setup_phy(tp, 0);
6128                 } else if (tp->tg3_flags & TG3_FLAG_POLL_SERDES) {
6129                         u32 mac_stat = tr32(MAC_STATUS);
6130                         int need_setup = 0;
6131
6132                         if (netif_carrier_ok(tp->dev) &&
6133                             (mac_stat & MAC_STATUS_LNKSTATE_CHANGED)) {
6134                                 need_setup = 1;
6135                         }
6136                         if (! netif_carrier_ok(tp->dev) &&
6137                             (mac_stat & (MAC_STATUS_PCS_SYNCED |
6138                                          MAC_STATUS_SIGNAL_DET))) {
6139                                 need_setup = 1;
6140                         }
6141                         if (need_setup) {
6142                                 tw32_f(MAC_MODE,
6143                                      (tp->mac_mode &
6144                                       ~MAC_MODE_PORT_MODE_MASK));
6145                                 udelay(40);
6146                                 tw32_f(MAC_MODE, tp->mac_mode);
6147                                 udelay(40);
6148                                 tg3_setup_phy(tp, 0);
6149                         }
6150                 } else if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
6151                         tg3_serdes_parallel_detect(tp);
6152
6153                 tp->timer_counter = tp->timer_multiplier;
6154         }
6155
6156         /* Heartbeat is only sent once every 120 seconds.  */
6157         if (!--tp->asf_counter) {
6158                 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
6159                         u32 val;
6160
6161                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_ALIVE);
6162                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4);
6163                         tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 3);
6164                         val = tr32(GRC_RX_CPU_EVENT);
6165                         val |= (1 << 14);
6166                         tw32(GRC_RX_CPU_EVENT, val);
6167                 }
6168                 tp->asf_counter = tp->asf_multiplier;
6169         }
6170
6171         spin_unlock(&tp->lock);
6172
6173         tp->timer.expires = jiffies + tp->timer_offset;
6174         add_timer(&tp->timer);
6175 }
6176
6177 static int tg3_test_interrupt(struct tg3 *tp)
6178 {
6179         struct net_device *dev = tp->dev;
6180         int err, i;
6181         u32 int_mbox = 0;
6182
6183         if (!netif_running(dev))
6184                 return -ENODEV;
6185
6186         tg3_disable_ints(tp);
6187
6188         free_irq(tp->pdev->irq, dev);
6189
6190         err = request_irq(tp->pdev->irq, tg3_test_isr,
6191                           SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
6192         if (err)
6193                 return err;
6194
6195         tg3_enable_ints(tp);
6196
6197         tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
6198                HOSTCC_MODE_NOW);
6199
6200         for (i = 0; i < 5; i++) {
6201                 int_mbox = tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
6202                 if (int_mbox != 0)
6203                         break;
6204                 msleep(10);
6205         }
6206
6207         tg3_disable_ints(tp);
6208
6209         free_irq(tp->pdev->irq, dev);
6210
6211         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI)
6212                 err = request_irq(tp->pdev->irq, tg3_msi,
6213                                   SA_SAMPLE_RANDOM, dev->name, dev);
6214         else {
6215                 irqreturn_t (*fn)(int, void *, struct pt_regs *)=tg3_interrupt;
6216                 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
6217                         fn = tg3_interrupt_tagged;
6218                 err = request_irq(tp->pdev->irq, fn,
6219                                   SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
6220         }
6221
6222         if (err)
6223                 return err;
6224
6225         if (int_mbox != 0)
6226                 return 0;
6227
6228         return -EIO;
6229 }
6230
6231 /* Returns 0 if MSI test succeeds or MSI test fails and INTx mode is
6232  * successfully restored
6233  */
6234 static int tg3_test_msi(struct tg3 *tp)
6235 {
6236         struct net_device *dev = tp->dev;
6237         int err;
6238         u16 pci_cmd;
6239
6240         if (!(tp->tg3_flags2 & TG3_FLG2_USING_MSI))
6241                 return 0;
6242
6243         /* Turn off SERR reporting in case MSI terminates with Master
6244          * Abort.
6245          */
6246         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
6247         pci_write_config_word(tp->pdev, PCI_COMMAND,
6248                               pci_cmd & ~PCI_COMMAND_SERR);
6249
6250         err = tg3_test_interrupt(tp);
6251
6252         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
6253
6254         if (!err)
6255                 return 0;
6256
6257         /* other failures */
6258         if (err != -EIO)
6259                 return err;
6260
6261         /* MSI test failed, go back to INTx mode */
6262         printk(KERN_WARNING PFX "%s: No interrupt was generated using MSI, "
6263                "switching to INTx mode. Please report this failure to "
6264                "the PCI maintainer and include system chipset information.\n",
6265                        tp->dev->name);
6266
6267         free_irq(tp->pdev->irq, dev);
6268         pci_disable_msi(tp->pdev);
6269
6270         tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6271
6272         {
6273                 irqreturn_t (*fn)(int, void *, struct pt_regs *)=tg3_interrupt;
6274                 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
6275                         fn = tg3_interrupt_tagged;
6276
6277                 err = request_irq(tp->pdev->irq, fn,
6278                                   SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
6279         }
6280         if (err)
6281                 return err;
6282
6283         /* Need to reset the chip because the MSI cycle may have terminated
6284          * with Master Abort.
6285          */
6286         tg3_full_lock(tp, 1);
6287
6288         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
6289         err = tg3_init_hw(tp);
6290
6291         tg3_full_unlock(tp);
6292
6293         if (err)
6294                 free_irq(tp->pdev->irq, dev);
6295
6296         return err;
6297 }
6298
6299 static int tg3_open(struct net_device *dev)
6300 {
6301         struct tg3 *tp = netdev_priv(dev);
6302         int err;
6303
6304         tg3_full_lock(tp, 0);
6305
6306         tg3_disable_ints(tp);
6307         tp->tg3_flags &= ~TG3_FLAG_INIT_COMPLETE;
6308
6309         tg3_full_unlock(tp);
6310
6311         /* The placement of this call is tied
6312          * to the setup and use of Host TX descriptors.
6313          */
6314         err = tg3_alloc_consistent(tp);
6315         if (err)
6316                 return err;
6317
6318         if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
6319             (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5750_AX) &&
6320             (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5750_BX)) {
6321                 /* All MSI supporting chips should support tagged
6322                  * status.  Assert that this is the case.
6323                  */
6324                 if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)) {
6325                         printk(KERN_WARNING PFX "%s: MSI without TAGGED? "
6326                                "Not using MSI.\n", tp->dev->name);
6327                 } else if (pci_enable_msi(tp->pdev) == 0) {
6328                         u32 msi_mode;
6329
6330                         msi_mode = tr32(MSGINT_MODE);
6331                         tw32(MSGINT_MODE, msi_mode | MSGINT_MODE_ENABLE);
6332                         tp->tg3_flags2 |= TG3_FLG2_USING_MSI;
6333                 }
6334         }
6335         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI)
6336                 err = request_irq(tp->pdev->irq, tg3_msi,
6337                                   SA_SAMPLE_RANDOM, dev->name, dev);
6338         else {
6339                 irqreturn_t (*fn)(int, void *, struct pt_regs *)=tg3_interrupt;
6340                 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
6341                         fn = tg3_interrupt_tagged;
6342
6343                 err = request_irq(tp->pdev->irq, fn,
6344                                   SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
6345         }
6346
6347         if (err) {
6348                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6349                         pci_disable_msi(tp->pdev);
6350                         tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6351                 }
6352                 tg3_free_consistent(tp);
6353                 return err;
6354         }
6355
6356         tg3_full_lock(tp, 0);
6357
6358         err = tg3_init_hw(tp);
6359         if (err) {
6360                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
6361                 tg3_free_rings(tp);
6362         } else {
6363                 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
6364                         tp->timer_offset = HZ;
6365                 else
6366                         tp->timer_offset = HZ / 10;
6367
6368                 BUG_ON(tp->timer_offset > HZ);
6369                 tp->timer_counter = tp->timer_multiplier =
6370                         (HZ / tp->timer_offset);
6371                 tp->asf_counter = tp->asf_multiplier =
6372                         ((HZ / tp->timer_offset) * 120);
6373
6374                 init_timer(&tp->timer);
6375                 tp->timer.expires = jiffies + tp->timer_offset;
6376                 tp->timer.data = (unsigned long) tp;
6377                 tp->timer.function = tg3_timer;
6378         }
6379
6380         tg3_full_unlock(tp);
6381
6382         if (err) {
6383                 free_irq(tp->pdev->irq, dev);
6384                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6385                         pci_disable_msi(tp->pdev);
6386                         tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6387                 }
6388                 tg3_free_consistent(tp);
6389                 return err;
6390         }
6391
6392         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6393                 err = tg3_test_msi(tp);
6394
6395                 if (err) {
6396                         tg3_full_lock(tp, 0);
6397
6398                         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6399                                 pci_disable_msi(tp->pdev);
6400                                 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6401                         }
6402                         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
6403                         tg3_free_rings(tp);
6404                         tg3_free_consistent(tp);
6405
6406                         tg3_full_unlock(tp);
6407
6408                         return err;
6409                 }
6410         }
6411
6412         tg3_full_lock(tp, 0);
6413
6414         add_timer(&tp->timer);
6415         tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
6416         tg3_enable_ints(tp);
6417
6418         tg3_full_unlock(tp);
6419
6420         netif_start_queue(dev);
6421
6422         return 0;
6423 }
6424
6425 #if 0
6426 /*static*/ void tg3_dump_state(struct tg3 *tp)
6427 {
6428         u32 val32, val32_2, val32_3, val32_4, val32_5;
6429         u16 val16;
6430         int i;
6431
6432         pci_read_config_word(tp->pdev, PCI_STATUS, &val16);
6433         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE, &val32);
6434         printk("DEBUG: PCI status [%04x] TG3PCI state[%08x]\n",
6435                val16, val32);
6436
6437         /* MAC block */
6438         printk("DEBUG: MAC_MODE[%08x] MAC_STATUS[%08x]\n",
6439                tr32(MAC_MODE), tr32(MAC_STATUS));
6440         printk("       MAC_EVENT[%08x] MAC_LED_CTRL[%08x]\n",
6441                tr32(MAC_EVENT), tr32(MAC_LED_CTRL));
6442         printk("DEBUG: MAC_TX_MODE[%08x] MAC_TX_STATUS[%08x]\n",
6443                tr32(MAC_TX_MODE), tr32(MAC_TX_STATUS));
6444         printk("       MAC_RX_MODE[%08x] MAC_RX_STATUS[%08x]\n",
6445                tr32(MAC_RX_MODE), tr32(MAC_RX_STATUS));
6446
6447         /* Send data initiator control block */
6448         printk("DEBUG: SNDDATAI_MODE[%08x] SNDDATAI_STATUS[%08x]\n",
6449                tr32(SNDDATAI_MODE), tr32(SNDDATAI_STATUS));
6450         printk("       SNDDATAI_STATSCTRL[%08x]\n",
6451                tr32(SNDDATAI_STATSCTRL));
6452
6453         /* Send data completion control block */
6454         printk("DEBUG: SNDDATAC_MODE[%08x]\n", tr32(SNDDATAC_MODE));
6455
6456         /* Send BD ring selector block */
6457         printk("DEBUG: SNDBDS_MODE[%08x] SNDBDS_STATUS[%08x]\n",
6458                tr32(SNDBDS_MODE), tr32(SNDBDS_STATUS));
6459
6460         /* Send BD initiator control block */
6461         printk("DEBUG: SNDBDI_MODE[%08x] SNDBDI_STATUS[%08x]\n",
6462                tr32(SNDBDI_MODE), tr32(SNDBDI_STATUS));
6463
6464         /* Send BD completion control block */
6465         printk("DEBUG: SNDBDC_MODE[%08x]\n", tr32(SNDBDC_MODE));
6466
6467         /* Receive list placement control block */
6468         printk("DEBUG: RCVLPC_MODE[%08x] RCVLPC_STATUS[%08x]\n",
6469                tr32(RCVLPC_MODE), tr32(RCVLPC_STATUS));
6470         printk("       RCVLPC_STATSCTRL[%08x]\n",
6471                tr32(RCVLPC_STATSCTRL));
6472
6473         /* Receive data and receive BD initiator control block */
6474         printk("DEBUG: RCVDBDI_MODE[%08x] RCVDBDI_STATUS[%08x]\n",
6475                tr32(RCVDBDI_MODE), tr32(RCVDBDI_STATUS));
6476
6477         /* Receive data completion control block */
6478         printk("DEBUG: RCVDCC_MODE[%08x]\n",
6479                tr32(RCVDCC_MODE));
6480
6481         /* Receive BD initiator control block */
6482         printk("DEBUG: RCVBDI_MODE[%08x] RCVBDI_STATUS[%08x]\n",
6483                tr32(RCVBDI_MODE), tr32(RCVBDI_STATUS));
6484
6485         /* Receive BD completion control block */
6486         printk("DEBUG: RCVCC_MODE[%08x] RCVCC_STATUS[%08x]\n",
6487                tr32(RCVCC_MODE), tr32(RCVCC_STATUS));
6488
6489         /* Receive list selector control block */
6490         printk("DEBUG: RCVLSC_MODE[%08x] RCVLSC_STATUS[%08x]\n",
6491                tr32(RCVLSC_MODE), tr32(RCVLSC_STATUS));
6492
6493         /* Mbuf cluster free block */
6494         printk("DEBUG: MBFREE_MODE[%08x] MBFREE_STATUS[%08x]\n",
6495                tr32(MBFREE_MODE), tr32(MBFREE_STATUS));
6496
6497         /* Host coalescing control block */
6498         printk("DEBUG: HOSTCC_MODE[%08x] HOSTCC_STATUS[%08x]\n",
6499                tr32(HOSTCC_MODE), tr32(HOSTCC_STATUS));
6500         printk("DEBUG: HOSTCC_STATS_BLK_HOST_ADDR[%08x%08x]\n",
6501                tr32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH),
6502                tr32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW));
6503         printk("DEBUG: HOSTCC_STATUS_BLK_HOST_ADDR[%08x%08x]\n",
6504                tr32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH),
6505                tr32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW));
6506         printk("DEBUG: HOSTCC_STATS_BLK_NIC_ADDR[%08x]\n",
6507                tr32(HOSTCC_STATS_BLK_NIC_ADDR));
6508         printk("DEBUG: HOSTCC_STATUS_BLK_NIC_ADDR[%08x]\n",
6509                tr32(HOSTCC_STATUS_BLK_NIC_ADDR));
6510
6511         /* Memory arbiter control block */
6512         printk("DEBUG: MEMARB_MODE[%08x] MEMARB_STATUS[%08x]\n",
6513                tr32(MEMARB_MODE), tr32(MEMARB_STATUS));
6514
6515         /* Buffer manager control block */
6516         printk("DEBUG: BUFMGR_MODE[%08x] BUFMGR_STATUS[%08x]\n",
6517                tr32(BUFMGR_MODE), tr32(BUFMGR_STATUS));
6518         printk("DEBUG: BUFMGR_MB_POOL_ADDR[%08x] BUFMGR_MB_POOL_SIZE[%08x]\n",
6519                tr32(BUFMGR_MB_POOL_ADDR), tr32(BUFMGR_MB_POOL_SIZE));
6520         printk("DEBUG: BUFMGR_DMA_DESC_POOL_ADDR[%08x] "
6521                "BUFMGR_DMA_DESC_POOL_SIZE[%08x]\n",
6522                tr32(BUFMGR_DMA_DESC_POOL_ADDR),
6523                tr32(BUFMGR_DMA_DESC_POOL_SIZE));
6524
6525         /* Read DMA control block */
6526         printk("DEBUG: RDMAC_MODE[%08x] RDMAC_STATUS[%08x]\n",
6527                tr32(RDMAC_MODE), tr32(RDMAC_STATUS));
6528
6529         /* Write DMA control block */
6530         printk("DEBUG: WDMAC_MODE[%08x] WDMAC_STATUS[%08x]\n",
6531                tr32(WDMAC_MODE), tr32(WDMAC_STATUS));
6532
6533         /* DMA completion block */
6534         printk("DEBUG: DMAC_MODE[%08x]\n",
6535                tr32(DMAC_MODE));
6536
6537         /* GRC block */
6538         printk("DEBUG: GRC_MODE[%08x] GRC_MISC_CFG[%08x]\n",
6539                tr32(GRC_MODE), tr32(GRC_MISC_CFG));
6540         printk("DEBUG: GRC_LOCAL_CTRL[%08x]\n",
6541                tr32(GRC_LOCAL_CTRL));
6542
6543         /* TG3_BDINFOs */
6544         printk("DEBUG: RCVDBDI_JUMBO_BD[%08x%08x:%08x:%08x]\n",
6545                tr32(RCVDBDI_JUMBO_BD + 0x0),
6546                tr32(RCVDBDI_JUMBO_BD + 0x4),
6547                tr32(RCVDBDI_JUMBO_BD + 0x8),
6548                tr32(RCVDBDI_JUMBO_BD + 0xc));
6549         printk("DEBUG: RCVDBDI_STD_BD[%08x%08x:%08x:%08x]\n",
6550                tr32(RCVDBDI_STD_BD + 0x0),
6551                tr32(RCVDBDI_STD_BD + 0x4),
6552                tr32(RCVDBDI_STD_BD + 0x8),
6553                tr32(RCVDBDI_STD_BD + 0xc));
6554         printk("DEBUG: RCVDBDI_MINI_BD[%08x%08x:%08x:%08x]\n",
6555                tr32(RCVDBDI_MINI_BD + 0x0),
6556                tr32(RCVDBDI_MINI_BD + 0x4),
6557                tr32(RCVDBDI_MINI_BD + 0x8),
6558                tr32(RCVDBDI_MINI_BD + 0xc));
6559
6560         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x0, &val32);
6561         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x4, &val32_2);
6562         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x8, &val32_3);
6563         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0xc, &val32_4);
6564         printk("DEBUG: SRAM_SEND_RCB_0[%08x%08x:%08x:%08x]\n",
6565                val32, val32_2, val32_3, val32_4);
6566
6567         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x0, &val32);
6568         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x4, &val32_2);
6569         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x8, &val32_3);
6570         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0xc, &val32_4);
6571         printk("DEBUG: SRAM_RCV_RET_RCB_0[%08x%08x:%08x:%08x]\n",
6572                val32, val32_2, val32_3, val32_4);
6573
6574         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x0, &val32);
6575         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x4, &val32_2);
6576         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x8, &val32_3);
6577         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0xc, &val32_4);
6578         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x10, &val32_5);
6579         printk("DEBUG: SRAM_STATUS_BLK[%08x:%08x:%08x:%08x:%08x]\n",
6580                val32, val32_2, val32_3, val32_4, val32_5);
6581
6582         /* SW status block */
6583         printk("DEBUG: Host status block [%08x:%08x:(%04x:%04x:%04x):(%04x:%04x)]\n",
6584                tp->hw_status->status,
6585                tp->hw_status->status_tag,
6586                tp->hw_status->rx_jumbo_consumer,
6587                tp->hw_status->rx_consumer,
6588                tp->hw_status->rx_mini_consumer,
6589                tp->hw_status->idx[0].rx_producer,
6590                tp->hw_status->idx[0].tx_consumer);
6591
6592         /* SW statistics block */
6593         printk("DEBUG: Host statistics block [%08x:%08x:%08x:%08x]\n",
6594                ((u32 *)tp->hw_stats)[0],
6595                ((u32 *)tp->hw_stats)[1],
6596                ((u32 *)tp->hw_stats)[2],
6597                ((u32 *)tp->hw_stats)[3]);
6598
6599         /* Mailboxes */
6600         printk("DEBUG: SNDHOST_PROD[%08x%08x] SNDNIC_PROD[%08x%08x]\n",
6601                tr32(MAILBOX_SNDHOST_PROD_IDX_0 + 0x0),
6602                tr32(MAILBOX_SNDHOST_PROD_IDX_0 + 0x4),
6603                tr32(MAILBOX_SNDNIC_PROD_IDX_0 + 0x0),
6604                tr32(MAILBOX_SNDNIC_PROD_IDX_0 + 0x4));
6605
6606         /* NIC side send descriptors. */
6607         for (i = 0; i < 6; i++) {
6608                 unsigned long txd;
6609
6610                 txd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_TX_BUFFER_DESC
6611                         + (i * sizeof(struct tg3_tx_buffer_desc));
6612                 printk("DEBUG: NIC TXD(%d)[%08x:%08x:%08x:%08x]\n",
6613                        i,
6614                        readl(txd + 0x0), readl(txd + 0x4),
6615                        readl(txd + 0x8), readl(txd + 0xc));
6616         }
6617
6618         /* NIC side RX descriptors. */
6619         for (i = 0; i < 6; i++) {
6620                 unsigned long rxd;
6621
6622                 rxd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_RX_BUFFER_DESC
6623                         + (i * sizeof(struct tg3_rx_buffer_desc));
6624                 printk("DEBUG: NIC RXD_STD(%d)[0][%08x:%08x:%08x:%08x]\n",
6625                        i,
6626                        readl(rxd + 0x0), readl(rxd + 0x4),
6627                        readl(rxd + 0x8), readl(rxd + 0xc));
6628                 rxd += (4 * sizeof(u32));
6629                 printk("DEBUG: NIC RXD_STD(%d)[1][%08x:%08x:%08x:%08x]\n",
6630                        i,
6631                        readl(rxd + 0x0), readl(rxd + 0x4),
6632                        readl(rxd + 0x8), readl(rxd + 0xc));
6633         }
6634
6635         for (i = 0; i < 6; i++) {
6636                 unsigned long rxd;
6637
6638                 rxd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_RX_JUMBO_BUFFER_DESC
6639                         + (i * sizeof(struct tg3_rx_buffer_desc));
6640                 printk("DEBUG: NIC RXD_JUMBO(%d)[0][%08x:%08x:%08x:%08x]\n",
6641                        i,
6642                        readl(rxd + 0x0), readl(rxd + 0x4),
6643                        readl(rxd + 0x8), readl(rxd + 0xc));
6644                 rxd += (4 * sizeof(u32));
6645                 printk("DEBUG: NIC RXD_JUMBO(%d)[1][%08x:%08x:%08x:%08x]\n",
6646                        i,
6647                        readl(rxd + 0x0), readl(rxd + 0x4),
6648                        readl(rxd + 0x8), readl(rxd + 0xc));
6649         }
6650 }
6651 #endif
6652
6653 static struct net_device_stats *tg3_get_stats(struct net_device *);
6654 static struct tg3_ethtool_stats *tg3_get_estats(struct tg3 *);
6655
6656 static int tg3_close(struct net_device *dev)
6657 {
6658         struct tg3 *tp = netdev_priv(dev);
6659
6660         netif_stop_queue(dev);
6661
6662         del_timer_sync(&tp->timer);
6663
6664         tg3_full_lock(tp, 1);
6665 #if 0
6666         tg3_dump_state(tp);
6667 #endif
6668
6669         tg3_disable_ints(tp);
6670
6671         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
6672         tg3_free_rings(tp);
6673         tp->tg3_flags &=
6674                 ~(TG3_FLAG_INIT_COMPLETE |
6675                   TG3_FLAG_GOT_SERDES_FLOWCTL);
6676         netif_carrier_off(tp->dev);
6677
6678         tg3_full_unlock(tp);
6679
6680         free_irq(tp->pdev->irq, dev);
6681         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6682                 pci_disable_msi(tp->pdev);
6683                 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6684         }
6685
6686         memcpy(&tp->net_stats_prev, tg3_get_stats(tp->dev),
6687                sizeof(tp->net_stats_prev));
6688         memcpy(&tp->estats_prev, tg3_get_estats(tp),
6689                sizeof(tp->estats_prev));
6690
6691         tg3_free_consistent(tp);
6692
6693         return 0;
6694 }
6695
6696 static inline unsigned long get_stat64(tg3_stat64_t *val)
6697 {
6698         unsigned long ret;
6699
6700 #if (BITS_PER_LONG == 32)
6701         ret = val->low;
6702 #else
6703         ret = ((u64)val->high << 32) | ((u64)val->low);
6704 #endif
6705         return ret;
6706 }
6707
6708 static unsigned long calc_crc_errors(struct tg3 *tp)
6709 {
6710         struct tg3_hw_stats *hw_stats = tp->hw_stats;
6711
6712         if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) &&
6713             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
6714              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
6715                 u32 val;
6716
6717                 spin_lock_bh(&tp->lock);
6718                 if (!tg3_readphy(tp, 0x1e, &val)) {
6719                         tg3_writephy(tp, 0x1e, val | 0x8000);
6720                         tg3_readphy(tp, 0x14, &val);
6721                 } else
6722                         val = 0;
6723                 spin_unlock_bh(&tp->lock);
6724
6725                 tp->phy_crc_errors += val;
6726
6727                 return tp->phy_crc_errors;
6728         }
6729
6730         return get_stat64(&hw_stats->rx_fcs_errors);
6731 }
6732
6733 #define ESTAT_ADD(member) \
6734         estats->member =        old_estats->member + \
6735                                 get_stat64(&hw_stats->member)
6736
6737 static struct tg3_ethtool_stats *tg3_get_estats(struct tg3 *tp)
6738 {
6739         struct tg3_ethtool_stats *estats = &tp->estats;
6740         struct tg3_ethtool_stats *old_estats = &tp->estats_prev;
6741         struct tg3_hw_stats *hw_stats = tp->hw_stats;
6742
6743         if (!hw_stats)
6744                 return old_estats;
6745
6746         ESTAT_ADD(rx_octets);
6747         ESTAT_ADD(rx_fragments);
6748         ESTAT_ADD(rx_ucast_packets);
6749         ESTAT_ADD(rx_mcast_packets);
6750         ESTAT_ADD(rx_bcast_packets);
6751         ESTAT_ADD(rx_fcs_errors);
6752         ESTAT_ADD(rx_align_errors);
6753         ESTAT_ADD(rx_xon_pause_rcvd);
6754         ESTAT_ADD(rx_xoff_pause_rcvd);
6755         ESTAT_ADD(rx_mac_ctrl_rcvd);
6756         ESTAT_ADD(rx_xoff_entered);
6757         ESTAT_ADD(rx_frame_too_long_errors);
6758         ESTAT_ADD(rx_jabbers);
6759         ESTAT_ADD(rx_undersize_packets);
6760         ESTAT_ADD(rx_in_length_errors);
6761         ESTAT_ADD(rx_out_length_errors);
6762         ESTAT_ADD(rx_64_or_less_octet_packets);
6763         ESTAT_ADD(rx_65_to_127_octet_packets);
6764         ESTAT_ADD(rx_128_to_255_octet_packets);
6765         ESTAT_ADD(rx_256_to_511_octet_packets);
6766         ESTAT_ADD(rx_512_to_1023_octet_packets);
6767         ESTAT_ADD(rx_1024_to_1522_octet_packets);
6768         ESTAT_ADD(rx_1523_to_2047_octet_packets);
6769         ESTAT_ADD(rx_2048_to_4095_octet_packets);
6770         ESTAT_ADD(rx_4096_to_8191_octet_packets);
6771         ESTAT_ADD(rx_8192_to_9022_octet_packets);
6772
6773         ESTAT_ADD(tx_octets);
6774         ESTAT_ADD(tx_collisions);
6775         ESTAT_ADD(tx_xon_sent);
6776         ESTAT_ADD(tx_xoff_sent);
6777         ESTAT_ADD(tx_flow_control);
6778         ESTAT_ADD(tx_mac_errors);
6779         ESTAT_ADD(tx_single_collisions);
6780         ESTAT_ADD(tx_mult_collisions);
6781         ESTAT_ADD(tx_deferred);
6782         ESTAT_ADD(tx_excessive_collisions);
6783         ESTAT_ADD(tx_late_collisions);
6784         ESTAT_ADD(tx_collide_2times);
6785         ESTAT_ADD(tx_collide_3times);
6786         ESTAT_ADD(tx_collide_4times);
6787         ESTAT_ADD(tx_collide_5times);
6788         ESTAT_ADD(tx_collide_6times);
6789         ESTAT_ADD(tx_collide_7times);
6790         ESTAT_ADD(tx_collide_8times);
6791         ESTAT_ADD(tx_collide_9times);
6792         ESTAT_ADD(tx_collide_10times);
6793         ESTAT_ADD(tx_collide_11times);
6794         ESTAT_ADD(tx_collide_12times);
6795         ESTAT_ADD(tx_collide_13times);
6796         ESTAT_ADD(tx_collide_14times);
6797         ESTAT_ADD(tx_collide_15times);
6798         ESTAT_ADD(tx_ucast_packets);
6799         ESTAT_ADD(tx_mcast_packets);
6800         ESTAT_ADD(tx_bcast_packets);
6801         ESTAT_ADD(tx_carrier_sense_errors);
6802         ESTAT_ADD(tx_discards);
6803         ESTAT_ADD(tx_errors);
6804
6805         ESTAT_ADD(dma_writeq_full);
6806         ESTAT_ADD(dma_write_prioq_full);
6807         ESTAT_ADD(rxbds_empty);
6808         ESTAT_ADD(rx_discards);
6809         ESTAT_ADD(rx_errors);
6810         ESTAT_ADD(rx_threshold_hit);
6811
6812         ESTAT_ADD(dma_readq_full);
6813         ESTAT_ADD(dma_read_prioq_full);
6814         ESTAT_ADD(tx_comp_queue_full);
6815
6816         ESTAT_ADD(ring_set_send_prod_index);
6817         ESTAT_ADD(ring_status_update);
6818         ESTAT_ADD(nic_irqs);
6819         ESTAT_ADD(nic_avoided_irqs);
6820         ESTAT_ADD(nic_tx_threshold_hit);
6821
6822         return estats;
6823 }
6824
6825 static struct net_device_stats *tg3_get_stats(struct net_device *dev)
6826 {
6827         struct tg3 *tp = netdev_priv(dev);
6828         struct net_device_stats *stats = &tp->net_stats;
6829         struct net_device_stats *old_stats = &tp->net_stats_prev;
6830         struct tg3_hw_stats *hw_stats = tp->hw_stats;
6831
6832         if (!hw_stats)
6833                 return old_stats;
6834
6835         stats->rx_packets = old_stats->rx_packets +
6836                 get_stat64(&hw_stats->rx_ucast_packets) +
6837                 get_stat64(&hw_stats->rx_mcast_packets) +
6838                 get_stat64(&hw_stats->rx_bcast_packets);
6839
6840         stats->tx_packets = old_stats->tx_packets +
6841                 get_stat64(&hw_stats->tx_ucast_packets) +
6842                 get_stat64(&hw_stats->tx_mcast_packets) +
6843                 get_stat64(&hw_stats->tx_bcast_packets);
6844
6845         stats->rx_bytes = old_stats->rx_bytes +
6846                 get_stat64(&hw_stats->rx_octets);
6847         stats->tx_bytes = old_stats->tx_bytes +
6848                 get_stat64(&hw_stats->tx_octets);
6849
6850         stats->rx_errors = old_stats->rx_errors +
6851                 get_stat64(&hw_stats->rx_errors) +
6852                 get_stat64(&hw_stats->rx_discards);
6853         stats->tx_errors = old_stats->tx_errors +
6854                 get_stat64(&hw_stats->tx_errors) +
6855                 get_stat64(&hw_stats->tx_mac_errors) +
6856                 get_stat64(&hw_stats->tx_carrier_sense_errors) +
6857                 get_stat64(&hw_stats->tx_discards);
6858
6859         stats->multicast = old_stats->multicast +
6860                 get_stat64(&hw_stats->rx_mcast_packets);
6861         stats->collisions = old_stats->collisions +
6862                 get_stat64(&hw_stats->tx_collisions);
6863
6864         stats->rx_length_errors = old_stats->rx_length_errors +
6865                 get_stat64(&hw_stats->rx_frame_too_long_errors) +
6866                 get_stat64(&hw_stats->rx_undersize_packets);
6867
6868         stats->rx_over_errors = old_stats->rx_over_errors +
6869                 get_stat64(&hw_stats->rxbds_empty);
6870         stats->rx_frame_errors = old_stats->rx_frame_errors +
6871                 get_stat64(&hw_stats->rx_align_errors);
6872         stats->tx_aborted_errors = old_stats->tx_aborted_errors +
6873                 get_stat64(&hw_stats->tx_discards);
6874         stats->tx_carrier_errors = old_stats->tx_carrier_errors +
6875                 get_stat64(&hw_stats->tx_carrier_sense_errors);
6876
6877         stats->rx_crc_errors = old_stats->rx_crc_errors +
6878                 calc_crc_errors(tp);
6879
6880         return stats;
6881 }
6882
6883 static inline u32 calc_crc(unsigned char *buf, int len)
6884 {
6885         u32 reg;
6886         u32 tmp;
6887         int j, k;
6888
6889         reg = 0xffffffff;
6890
6891         for (j = 0; j < len; j++) {
6892                 reg ^= buf[j];
6893
6894                 for (k = 0; k < 8; k++) {
6895                         tmp = reg & 0x01;
6896
6897                         reg >>= 1;
6898
6899                         if (tmp) {
6900                                 reg ^= 0xedb88320;
6901                         }
6902                 }
6903         }
6904
6905         return ~reg;
6906 }
6907
6908 static void tg3_set_multi(struct tg3 *tp, unsigned int accept_all)
6909 {
6910         /* accept or reject all multicast frames */
6911         tw32(MAC_HASH_REG_0, accept_all ? 0xffffffff : 0);
6912         tw32(MAC_HASH_REG_1, accept_all ? 0xffffffff : 0);
6913         tw32(MAC_HASH_REG_2, accept_all ? 0xffffffff : 0);
6914         tw32(MAC_HASH_REG_3, accept_all ? 0xffffffff : 0);
6915 }
6916
6917 static void __tg3_set_rx_mode(struct net_device *dev)
6918 {
6919         struct tg3 *tp = netdev_priv(dev);
6920         u32 rx_mode;
6921
6922         rx_mode = tp->rx_mode & ~(RX_MODE_PROMISC |
6923                                   RX_MODE_KEEP_VLAN_TAG);
6924
6925         /* When ASF is in use, we always keep the RX_MODE_KEEP_VLAN_TAG
6926          * flag clear.
6927          */
6928 #if TG3_VLAN_TAG_USED
6929         if (!tp->vlgrp &&
6930             !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
6931                 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
6932 #else
6933         /* By definition, VLAN is disabled always in this
6934          * case.
6935          */
6936         if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
6937                 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
6938 #endif
6939
6940         if (dev->flags & IFF_PROMISC) {
6941                 /* Promiscuous mode. */
6942                 rx_mode |= RX_MODE_PROMISC;
6943         } else if (dev->flags & IFF_ALLMULTI) {
6944                 /* Accept all multicast. */
6945                 tg3_set_multi (tp, 1);
6946         } else if (dev->mc_count < 1) {
6947                 /* Reject all multicast. */
6948                 tg3_set_multi (tp, 0);
6949         } else {
6950                 /* Accept one or more multicast(s). */
6951                 struct dev_mc_list *mclist;
6952                 unsigned int i;
6953                 u32 mc_filter[4] = { 0, };
6954                 u32 regidx;
6955                 u32 bit;
6956                 u32 crc;
6957
6958                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
6959                      i++, mclist = mclist->next) {
6960
6961                         crc = calc_crc (mclist->dmi_addr, ETH_ALEN);
6962                         bit = ~crc & 0x7f;
6963                         regidx = (bit & 0x60) >> 5;
6964                         bit &= 0x1f;
6965                         mc_filter[regidx] |= (1 << bit);
6966                 }
6967
6968                 tw32(MAC_HASH_REG_0, mc_filter[0]);
6969                 tw32(MAC_HASH_REG_1, mc_filter[1]);
6970                 tw32(MAC_HASH_REG_2, mc_filter[2]);
6971                 tw32(MAC_HASH_REG_3, mc_filter[3]);
6972         }
6973
6974         if (rx_mode != tp->rx_mode) {
6975                 tp->rx_mode = rx_mode;
6976                 tw32_f(MAC_RX_MODE, rx_mode);
6977                 udelay(10);
6978         }
6979 }
6980
6981 static void tg3_set_rx_mode(struct net_device *dev)
6982 {
6983         struct tg3 *tp = netdev_priv(dev);
6984
6985         tg3_full_lock(tp, 0);
6986         __tg3_set_rx_mode(dev);
6987         tg3_full_unlock(tp);
6988 }
6989
6990 #define TG3_REGDUMP_LEN         (32 * 1024)
6991
6992 static int tg3_get_regs_len(struct net_device *dev)
6993 {
6994         return TG3_REGDUMP_LEN;
6995 }
6996
6997 static void tg3_get_regs(struct net_device *dev,
6998                 struct ethtool_regs *regs, void *_p)
6999 {
7000         u32 *p = _p;
7001         struct tg3 *tp = netdev_priv(dev);
7002         u8 *orig_p = _p;
7003         int i;
7004
7005         regs->version = 0;
7006
7007         memset(p, 0, TG3_REGDUMP_LEN);
7008
7009         tg3_full_lock(tp, 0);
7010
7011 #define __GET_REG32(reg)        (*(p)++ = tr32(reg))
7012 #define GET_REG32_LOOP(base,len)                \
7013 do {    p = (u32 *)(orig_p + (base));           \
7014         for (i = 0; i < len; i += 4)            \
7015                 __GET_REG32((base) + i);        \
7016 } while (0)
7017 #define GET_REG32_1(reg)                        \
7018 do {    p = (u32 *)(orig_p + (reg));            \
7019         __GET_REG32((reg));                     \
7020 } while (0)
7021
7022         GET_REG32_LOOP(TG3PCI_VENDOR, 0xb0);
7023         GET_REG32_LOOP(MAILBOX_INTERRUPT_0, 0x200);
7024         GET_REG32_LOOP(MAC_MODE, 0x4f0);
7025         GET_REG32_LOOP(SNDDATAI_MODE, 0xe0);
7026         GET_REG32_1(SNDDATAC_MODE);
7027         GET_REG32_LOOP(SNDBDS_MODE, 0x80);
7028         GET_REG32_LOOP(SNDBDI_MODE, 0x48);
7029         GET_REG32_1(SNDBDC_MODE);
7030         GET_REG32_LOOP(RCVLPC_MODE, 0x20);
7031         GET_REG32_LOOP(RCVLPC_SELLST_BASE, 0x15c);
7032         GET_REG32_LOOP(RCVDBDI_MODE, 0x0c);
7033         GET_REG32_LOOP(RCVDBDI_JUMBO_BD, 0x3c);
7034         GET_REG32_LOOP(RCVDBDI_BD_PROD_IDX_0, 0x44);
7035         GET_REG32_1(RCVDCC_MODE);
7036         GET_REG32_LOOP(RCVBDI_MODE, 0x20);
7037         GET_REG32_LOOP(RCVCC_MODE, 0x14);
7038         GET_REG32_LOOP(RCVLSC_MODE, 0x08);
7039         GET_REG32_1(MBFREE_MODE);
7040         GET_REG32_LOOP(HOSTCC_MODE, 0x100);
7041         GET_REG32_LOOP(MEMARB_MODE, 0x10);
7042         GET_REG32_LOOP(BUFMGR_MODE, 0x58);
7043         GET_REG32_LOOP(RDMAC_MODE, 0x08);
7044         GET_REG32_LOOP(WDMAC_MODE, 0x08);
7045         GET_REG32_LOOP(RX_CPU_BASE, 0x280);
7046         GET_REG32_LOOP(TX_CPU_BASE, 0x280);
7047         GET_REG32_LOOP(GRCMBOX_INTERRUPT_0, 0x110);
7048         GET_REG32_LOOP(FTQ_RESET, 0x120);
7049         GET_REG32_LOOP(MSGINT_MODE, 0x0c);
7050         GET_REG32_1(DMAC_MODE);
7051         GET_REG32_LOOP(GRC_MODE, 0x4c);
7052         if (tp->tg3_flags & TG3_FLAG_NVRAM)
7053                 GET_REG32_LOOP(NVRAM_CMD, 0x24);
7054
7055 #undef __GET_REG32
7056 #undef GET_REG32_LOOP
7057 #undef GET_REG32_1
7058
7059         tg3_full_unlock(tp);
7060 }
7061
7062 static int tg3_get_eeprom_len(struct net_device *dev)
7063 {
7064         struct tg3 *tp = netdev_priv(dev);
7065
7066         return tp->nvram_size;
7067 }
7068
7069 static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val);
7070
7071 static int tg3_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
7072 {
7073         struct tg3 *tp = netdev_priv(dev);
7074         int ret;
7075         u8  *pd;
7076         u32 i, offset, len, val, b_offset, b_count;
7077
7078         offset = eeprom->offset;
7079         len = eeprom->len;
7080         eeprom->len = 0;
7081
7082         eeprom->magic = TG3_EEPROM_MAGIC;
7083
7084         if (offset & 3) {
7085                 /* adjustments to start on required 4 byte boundary */
7086                 b_offset = offset & 3;
7087                 b_count = 4 - b_offset;
7088                 if (b_count > len) {
7089                         /* i.e. offset=1 len=2 */
7090                         b_count = len;
7091                 }
7092                 ret = tg3_nvram_read(tp, offset-b_offset, &val);
7093                 if (ret)
7094                         return ret;
7095                 val = cpu_to_le32(val);
7096                 memcpy(data, ((char*)&val) + b_offset, b_count);
7097                 len -= b_count;
7098                 offset += b_count;
7099                 eeprom->len += b_count;
7100         }
7101
7102         /* read bytes upto the last 4 byte boundary */
7103         pd = &data[eeprom->len];
7104         for (i = 0; i < (len - (len & 3)); i += 4) {
7105                 ret = tg3_nvram_read(tp, offset + i, &val);
7106                 if (ret) {
7107                         eeprom->len += i;
7108                         return ret;
7109                 }
7110                 val = cpu_to_le32(val);
7111                 memcpy(pd + i, &val, 4);
7112         }
7113         eeprom->len += i;
7114
7115         if (len & 3) {
7116                 /* read last bytes not ending on 4 byte boundary */
7117                 pd = &data[eeprom->len];
7118                 b_count = len & 3;
7119                 b_offset = offset + len - b_count;
7120                 ret = tg3_nvram_read(tp, b_offset, &val);
7121                 if (ret)
7122                         return ret;
7123                 val = cpu_to_le32(val);
7124                 memcpy(pd, ((char*)&val), b_count);
7125                 eeprom->len += b_count;
7126         }
7127         return 0;
7128 }
7129
7130 static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf);
7131
7132 static int tg3_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
7133 {
7134         struct tg3 *tp = netdev_priv(dev);
7135         int ret;
7136         u32 offset, len, b_offset, odd_len, start, end;
7137         u8 *buf;
7138
7139         if (eeprom->magic != TG3_EEPROM_MAGIC)
7140                 return -EINVAL;
7141
7142         offset = eeprom->offset;
7143         len = eeprom->len;
7144
7145         if ((b_offset = (offset & 3))) {
7146                 /* adjustments to start on required 4 byte boundary */
7147                 ret = tg3_nvram_read(tp, offset-b_offset, &start);
7148                 if (ret)
7149                         return ret;
7150                 start = cpu_to_le32(start);
7151                 len += b_offset;
7152                 offset &= ~3;
7153                 if (len < 4)
7154                         len = 4;
7155         }
7156
7157         odd_len = 0;
7158         if (len & 3) {
7159                 /* adjustments to end on required 4 byte boundary */
7160                 odd_len = 1;
7161                 len = (len + 3) & ~3;
7162                 ret = tg3_nvram_read(tp, offset+len-4, &end);
7163                 if (ret)
7164                         return ret;
7165                 end = cpu_to_le32(end);
7166         }
7167
7168         buf = data;
7169         if (b_offset || odd_len) {
7170                 buf = kmalloc(len, GFP_KERNEL);
7171                 if (buf == 0)
7172                         return -ENOMEM;
7173                 if (b_offset)
7174                         memcpy(buf, &start, 4);
7175                 if (odd_len)
7176                         memcpy(buf+len-4, &end, 4);
7177                 memcpy(buf + b_offset, data, eeprom->len);
7178         }
7179
7180         ret = tg3_nvram_write_block(tp, offset, len, buf);
7181
7182         if (buf != data)
7183                 kfree(buf);
7184
7185         return ret;
7186 }
7187
7188 static int tg3_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7189 {
7190         struct tg3 *tp = netdev_priv(dev);
7191
7192         cmd->supported = (SUPPORTED_Autoneg);
7193
7194         if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
7195                 cmd->supported |= (SUPPORTED_1000baseT_Half |
7196                                    SUPPORTED_1000baseT_Full);
7197
7198         if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES))
7199                 cmd->supported |= (SUPPORTED_100baseT_Half |
7200                                   SUPPORTED_100baseT_Full |
7201                                   SUPPORTED_10baseT_Half |
7202                                   SUPPORTED_10baseT_Full |
7203                                   SUPPORTED_MII);
7204         else
7205                 cmd->supported |= SUPPORTED_FIBRE;
7206
7207         cmd->advertising = tp->link_config.advertising;
7208         if (netif_running(dev)) {
7209                 cmd->speed = tp->link_config.active_speed;
7210                 cmd->duplex = tp->link_config.active_duplex;
7211         }
7212         cmd->port = 0;
7213         cmd->phy_address = PHY_ADDR;
7214         cmd->transceiver = 0;
7215         cmd->autoneg = tp->link_config.autoneg;
7216         cmd->maxtxpkt = 0;
7217         cmd->maxrxpkt = 0;
7218         return 0;
7219 }
7220
7221 static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7222 {
7223         struct tg3 *tp = netdev_priv(dev);
7224
7225         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
7226                 /* These are the only valid advertisement bits allowed.  */
7227                 if (cmd->autoneg == AUTONEG_ENABLE &&
7228                     (cmd->advertising & ~(ADVERTISED_1000baseT_Half |
7229                                           ADVERTISED_1000baseT_Full |
7230                                           ADVERTISED_Autoneg |
7231                                           ADVERTISED_FIBRE)))
7232                         return -EINVAL;
7233         }
7234
7235         tg3_full_lock(tp, 0);
7236
7237         tp->link_config.autoneg = cmd->autoneg;
7238         if (cmd->autoneg == AUTONEG_ENABLE) {
7239                 tp->link_config.advertising = cmd->advertising;
7240                 tp->link_config.speed = SPEED_INVALID;
7241                 tp->link_config.duplex = DUPLEX_INVALID;
7242         } else {
7243                 tp->link_config.advertising = 0;
7244                 tp->link_config.speed = cmd->speed;
7245                 tp->link_config.duplex = cmd->duplex;
7246         }
7247
7248         if (netif_running(dev))
7249                 tg3_setup_phy(tp, 1);
7250
7251         tg3_full_unlock(tp);
7252
7253         return 0;
7254 }
7255
7256 static void tg3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
7257 {
7258         struct tg3 *tp = netdev_priv(dev);
7259
7260         strcpy(info->driver, DRV_MODULE_NAME);
7261         strcpy(info->version, DRV_MODULE_VERSION);
7262         strcpy(info->bus_info, pci_name(tp->pdev));
7263 }
7264
7265 static void tg3_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7266 {
7267         struct tg3 *tp = netdev_priv(dev);
7268
7269         wol->supported = WAKE_MAGIC;
7270         wol->wolopts = 0;
7271         if (tp->tg3_flags & TG3_FLAG_WOL_ENABLE)
7272                 wol->wolopts = WAKE_MAGIC;
7273         memset(&wol->sopass, 0, sizeof(wol->sopass));
7274 }
7275
7276 static int tg3_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7277 {
7278         struct tg3 *tp = netdev_priv(dev);
7279
7280         if (wol->wolopts & ~WAKE_MAGIC)
7281                 return -EINVAL;
7282         if ((wol->wolopts & WAKE_MAGIC) &&
7283             tp->tg3_flags2 & TG3_FLG2_PHY_SERDES &&
7284             !(tp->tg3_flags & TG3_FLAG_SERDES_WOL_CAP))
7285                 return -EINVAL;
7286
7287         spin_lock_bh(&tp->lock);
7288         if (wol->wolopts & WAKE_MAGIC)
7289                 tp->tg3_flags |= TG3_FLAG_WOL_ENABLE;
7290         else
7291                 tp->tg3_flags &= ~TG3_FLAG_WOL_ENABLE;
7292         spin_unlock_bh(&tp->lock);
7293
7294         return 0;
7295 }
7296
7297 static u32 tg3_get_msglevel(struct net_device *dev)
7298 {
7299         struct tg3 *tp = netdev_priv(dev);
7300         return tp->msg_enable;
7301 }
7302
7303 static void tg3_set_msglevel(struct net_device *dev, u32 value)
7304 {
7305         struct tg3 *tp = netdev_priv(dev);
7306         tp->msg_enable = value;
7307 }
7308
7309 #if TG3_TSO_SUPPORT != 0
7310 static int tg3_set_tso(struct net_device *dev, u32 value)
7311 {
7312         struct tg3 *tp = netdev_priv(dev);
7313
7314         if (!(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
7315                 if (value)
7316                         return -EINVAL;
7317                 return 0;
7318         }
7319         return ethtool_op_set_tso(dev, value);
7320 }
7321 #endif
7322
7323 static int tg3_nway_reset(struct net_device *dev)
7324 {
7325         struct tg3 *tp = netdev_priv(dev);
7326         u32 bmcr;
7327         int r;
7328
7329         if (!netif_running(dev))
7330                 return -EAGAIN;
7331
7332         spin_lock_bh(&tp->lock);
7333         r = -EINVAL;
7334         tg3_readphy(tp, MII_BMCR, &bmcr);
7335         if (!tg3_readphy(tp, MII_BMCR, &bmcr) &&
7336             (bmcr & BMCR_ANENABLE)) {
7337                 tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANRESTART);
7338                 r = 0;
7339         }
7340         spin_unlock_bh(&tp->lock);
7341
7342         return r;
7343 }
7344
7345 static void tg3_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
7346 {
7347         struct tg3 *tp = netdev_priv(dev);
7348
7349         ering->rx_max_pending = TG3_RX_RING_SIZE - 1;
7350         ering->rx_mini_max_pending = 0;
7351         ering->rx_jumbo_max_pending = TG3_RX_JUMBO_RING_SIZE - 1;
7352
7353         ering->rx_pending = tp->rx_pending;
7354         ering->rx_mini_pending = 0;
7355         ering->rx_jumbo_pending = tp->rx_jumbo_pending;
7356         ering->tx_pending = tp->tx_pending;
7357 }
7358
7359 static int tg3_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
7360 {
7361         struct tg3 *tp = netdev_priv(dev);
7362         int irq_sync = 0;
7363
7364         if ((ering->rx_pending > TG3_RX_RING_SIZE - 1) ||
7365             (ering->rx_jumbo_pending > TG3_RX_JUMBO_RING_SIZE - 1) ||
7366             (ering->tx_pending > TG3_TX_RING_SIZE - 1))
7367                 return -EINVAL;
7368
7369         if (netif_running(dev)) {
7370                 tg3_netif_stop(tp);
7371                 irq_sync = 1;
7372         }
7373
7374         tg3_full_lock(tp, irq_sync);
7375
7376         tp->rx_pending = ering->rx_pending;
7377
7378         if ((tp->tg3_flags2 & TG3_FLG2_MAX_RXPEND_64) &&
7379             tp->rx_pending > 63)
7380                 tp->rx_pending = 63;
7381         tp->rx_jumbo_pending = ering->rx_jumbo_pending;
7382         tp->tx_pending = ering->tx_pending;
7383
7384         if (netif_running(dev)) {
7385                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
7386                 tg3_init_hw(tp);
7387                 tg3_netif_start(tp);
7388         }
7389
7390         tg3_full_unlock(tp);
7391
7392         return 0;
7393 }
7394
7395 static void tg3_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
7396 {
7397         struct tg3 *tp = netdev_priv(dev);
7398
7399         epause->autoneg = (tp->tg3_flags & TG3_FLAG_PAUSE_AUTONEG) != 0;
7400         epause->rx_pause = (tp->tg3_flags & TG3_FLAG_RX_PAUSE) != 0;
7401         epause->tx_pause = (tp->tg3_flags & TG3_FLAG_TX_PAUSE) != 0;
7402 }
7403
7404 static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
7405 {
7406         struct tg3 *tp = netdev_priv(dev);
7407         int irq_sync = 0;
7408
7409         if (netif_running(dev)) {
7410                 tg3_netif_stop(tp);
7411                 irq_sync = 1;
7412         }
7413
7414         tg3_full_lock(tp, irq_sync);
7415
7416         if (epause->autoneg)
7417                 tp->tg3_flags |= TG3_FLAG_PAUSE_AUTONEG;
7418         else
7419                 tp->tg3_flags &= ~TG3_FLAG_PAUSE_AUTONEG;
7420         if (epause->rx_pause)
7421                 tp->tg3_flags |= TG3_FLAG_RX_PAUSE;
7422         else
7423                 tp->tg3_flags &= ~TG3_FLAG_RX_PAUSE;
7424         if (epause->tx_pause)
7425                 tp->tg3_flags |= TG3_FLAG_TX_PAUSE;
7426         else
7427                 tp->tg3_flags &= ~TG3_FLAG_TX_PAUSE;
7428
7429         if (netif_running(dev)) {
7430                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
7431                 tg3_init_hw(tp);
7432                 tg3_netif_start(tp);
7433         }
7434
7435         tg3_full_unlock(tp);
7436
7437         return 0;
7438 }
7439
7440 static u32 tg3_get_rx_csum(struct net_device *dev)
7441 {
7442         struct tg3 *tp = netdev_priv(dev);
7443         return (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0;
7444 }
7445
7446 static int tg3_set_rx_csum(struct net_device *dev, u32 data)
7447 {
7448         struct tg3 *tp = netdev_priv(dev);
7449
7450         if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
7451                 if (data != 0)
7452                         return -EINVAL;
7453                 return 0;
7454         }
7455
7456         spin_lock_bh(&tp->lock);
7457         if (data)
7458                 tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
7459         else
7460                 tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
7461         spin_unlock_bh(&tp->lock);
7462
7463         return 0;
7464 }
7465
7466 static int tg3_set_tx_csum(struct net_device *dev, u32 data)
7467 {
7468         struct tg3 *tp = netdev_priv(dev);
7469
7470         if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
7471                 if (data != 0)
7472                         return -EINVAL;
7473                 return 0;
7474         }
7475
7476         if (data)
7477                 dev->features |= NETIF_F_IP_CSUM;
7478         else
7479                 dev->features &= ~NETIF_F_IP_CSUM;
7480
7481         return 0;
7482 }
7483
7484 static int tg3_get_stats_count (struct net_device *dev)
7485 {
7486         return TG3_NUM_STATS;
7487 }
7488
7489 static int tg3_get_test_count (struct net_device *dev)
7490 {
7491         return TG3_NUM_TEST;
7492 }
7493
7494 static void tg3_get_strings (struct net_device *dev, u32 stringset, u8 *buf)
7495 {
7496         switch (stringset) {
7497         case ETH_SS_STATS:
7498                 memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
7499                 break;
7500         case ETH_SS_TEST:
7501                 memcpy(buf, &ethtool_test_keys, sizeof(ethtool_test_keys));
7502                 break;
7503         default:
7504                 WARN_ON(1);     /* we need a WARN() */
7505                 break;
7506         }
7507 }
7508
7509 static void tg3_get_ethtool_stats (struct net_device *dev,
7510                                    struct ethtool_stats *estats, u64 *tmp_stats)
7511 {
7512         struct tg3 *tp = netdev_priv(dev);
7513         memcpy(tmp_stats, tg3_get_estats(tp), sizeof(tp->estats));
7514 }
7515
7516 #define NVRAM_TEST_SIZE 0x100
7517
7518 static int tg3_test_nvram(struct tg3 *tp)
7519 {
7520         u32 *buf, csum;
7521         int i, j, err = 0;
7522
7523         buf = kmalloc(NVRAM_TEST_SIZE, GFP_KERNEL);
7524         if (buf == NULL)
7525                 return -ENOMEM;
7526
7527         for (i = 0, j = 0; i < NVRAM_TEST_SIZE; i += 4, j++) {
7528                 u32 val;
7529
7530                 if ((err = tg3_nvram_read(tp, i, &val)) != 0)
7531                         break;
7532                 buf[j] = cpu_to_le32(val);
7533         }
7534         if (i < NVRAM_TEST_SIZE)
7535                 goto out;
7536
7537         err = -EIO;
7538         if (cpu_to_be32(buf[0]) != TG3_EEPROM_MAGIC)
7539                 goto out;
7540
7541         /* Bootstrap checksum at offset 0x10 */
7542         csum = calc_crc((unsigned char *) buf, 0x10);
7543         if(csum != cpu_to_le32(buf[0x10/4]))
7544                 goto out;
7545
7546         /* Manufacturing block starts at offset 0x74, checksum at 0xfc */
7547         csum = calc_crc((unsigned char *) &buf[0x74/4], 0x88);
7548         if (csum != cpu_to_le32(buf[0xfc/4]))
7549                  goto out;
7550
7551         err = 0;
7552
7553 out:
7554         kfree(buf);
7555         return err;
7556 }
7557
7558 #define TG3_SERDES_TIMEOUT_SEC  2
7559 #define TG3_COPPER_TIMEOUT_SEC  6
7560
7561 static int tg3_test_link(struct tg3 *tp)
7562 {
7563         int i, max;
7564
7565         if (!netif_running(tp->dev))
7566                 return -ENODEV;
7567
7568         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
7569                 max = TG3_SERDES_TIMEOUT_SEC;
7570         else
7571                 max = TG3_COPPER_TIMEOUT_SEC;
7572
7573         for (i = 0; i < max; i++) {
7574                 if (netif_carrier_ok(tp->dev))
7575                         return 0;
7576
7577                 if (msleep_interruptible(1000))
7578                         break;
7579         }
7580
7581         return -EIO;
7582 }
7583
7584 /* Only test the commonly used registers */
7585 static int tg3_test_registers(struct tg3 *tp)
7586 {
7587         int i, is_5705;
7588         u32 offset, read_mask, write_mask, val, save_val, read_val;
7589         static struct {
7590                 u16 offset;
7591                 u16 flags;
7592 #define TG3_FL_5705     0x1
7593 #define TG3_FL_NOT_5705 0x2
7594 #define TG3_FL_NOT_5788 0x4
7595                 u32 read_mask;
7596                 u32 write_mask;
7597         } reg_tbl[] = {
7598                 /* MAC Control Registers */
7599                 { MAC_MODE, TG3_FL_NOT_5705,
7600                         0x00000000, 0x00ef6f8c },
7601                 { MAC_MODE, TG3_FL_5705,
7602                         0x00000000, 0x01ef6b8c },
7603                 { MAC_STATUS, TG3_FL_NOT_5705,
7604                         0x03800107, 0x00000000 },
7605                 { MAC_STATUS, TG3_FL_5705,
7606                         0x03800100, 0x00000000 },
7607                 { MAC_ADDR_0_HIGH, 0x0000,
7608                         0x00000000, 0x0000ffff },
7609                 { MAC_ADDR_0_LOW, 0x0000,
7610                         0x00000000, 0xffffffff },
7611                 { MAC_RX_MTU_SIZE, 0x0000,
7612                         0x00000000, 0x0000ffff },
7613                 { MAC_TX_MODE, 0x0000,
7614                         0x00000000, 0x00000070 },
7615                 { MAC_TX_LENGTHS, 0x0000,
7616                         0x00000000, 0x00003fff },
7617                 { MAC_RX_MODE, TG3_FL_NOT_5705,
7618                         0x00000000, 0x000007fc },
7619                 { MAC_RX_MODE, TG3_FL_5705,
7620                         0x00000000, 0x000007dc },
7621                 { MAC_HASH_REG_0, 0x0000,
7622                         0x00000000, 0xffffffff },
7623                 { MAC_HASH_REG_1, 0x0000,
7624                         0x00000000, 0xffffffff },
7625                 { MAC_HASH_REG_2, 0x0000,
7626                         0x00000000, 0xffffffff },
7627                 { MAC_HASH_REG_3, 0x0000,
7628                         0x00000000, 0xffffffff },
7629
7630                 /* Receive Data and Receive BD Initiator Control Registers. */
7631                 { RCVDBDI_JUMBO_BD+0, TG3_FL_NOT_5705,
7632                         0x00000000, 0xffffffff },
7633                 { RCVDBDI_JUMBO_BD+4, TG3_FL_NOT_5705,
7634                         0x00000000, 0xffffffff },
7635                 { RCVDBDI_JUMBO_BD+8, TG3_FL_NOT_5705,
7636                         0x00000000, 0x00000003 },
7637                 { RCVDBDI_JUMBO_BD+0xc, TG3_FL_NOT_5705,
7638                         0x00000000, 0xffffffff },
7639                 { RCVDBDI_STD_BD+0, 0x0000,
7640                         0x00000000, 0xffffffff },
7641                 { RCVDBDI_STD_BD+4, 0x0000,
7642                         0x00000000, 0xffffffff },
7643                 { RCVDBDI_STD_BD+8, 0x0000,
7644                         0x00000000, 0xffff0002 },
7645                 { RCVDBDI_STD_BD+0xc, 0x0000,
7646                         0x00000000, 0xffffffff },
7647
7648                 /* Receive BD Initiator Control Registers. */
7649                 { RCVBDI_STD_THRESH, TG3_FL_NOT_5705,
7650                         0x00000000, 0xffffffff },
7651                 { RCVBDI_STD_THRESH, TG3_FL_5705,
7652                         0x00000000, 0x000003ff },
7653                 { RCVBDI_JUMBO_THRESH, TG3_FL_NOT_5705,
7654                         0x00000000, 0xffffffff },
7655
7656                 /* Host Coalescing Control Registers. */
7657                 { HOSTCC_MODE, TG3_FL_NOT_5705,
7658                         0x00000000, 0x00000004 },
7659                 { HOSTCC_MODE, TG3_FL_5705,
7660                         0x00000000, 0x000000f6 },
7661                 { HOSTCC_RXCOL_TICKS, TG3_FL_NOT_5705,
7662                         0x00000000, 0xffffffff },
7663                 { HOSTCC_RXCOL_TICKS, TG3_FL_5705,
7664                         0x00000000, 0x000003ff },
7665                 { HOSTCC_TXCOL_TICKS, TG3_FL_NOT_5705,
7666                         0x00000000, 0xffffffff },
7667                 { HOSTCC_TXCOL_TICKS, TG3_FL_5705,
7668                         0x00000000, 0x000003ff },
7669                 { HOSTCC_RXMAX_FRAMES, TG3_FL_NOT_5705,
7670                         0x00000000, 0xffffffff },
7671                 { HOSTCC_RXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
7672                         0x00000000, 0x000000ff },
7673                 { HOSTCC_TXMAX_FRAMES, TG3_FL_NOT_5705,
7674                         0x00000000, 0xffffffff },
7675                 { HOSTCC_TXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
7676                         0x00000000, 0x000000ff },
7677                 { HOSTCC_RXCOAL_TICK_INT, TG3_FL_NOT_5705,
7678                         0x00000000, 0xffffffff },
7679                 { HOSTCC_TXCOAL_TICK_INT, TG3_FL_NOT_5705,
7680                         0x00000000, 0xffffffff },
7681                 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_NOT_5705,
7682                         0x00000000, 0xffffffff },
7683                 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
7684                         0x00000000, 0x000000ff },
7685                 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_NOT_5705,
7686                         0x00000000, 0xffffffff },
7687                 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
7688                         0x00000000, 0x000000ff },
7689                 { HOSTCC_STAT_COAL_TICKS, TG3_FL_NOT_5705,
7690                         0x00000000, 0xffffffff },
7691                 { HOSTCC_STATS_BLK_HOST_ADDR, TG3_FL_NOT_5705,
7692                         0x00000000, 0xffffffff },
7693                 { HOSTCC_STATS_BLK_HOST_ADDR+4, TG3_FL_NOT_5705,
7694                         0x00000000, 0xffffffff },
7695                 { HOSTCC_STATUS_BLK_HOST_ADDR, 0x0000,
7696                         0x00000000, 0xffffffff },
7697                 { HOSTCC_STATUS_BLK_HOST_ADDR+4, 0x0000,
7698                         0x00000000, 0xffffffff },
7699                 { HOSTCC_STATS_BLK_NIC_ADDR, 0x0000,
7700                         0xffffffff, 0x00000000 },
7701                 { HOSTCC_STATUS_BLK_NIC_ADDR, 0x0000,
7702                         0xffffffff, 0x00000000 },
7703
7704                 /* Buffer Manager Control Registers. */
7705                 { BUFMGR_MB_POOL_ADDR, 0x0000,
7706                         0x00000000, 0x007fff80 },
7707                 { BUFMGR_MB_POOL_SIZE, 0x0000,
7708                         0x00000000, 0x007fffff },
7709                 { BUFMGR_MB_RDMA_LOW_WATER, 0x0000,
7710                         0x00000000, 0x0000003f },
7711                 { BUFMGR_MB_MACRX_LOW_WATER, 0x0000,
7712                         0x00000000, 0x000001ff },
7713                 { BUFMGR_MB_HIGH_WATER, 0x0000,
7714                         0x00000000, 0x000001ff },
7715                 { BUFMGR_DMA_DESC_POOL_ADDR, TG3_FL_NOT_5705,
7716                         0xffffffff, 0x00000000 },
7717                 { BUFMGR_DMA_DESC_POOL_SIZE, TG3_FL_NOT_5705,
7718                         0xffffffff, 0x00000000 },
7719
7720                 /* Mailbox Registers */
7721                 { GRCMBOX_RCVSTD_PROD_IDX+4, 0x0000,
7722                         0x00000000, 0x000001ff },
7723                 { GRCMBOX_RCVJUMBO_PROD_IDX+4, TG3_FL_NOT_5705,
7724                         0x00000000, 0x000001ff },
7725                 { GRCMBOX_RCVRET_CON_IDX_0+4, 0x0000,
7726                         0x00000000, 0x000007ff },
7727                 { GRCMBOX_SNDHOST_PROD_IDX_0+4, 0x0000,
7728                         0x00000000, 0x000001ff },
7729
7730                 { 0xffff, 0x0000, 0x00000000, 0x00000000 },
7731         };
7732
7733         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
7734                 is_5705 = 1;
7735         else
7736                 is_5705 = 0;
7737
7738         for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
7739                 if (is_5705 && (reg_tbl[i].flags & TG3_FL_NOT_5705))
7740                         continue;
7741
7742                 if (!is_5705 && (reg_tbl[i].flags & TG3_FL_5705))
7743                         continue;
7744
7745                 if ((tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
7746                     (reg_tbl[i].flags & TG3_FL_NOT_5788))
7747                         continue;
7748
7749                 offset = (u32) reg_tbl[i].offset;
7750                 read_mask = reg_tbl[i].read_mask;
7751                 write_mask = reg_tbl[i].write_mask;
7752
7753                 /* Save the original register content */
7754                 save_val = tr32(offset);
7755
7756                 /* Determine the read-only value. */
7757                 read_val = save_val & read_mask;
7758
7759                 /* Write zero to the register, then make sure the read-only bits
7760                  * are not changed and the read/write bits are all zeros.
7761                  */
7762                 tw32(offset, 0);
7763
7764                 val = tr32(offset);
7765
7766                 /* Test the read-only and read/write bits. */
7767                 if (((val & read_mask) != read_val) || (val & write_mask))
7768                         goto out;
7769
7770                 /* Write ones to all the bits defined by RdMask and WrMask, then
7771                  * make sure the read-only bits are not changed and the
7772                  * read/write bits are all ones.
7773                  */
7774                 tw32(offset, read_mask | write_mask);
7775
7776                 val = tr32(offset);
7777
7778                 /* Test the read-only bits. */
7779                 if ((val & read_mask) != read_val)
7780                         goto out;
7781
7782                 /* Test the read/write bits. */
7783                 if ((val & write_mask) != write_mask)
7784                         goto out;
7785
7786                 tw32(offset, save_val);
7787         }
7788
7789         return 0;
7790
7791 out:
7792         printk(KERN_ERR PFX "Register test failed at offset %x\n", offset);
7793         tw32(offset, save_val);
7794         return -EIO;
7795 }
7796
7797 static int tg3_do_mem_test(struct tg3 *tp, u32 offset, u32 len)
7798 {
7799         static u32 test_pattern[] = { 0x00000000, 0xffffffff, 0xaa55a55a };
7800         int i;
7801         u32 j;
7802
7803         for (i = 0; i < sizeof(test_pattern)/sizeof(u32); i++) {
7804                 for (j = 0; j < len; j += 4) {
7805                         u32 val;
7806
7807                         tg3_write_mem(tp, offset + j, test_pattern[i]);
7808                         tg3_read_mem(tp, offset + j, &val);
7809                         if (val != test_pattern[i])
7810                                 return -EIO;
7811                 }
7812         }
7813         return 0;
7814 }
7815
7816 static int tg3_test_memory(struct tg3 *tp)
7817 {
7818         static struct mem_entry {
7819                 u32 offset;
7820                 u32 len;
7821         } mem_tbl_570x[] = {
7822                 { 0x00000000, 0x01000},
7823                 { 0x00002000, 0x1c000},
7824                 { 0xffffffff, 0x00000}
7825         }, mem_tbl_5705[] = {
7826                 { 0x00000100, 0x0000c},
7827                 { 0x00000200, 0x00008},
7828                 { 0x00000b50, 0x00400},
7829                 { 0x00004000, 0x00800},
7830                 { 0x00006000, 0x01000},
7831                 { 0x00008000, 0x02000},
7832                 { 0x00010000, 0x0e000},
7833                 { 0xffffffff, 0x00000}
7834         };
7835         struct mem_entry *mem_tbl;
7836         int err = 0;
7837         int i;
7838
7839         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
7840                 mem_tbl = mem_tbl_5705;
7841         else
7842                 mem_tbl = mem_tbl_570x;
7843
7844         for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
7845                 if ((err = tg3_do_mem_test(tp, mem_tbl[i].offset,
7846                     mem_tbl[i].len)) != 0)
7847                         break;
7848         }
7849
7850         return err;
7851 }
7852
7853 static int tg3_test_loopback(struct tg3 *tp)
7854 {
7855         u32 mac_mode, send_idx, rx_start_idx, rx_idx, tx_idx, opaque_key;
7856         u32 desc_idx;
7857         struct sk_buff *skb, *rx_skb;
7858         u8 *tx_data;
7859         dma_addr_t map;
7860         int num_pkts, tx_len, rx_len, i, err;
7861         struct tg3_rx_buffer_desc *desc;
7862
7863         if (!netif_running(tp->dev))
7864                 return -ENODEV;
7865
7866         err = -EIO;
7867
7868         tg3_abort_hw(tp, 1);
7869
7870         tg3_reset_hw(tp);
7871
7872         mac_mode = (tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK) |
7873                    MAC_MODE_PORT_INT_LPBACK | MAC_MODE_LINK_POLARITY |
7874                    MAC_MODE_PORT_MODE_GMII;
7875         tw32(MAC_MODE, mac_mode);
7876
7877         tx_len = 1514;
7878         skb = dev_alloc_skb(tx_len);
7879         tx_data = skb_put(skb, tx_len);
7880         memcpy(tx_data, tp->dev->dev_addr, 6);
7881         memset(tx_data + 6, 0x0, 8);
7882
7883         tw32(MAC_RX_MTU_SIZE, tx_len + 4);
7884
7885         for (i = 14; i < tx_len; i++)
7886                 tx_data[i] = (u8) (i & 0xff);
7887
7888         map = pci_map_single(tp->pdev, skb->data, tx_len, PCI_DMA_TODEVICE);
7889
7890         tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
7891              HOSTCC_MODE_NOW);
7892
7893         udelay(10);
7894
7895         rx_start_idx = tp->hw_status->idx[0].rx_producer;
7896
7897         send_idx = 0;
7898         num_pkts = 0;
7899
7900         tg3_set_txd(tp, send_idx, map, tx_len, 0, 1);
7901
7902         send_idx++;
7903         num_pkts++;
7904
7905         tw32_tx_mbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW, send_idx);
7906         tr32(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW);
7907
7908         udelay(10);
7909
7910         for (i = 0; i < 10; i++) {
7911                 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
7912                        HOSTCC_MODE_NOW);
7913
7914                 udelay(10);
7915
7916                 tx_idx = tp->hw_status->idx[0].tx_consumer;
7917                 rx_idx = tp->hw_status->idx[0].rx_producer;
7918                 if ((tx_idx == send_idx) &&
7919                     (rx_idx == (rx_start_idx + num_pkts)))
7920                         break;
7921         }
7922
7923         pci_unmap_single(tp->pdev, map, tx_len, PCI_DMA_TODEVICE);
7924         dev_kfree_skb(skb);
7925
7926         if (tx_idx != send_idx)
7927                 goto out;
7928
7929         if (rx_idx != rx_start_idx + num_pkts)
7930                 goto out;
7931
7932         desc = &tp->rx_rcb[rx_start_idx];
7933         desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
7934         opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
7935         if (opaque_key != RXD_OPAQUE_RING_STD)
7936                 goto out;
7937
7938         if ((desc->err_vlan & RXD_ERR_MASK) != 0 &&
7939             (desc->err_vlan != RXD_ERR_ODD_NIBBLE_RCVD_MII))
7940                 goto out;
7941
7942         rx_len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT) - 4;
7943         if (rx_len != tx_len)
7944                 goto out;
7945
7946         rx_skb = tp->rx_std_buffers[desc_idx].skb;
7947
7948         map = pci_unmap_addr(&tp->rx_std_buffers[desc_idx], mapping);
7949         pci_dma_sync_single_for_cpu(tp->pdev, map, rx_len, PCI_DMA_FROMDEVICE);
7950
7951         for (i = 14; i < tx_len; i++) {
7952                 if (*(rx_skb->data + i) != (u8) (i & 0xff))
7953                         goto out;
7954         }
7955         err = 0;
7956
7957         /* tg3_free_rings will unmap and free the rx_skb */
7958 out:
7959         return err;
7960 }
7961
7962 static void tg3_self_test(struct net_device *dev, struct ethtool_test *etest,
7963                           u64 *data)
7964 {
7965         struct tg3 *tp = netdev_priv(dev);
7966
7967         memset(data, 0, sizeof(u64) * TG3_NUM_TEST);
7968
7969         if (tg3_test_nvram(tp) != 0) {
7970                 etest->flags |= ETH_TEST_FL_FAILED;
7971                 data[0] = 1;
7972         }
7973         if (tg3_test_link(tp) != 0) {
7974                 etest->flags |= ETH_TEST_FL_FAILED;
7975                 data[1] = 1;
7976         }
7977         if (etest->flags & ETH_TEST_FL_OFFLINE) {
7978                 int irq_sync = 0;
7979
7980                 if (netif_running(dev)) {
7981                         tg3_netif_stop(tp);
7982                         irq_sync = 1;
7983                 }
7984
7985                 tg3_full_lock(tp, irq_sync);
7986
7987                 tg3_halt(tp, RESET_KIND_SUSPEND, 1);
7988                 tg3_nvram_lock(tp);
7989                 tg3_halt_cpu(tp, RX_CPU_BASE);
7990                 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
7991                         tg3_halt_cpu(tp, TX_CPU_BASE);
7992                 tg3_nvram_unlock(tp);
7993
7994                 if (tg3_test_registers(tp) != 0) {
7995                         etest->flags |= ETH_TEST_FL_FAILED;
7996                         data[2] = 1;
7997                 }
7998                 if (tg3_test_memory(tp) != 0) {
7999                         etest->flags |= ETH_TEST_FL_FAILED;
8000                         data[3] = 1;
8001                 }
8002                 if (tg3_test_loopback(tp) != 0) {
8003                         etest->flags |= ETH_TEST_FL_FAILED;
8004                         data[4] = 1;
8005                 }
8006
8007                 tg3_full_unlock(tp);
8008
8009                 if (tg3_test_interrupt(tp) != 0) {
8010                         etest->flags |= ETH_TEST_FL_FAILED;
8011                         data[5] = 1;
8012                 }
8013
8014                 tg3_full_lock(tp, 0);
8015
8016                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8017                 if (netif_running(dev)) {
8018                         tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
8019                         tg3_init_hw(tp);
8020                         tg3_netif_start(tp);
8021                 }
8022
8023                 tg3_full_unlock(tp);
8024         }
8025 }
8026
8027 static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
8028 {
8029         struct mii_ioctl_data *data = if_mii(ifr);
8030         struct tg3 *tp = netdev_priv(dev);
8031         int err;
8032
8033         switch(cmd) {
8034         case SIOCGMIIPHY:
8035                 data->phy_id = PHY_ADDR;
8036
8037                 /* fallthru */
8038         case SIOCGMIIREG: {
8039                 u32 mii_regval;
8040
8041                 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
8042                         break;                  /* We have no PHY */
8043
8044                 spin_lock_bh(&tp->lock);
8045                 err = tg3_readphy(tp, data->reg_num & 0x1f, &mii_regval);
8046                 spin_unlock_bh(&tp->lock);
8047
8048                 data->val_out = mii_regval;
8049
8050                 return err;
8051         }
8052
8053         case SIOCSMIIREG:
8054                 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
8055                         break;                  /* We have no PHY */
8056
8057                 if (!capable(CAP_NET_ADMIN))
8058                         return -EPERM;
8059
8060                 spin_lock_bh(&tp->lock);
8061                 err = tg3_writephy(tp, data->reg_num & 0x1f, data->val_in);
8062                 spin_unlock_bh(&tp->lock);
8063
8064                 return err;
8065
8066         default:
8067                 /* do nothing */
8068                 break;
8069         }
8070         return -EOPNOTSUPP;
8071 }
8072
8073 #if TG3_VLAN_TAG_USED
8074 static void tg3_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
8075 {
8076         struct tg3 *tp = netdev_priv(dev);
8077
8078         tg3_full_lock(tp, 0);
8079
8080         tp->vlgrp = grp;
8081
8082         /* Update RX_MODE_KEEP_VLAN_TAG bit in RX_MODE register. */
8083         __tg3_set_rx_mode(dev);
8084
8085         tg3_full_unlock(tp);
8086 }
8087
8088 static void tg3_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
8089 {
8090         struct tg3 *tp = netdev_priv(dev);
8091
8092         tg3_full_lock(tp, 0);
8093         if (tp->vlgrp)
8094                 tp->vlgrp->vlan_devices[vid] = NULL;
8095         tg3_full_unlock(tp);
8096 }
8097 #endif
8098
8099 static int tg3_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
8100 {
8101         struct tg3 *tp = netdev_priv(dev);
8102
8103         memcpy(ec, &tp->coal, sizeof(*ec));
8104         return 0;
8105 }
8106
8107 static int tg3_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
8108 {
8109         struct tg3 *tp = netdev_priv(dev);
8110         u32 max_rxcoal_tick_int = 0, max_txcoal_tick_int = 0;
8111         u32 max_stat_coal_ticks = 0, min_stat_coal_ticks = 0;
8112
8113         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
8114                 max_rxcoal_tick_int = MAX_RXCOAL_TICK_INT;
8115                 max_txcoal_tick_int = MAX_TXCOAL_TICK_INT;
8116                 max_stat_coal_ticks = MAX_STAT_COAL_TICKS;
8117                 min_stat_coal_ticks = MIN_STAT_COAL_TICKS;
8118         }
8119
8120         if ((ec->rx_coalesce_usecs > MAX_RXCOL_TICKS) ||
8121             (ec->tx_coalesce_usecs > MAX_TXCOL_TICKS) ||
8122             (ec->rx_max_coalesced_frames > MAX_RXMAX_FRAMES) ||
8123             (ec->tx_max_coalesced_frames > MAX_TXMAX_FRAMES) ||
8124             (ec->rx_coalesce_usecs_irq > max_rxcoal_tick_int) ||
8125             (ec->tx_coalesce_usecs_irq > max_txcoal_tick_int) ||
8126             (ec->rx_max_coalesced_frames_irq > MAX_RXCOAL_MAXF_INT) ||
8127             (ec->tx_max_coalesced_frames_irq > MAX_TXCOAL_MAXF_INT) ||
8128             (ec->stats_block_coalesce_usecs > max_stat_coal_ticks) ||
8129             (ec->stats_block_coalesce_usecs < min_stat_coal_ticks))
8130                 return -EINVAL;
8131
8132         /* No rx interrupts will be generated if both are zero */
8133         if ((ec->rx_coalesce_usecs == 0) &&
8134             (ec->rx_max_coalesced_frames == 0))
8135                 return -EINVAL;
8136
8137         /* No tx interrupts will be generated if both are zero */
8138         if ((ec->tx_coalesce_usecs == 0) &&
8139             (ec->tx_max_coalesced_frames == 0))
8140                 return -EINVAL;
8141
8142         /* Only copy relevant parameters, ignore all others. */
8143         tp->coal.rx_coalesce_usecs = ec->rx_coalesce_usecs;
8144         tp->coal.tx_coalesce_usecs = ec->tx_coalesce_usecs;
8145         tp->coal.rx_max_coalesced_frames = ec->rx_max_coalesced_frames;
8146         tp->coal.tx_max_coalesced_frames = ec->tx_max_coalesced_frames;
8147         tp->coal.rx_coalesce_usecs_irq = ec->rx_coalesce_usecs_irq;
8148         tp->coal.tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq;
8149         tp->coal.rx_max_coalesced_frames_irq = ec->rx_max_coalesced_frames_irq;
8150         tp->coal.tx_max_coalesced_frames_irq = ec->tx_max_coalesced_frames_irq;
8151         tp->coal.stats_block_coalesce_usecs = ec->stats_block_coalesce_usecs;
8152
8153         if (netif_running(dev)) {
8154                 tg3_full_lock(tp, 0);
8155                 __tg3_set_coalesce(tp, &tp->coal);
8156                 tg3_full_unlock(tp);
8157         }
8158         return 0;
8159 }
8160
8161 static struct ethtool_ops tg3_ethtool_ops = {
8162         .get_settings           = tg3_get_settings,
8163         .set_settings           = tg3_set_settings,
8164         .get_drvinfo            = tg3_get_drvinfo,
8165         .get_regs_len           = tg3_get_regs_len,
8166         .get_regs               = tg3_get_regs,
8167         .get_wol                = tg3_get_wol,
8168         .set_wol                = tg3_set_wol,
8169         .get_msglevel           = tg3_get_msglevel,
8170         .set_msglevel           = tg3_set_msglevel,
8171         .nway_reset             = tg3_nway_reset,
8172         .get_link               = ethtool_op_get_link,
8173         .get_eeprom_len         = tg3_get_eeprom_len,
8174         .get_eeprom             = tg3_get_eeprom,
8175         .set_eeprom             = tg3_set_eeprom,
8176         .get_ringparam          = tg3_get_ringparam,
8177         .set_ringparam          = tg3_set_ringparam,
8178         .get_pauseparam         = tg3_get_pauseparam,
8179         .set_pauseparam         = tg3_set_pauseparam,
8180         .get_rx_csum            = tg3_get_rx_csum,
8181         .set_rx_csum            = tg3_set_rx_csum,
8182         .get_tx_csum            = ethtool_op_get_tx_csum,
8183         .set_tx_csum            = tg3_set_tx_csum,
8184         .get_sg                 = ethtool_op_get_sg,
8185         .set_sg                 = ethtool_op_set_sg,
8186 #if TG3_TSO_SUPPORT != 0
8187         .get_tso                = ethtool_op_get_tso,
8188         .set_tso                = tg3_set_tso,
8189 #endif
8190         .self_test_count        = tg3_get_test_count,
8191         .self_test              = tg3_self_test,
8192         .get_strings            = tg3_get_strings,
8193         .get_stats_count        = tg3_get_stats_count,
8194         .get_ethtool_stats      = tg3_get_ethtool_stats,
8195         .get_coalesce           = tg3_get_coalesce,
8196         .set_coalesce           = tg3_set_coalesce,
8197 };
8198
8199 static void __devinit tg3_get_eeprom_size(struct tg3 *tp)
8200 {
8201         u32 cursize, val;
8202
8203         tp->nvram_size = EEPROM_CHIP_SIZE;
8204
8205         if (tg3_nvram_read(tp, 0, &val) != 0)
8206                 return;
8207
8208         if (swab32(val) != TG3_EEPROM_MAGIC)
8209                 return;
8210
8211         /*
8212          * Size the chip by reading offsets at increasing powers of two.
8213          * When we encounter our validation signature, we know the addressing
8214          * has wrapped around, and thus have our chip size.
8215          */
8216         cursize = 0x800;
8217
8218         while (cursize < tp->nvram_size) {
8219                 if (tg3_nvram_read(tp, cursize, &val) != 0)
8220                         return;
8221
8222                 if (swab32(val) == TG3_EEPROM_MAGIC)
8223                         break;
8224
8225                 cursize <<= 1;
8226         }
8227
8228         tp->nvram_size = cursize;
8229 }
8230
8231 static void __devinit tg3_get_nvram_size(struct tg3 *tp)
8232 {
8233         u32 val;
8234
8235         if (tg3_nvram_read(tp, 0xf0, &val) == 0) {
8236                 if (val != 0) {
8237                         tp->nvram_size = (val >> 16) * 1024;
8238                         return;
8239                 }
8240         }
8241         tp->nvram_size = 0x20000;
8242 }
8243
8244 static void __devinit tg3_get_nvram_info(struct tg3 *tp)
8245 {
8246         u32 nvcfg1;
8247
8248         nvcfg1 = tr32(NVRAM_CFG1);
8249         if (nvcfg1 & NVRAM_CFG1_FLASHIF_ENAB) {
8250                 tp->tg3_flags2 |= TG3_FLG2_FLASH;
8251         }
8252         else {
8253                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
8254                 tw32(NVRAM_CFG1, nvcfg1);
8255         }
8256
8257         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
8258                 switch (nvcfg1 & NVRAM_CFG1_VENDOR_MASK) {
8259                         case FLASH_VENDOR_ATMEL_FLASH_BUFFERED:
8260                                 tp->nvram_jedecnum = JEDEC_ATMEL;
8261                                 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
8262                                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8263                                 break;
8264                         case FLASH_VENDOR_ATMEL_FLASH_UNBUFFERED:
8265                                 tp->nvram_jedecnum = JEDEC_ATMEL;
8266                                 tp->nvram_pagesize = ATMEL_AT25F512_PAGE_SIZE;
8267                                 break;
8268                         case FLASH_VENDOR_ATMEL_EEPROM:
8269                                 tp->nvram_jedecnum = JEDEC_ATMEL;
8270                                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
8271                                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8272                                 break;
8273                         case FLASH_VENDOR_ST:
8274                                 tp->nvram_jedecnum = JEDEC_ST;
8275                                 tp->nvram_pagesize = ST_M45PEX0_PAGE_SIZE;
8276                                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8277                                 break;
8278                         case FLASH_VENDOR_SAIFUN:
8279                                 tp->nvram_jedecnum = JEDEC_SAIFUN;
8280                                 tp->nvram_pagesize = SAIFUN_SA25F0XX_PAGE_SIZE;
8281                                 break;
8282                         case FLASH_VENDOR_SST_SMALL:
8283                         case FLASH_VENDOR_SST_LARGE:
8284                                 tp->nvram_jedecnum = JEDEC_SST;
8285                                 tp->nvram_pagesize = SST_25VF0X0_PAGE_SIZE;
8286                                 break;
8287                 }
8288         }
8289         else {
8290                 tp->nvram_jedecnum = JEDEC_ATMEL;
8291                 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
8292                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8293         }
8294 }
8295
8296 static void __devinit tg3_get_5752_nvram_info(struct tg3 *tp)
8297 {
8298         u32 nvcfg1;
8299
8300         nvcfg1 = tr32(NVRAM_CFG1);
8301
8302         /* NVRAM protection for TPM */
8303         if (nvcfg1 & (1 << 27))
8304                 tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
8305
8306         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
8307                 case FLASH_5752VENDOR_ATMEL_EEPROM_64KHZ:
8308                 case FLASH_5752VENDOR_ATMEL_EEPROM_376KHZ:
8309                         tp->nvram_jedecnum = JEDEC_ATMEL;
8310                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8311                         break;
8312                 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
8313                         tp->nvram_jedecnum = JEDEC_ATMEL;
8314                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8315                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
8316                         break;
8317                 case FLASH_5752VENDOR_ST_M45PE10:
8318                 case FLASH_5752VENDOR_ST_M45PE20:
8319                 case FLASH_5752VENDOR_ST_M45PE40:
8320                         tp->nvram_jedecnum = JEDEC_ST;
8321                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
8322                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
8323                         break;
8324         }
8325
8326         if (tp->tg3_flags2 & TG3_FLG2_FLASH) {
8327                 switch (nvcfg1 & NVRAM_CFG1_5752PAGE_SIZE_MASK) {
8328                         case FLASH_5752PAGE_SIZE_256:
8329                                 tp->nvram_pagesize = 256;
8330                                 break;
8331                         case FLASH_5752PAGE_SIZE_512:
8332                                 tp->nvram_pagesize = 512;
8333                                 break;
8334                         case FLASH_5752PAGE_SIZE_1K:
8335                                 tp->nvram_pagesize = 1024;
8336                                 break;
8337                         case FLASH_5752PAGE_SIZE_2K:
8338                                 tp->nvram_pagesize = 2048;
8339                                 break;
8340                         case FLASH_5752PAGE_SIZE_4K:
8341                                 tp->nvram_pagesize = 4096;
8342                                 break;
8343                         case FLASH_5752PAGE_SIZE_264:
8344                                 tp->nvram_pagesize = 264;
8345                                 break;
8346                 }
8347         }
8348         else {
8349                 /* For eeprom, set pagesize to maximum eeprom size */
8350                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
8351
8352                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
8353                 tw32(NVRAM_CFG1, nvcfg1);
8354         }
8355 }
8356
8357 /* Chips other than 5700/5701 use the NVRAM for fetching info. */
8358 static void __devinit tg3_nvram_init(struct tg3 *tp)
8359 {
8360         int j;
8361
8362         if (tp->tg3_flags2 & TG3_FLG2_SUN_570X)
8363                 return;
8364
8365         tw32_f(GRC_EEPROM_ADDR,
8366              (EEPROM_ADDR_FSM_RESET |
8367               (EEPROM_DEFAULT_CLOCK_PERIOD <<
8368                EEPROM_ADDR_CLKPERD_SHIFT)));
8369
8370         /* XXX schedule_timeout() ... */
8371         for (j = 0; j < 100; j++)
8372                 udelay(10);
8373
8374         /* Enable seeprom accesses. */
8375         tw32_f(GRC_LOCAL_CTRL,
8376              tr32(GRC_LOCAL_CTRL) | GRC_LCLCTRL_AUTO_SEEPROM);
8377         udelay(100);
8378
8379         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
8380             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) {
8381                 tp->tg3_flags |= TG3_FLAG_NVRAM;
8382
8383                 tg3_enable_nvram_access(tp);
8384
8385                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
8386                         tg3_get_5752_nvram_info(tp);
8387                 else
8388                         tg3_get_nvram_info(tp);
8389
8390                 tg3_get_nvram_size(tp);
8391
8392                 tg3_disable_nvram_access(tp);
8393
8394         } else {
8395                 tp->tg3_flags &= ~(TG3_FLAG_NVRAM | TG3_FLAG_NVRAM_BUFFERED);
8396
8397                 tg3_get_eeprom_size(tp);
8398         }
8399 }
8400
8401 static int tg3_nvram_read_using_eeprom(struct tg3 *tp,
8402                                         u32 offset, u32 *val)
8403 {
8404         u32 tmp;
8405         int i;
8406
8407         if (offset > EEPROM_ADDR_ADDR_MASK ||
8408             (offset % 4) != 0)
8409                 return -EINVAL;
8410
8411         tmp = tr32(GRC_EEPROM_ADDR) & ~(EEPROM_ADDR_ADDR_MASK |
8412                                         EEPROM_ADDR_DEVID_MASK |
8413                                         EEPROM_ADDR_READ);
8414         tw32(GRC_EEPROM_ADDR,
8415              tmp |
8416              (0 << EEPROM_ADDR_DEVID_SHIFT) |
8417              ((offset << EEPROM_ADDR_ADDR_SHIFT) &
8418               EEPROM_ADDR_ADDR_MASK) |
8419              EEPROM_ADDR_READ | EEPROM_ADDR_START);
8420
8421         for (i = 0; i < 10000; i++) {
8422                 tmp = tr32(GRC_EEPROM_ADDR);
8423
8424                 if (tmp & EEPROM_ADDR_COMPLETE)
8425                         break;
8426                 udelay(100);
8427         }
8428         if (!(tmp & EEPROM_ADDR_COMPLETE))
8429                 return -EBUSY;
8430
8431         *val = tr32(GRC_EEPROM_DATA);
8432         return 0;
8433 }
8434
8435 #define NVRAM_CMD_TIMEOUT 10000
8436
8437 static int tg3_nvram_exec_cmd(struct tg3 *tp, u32 nvram_cmd)
8438 {
8439         int i;
8440
8441         tw32(NVRAM_CMD, nvram_cmd);
8442         for (i = 0; i < NVRAM_CMD_TIMEOUT; i++) {
8443                 udelay(10);
8444                 if (tr32(NVRAM_CMD) & NVRAM_CMD_DONE) {
8445                         udelay(10);
8446                         break;
8447                 }
8448         }
8449         if (i == NVRAM_CMD_TIMEOUT) {
8450                 return -EBUSY;
8451         }
8452         return 0;
8453 }
8454
8455 static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
8456 {
8457         int ret;
8458
8459         if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
8460                 printk(KERN_ERR PFX "Attempt to do nvram_read on Sun 570X\n");
8461                 return -EINVAL;
8462         }
8463
8464         if (!(tp->tg3_flags & TG3_FLAG_NVRAM))
8465                 return tg3_nvram_read_using_eeprom(tp, offset, val);
8466
8467         if ((tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) &&
8468                 (tp->tg3_flags2 & TG3_FLG2_FLASH) &&
8469                 (tp->nvram_jedecnum == JEDEC_ATMEL)) {
8470
8471                 offset = ((offset / tp->nvram_pagesize) <<
8472                           ATMEL_AT45DB0X1B_PAGE_POS) +
8473                         (offset % tp->nvram_pagesize);
8474         }
8475
8476         if (offset > NVRAM_ADDR_MSK)
8477                 return -EINVAL;
8478
8479         tg3_nvram_lock(tp);
8480
8481         tg3_enable_nvram_access(tp);
8482
8483         tw32(NVRAM_ADDR, offset);
8484         ret = tg3_nvram_exec_cmd(tp, NVRAM_CMD_RD | NVRAM_CMD_GO |
8485                 NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_DONE);
8486
8487         if (ret == 0)
8488                 *val = swab32(tr32(NVRAM_RDDATA));
8489
8490         tg3_nvram_unlock(tp);
8491
8492         tg3_disable_nvram_access(tp);
8493
8494         return ret;
8495 }
8496
8497 static int tg3_nvram_write_block_using_eeprom(struct tg3 *tp,
8498                                     u32 offset, u32 len, u8 *buf)
8499 {
8500         int i, j, rc = 0;
8501         u32 val;
8502
8503         for (i = 0; i < len; i += 4) {
8504                 u32 addr, data;
8505
8506                 addr = offset + i;
8507
8508                 memcpy(&data, buf + i, 4);
8509
8510                 tw32(GRC_EEPROM_DATA, cpu_to_le32(data));
8511
8512                 val = tr32(GRC_EEPROM_ADDR);
8513                 tw32(GRC_EEPROM_ADDR, val | EEPROM_ADDR_COMPLETE);
8514
8515                 val &= ~(EEPROM_ADDR_ADDR_MASK | EEPROM_ADDR_DEVID_MASK |
8516                         EEPROM_ADDR_READ);
8517                 tw32(GRC_EEPROM_ADDR, val |
8518                         (0 << EEPROM_ADDR_DEVID_SHIFT) |
8519                         (addr & EEPROM_ADDR_ADDR_MASK) |
8520                         EEPROM_ADDR_START |
8521                         EEPROM_ADDR_WRITE);
8522
8523                 for (j = 0; j < 10000; j++) {
8524                         val = tr32(GRC_EEPROM_ADDR);
8525
8526                         if (val & EEPROM_ADDR_COMPLETE)
8527                                 break;
8528                         udelay(100);
8529                 }
8530                 if (!(val & EEPROM_ADDR_COMPLETE)) {
8531                         rc = -EBUSY;
8532                         break;
8533                 }
8534         }
8535
8536         return rc;
8537 }
8538
8539 /* offset and length are dword aligned */
8540 static int tg3_nvram_write_block_unbuffered(struct tg3 *tp, u32 offset, u32 len,
8541                 u8 *buf)
8542 {
8543         int ret = 0;
8544         u32 pagesize = tp->nvram_pagesize;
8545         u32 pagemask = pagesize - 1;
8546         u32 nvram_cmd;
8547         u8 *tmp;
8548
8549         tmp = kmalloc(pagesize, GFP_KERNEL);
8550         if (tmp == NULL)
8551                 return -ENOMEM;
8552
8553         while (len) {
8554                 int j;
8555                 u32 phy_addr, page_off, size;
8556
8557                 phy_addr = offset & ~pagemask;
8558
8559                 for (j = 0; j < pagesize; j += 4) {
8560                         if ((ret = tg3_nvram_read(tp, phy_addr + j,
8561                                                 (u32 *) (tmp + j))))
8562                                 break;
8563                 }
8564                 if (ret)
8565                         break;
8566
8567                 page_off = offset & pagemask;
8568                 size = pagesize;
8569                 if (len < size)
8570                         size = len;
8571
8572                 len -= size;
8573
8574                 memcpy(tmp + page_off, buf, size);
8575
8576                 offset = offset + (pagesize - page_off);
8577
8578                 tg3_enable_nvram_access(tp);
8579
8580                 /*
8581                  * Before we can erase the flash page, we need
8582                  * to issue a special "write enable" command.
8583                  */
8584                 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
8585
8586                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
8587                         break;
8588
8589                 /* Erase the target page */
8590                 tw32(NVRAM_ADDR, phy_addr);
8591
8592                 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR |
8593                         NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_ERASE;
8594
8595                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
8596                         break;
8597
8598                 /* Issue another write enable to start the write. */
8599                 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
8600
8601                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
8602                         break;
8603
8604                 for (j = 0; j < pagesize; j += 4) {
8605                         u32 data;
8606
8607                         data = *((u32 *) (tmp + j));
8608                         tw32(NVRAM_WRDATA, cpu_to_be32(data));
8609
8610                         tw32(NVRAM_ADDR, phy_addr + j);
8611
8612                         nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE |
8613                                 NVRAM_CMD_WR;
8614
8615                         if (j == 0)
8616                                 nvram_cmd |= NVRAM_CMD_FIRST;
8617                         else if (j == (pagesize - 4))
8618                                 nvram_cmd |= NVRAM_CMD_LAST;
8619
8620                         if ((ret = tg3_nvram_exec_cmd(tp, nvram_cmd)))
8621                                 break;
8622                 }
8623                 if (ret)
8624                         break;
8625         }
8626
8627         nvram_cmd = NVRAM_CMD_WRDI | NVRAM_CMD_GO | NVRAM_CMD_DONE;
8628         tg3_nvram_exec_cmd(tp, nvram_cmd);
8629
8630         kfree(tmp);
8631
8632         return ret;
8633 }
8634
8635 /* offset and length are dword aligned */
8636 static int tg3_nvram_write_block_buffered(struct tg3 *tp, u32 offset, u32 len,
8637                 u8 *buf)
8638 {
8639         int i, ret = 0;
8640
8641         for (i = 0; i < len; i += 4, offset += 4) {
8642                 u32 data, page_off, phy_addr, nvram_cmd;
8643
8644                 memcpy(&data, buf + i, 4);
8645                 tw32(NVRAM_WRDATA, cpu_to_be32(data));
8646
8647                 page_off = offset % tp->nvram_pagesize;
8648
8649                 if ((tp->tg3_flags2 & TG3_FLG2_FLASH) &&
8650                         (tp->nvram_jedecnum == JEDEC_ATMEL)) {
8651
8652                         phy_addr = ((offset / tp->nvram_pagesize) <<
8653                                     ATMEL_AT45DB0X1B_PAGE_POS) + page_off;
8654                 }
8655                 else {
8656                         phy_addr = offset;
8657                 }
8658
8659                 tw32(NVRAM_ADDR, phy_addr);
8660
8661                 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR;
8662
8663                 if ((page_off == 0) || (i == 0))
8664                         nvram_cmd |= NVRAM_CMD_FIRST;
8665                 else if (page_off == (tp->nvram_pagesize - 4))
8666                         nvram_cmd |= NVRAM_CMD_LAST;
8667
8668                 if (i == (len - 4))
8669                         nvram_cmd |= NVRAM_CMD_LAST;
8670
8671                 if ((tp->nvram_jedecnum == JEDEC_ST) &&
8672                         (nvram_cmd & NVRAM_CMD_FIRST)) {
8673
8674                         if ((ret = tg3_nvram_exec_cmd(tp,
8675                                 NVRAM_CMD_WREN | NVRAM_CMD_GO |
8676                                 NVRAM_CMD_DONE)))
8677
8678                                 break;
8679                 }
8680                 if (!(tp->tg3_flags2 & TG3_FLG2_FLASH)) {
8681                         /* We always do complete word writes to eeprom. */
8682                         nvram_cmd |= (NVRAM_CMD_FIRST | NVRAM_CMD_LAST);
8683                 }
8684
8685                 if ((ret = tg3_nvram_exec_cmd(tp, nvram_cmd)))
8686                         break;
8687         }
8688         return ret;
8689 }
8690
8691 /* offset and length are dword aligned */
8692 static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
8693 {
8694         int ret;
8695
8696         if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
8697                 printk(KERN_ERR PFX "Attempt to do nvram_write on Sun 570X\n");
8698                 return -EINVAL;
8699         }
8700
8701         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
8702                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl &
8703                        ~GRC_LCLCTRL_GPIO_OUTPUT1);
8704                 udelay(40);
8705         }
8706
8707         if (!(tp->tg3_flags & TG3_FLAG_NVRAM)) {
8708                 ret = tg3_nvram_write_block_using_eeprom(tp, offset, len, buf);
8709         }
8710         else {
8711                 u32 grc_mode;
8712
8713                 tg3_nvram_lock(tp);
8714
8715                 tg3_enable_nvram_access(tp);
8716                 if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
8717                     !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM))
8718                         tw32(NVRAM_WRITE1, 0x406);
8719
8720                 grc_mode = tr32(GRC_MODE);
8721                 tw32(GRC_MODE, grc_mode | GRC_MODE_NVRAM_WR_ENABLE);
8722
8723                 if ((tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) ||
8724                         !(tp->tg3_flags2 & TG3_FLG2_FLASH)) {
8725
8726                         ret = tg3_nvram_write_block_buffered(tp, offset, len,
8727                                 buf);
8728                 }
8729                 else {
8730                         ret = tg3_nvram_write_block_unbuffered(tp, offset, len,
8731                                 buf);
8732                 }
8733
8734                 grc_mode = tr32(GRC_MODE);
8735                 tw32(GRC_MODE, grc_mode & ~GRC_MODE_NVRAM_WR_ENABLE);
8736
8737                 tg3_disable_nvram_access(tp);
8738                 tg3_nvram_unlock(tp);
8739         }
8740
8741         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
8742                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
8743                 udelay(40);
8744         }
8745
8746         return ret;
8747 }
8748
8749 struct subsys_tbl_ent {
8750         u16 subsys_vendor, subsys_devid;
8751         u32 phy_id;
8752 };
8753
8754 static struct subsys_tbl_ent subsys_id_to_phy_id[] = {
8755         /* Broadcom boards. */
8756         { PCI_VENDOR_ID_BROADCOM, 0x1644, PHY_ID_BCM5401 }, /* BCM95700A6 */
8757         { PCI_VENDOR_ID_BROADCOM, 0x0001, PHY_ID_BCM5701 }, /* BCM95701A5 */
8758         { PCI_VENDOR_ID_BROADCOM, 0x0002, PHY_ID_BCM8002 }, /* BCM95700T6 */
8759         { PCI_VENDOR_ID_BROADCOM, 0x0003, 0 },              /* BCM95700A9 */
8760         { PCI_VENDOR_ID_BROADCOM, 0x0005, PHY_ID_BCM5701 }, /* BCM95701T1 */
8761         { PCI_VENDOR_ID_BROADCOM, 0x0006, PHY_ID_BCM5701 }, /* BCM95701T8 */
8762         { PCI_VENDOR_ID_BROADCOM, 0x0007, 0 },              /* BCM95701A7 */
8763         { PCI_VENDOR_ID_BROADCOM, 0x0008, PHY_ID_BCM5701 }, /* BCM95701A10 */
8764         { PCI_VENDOR_ID_BROADCOM, 0x8008, PHY_ID_BCM5701 }, /* BCM95701A12 */
8765         { PCI_VENDOR_ID_BROADCOM, 0x0009, PHY_ID_BCM5703 }, /* BCM95703Ax1 */
8766         { PCI_VENDOR_ID_BROADCOM, 0x8009, PHY_ID_BCM5703 }, /* BCM95703Ax2 */
8767
8768         /* 3com boards. */
8769         { PCI_VENDOR_ID_3COM, 0x1000, PHY_ID_BCM5401 }, /* 3C996T */
8770         { PCI_VENDOR_ID_3COM, 0x1006, PHY_ID_BCM5701 }, /* 3C996BT */
8771         { PCI_VENDOR_ID_3COM, 0x1004, 0 },              /* 3C996SX */
8772         { PCI_VENDOR_ID_3COM, 0x1007, PHY_ID_BCM5701 }, /* 3C1000T */
8773         { PCI_VENDOR_ID_3COM, 0x1008, PHY_ID_BCM5701 }, /* 3C940BR01 */
8774
8775         /* DELL boards. */
8776         { PCI_VENDOR_ID_DELL, 0x00d1, PHY_ID_BCM5401 }, /* VIPER */
8777         { PCI_VENDOR_ID_DELL, 0x0106, PHY_ID_BCM5401 }, /* JAGUAR */
8778         { PCI_VENDOR_ID_DELL, 0x0109, PHY_ID_BCM5411 }, /* MERLOT */
8779         { PCI_VENDOR_ID_DELL, 0x010a, PHY_ID_BCM5411 }, /* SLIM_MERLOT */
8780
8781         /* Compaq boards. */
8782         { PCI_VENDOR_ID_COMPAQ, 0x007c, PHY_ID_BCM5701 }, /* BANSHEE */
8783         { PCI_VENDOR_ID_COMPAQ, 0x009a, PHY_ID_BCM5701 }, /* BANSHEE_2 */
8784         { PCI_VENDOR_ID_COMPAQ, 0x007d, 0 },              /* CHANGELING */
8785         { PCI_VENDOR_ID_COMPAQ, 0x0085, PHY_ID_BCM5701 }, /* NC7780 */
8786         { PCI_VENDOR_ID_COMPAQ, 0x0099, PHY_ID_BCM5701 }, /* NC7780_2 */
8787
8788         /* IBM boards. */
8789         { PCI_VENDOR_ID_IBM, 0x0281, 0 } /* IBM??? */
8790 };
8791
8792 static inline struct subsys_tbl_ent *lookup_by_subsys(struct tg3 *tp)
8793 {
8794         int i;
8795
8796         for (i = 0; i < ARRAY_SIZE(subsys_id_to_phy_id); i++) {
8797                 if ((subsys_id_to_phy_id[i].subsys_vendor ==
8798                      tp->pdev->subsystem_vendor) &&
8799                     (subsys_id_to_phy_id[i].subsys_devid ==
8800                      tp->pdev->subsystem_device))
8801                         return &subsys_id_to_phy_id[i];
8802         }
8803         return NULL;
8804 }
8805
8806 /* Since this function may be called in D3-hot power state during
8807  * tg3_init_one(), only config cycles are allowed.
8808  */
8809 static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
8810 {
8811         u32 val;
8812
8813         /* Make sure register accesses (indirect or otherwise)
8814          * will function correctly.
8815          */
8816         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
8817                                tp->misc_host_ctrl);
8818
8819         tp->phy_id = PHY_ID_INVALID;
8820         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
8821
8822         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
8823         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
8824                 u32 nic_cfg, led_cfg;
8825                 u32 nic_phy_id, ver, cfg2 = 0, eeprom_phy_id;
8826                 int eeprom_phy_serdes = 0;
8827
8828                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
8829                 tp->nic_sram_data_cfg = nic_cfg;
8830
8831                 tg3_read_mem(tp, NIC_SRAM_DATA_VER, &ver);
8832                 ver >>= NIC_SRAM_DATA_VER_SHIFT;
8833                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700) &&
8834                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) &&
8835                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5703) &&
8836                     (ver > 0) && (ver < 0x100))
8837                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_2, &cfg2);
8838
8839                 if ((nic_cfg & NIC_SRAM_DATA_CFG_PHY_TYPE_MASK) ==
8840                     NIC_SRAM_DATA_CFG_PHY_TYPE_FIBER)
8841                         eeprom_phy_serdes = 1;
8842
8843                 tg3_read_mem(tp, NIC_SRAM_DATA_PHY_ID, &nic_phy_id);
8844                 if (nic_phy_id != 0) {
8845                         u32 id1 = nic_phy_id & NIC_SRAM_DATA_PHY_ID1_MASK;
8846                         u32 id2 = nic_phy_id & NIC_SRAM_DATA_PHY_ID2_MASK;
8847
8848                         eeprom_phy_id  = (id1 >> 16) << 10;
8849                         eeprom_phy_id |= (id2 & 0xfc00) << 16;
8850                         eeprom_phy_id |= (id2 & 0x03ff) <<  0;
8851                 } else
8852                         eeprom_phy_id = 0;
8853
8854                 tp->phy_id = eeprom_phy_id;
8855                 if (eeprom_phy_serdes) {
8856                         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
8857                                 tp->tg3_flags2 |= TG3_FLG2_MII_SERDES;
8858                         else
8859                                 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
8860                 }
8861
8862                 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
8863                         led_cfg = cfg2 & (NIC_SRAM_DATA_CFG_LED_MODE_MASK |
8864                                     SHASTA_EXT_LED_MODE_MASK);
8865                 else
8866                         led_cfg = nic_cfg & NIC_SRAM_DATA_CFG_LED_MODE_MASK;
8867
8868                 switch (led_cfg) {
8869                 default:
8870                 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_1:
8871                         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
8872                         break;
8873
8874                 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_2:
8875                         tp->led_ctrl = LED_CTRL_MODE_PHY_2;
8876                         break;
8877
8878                 case NIC_SRAM_DATA_CFG_LED_MODE_MAC:
8879                         tp->led_ctrl = LED_CTRL_MODE_MAC;
8880
8881                         /* Default to PHY_1_MODE if 0 (MAC_MODE) is
8882                          * read on some older 5700/5701 bootcode.
8883                          */
8884                         if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
8885                             ASIC_REV_5700 ||
8886                             GET_ASIC_REV(tp->pci_chip_rev_id) ==
8887                             ASIC_REV_5701)
8888                                 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
8889
8890                         break;
8891
8892                 case SHASTA_EXT_LED_SHARED:
8893                         tp->led_ctrl = LED_CTRL_MODE_SHARED;
8894                         if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0 &&
8895                             tp->pci_chip_rev_id != CHIPREV_ID_5750_A1)
8896                                 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
8897                                                  LED_CTRL_MODE_PHY_2);
8898                         break;
8899
8900                 case SHASTA_EXT_LED_MAC:
8901                         tp->led_ctrl = LED_CTRL_MODE_SHASTA_MAC;
8902                         break;
8903
8904                 case SHASTA_EXT_LED_COMBO:
8905                         tp->led_ctrl = LED_CTRL_MODE_COMBO;
8906                         if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0)
8907                                 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
8908                                                  LED_CTRL_MODE_PHY_2);
8909                         break;
8910
8911                 };
8912
8913                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
8914                      GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) &&
8915                     tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL)
8916                         tp->led_ctrl = LED_CTRL_MODE_PHY_2;
8917
8918                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700) &&
8919                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) &&
8920                     (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP))
8921                         tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
8922
8923                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
8924                         tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
8925                         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
8926                                 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
8927                 }
8928                 if (nic_cfg & NIC_SRAM_DATA_CFG_FIBER_WOL)
8929                         tp->tg3_flags |= TG3_FLAG_SERDES_WOL_CAP;
8930
8931                 if (cfg2 & (1 << 17))
8932                         tp->tg3_flags2 |= TG3_FLG2_CAPACITIVE_COUPLING;
8933
8934                 /* serdes signal pre-emphasis in register 0x590 set by */
8935                 /* bootcode if bit 18 is set */
8936                 if (cfg2 & (1 << 18))
8937                         tp->tg3_flags2 |= TG3_FLG2_SERDES_PREEMPHASIS;
8938         }
8939 }
8940
8941 static int __devinit tg3_phy_probe(struct tg3 *tp)
8942 {
8943         u32 hw_phy_id_1, hw_phy_id_2;
8944         u32 hw_phy_id, hw_phy_id_masked;
8945         int err;
8946
8947         /* Reading the PHY ID register can conflict with ASF
8948          * firwmare access to the PHY hardware.
8949          */
8950         err = 0;
8951         if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
8952                 hw_phy_id = hw_phy_id_masked = PHY_ID_INVALID;
8953         } else {
8954                 /* Now read the physical PHY_ID from the chip and verify
8955                  * that it is sane.  If it doesn't look good, we fall back
8956                  * to either the hard-coded table based PHY_ID and failing
8957                  * that the value found in the eeprom area.
8958                  */
8959                 err |= tg3_readphy(tp, MII_PHYSID1, &hw_phy_id_1);
8960                 err |= tg3_readphy(tp, MII_PHYSID2, &hw_phy_id_2);
8961
8962                 hw_phy_id  = (hw_phy_id_1 & 0xffff) << 10;
8963                 hw_phy_id |= (hw_phy_id_2 & 0xfc00) << 16;
8964                 hw_phy_id |= (hw_phy_id_2 & 0x03ff) <<  0;
8965
8966                 hw_phy_id_masked = hw_phy_id & PHY_ID_MASK;
8967         }
8968
8969         if (!err && KNOWN_PHY_ID(hw_phy_id_masked)) {
8970                 tp->phy_id = hw_phy_id;
8971                 if (hw_phy_id_masked == PHY_ID_BCM8002)
8972                         tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
8973         } else {
8974                 if (tp->phy_id != PHY_ID_INVALID) {
8975                         /* Do nothing, phy ID already set up in
8976                          * tg3_get_eeprom_hw_cfg().
8977                          */
8978                 } else {
8979                         struct subsys_tbl_ent *p;
8980
8981                         /* No eeprom signature?  Try the hardcoded
8982                          * subsys device table.
8983                          */
8984                         p = lookup_by_subsys(tp);
8985                         if (!p)
8986                                 return -ENODEV;
8987
8988                         tp->phy_id = p->phy_id;
8989                         if (!tp->phy_id ||
8990                             tp->phy_id == PHY_ID_BCM8002)
8991                                 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
8992                 }
8993         }
8994
8995         if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) &&
8996             !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
8997                 u32 bmsr, adv_reg, tg3_ctrl;
8998
8999                 tg3_readphy(tp, MII_BMSR, &bmsr);
9000                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
9001                     (bmsr & BMSR_LSTATUS))
9002                         goto skip_phy_reset;
9003
9004                 err = tg3_phy_reset(tp);
9005                 if (err)
9006                         return err;
9007
9008                 adv_reg = (ADVERTISE_10HALF | ADVERTISE_10FULL |
9009                            ADVERTISE_100HALF | ADVERTISE_100FULL |
9010                            ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
9011                 tg3_ctrl = 0;
9012                 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY)) {
9013                         tg3_ctrl = (MII_TG3_CTRL_ADV_1000_HALF |
9014                                     MII_TG3_CTRL_ADV_1000_FULL);
9015                         if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
9016                             tp->pci_chip_rev_id == CHIPREV_ID_5701_B0)
9017                                 tg3_ctrl |= (MII_TG3_CTRL_AS_MASTER |
9018                                              MII_TG3_CTRL_ENABLE_AS_MASTER);
9019                 }
9020
9021                 if (!tg3_copper_is_advertising_all(tp)) {
9022                         tg3_writephy(tp, MII_ADVERTISE, adv_reg);
9023
9024                         if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
9025                                 tg3_writephy(tp, MII_TG3_CTRL, tg3_ctrl);
9026
9027                         tg3_writephy(tp, MII_BMCR,
9028                                      BMCR_ANENABLE | BMCR_ANRESTART);
9029                 }
9030                 tg3_phy_set_wirespeed(tp);
9031
9032                 tg3_writephy(tp, MII_ADVERTISE, adv_reg);
9033                 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
9034                         tg3_writephy(tp, MII_TG3_CTRL, tg3_ctrl);
9035         }
9036
9037 skip_phy_reset:
9038         if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
9039                 err = tg3_init_5401phy_dsp(tp);
9040                 if (err)
9041                         return err;
9042         }
9043
9044         if (!err && ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401)) {
9045                 err = tg3_init_5401phy_dsp(tp);
9046         }
9047
9048         if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)
9049                 tp->link_config.advertising =
9050                         (ADVERTISED_1000baseT_Half |
9051                          ADVERTISED_1000baseT_Full |
9052                          ADVERTISED_Autoneg |
9053                          ADVERTISED_FIBRE);
9054         if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
9055                 tp->link_config.advertising &=
9056                         ~(ADVERTISED_1000baseT_Half |
9057                           ADVERTISED_1000baseT_Full);
9058
9059         return err;
9060 }
9061
9062 static void __devinit tg3_read_partno(struct tg3 *tp)
9063 {
9064         unsigned char vpd_data[256];
9065         int i;
9066
9067         if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
9068                 /* Sun decided not to put the necessary bits in the
9069                  * NVRAM of their onboard tg3 parts :(
9070                  */
9071                 strcpy(tp->board_part_number, "Sun 570X");
9072                 return;
9073         }
9074
9075         for (i = 0; i < 256; i += 4) {
9076                 u32 tmp;
9077
9078                 if (tg3_nvram_read(tp, 0x100 + i, &tmp))
9079                         goto out_not_found;
9080
9081                 vpd_data[i + 0] = ((tmp >>  0) & 0xff);
9082                 vpd_data[i + 1] = ((tmp >>  8) & 0xff);
9083                 vpd_data[i + 2] = ((tmp >> 16) & 0xff);
9084                 vpd_data[i + 3] = ((tmp >> 24) & 0xff);
9085         }
9086
9087         /* Now parse and find the part number. */
9088         for (i = 0; i < 256; ) {
9089                 unsigned char val = vpd_data[i];
9090                 int block_end;
9091
9092                 if (val == 0x82 || val == 0x91) {
9093                         i = (i + 3 +
9094                              (vpd_data[i + 1] +
9095                               (vpd_data[i + 2] << 8)));
9096                         continue;
9097                 }
9098
9099                 if (val != 0x90)
9100                         goto out_not_found;
9101
9102                 block_end = (i + 3 +
9103                              (vpd_data[i + 1] +
9104                               (vpd_data[i + 2] << 8)));
9105                 i += 3;
9106                 while (i < block_end) {
9107                         if (vpd_data[i + 0] == 'P' &&
9108                             vpd_data[i + 1] == 'N') {
9109                                 int partno_len = vpd_data[i + 2];
9110
9111                                 if (partno_len > 24)
9112                                         goto out_not_found;
9113
9114                                 memcpy(tp->board_part_number,
9115                                        &vpd_data[i + 3],
9116                                        partno_len);
9117
9118                                 /* Success. */
9119                                 return;
9120                         }
9121                 }
9122
9123                 /* Part number not found. */
9124                 goto out_not_found;
9125         }
9126
9127 out_not_found:
9128         strcpy(tp->board_part_number, "none");
9129 }
9130
9131 #ifdef CONFIG_SPARC64
9132 static int __devinit tg3_is_sun_570X(struct tg3 *tp)
9133 {
9134         struct pci_dev *pdev = tp->pdev;
9135         struct pcidev_cookie *pcp = pdev->sysdata;
9136
9137         if (pcp != NULL) {
9138                 int node = pcp->prom_node;
9139                 u32 venid;
9140                 int err;
9141
9142                 err = prom_getproperty(node, "subsystem-vendor-id",
9143                                        (char *) &venid, sizeof(venid));
9144                 if (err == 0 || err == -1)
9145                         return 0;
9146                 if (venid == PCI_VENDOR_ID_SUN)
9147                         return 1;
9148         }
9149         return 0;
9150 }
9151 #endif
9152
9153 static int __devinit tg3_get_invariants(struct tg3 *tp)
9154 {
9155         static struct pci_device_id write_reorder_chipsets[] = {
9156                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
9157                              PCI_DEVICE_ID_INTEL_82801AA_8) },
9158                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
9159                              PCI_DEVICE_ID_INTEL_82801AB_8) },
9160                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
9161                              PCI_DEVICE_ID_INTEL_82801BA_11) },
9162                 { PCI_DEVICE(PCI_VENDOR_ID_INTEL,
9163                              PCI_DEVICE_ID_INTEL_82801BA_6) },
9164                 { PCI_DEVICE(PCI_VENDOR_ID_AMD,
9165                              PCI_DEVICE_ID_AMD_FE_GATE_700C) },
9166                 { },
9167         };
9168         u32 misc_ctrl_reg;
9169         u32 cacheline_sz_reg;
9170         u32 pci_state_reg, grc_misc_cfg;
9171         u32 val;
9172         u16 pci_cmd;
9173         int err;
9174
9175 #ifdef CONFIG_SPARC64
9176         if (tg3_is_sun_570X(tp))
9177                 tp->tg3_flags2 |= TG3_FLG2_SUN_570X;
9178 #endif
9179
9180         /* If we have an AMD 762 or Intel ICH/ICH0/ICH2 chipset, write
9181          * reordering to the mailbox registers done by the host
9182          * controller can cause major troubles.  We read back from
9183          * every mailbox register write to force the writes to be
9184          * posted to the chip in order.
9185          */
9186         if (pci_dev_present(write_reorder_chipsets))
9187                 tp->tg3_flags |= TG3_FLAG_MBOX_WRITE_REORDER;
9188
9189         /* Force memory write invalidate off.  If we leave it on,
9190          * then on 5700_BX chips we have to enable a workaround.
9191          * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary
9192          * to match the cacheline size.  The Broadcom driver have this
9193          * workaround but turns MWI off all the times so never uses
9194          * it.  This seems to suggest that the workaround is insufficient.
9195          */
9196         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
9197         pci_cmd &= ~PCI_COMMAND_INVALIDATE;
9198         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
9199
9200         /* It is absolutely critical that TG3PCI_MISC_HOST_CTRL
9201          * has the register indirect write enable bit set before
9202          * we try to access any of the MMIO registers.  It is also
9203          * critical that the PCI-X hw workaround situation is decided
9204          * before that as well.
9205          */
9206         pci_read_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
9207                               &misc_ctrl_reg);
9208
9209         tp->pci_chip_rev_id = (misc_ctrl_reg >>
9210                                MISC_HOST_CTRL_CHIPREV_SHIFT);
9211
9212         /* Wrong chip ID in 5752 A0. This code can be removed later
9213          * as A0 is not in production.
9214          */
9215         if (tp->pci_chip_rev_id == CHIPREV_ID_5752_A0_HW)
9216                 tp->pci_chip_rev_id = CHIPREV_ID_5752_A0;
9217
9218         /* Find msi capability. */
9219         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
9220                 tp->msi_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_MSI);
9221
9222         /* Initialize misc host control in PCI block. */
9223         tp->misc_host_ctrl |= (misc_ctrl_reg &
9224                                MISC_HOST_CTRL_CHIPREV);
9225         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
9226                                tp->misc_host_ctrl);
9227
9228         pci_read_config_dword(tp->pdev, TG3PCI_CACHELINESZ,
9229                               &cacheline_sz_reg);
9230
9231         tp->pci_cacheline_sz = (cacheline_sz_reg >>  0) & 0xff;
9232         tp->pci_lat_timer    = (cacheline_sz_reg >>  8) & 0xff;
9233         tp->pci_hdr_type     = (cacheline_sz_reg >> 16) & 0xff;
9234         tp->pci_bist         = (cacheline_sz_reg >> 24) & 0xff;
9235
9236         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
9237             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
9238             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
9239                 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
9240
9241         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) ||
9242             (tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
9243                 tp->tg3_flags2 |= TG3_FLG2_5705_PLUS;
9244
9245         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
9246                 tp->tg3_flags2 |= TG3_FLG2_HW_TSO;
9247
9248         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 &&
9249             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750 &&
9250             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752)
9251                 tp->tg3_flags2 |= TG3_FLG2_JUMBO_CAPABLE;
9252
9253         if (pci_find_capability(tp->pdev, PCI_CAP_ID_EXP) != 0)
9254                 tp->tg3_flags2 |= TG3_FLG2_PCI_EXPRESS;
9255
9256         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 &&
9257             tp->pci_lat_timer < 64) {
9258                 tp->pci_lat_timer = 64;
9259
9260                 cacheline_sz_reg  = ((tp->pci_cacheline_sz & 0xff) <<  0);
9261                 cacheline_sz_reg |= ((tp->pci_lat_timer    & 0xff) <<  8);
9262                 cacheline_sz_reg |= ((tp->pci_hdr_type     & 0xff) << 16);
9263                 cacheline_sz_reg |= ((tp->pci_bist         & 0xff) << 24);
9264
9265                 pci_write_config_dword(tp->pdev, TG3PCI_CACHELINESZ,
9266                                        cacheline_sz_reg);
9267         }
9268
9269         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
9270                               &pci_state_reg);
9271
9272         if ((pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0) {
9273                 tp->tg3_flags |= TG3_FLAG_PCIX_MODE;
9274
9275                 /* If this is a 5700 BX chipset, and we are in PCI-X
9276                  * mode, enable register write workaround.
9277                  *
9278                  * The workaround is to use indirect register accesses
9279                  * for all chip writes not to mailbox registers.
9280                  */
9281                 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5700_BX) {
9282                         u32 pm_reg;
9283                         u16 pci_cmd;
9284
9285                         tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
9286
9287                         /* The chip can have it's power management PCI config
9288                          * space registers clobbered due to this bug.
9289                          * So explicitly force the chip into D0 here.
9290                          */
9291                         pci_read_config_dword(tp->pdev, TG3PCI_PM_CTRL_STAT,
9292                                               &pm_reg);
9293                         pm_reg &= ~PCI_PM_CTRL_STATE_MASK;
9294                         pm_reg |= PCI_PM_CTRL_PME_ENABLE | 0 /* D0 */;
9295                         pci_write_config_dword(tp->pdev, TG3PCI_PM_CTRL_STAT,
9296                                                pm_reg);
9297
9298                         /* Also, force SERR#/PERR# in PCI command. */
9299                         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
9300                         pci_cmd |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
9301                         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
9302                 }
9303         }
9304
9305         /* Back to back register writes can cause problems on this chip,
9306          * the workaround is to read back all reg writes except those to
9307          * mailbox regs.  See tg3_write_indirect_reg32().
9308          *
9309          * PCI Express 5750_A0 rev chips need this workaround too.
9310          */
9311         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 ||
9312             ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
9313              tp->pci_chip_rev_id == CHIPREV_ID_5750_A0))
9314                 tp->tg3_flags |= TG3_FLAG_5701_REG_WRITE_BUG;
9315
9316         if ((pci_state_reg & PCISTATE_BUS_SPEED_HIGH) != 0)
9317                 tp->tg3_flags |= TG3_FLAG_PCI_HIGH_SPEED;
9318         if ((pci_state_reg & PCISTATE_BUS_32BIT) != 0)
9319                 tp->tg3_flags |= TG3_FLAG_PCI_32BIT;
9320
9321         /* Chip-specific fixup from Broadcom driver */
9322         if ((tp->pci_chip_rev_id == CHIPREV_ID_5704_A0) &&
9323             (!(pci_state_reg & PCISTATE_RETRY_SAME_DMA))) {
9324                 pci_state_reg |= PCISTATE_RETRY_SAME_DMA;
9325                 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, pci_state_reg);
9326         }
9327
9328         /* Get eeprom hw config before calling tg3_set_power_state().
9329          * In particular, the TG3_FLAG_EEPROM_WRITE_PROT flag must be
9330          * determined before calling tg3_set_power_state() so that
9331          * we know whether or not to switch out of Vaux power.
9332          * When the flag is set, it means that GPIO1 is used for eeprom
9333          * write protect and also implies that it is a LOM where GPIOs
9334          * are not used to switch power.
9335          */
9336         tg3_get_eeprom_hw_cfg(tp);
9337
9338         /* Set up tp->grc_local_ctrl before calling tg3_set_power_state().
9339          * GPIO1 driven high will bring 5700's external PHY out of reset.
9340          * It is also used as eeprom write protect on LOMs.
9341          */
9342         tp->grc_local_ctrl = GRC_LCLCTRL_INT_ON_ATTN | GRC_LCLCTRL_AUTO_SEEPROM;
9343         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
9344             (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT))
9345                 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
9346                                        GRC_LCLCTRL_GPIO_OUTPUT1);
9347         /* Unused GPIO3 must be driven as output on 5752 because there
9348          * are no pull-up resistors on unused GPIO pins.
9349          */
9350         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
9351                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
9352
9353         /* Force the chip into D0. */
9354         err = tg3_set_power_state(tp, 0);
9355         if (err) {
9356                 printk(KERN_ERR PFX "(%s) transition to D0 failed\n",
9357                        pci_name(tp->pdev));
9358                 return err;
9359         }
9360
9361         /* 5700 B0 chips do not support checksumming correctly due
9362          * to hardware bugs.
9363          */
9364         if (tp->pci_chip_rev_id == CHIPREV_ID_5700_B0)
9365                 tp->tg3_flags |= TG3_FLAG_BROKEN_CHECKSUMS;
9366
9367         /* Pseudo-header checksum is done by hardware logic and not
9368          * the offload processers, so make the chip do the pseudo-
9369          * header checksums on receive.  For transmit it is more
9370          * convenient to do the pseudo-header checksum in software
9371          * as Linux does that on transmit for us in all cases.
9372          */
9373         tp->tg3_flags |= TG3_FLAG_NO_TX_PSEUDO_CSUM;
9374         tp->tg3_flags &= ~TG3_FLAG_NO_RX_PSEUDO_CSUM;
9375
9376         /* Derive initial jumbo mode from MTU assigned in
9377          * ether_setup() via the alloc_etherdev() call
9378          */
9379         if (tp->dev->mtu > ETH_DATA_LEN &&
9380             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5780)
9381                 tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
9382
9383         /* Determine WakeOnLan speed to use. */
9384         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
9385             tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
9386             tp->pci_chip_rev_id == CHIPREV_ID_5701_B0 ||
9387             tp->pci_chip_rev_id == CHIPREV_ID_5701_B2) {
9388                 tp->tg3_flags &= ~(TG3_FLAG_WOL_SPEED_100MB);
9389         } else {
9390                 tp->tg3_flags |= TG3_FLAG_WOL_SPEED_100MB;
9391         }
9392
9393         /* A few boards don't want Ethernet@WireSpeed phy feature */
9394         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
9395             ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) &&
9396              (tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) &&
9397              (tp->pci_chip_rev_id != CHIPREV_ID_5705_A1)) ||
9398             (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
9399                 tp->tg3_flags2 |= TG3_FLG2_NO_ETH_WIRE_SPEED;
9400
9401         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5703_AX ||
9402             GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5704_AX)
9403                 tp->tg3_flags2 |= TG3_FLG2_PHY_ADC_BUG;
9404         if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0)
9405                 tp->tg3_flags2 |= TG3_FLG2_PHY_5704_A0_BUG;
9406
9407         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
9408                 tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
9409
9410         tp->coalesce_mode = 0;
9411         if (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_AX &&
9412             GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_BX)
9413                 tp->coalesce_mode |= HOSTCC_MODE_32BYTE;
9414
9415         /* Initialize MAC MI mode, polling disabled. */
9416         tw32_f(MAC_MI_MODE, tp->mi_mode);
9417         udelay(80);
9418
9419         /* Initialize data/descriptor byte/word swapping. */
9420         val = tr32(GRC_MODE);
9421         val &= GRC_MODE_HOST_STACKUP;
9422         tw32(GRC_MODE, val | tp->grc_mode);
9423
9424         tg3_switch_clocks(tp);
9425
9426         /* Clear this out for sanity. */
9427         tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
9428
9429         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
9430                               &pci_state_reg);
9431         if ((pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0 &&
9432             (tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG) == 0) {
9433                 u32 chiprevid = GET_CHIP_REV_ID(tp->misc_host_ctrl);
9434
9435                 if (chiprevid == CHIPREV_ID_5701_A0 ||
9436                     chiprevid == CHIPREV_ID_5701_B0 ||
9437                     chiprevid == CHIPREV_ID_5701_B2 ||
9438                     chiprevid == CHIPREV_ID_5701_B5) {
9439                         void __iomem *sram_base;
9440
9441                         /* Write some dummy words into the SRAM status block
9442                          * area, see if it reads back correctly.  If the return
9443                          * value is bad, force enable the PCIX workaround.
9444                          */
9445                         sram_base = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_STATS_BLK;
9446
9447                         writel(0x00000000, sram_base);
9448                         writel(0x00000000, sram_base + 4);
9449                         writel(0xffffffff, sram_base + 4);
9450                         if (readl(sram_base) != 0x00000000)
9451                                 tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
9452                 }
9453         }
9454
9455         udelay(50);
9456         tg3_nvram_init(tp);
9457
9458         grc_misc_cfg = tr32(GRC_MISC_CFG);
9459         grc_misc_cfg &= GRC_MISC_CFG_BOARD_ID_MASK;
9460
9461         /* Broadcom's driver says that CIOBE multisplit has a bug */
9462 #if 0
9463         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
9464             grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5704CIOBE) {
9465                 tp->tg3_flags |= TG3_FLAG_SPLIT_MODE;
9466                 tp->split_mode_max_reqs = SPLIT_MODE_5704_MAX_REQ;
9467         }
9468 #endif
9469         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
9470             (grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788 ||
9471              grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788M))
9472                 tp->tg3_flags2 |= TG3_FLG2_IS_5788;
9473
9474         if (!(tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
9475             (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700))
9476                 tp->tg3_flags |= TG3_FLAG_TAGGED_STATUS;
9477         if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
9478                 tp->coalesce_mode |= (HOSTCC_MODE_CLRTICK_RXBD |
9479                                       HOSTCC_MODE_CLRTICK_TXBD);
9480
9481                 tp->misc_host_ctrl |= MISC_HOST_CTRL_TAGGED_STATUS;
9482                 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
9483                                        tp->misc_host_ctrl);
9484         }
9485
9486         /* these are limited to 10/100 only */
9487         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 &&
9488              (grc_misc_cfg == 0x8000 || grc_misc_cfg == 0x4000)) ||
9489             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
9490              tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
9491              (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5901 ||
9492               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5901_2 ||
9493               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5705F)) ||
9494             (tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
9495              (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5751F ||
9496               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5753F)))
9497                 tp->tg3_flags |= TG3_FLAG_10_100_ONLY;
9498
9499         err = tg3_phy_probe(tp);
9500         if (err) {
9501                 printk(KERN_ERR PFX "(%s) phy probe failed, err %d\n",
9502                        pci_name(tp->pdev), err);
9503                 /* ... but do not return immediately ... */
9504         }
9505
9506         tg3_read_partno(tp);
9507
9508         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
9509                 tp->tg3_flags &= ~TG3_FLAG_USE_MI_INTERRUPT;
9510         } else {
9511                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
9512                         tp->tg3_flags |= TG3_FLAG_USE_MI_INTERRUPT;
9513                 else
9514                         tp->tg3_flags &= ~TG3_FLAG_USE_MI_INTERRUPT;
9515         }
9516
9517         /* 5700 {AX,BX} chips have a broken status block link
9518          * change bit implementation, so we must use the
9519          * status register in those cases.
9520          */
9521         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
9522                 tp->tg3_flags |= TG3_FLAG_USE_LINKCHG_REG;
9523         else
9524                 tp->tg3_flags &= ~TG3_FLAG_USE_LINKCHG_REG;
9525
9526         /* The led_ctrl is set during tg3_phy_probe, here we might
9527          * have to force the link status polling mechanism based
9528          * upon subsystem IDs.
9529          */
9530         if (tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
9531             !(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
9532                 tp->tg3_flags |= (TG3_FLAG_USE_MI_INTERRUPT |
9533                                   TG3_FLAG_USE_LINKCHG_REG);
9534         }
9535
9536         /* For all SERDES we poll the MAC status register. */
9537         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
9538                 tp->tg3_flags |= TG3_FLAG_POLL_SERDES;
9539         else
9540                 tp->tg3_flags &= ~TG3_FLAG_POLL_SERDES;
9541
9542         /* 5700 BX chips need to have their TX producer index mailboxes
9543          * written twice to workaround a bug.
9544          */
9545         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5700_BX)
9546                 tp->tg3_flags |= TG3_FLAG_TXD_MBOX_HWBUG;
9547         else
9548                 tp->tg3_flags &= ~TG3_FLAG_TXD_MBOX_HWBUG;
9549
9550         /* It seems all chips can get confused if TX buffers
9551          * straddle the 4GB address boundary in some cases.
9552          */
9553         tp->dev->hard_start_xmit = tg3_start_xmit;
9554
9555         tp->rx_offset = 2;
9556         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 &&
9557             (tp->tg3_flags & TG3_FLAG_PCIX_MODE) != 0)
9558                 tp->rx_offset = 0;
9559
9560         /* By default, disable wake-on-lan.  User can change this
9561          * using ETHTOOL_SWOL.
9562          */
9563         tp->tg3_flags &= ~TG3_FLAG_WOL_ENABLE;
9564
9565         return err;
9566 }
9567
9568 #ifdef CONFIG_SPARC64
9569 static int __devinit tg3_get_macaddr_sparc(struct tg3 *tp)
9570 {
9571         struct net_device *dev = tp->dev;
9572         struct pci_dev *pdev = tp->pdev;
9573         struct pcidev_cookie *pcp = pdev->sysdata;
9574
9575         if (pcp != NULL) {
9576                 int node = pcp->prom_node;
9577
9578                 if (prom_getproplen(node, "local-mac-address") == 6) {
9579                         prom_getproperty(node, "local-mac-address",
9580                                          dev->dev_addr, 6);
9581                         return 0;
9582                 }
9583         }
9584         return -ENODEV;
9585 }
9586
9587 static int __devinit tg3_get_default_macaddr_sparc(struct tg3 *tp)
9588 {
9589         struct net_device *dev = tp->dev;
9590
9591         memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
9592         return 0;
9593 }
9594 #endif
9595
9596 static int __devinit tg3_get_device_address(struct tg3 *tp)
9597 {
9598         struct net_device *dev = tp->dev;
9599         u32 hi, lo, mac_offset;
9600
9601 #ifdef CONFIG_SPARC64
9602         if (!tg3_get_macaddr_sparc(tp))
9603                 return 0;
9604 #endif
9605
9606         mac_offset = 0x7c;
9607         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
9608              !(tp->tg3_flags & TG3_FLG2_SUN_570X)) ||
9609             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
9610                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
9611                         mac_offset = 0xcc;
9612                 if (tg3_nvram_lock(tp))
9613                         tw32_f(NVRAM_CMD, NVRAM_CMD_RESET);
9614                 else
9615                         tg3_nvram_unlock(tp);
9616         }
9617
9618         /* First try to get it from MAC address mailbox. */
9619         tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_HIGH_MBOX, &hi);
9620         if ((hi >> 16) == 0x484b) {
9621                 dev->dev_addr[0] = (hi >>  8) & 0xff;
9622                 dev->dev_addr[1] = (hi >>  0) & 0xff;
9623
9624                 tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_LOW_MBOX, &lo);
9625                 dev->dev_addr[2] = (lo >> 24) & 0xff;
9626                 dev->dev_addr[3] = (lo >> 16) & 0xff;
9627                 dev->dev_addr[4] = (lo >>  8) & 0xff;
9628                 dev->dev_addr[5] = (lo >>  0) & 0xff;
9629         }
9630         /* Next, try NVRAM. */
9631         else if (!(tp->tg3_flags & TG3_FLG2_SUN_570X) &&
9632                  !tg3_nvram_read(tp, mac_offset + 0, &hi) &&
9633                  !tg3_nvram_read(tp, mac_offset + 4, &lo)) {
9634                 dev->dev_addr[0] = ((hi >> 16) & 0xff);
9635                 dev->dev_addr[1] = ((hi >> 24) & 0xff);
9636                 dev->dev_addr[2] = ((lo >>  0) & 0xff);
9637                 dev->dev_addr[3] = ((lo >>  8) & 0xff);
9638                 dev->dev_addr[4] = ((lo >> 16) & 0xff);
9639                 dev->dev_addr[5] = ((lo >> 24) & 0xff);
9640         }
9641         /* Finally just fetch it out of the MAC control regs. */
9642         else {
9643                 hi = tr32(MAC_ADDR_0_HIGH);
9644                 lo = tr32(MAC_ADDR_0_LOW);
9645
9646                 dev->dev_addr[5] = lo & 0xff;
9647                 dev->dev_addr[4] = (lo >> 8) & 0xff;
9648                 dev->dev_addr[3] = (lo >> 16) & 0xff;
9649                 dev->dev_addr[2] = (lo >> 24) & 0xff;
9650                 dev->dev_addr[1] = hi & 0xff;
9651                 dev->dev_addr[0] = (hi >> 8) & 0xff;
9652         }
9653
9654         if (!is_valid_ether_addr(&dev->dev_addr[0])) {
9655 #ifdef CONFIG_SPARC64
9656                 if (!tg3_get_default_macaddr_sparc(tp))
9657                         return 0;
9658 #endif
9659                 return -EINVAL;
9660         }
9661         return 0;
9662 }
9663
9664 #define BOUNDARY_SINGLE_CACHELINE       1
9665 #define BOUNDARY_MULTI_CACHELINE        2
9666
9667 static u32 __devinit tg3_calc_dma_bndry(struct tg3 *tp, u32 val)
9668 {
9669         int cacheline_size;
9670         u8 byte;
9671         int goal;
9672
9673         pci_read_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE, &byte);
9674         if (byte == 0)
9675                 cacheline_size = 1024;
9676         else
9677                 cacheline_size = (int) byte * 4;
9678
9679         /* On 5703 and later chips, the boundary bits have no
9680          * effect.
9681          */
9682         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
9683             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701 &&
9684             !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
9685                 goto out;
9686
9687 #if defined(CONFIG_PPC64) || defined(CONFIG_IA64) || defined(CONFIG_PARISC)
9688         goal = BOUNDARY_MULTI_CACHELINE;
9689 #else
9690 #if defined(CONFIG_SPARC64) || defined(CONFIG_ALPHA)
9691         goal = BOUNDARY_SINGLE_CACHELINE;
9692 #else
9693         goal = 0;
9694 #endif
9695 #endif
9696
9697         if (!goal)
9698                 goto out;
9699
9700         /* PCI controllers on most RISC systems tend to disconnect
9701          * when a device tries to burst across a cache-line boundary.
9702          * Therefore, letting tg3 do so just wastes PCI bandwidth.
9703          *
9704          * Unfortunately, for PCI-E there are only limited
9705          * write-side controls for this, and thus for reads
9706          * we will still get the disconnects.  We'll also waste
9707          * these PCI cycles for both read and write for chips
9708          * other than 5700 and 5701 which do not implement the
9709          * boundary bits.
9710          */
9711         if ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
9712             !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)) {
9713                 switch (cacheline_size) {
9714                 case 16:
9715                 case 32:
9716                 case 64:
9717                 case 128:
9718                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
9719                                 val |= (DMA_RWCTRL_READ_BNDRY_128_PCIX |
9720                                         DMA_RWCTRL_WRITE_BNDRY_128_PCIX);
9721                         } else {
9722                                 val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
9723                                         DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
9724                         }
9725                         break;
9726
9727                 case 256:
9728                         val |= (DMA_RWCTRL_READ_BNDRY_256_PCIX |
9729                                 DMA_RWCTRL_WRITE_BNDRY_256_PCIX);
9730                         break;
9731
9732                 default:
9733                         val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
9734                                 DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
9735                         break;
9736                 };
9737         } else if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
9738                 switch (cacheline_size) {
9739                 case 16:
9740                 case 32:
9741                 case 64:
9742                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
9743                                 val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
9744                                 val |= DMA_RWCTRL_WRITE_BNDRY_64_PCIE;
9745                                 break;
9746                         }
9747                         /* fallthrough */
9748                 case 128:
9749                 default:
9750                         val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
9751                         val |= DMA_RWCTRL_WRITE_BNDRY_128_PCIE;
9752                         break;
9753                 };
9754         } else {
9755                 switch (cacheline_size) {
9756                 case 16:
9757                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
9758                                 val |= (DMA_RWCTRL_READ_BNDRY_16 |
9759                                         DMA_RWCTRL_WRITE_BNDRY_16);
9760                                 break;
9761                         }
9762                         /* fallthrough */
9763                 case 32:
9764                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
9765                                 val |= (DMA_RWCTRL_READ_BNDRY_32 |
9766                                         DMA_RWCTRL_WRITE_BNDRY_32);
9767                                 break;
9768                         }
9769                         /* fallthrough */
9770                 case 64:
9771                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
9772                                 val |= (DMA_RWCTRL_READ_BNDRY_64 |
9773                                         DMA_RWCTRL_WRITE_BNDRY_64);
9774                                 break;
9775                         }
9776                         /* fallthrough */
9777                 case 128:
9778                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
9779                                 val |= (DMA_RWCTRL_READ_BNDRY_128 |
9780                                         DMA_RWCTRL_WRITE_BNDRY_128);
9781                                 break;
9782                         }
9783                         /* fallthrough */
9784                 case 256:
9785                         val |= (DMA_RWCTRL_READ_BNDRY_256 |
9786                                 DMA_RWCTRL_WRITE_BNDRY_256);
9787                         break;
9788                 case 512:
9789                         val |= (DMA_RWCTRL_READ_BNDRY_512 |
9790                                 DMA_RWCTRL_WRITE_BNDRY_512);
9791                         break;
9792                 case 1024:
9793                 default:
9794                         val |= (DMA_RWCTRL_READ_BNDRY_1024 |
9795                                 DMA_RWCTRL_WRITE_BNDRY_1024);
9796                         break;
9797                 };
9798         }
9799
9800 out:
9801         return val;
9802 }
9803
9804 static int __devinit tg3_do_test_dma(struct tg3 *tp, u32 *buf, dma_addr_t buf_dma, int size, int to_device)
9805 {
9806         struct tg3_internal_buffer_desc test_desc;
9807         u32 sram_dma_descs;
9808         int i, ret;
9809
9810         sram_dma_descs = NIC_SRAM_DMA_DESC_POOL_BASE;
9811
9812         tw32(FTQ_RCVBD_COMP_FIFO_ENQDEQ, 0);
9813         tw32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ, 0);
9814         tw32(RDMAC_STATUS, 0);
9815         tw32(WDMAC_STATUS, 0);
9816
9817         tw32(BUFMGR_MODE, 0);
9818         tw32(FTQ_RESET, 0);
9819
9820         test_desc.addr_hi = ((u64) buf_dma) >> 32;
9821         test_desc.addr_lo = buf_dma & 0xffffffff;
9822         test_desc.nic_mbuf = 0x00002100;
9823         test_desc.len = size;
9824
9825         /*
9826          * HP ZX1 was seeing test failures for 5701 cards running at 33Mhz
9827          * the *second* time the tg3 driver was getting loaded after an
9828          * initial scan.
9829          *
9830          * Broadcom tells me:
9831          *   ...the DMA engine is connected to the GRC block and a DMA
9832          *   reset may affect the GRC block in some unpredictable way...
9833          *   The behavior of resets to individual blocks has not been tested.
9834          *
9835          * Broadcom noted the GRC reset will also reset all sub-components.
9836          */
9837         if (to_device) {
9838                 test_desc.cqid_sqid = (13 << 8) | 2;
9839
9840                 tw32_f(RDMAC_MODE, RDMAC_MODE_ENABLE);
9841                 udelay(40);
9842         } else {
9843                 test_desc.cqid_sqid = (16 << 8) | 7;
9844
9845                 tw32_f(WDMAC_MODE, WDMAC_MODE_ENABLE);
9846                 udelay(40);
9847         }
9848         test_desc.flags = 0x00000005;
9849
9850         for (i = 0; i < (sizeof(test_desc) / sizeof(u32)); i++) {
9851                 u32 val;
9852
9853                 val = *(((u32 *)&test_desc) + i);
9854                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR,
9855                                        sram_dma_descs + (i * sizeof(u32)));
9856                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
9857         }
9858         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
9859
9860         if (to_device) {
9861                 tw32(FTQ_DMA_HIGH_READ_FIFO_ENQDEQ, sram_dma_descs);
9862         } else {
9863                 tw32(FTQ_DMA_HIGH_WRITE_FIFO_ENQDEQ, sram_dma_descs);
9864         }
9865
9866         ret = -ENODEV;
9867         for (i = 0; i < 40; i++) {
9868                 u32 val;
9869
9870                 if (to_device)
9871                         val = tr32(FTQ_RCVBD_COMP_FIFO_ENQDEQ);
9872                 else
9873                         val = tr32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ);
9874                 if ((val & 0xffff) == sram_dma_descs) {
9875                         ret = 0;
9876                         break;
9877                 }
9878
9879                 udelay(100);
9880         }
9881
9882         return ret;
9883 }
9884
9885 #define TEST_BUFFER_SIZE        0x2000
9886
9887 static int __devinit tg3_test_dma(struct tg3 *tp)
9888 {
9889         dma_addr_t buf_dma;
9890         u32 *buf, saved_dma_rwctrl;
9891         int ret;
9892
9893         buf = pci_alloc_consistent(tp->pdev, TEST_BUFFER_SIZE, &buf_dma);
9894         if (!buf) {
9895                 ret = -ENOMEM;
9896                 goto out_nofree;
9897         }
9898
9899         tp->dma_rwctrl = ((0x7 << DMA_RWCTRL_PCI_WRITE_CMD_SHIFT) |
9900                           (0x6 << DMA_RWCTRL_PCI_READ_CMD_SHIFT));
9901
9902         tp->dma_rwctrl = tg3_calc_dma_bndry(tp, tp->dma_rwctrl);
9903
9904         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
9905                 /* DMA read watermark not used on PCIE */
9906                 tp->dma_rwctrl |= 0x00180000;
9907         } else if (!(tp->tg3_flags & TG3_FLAG_PCIX_MODE)) {
9908                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 ||
9909                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
9910                         tp->dma_rwctrl |= 0x003f0000;
9911                 else
9912                         tp->dma_rwctrl |= 0x003f000f;
9913         } else {
9914                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
9915                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
9916                         u32 ccval = (tr32(TG3PCI_CLOCK_CTRL) & 0x1f);
9917
9918                         if (ccval == 0x6 || ccval == 0x7)
9919                                 tp->dma_rwctrl |= DMA_RWCTRL_ONE_DMA;
9920
9921                         /* Set bit 23 to enable PCIX hw bug fix */
9922                         tp->dma_rwctrl |= 0x009f0000;
9923                 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
9924                         /* 5780 always in PCIX mode */
9925                         tp->dma_rwctrl |= 0x00144000;
9926                 } else {
9927                         tp->dma_rwctrl |= 0x001b000f;
9928                 }
9929         }
9930
9931         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
9932             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
9933                 tp->dma_rwctrl &= 0xfffffff0;
9934
9935         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
9936             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
9937                 /* Remove this if it causes problems for some boards. */
9938                 tp->dma_rwctrl |= DMA_RWCTRL_USE_MEM_READ_MULT;
9939
9940                 /* On 5700/5701 chips, we need to set this bit.
9941                  * Otherwise the chip will issue cacheline transactions
9942                  * to streamable DMA memory with not all the byte
9943                  * enables turned on.  This is an error on several
9944                  * RISC PCI controllers, in particular sparc64.
9945                  *
9946                  * On 5703/5704 chips, this bit has been reassigned
9947                  * a different meaning.  In particular, it is used
9948                  * on those chips to enable a PCI-X workaround.
9949                  */
9950                 tp->dma_rwctrl |= DMA_RWCTRL_ASSERT_ALL_BE;
9951         }
9952
9953         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
9954
9955 #if 0
9956         /* Unneeded, already done by tg3_get_invariants.  */
9957         tg3_switch_clocks(tp);
9958 #endif
9959
9960         ret = 0;
9961         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
9962             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701)
9963                 goto out;
9964
9965         /* It is best to perform DMA test with maximum write burst size
9966          * to expose the 5700/5701 write DMA bug.
9967          */
9968         saved_dma_rwctrl = tp->dma_rwctrl;
9969         tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
9970         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
9971
9972         while (1) {
9973                 u32 *p = buf, i;
9974
9975                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++)
9976                         p[i] = i;
9977
9978                 /* Send the buffer to the chip. */
9979                 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, 1);
9980                 if (ret) {
9981                         printk(KERN_ERR "tg3_test_dma() Write the buffer failed %d\n", ret);
9982                         break;
9983                 }
9984
9985 #if 0
9986                 /* validate data reached card RAM correctly. */
9987                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
9988                         u32 val;
9989                         tg3_read_mem(tp, 0x2100 + (i*4), &val);
9990                         if (le32_to_cpu(val) != p[i]) {
9991                                 printk(KERN_ERR "  tg3_test_dma()  Card buffer corrupted on write! (%d != %d)\n", val, i);
9992                                 /* ret = -ENODEV here? */
9993                         }
9994                         p[i] = 0;
9995                 }
9996 #endif
9997                 /* Now read it back. */
9998                 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, 0);
9999                 if (ret) {
10000                         printk(KERN_ERR "tg3_test_dma() Read the buffer failed %d\n", ret);
10001
10002                         break;
10003                 }
10004
10005                 /* Verify it. */
10006                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
10007                         if (p[i] == i)
10008                                 continue;
10009
10010                         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
10011                             DMA_RWCTRL_WRITE_BNDRY_16) {
10012                                 tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
10013                                 tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
10014                                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
10015                                 break;
10016                         } else {
10017                                 printk(KERN_ERR "tg3_test_dma() buffer corrupted on read back! (%d != %d)\n", p[i], i);
10018                                 ret = -ENODEV;
10019                                 goto out;
10020                         }
10021                 }
10022
10023                 if (i == (TEST_BUFFER_SIZE / sizeof(u32))) {
10024                         /* Success. */
10025                         ret = 0;
10026                         break;
10027                 }
10028         }
10029         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
10030             DMA_RWCTRL_WRITE_BNDRY_16) {
10031                 static struct pci_device_id dma_wait_state_chipsets[] = {
10032                         { PCI_DEVICE(PCI_VENDOR_ID_APPLE,
10033                                      PCI_DEVICE_ID_APPLE_UNI_N_PCI15) },
10034                         { },
10035                 };
10036
10037                 /* DMA test passed without adjusting DMA boundary,
10038                  * now look for chipsets that are known to expose the
10039                  * DMA bug without failing the test.
10040                  */
10041                 if (pci_dev_present(dma_wait_state_chipsets)) {
10042                         tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
10043                         tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
10044                 }
10045                 else
10046                         /* Safe to use the calculated DMA boundary. */
10047                         tp->dma_rwctrl = saved_dma_rwctrl;
10048
10049                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
10050         }
10051
10052 out:
10053         pci_free_consistent(tp->pdev, TEST_BUFFER_SIZE, buf, buf_dma);
10054 out_nofree:
10055         return ret;
10056 }
10057
10058 static void __devinit tg3_init_link_config(struct tg3 *tp)
10059 {
10060         tp->link_config.advertising =
10061                 (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
10062                  ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
10063                  ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full |
10064                  ADVERTISED_Autoneg | ADVERTISED_MII);
10065         tp->link_config.speed = SPEED_INVALID;
10066         tp->link_config.duplex = DUPLEX_INVALID;
10067         tp->link_config.autoneg = AUTONEG_ENABLE;
10068         netif_carrier_off(tp->dev);
10069         tp->link_config.active_speed = SPEED_INVALID;
10070         tp->link_config.active_duplex = DUPLEX_INVALID;
10071         tp->link_config.phy_is_low_power = 0;
10072         tp->link_config.orig_speed = SPEED_INVALID;
10073         tp->link_config.orig_duplex = DUPLEX_INVALID;
10074         tp->link_config.orig_autoneg = AUTONEG_INVALID;
10075 }
10076
10077 static void __devinit tg3_init_bufmgr_config(struct tg3 *tp)
10078 {
10079         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
10080                 tp->bufmgr_config.mbuf_read_dma_low_water =
10081                         DEFAULT_MB_RDMA_LOW_WATER_5705;
10082                 tp->bufmgr_config.mbuf_mac_rx_low_water =
10083                         DEFAULT_MB_MACRX_LOW_WATER_5705;
10084                 tp->bufmgr_config.mbuf_high_water =
10085                         DEFAULT_MB_HIGH_WATER_5705;
10086
10087                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
10088                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO_5780;
10089                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
10090                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO_5780;
10091                 tp->bufmgr_config.mbuf_high_water_jumbo =
10092                         DEFAULT_MB_HIGH_WATER_JUMBO_5780;
10093         } else {
10094                 tp->bufmgr_config.mbuf_read_dma_low_water =
10095                         DEFAULT_MB_RDMA_LOW_WATER;
10096                 tp->bufmgr_config.mbuf_mac_rx_low_water =
10097                         DEFAULT_MB_MACRX_LOW_WATER;
10098                 tp->bufmgr_config.mbuf_high_water =
10099                         DEFAULT_MB_HIGH_WATER;
10100
10101                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
10102                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO;
10103                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
10104                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO;
10105                 tp->bufmgr_config.mbuf_high_water_jumbo =
10106                         DEFAULT_MB_HIGH_WATER_JUMBO;
10107         }
10108
10109         tp->bufmgr_config.dma_low_water = DEFAULT_DMA_LOW_WATER;
10110         tp->bufmgr_config.dma_high_water = DEFAULT_DMA_HIGH_WATER;
10111 }
10112
10113 static char * __devinit tg3_phy_string(struct tg3 *tp)
10114 {
10115         switch (tp->phy_id & PHY_ID_MASK) {
10116         case PHY_ID_BCM5400:    return "5400";
10117         case PHY_ID_BCM5401:    return "5401";
10118         case PHY_ID_BCM5411:    return "5411";
10119         case PHY_ID_BCM5701:    return "5701";
10120         case PHY_ID_BCM5703:    return "5703";
10121         case PHY_ID_BCM5704:    return "5704";
10122         case PHY_ID_BCM5705:    return "5705";
10123         case PHY_ID_BCM5750:    return "5750";
10124         case PHY_ID_BCM5752:    return "5752";
10125         case PHY_ID_BCM5780:    return "5780";
10126         case PHY_ID_BCM8002:    return "8002/serdes";
10127         case 0:                 return "serdes";
10128         default:                return "unknown";
10129         };
10130 }
10131
10132 static struct pci_dev * __devinit tg3_find_5704_peer(struct tg3 *tp)
10133 {
10134         struct pci_dev *peer;
10135         unsigned int func, devnr = tp->pdev->devfn & ~7;
10136
10137         for (func = 0; func < 8; func++) {
10138                 peer = pci_get_slot(tp->pdev->bus, devnr | func);
10139                 if (peer && peer != tp->pdev)
10140                         break;
10141                 pci_dev_put(peer);
10142         }
10143         if (!peer || peer == tp->pdev)
10144                 BUG();
10145
10146         /*
10147          * We don't need to keep the refcount elevated; there's no way
10148          * to remove one half of this device without removing the other
10149          */
10150         pci_dev_put(peer);
10151
10152         return peer;
10153 }
10154
10155 static void __devinit tg3_init_coal(struct tg3 *tp)
10156 {
10157         struct ethtool_coalesce *ec = &tp->coal;
10158
10159         memset(ec, 0, sizeof(*ec));
10160         ec->cmd = ETHTOOL_GCOALESCE;
10161         ec->rx_coalesce_usecs = LOW_RXCOL_TICKS;
10162         ec->tx_coalesce_usecs = LOW_TXCOL_TICKS;
10163         ec->rx_max_coalesced_frames = LOW_RXMAX_FRAMES;
10164         ec->tx_max_coalesced_frames = LOW_TXMAX_FRAMES;
10165         ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT;
10166         ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT;
10167         ec->rx_max_coalesced_frames_irq = DEFAULT_RXCOAL_MAXF_INT;
10168         ec->tx_max_coalesced_frames_irq = DEFAULT_TXCOAL_MAXF_INT;
10169         ec->stats_block_coalesce_usecs = DEFAULT_STAT_COAL_TICKS;
10170
10171         if (tp->coalesce_mode & (HOSTCC_MODE_CLRTICK_RXBD |
10172                                  HOSTCC_MODE_CLRTICK_TXBD)) {
10173                 ec->rx_coalesce_usecs = LOW_RXCOL_TICKS_CLRTCKS;
10174                 ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT_CLRTCKS;
10175                 ec->tx_coalesce_usecs = LOW_TXCOL_TICKS_CLRTCKS;
10176                 ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT_CLRTCKS;
10177         }
10178
10179         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
10180                 ec->rx_coalesce_usecs_irq = 0;
10181                 ec->tx_coalesce_usecs_irq = 0;
10182                 ec->stats_block_coalesce_usecs = 0;
10183         }
10184 }
10185
10186 static int __devinit tg3_init_one(struct pci_dev *pdev,
10187                                   const struct pci_device_id *ent)
10188 {
10189         static int tg3_version_printed = 0;
10190         unsigned long tg3reg_base, tg3reg_len;
10191         struct net_device *dev;
10192         struct tg3 *tp;
10193         int i, err, pci_using_dac, pm_cap;
10194
10195         if (tg3_version_printed++ == 0)
10196                 printk(KERN_INFO "%s", version);
10197
10198         err = pci_enable_device(pdev);
10199         if (err) {
10200                 printk(KERN_ERR PFX "Cannot enable PCI device, "
10201                        "aborting.\n");
10202                 return err;
10203         }
10204
10205         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
10206                 printk(KERN_ERR PFX "Cannot find proper PCI device "
10207                        "base address, aborting.\n");
10208                 err = -ENODEV;
10209                 goto err_out_disable_pdev;
10210         }
10211
10212         err = pci_request_regions(pdev, DRV_MODULE_NAME);
10213         if (err) {
10214                 printk(KERN_ERR PFX "Cannot obtain PCI resources, "
10215                        "aborting.\n");
10216                 goto err_out_disable_pdev;
10217         }
10218
10219         pci_set_master(pdev);
10220
10221         /* Find power-management capability. */
10222         pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
10223         if (pm_cap == 0) {
10224                 printk(KERN_ERR PFX "Cannot find PowerManagement capability, "
10225                        "aborting.\n");
10226                 err = -EIO;
10227                 goto err_out_free_res;
10228         }
10229
10230         /* Configure DMA attributes. */
10231         err = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
10232         if (!err) {
10233                 pci_using_dac = 1;
10234                 err = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL);
10235                 if (err < 0) {
10236                         printk(KERN_ERR PFX "Unable to obtain 64 bit DMA "
10237                                "for consistent allocations\n");
10238                         goto err_out_free_res;
10239                 }
10240         } else {
10241                 err = pci_set_dma_mask(pdev, 0xffffffffULL);
10242                 if (err) {
10243                         printk(KERN_ERR PFX "No usable DMA configuration, "
10244                                "aborting.\n");
10245                         goto err_out_free_res;
10246                 }
10247                 pci_using_dac = 0;
10248         }
10249
10250         tg3reg_base = pci_resource_start(pdev, 0);
10251         tg3reg_len = pci_resource_len(pdev, 0);
10252
10253         dev = alloc_etherdev(sizeof(*tp));
10254         if (!dev) {
10255                 printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
10256                 err = -ENOMEM;
10257                 goto err_out_free_res;
10258         }
10259
10260         SET_MODULE_OWNER(dev);
10261         SET_NETDEV_DEV(dev, &pdev->dev);
10262
10263         if (pci_using_dac)
10264                 dev->features |= NETIF_F_HIGHDMA;
10265         dev->features |= NETIF_F_LLTX;
10266 #if TG3_VLAN_TAG_USED
10267         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
10268         dev->vlan_rx_register = tg3_vlan_rx_register;
10269         dev->vlan_rx_kill_vid = tg3_vlan_rx_kill_vid;
10270 #endif
10271
10272         tp = netdev_priv(dev);
10273         tp->pdev = pdev;
10274         tp->dev = dev;
10275         tp->pm_cap = pm_cap;
10276         tp->mac_mode = TG3_DEF_MAC_MODE;
10277         tp->rx_mode = TG3_DEF_RX_MODE;
10278         tp->tx_mode = TG3_DEF_TX_MODE;
10279         tp->mi_mode = MAC_MI_MODE_BASE;
10280         if (tg3_debug > 0)
10281                 tp->msg_enable = tg3_debug;
10282         else
10283                 tp->msg_enable = TG3_DEF_MSG_ENABLE;
10284
10285         /* The word/byte swap controls here control register access byte
10286          * swapping.  DMA data byte swapping is controlled in the GRC_MODE
10287          * setting below.
10288          */
10289         tp->misc_host_ctrl =
10290                 MISC_HOST_CTRL_MASK_PCI_INT |
10291                 MISC_HOST_CTRL_WORD_SWAP |
10292                 MISC_HOST_CTRL_INDIR_ACCESS |
10293                 MISC_HOST_CTRL_PCISTATE_RW;
10294
10295         /* The NONFRM (non-frame) byte/word swap controls take effect
10296          * on descriptor entries, anything which isn't packet data.
10297          *
10298          * The StrongARM chips on the board (one for tx, one for rx)
10299          * are running in big-endian mode.
10300          */
10301         tp->grc_mode = (GRC_MODE_WSWAP_DATA | GRC_MODE_BSWAP_DATA |
10302                         GRC_MODE_WSWAP_NONFRM_DATA);
10303 #ifdef __BIG_ENDIAN
10304         tp->grc_mode |= GRC_MODE_BSWAP_NONFRM_DATA;
10305 #endif
10306         spin_lock_init(&tp->lock);
10307         spin_lock_init(&tp->tx_lock);
10308         spin_lock_init(&tp->indirect_lock);
10309         INIT_WORK(&tp->reset_task, tg3_reset_task, tp);
10310
10311         tp->regs = ioremap_nocache(tg3reg_base, tg3reg_len);
10312         if (tp->regs == 0UL) {
10313                 printk(KERN_ERR PFX "Cannot map device registers, "
10314                        "aborting.\n");
10315                 err = -ENOMEM;
10316                 goto err_out_free_dev;
10317         }
10318
10319         tg3_init_link_config(tp);
10320
10321         tp->rx_pending = TG3_DEF_RX_RING_PENDING;
10322         tp->rx_jumbo_pending = TG3_DEF_RX_JUMBO_RING_PENDING;
10323         tp->tx_pending = TG3_DEF_TX_RING_PENDING;
10324
10325         dev->open = tg3_open;
10326         dev->stop = tg3_close;
10327         dev->get_stats = tg3_get_stats;
10328         dev->set_multicast_list = tg3_set_rx_mode;
10329         dev->set_mac_address = tg3_set_mac_addr;
10330         dev->do_ioctl = tg3_ioctl;
10331         dev->tx_timeout = tg3_tx_timeout;
10332         dev->poll = tg3_poll;
10333         dev->ethtool_ops = &tg3_ethtool_ops;
10334         dev->weight = 64;
10335         dev->watchdog_timeo = TG3_TX_TIMEOUT;
10336         dev->change_mtu = tg3_change_mtu;
10337         dev->irq = pdev->irq;
10338 #ifdef CONFIG_NET_POLL_CONTROLLER
10339         dev->poll_controller = tg3_poll_controller;
10340 #endif
10341
10342         err = tg3_get_invariants(tp);
10343         if (err) {
10344                 printk(KERN_ERR PFX "Problem fetching invariants of chip, "
10345                        "aborting.\n");
10346                 goto err_out_iounmap;
10347         }
10348
10349         tg3_init_bufmgr_config(tp);
10350
10351 #if TG3_TSO_SUPPORT != 0
10352         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
10353                 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
10354         }
10355         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
10356             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 ||
10357             tp->pci_chip_rev_id == CHIPREV_ID_5705_A0 ||
10358             (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0) {
10359                 tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
10360         } else {
10361                 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
10362         }
10363
10364         /* TSO is off by default, user can enable using ethtool.  */
10365 #if 0
10366         if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)
10367                 dev->features |= NETIF_F_TSO;
10368 #endif
10369
10370 #endif
10371
10372         if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 &&
10373             !(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) &&
10374             !(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH)) {
10375                 tp->tg3_flags2 |= TG3_FLG2_MAX_RXPEND_64;
10376                 tp->rx_pending = 63;
10377         }
10378
10379         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
10380                 tp->pdev_peer = tg3_find_5704_peer(tp);
10381
10382         err = tg3_get_device_address(tp);
10383         if (err) {
10384                 printk(KERN_ERR PFX "Could not obtain valid ethernet address, "
10385                        "aborting.\n");
10386                 goto err_out_iounmap;
10387         }
10388
10389         /*
10390          * Reset chip in case UNDI or EFI driver did not shutdown
10391          * DMA self test will enable WDMAC and we'll see (spurious)
10392          * pending DMA on the PCI bus at that point.
10393          */
10394         if ((tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE) ||
10395             (tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
10396                 pci_save_state(tp->pdev);
10397                 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
10398                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
10399         }
10400
10401         err = tg3_test_dma(tp);
10402         if (err) {
10403                 printk(KERN_ERR PFX "DMA engine test failed, aborting.\n");
10404                 goto err_out_iounmap;
10405         }
10406
10407         /* Tigon3 can do ipv4 only... and some chips have buggy
10408          * checksumming.
10409          */
10410         if ((tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) == 0) {
10411                 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
10412                 tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
10413         } else
10414                 tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
10415
10416         if (tp->tg3_flags2 & TG3_FLG2_IS_5788)
10417                 dev->features &= ~NETIF_F_HIGHDMA;
10418
10419         /* flow control autonegotiation is default behavior */
10420         tp->tg3_flags |= TG3_FLAG_PAUSE_AUTONEG;
10421
10422         tg3_init_coal(tp);
10423
10424         err = register_netdev(dev);
10425         if (err) {
10426                 printk(KERN_ERR PFX "Cannot register net device, "
10427                        "aborting.\n");
10428                 goto err_out_iounmap;
10429         }
10430
10431         pci_set_drvdata(pdev, dev);
10432
10433         /* Now that we have fully setup the chip, save away a snapshot
10434          * of the PCI config space.  We need to restore this after
10435          * GRC_MISC_CFG core clock resets and some resume events.
10436          */
10437         pci_save_state(tp->pdev);
10438
10439         printk(KERN_INFO "%s: Tigon3 [partno(%s) rev %04x PHY(%s)] (PCI%s:%s:%s) %sBaseT Ethernet ",
10440                dev->name,
10441                tp->board_part_number,
10442                tp->pci_chip_rev_id,
10443                tg3_phy_string(tp),
10444                ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) ? "X" : ""),
10445                ((tp->tg3_flags & TG3_FLAG_PCI_HIGH_SPEED) ?
10446                 ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) ? "133MHz" : "66MHz") :
10447                 ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) ? "100MHz" : "33MHz")),
10448                ((tp->tg3_flags & TG3_FLAG_PCI_32BIT) ? "32-bit" : "64-bit"),
10449                (tp->tg3_flags & TG3_FLAG_10_100_ONLY) ? "10/100" : "10/100/1000");
10450
10451         for (i = 0; i < 6; i++)
10452                 printk("%2.2x%c", dev->dev_addr[i],
10453                        i == 5 ? '\n' : ':');
10454
10455         printk(KERN_INFO "%s: RXcsums[%d] LinkChgREG[%d] "
10456                "MIirq[%d] ASF[%d] Split[%d] WireSpeed[%d] "
10457                "TSOcap[%d] \n",
10458                dev->name,
10459                (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0,
10460                (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) != 0,
10461                (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT) != 0,
10462                (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0,
10463                (tp->tg3_flags & TG3_FLAG_SPLIT_MODE) != 0,
10464                (tp->tg3_flags2 & TG3_FLG2_NO_ETH_WIRE_SPEED) == 0,
10465                (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) != 0);
10466         printk(KERN_INFO "%s: dma_rwctrl[%08x]\n",
10467                dev->name, tp->dma_rwctrl);
10468
10469         return 0;
10470
10471 err_out_iounmap:
10472         iounmap(tp->regs);
10473
10474 err_out_free_dev:
10475         free_netdev(dev);
10476
10477 err_out_free_res:
10478         pci_release_regions(pdev);
10479
10480 err_out_disable_pdev:
10481         pci_disable_device(pdev);
10482         pci_set_drvdata(pdev, NULL);
10483         return err;
10484 }
10485
10486 static void __devexit tg3_remove_one(struct pci_dev *pdev)
10487 {
10488         struct net_device *dev = pci_get_drvdata(pdev);
10489
10490         if (dev) {
10491                 struct tg3 *tp = netdev_priv(dev);
10492
10493                 unregister_netdev(dev);
10494                 iounmap(tp->regs);
10495                 free_netdev(dev);
10496                 pci_release_regions(pdev);
10497                 pci_disable_device(pdev);
10498                 pci_set_drvdata(pdev, NULL);
10499         }
10500 }
10501
10502 static int tg3_suspend(struct pci_dev *pdev, pm_message_t state)
10503 {
10504         struct net_device *dev = pci_get_drvdata(pdev);
10505         struct tg3 *tp = netdev_priv(dev);
10506         int err;
10507
10508         if (!netif_running(dev))
10509                 return 0;
10510
10511         tg3_netif_stop(tp);
10512
10513         del_timer_sync(&tp->timer);
10514
10515         tg3_full_lock(tp, 1);
10516         tg3_disable_ints(tp);
10517         tg3_full_unlock(tp);
10518
10519         netif_device_detach(dev);
10520
10521         tg3_full_lock(tp, 0);
10522         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
10523         tg3_full_unlock(tp);
10524
10525         err = tg3_set_power_state(tp, pci_choose_state(pdev, state));
10526         if (err) {
10527                 tg3_full_lock(tp, 0);
10528
10529                 tg3_init_hw(tp);
10530
10531                 tp->timer.expires = jiffies + tp->timer_offset;
10532                 add_timer(&tp->timer);
10533
10534                 netif_device_attach(dev);
10535                 tg3_netif_start(tp);
10536
10537                 tg3_full_unlock(tp);
10538         }
10539
10540         return err;
10541 }
10542
10543 static int tg3_resume(struct pci_dev *pdev)
10544 {
10545         struct net_device *dev = pci_get_drvdata(pdev);
10546         struct tg3 *tp = netdev_priv(dev);
10547         int err;
10548
10549         if (!netif_running(dev))
10550                 return 0;
10551
10552         pci_restore_state(tp->pdev);
10553
10554         err = tg3_set_power_state(tp, 0);
10555         if (err)
10556                 return err;
10557
10558         netif_device_attach(dev);
10559
10560         tg3_full_lock(tp, 0);
10561
10562         tg3_init_hw(tp);
10563
10564         tp->timer.expires = jiffies + tp->timer_offset;
10565         add_timer(&tp->timer);
10566
10567         tg3_netif_start(tp);
10568
10569         tg3_full_unlock(tp);
10570
10571         return 0;
10572 }
10573
10574 static struct pci_driver tg3_driver = {
10575         .name           = DRV_MODULE_NAME,
10576         .id_table       = tg3_pci_tbl,
10577         .probe          = tg3_init_one,
10578         .remove         = __devexit_p(tg3_remove_one),
10579         .suspend        = tg3_suspend,
10580         .resume         = tg3_resume
10581 };
10582
10583 static int __init tg3_init(void)
10584 {
10585         return pci_module_init(&tg3_driver);
10586 }
10587
10588 static void __exit tg3_cleanup(void)
10589 {
10590         pci_unregister_driver(&tg3_driver);
10591 }
10592
10593 module_init(tg3_init);
10594 module_exit(tg3_cleanup);