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