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                 tg3_full_unlock(tp);
6894                 return err;
6895         }
6896
6897         tg3_disable_ints(tp);
6898         tp->tg3_flags &= ~TG3_FLAG_INIT_COMPLETE;
6899
6900         tg3_full_unlock(tp);
6901
6902         /* The placement of this call is tied
6903          * to the setup and use of Host TX descriptors.
6904          */
6905         err = tg3_alloc_consistent(tp);
6906         if (err)
6907                 return err;
6908
6909         if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
6910             (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5750_AX) &&
6911             (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5750_BX) &&
6912             !((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) &&
6913               (tp->pdev_peer == tp->pdev))) {
6914                 /* All MSI supporting chips should support tagged
6915                  * status.  Assert that this is the case.
6916                  */
6917                 if (!(tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)) {
6918                         printk(KERN_WARNING PFX "%s: MSI without TAGGED? "
6919                                "Not using MSI.\n", tp->dev->name);
6920                 } else if (pci_enable_msi(tp->pdev) == 0) {
6921                         u32 msi_mode;
6922
6923                         msi_mode = tr32(MSGINT_MODE);
6924                         tw32(MSGINT_MODE, msi_mode | MSGINT_MODE_ENABLE);
6925                         tp->tg3_flags2 |= TG3_FLG2_USING_MSI;
6926                 }
6927         }
6928         err = tg3_request_irq(tp);
6929
6930         if (err) {
6931                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6932                         pci_disable_msi(tp->pdev);
6933                         tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6934                 }
6935                 tg3_free_consistent(tp);
6936                 return err;
6937         }
6938
6939         tg3_full_lock(tp, 0);
6940
6941         err = tg3_init_hw(tp, 1);
6942         if (err) {
6943                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
6944                 tg3_free_rings(tp);
6945         } else {
6946                 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
6947                         tp->timer_offset = HZ;
6948                 else
6949                         tp->timer_offset = HZ / 10;
6950
6951                 BUG_ON(tp->timer_offset > HZ);
6952                 tp->timer_counter = tp->timer_multiplier =
6953                         (HZ / tp->timer_offset);
6954                 tp->asf_counter = tp->asf_multiplier =
6955                         ((HZ / tp->timer_offset) * 2);
6956
6957                 init_timer(&tp->timer);
6958                 tp->timer.expires = jiffies + tp->timer_offset;
6959                 tp->timer.data = (unsigned long) tp;
6960                 tp->timer.function = tg3_timer;
6961         }
6962
6963         tg3_full_unlock(tp);
6964
6965         if (err) {
6966                 free_irq(tp->pdev->irq, dev);
6967                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6968                         pci_disable_msi(tp->pdev);
6969                         tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6970                 }
6971                 tg3_free_consistent(tp);
6972                 return err;
6973         }
6974
6975         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6976                 err = tg3_test_msi(tp);
6977
6978                 if (err) {
6979                         tg3_full_lock(tp, 0);
6980
6981                         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6982                                 pci_disable_msi(tp->pdev);
6983                                 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
6984                         }
6985                         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
6986                         tg3_free_rings(tp);
6987                         tg3_free_consistent(tp);
6988
6989                         tg3_full_unlock(tp);
6990
6991                         return err;
6992                 }
6993
6994                 if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
6995                         if (tp->tg3_flags2 & TG3_FLG2_1SHOT_MSI) {
6996                                 u32 val = tr32(0x7c04);
6997
6998                                 tw32(0x7c04, val | (1 << 29));
6999                         }
7000                 }
7001         }
7002
7003         tg3_full_lock(tp, 0);
7004
7005         add_timer(&tp->timer);
7006         tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
7007         tg3_enable_ints(tp);
7008
7009         tg3_full_unlock(tp);
7010
7011         netif_start_queue(dev);
7012
7013         return 0;
7014 }
7015
7016 #if 0
7017 /*static*/ void tg3_dump_state(struct tg3 *tp)
7018 {
7019         u32 val32, val32_2, val32_3, val32_4, val32_5;
7020         u16 val16;
7021         int i;
7022
7023         pci_read_config_word(tp->pdev, PCI_STATUS, &val16);
7024         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE, &val32);
7025         printk("DEBUG: PCI status [%04x] TG3PCI state[%08x]\n",
7026                val16, val32);
7027
7028         /* MAC block */
7029         printk("DEBUG: MAC_MODE[%08x] MAC_STATUS[%08x]\n",
7030                tr32(MAC_MODE), tr32(MAC_STATUS));
7031         printk("       MAC_EVENT[%08x] MAC_LED_CTRL[%08x]\n",
7032                tr32(MAC_EVENT), tr32(MAC_LED_CTRL));
7033         printk("DEBUG: MAC_TX_MODE[%08x] MAC_TX_STATUS[%08x]\n",
7034                tr32(MAC_TX_MODE), tr32(MAC_TX_STATUS));
7035         printk("       MAC_RX_MODE[%08x] MAC_RX_STATUS[%08x]\n",
7036                tr32(MAC_RX_MODE), tr32(MAC_RX_STATUS));
7037
7038         /* Send data initiator control block */
7039         printk("DEBUG: SNDDATAI_MODE[%08x] SNDDATAI_STATUS[%08x]\n",
7040                tr32(SNDDATAI_MODE), tr32(SNDDATAI_STATUS));
7041         printk("       SNDDATAI_STATSCTRL[%08x]\n",
7042                tr32(SNDDATAI_STATSCTRL));
7043
7044         /* Send data completion control block */
7045         printk("DEBUG: SNDDATAC_MODE[%08x]\n", tr32(SNDDATAC_MODE));
7046
7047         /* Send BD ring selector block */
7048         printk("DEBUG: SNDBDS_MODE[%08x] SNDBDS_STATUS[%08x]\n",
7049                tr32(SNDBDS_MODE), tr32(SNDBDS_STATUS));
7050
7051         /* Send BD initiator control block */
7052         printk("DEBUG: SNDBDI_MODE[%08x] SNDBDI_STATUS[%08x]\n",
7053                tr32(SNDBDI_MODE), tr32(SNDBDI_STATUS));
7054
7055         /* Send BD completion control block */
7056         printk("DEBUG: SNDBDC_MODE[%08x]\n", tr32(SNDBDC_MODE));
7057
7058         /* Receive list placement control block */
7059         printk("DEBUG: RCVLPC_MODE[%08x] RCVLPC_STATUS[%08x]\n",
7060                tr32(RCVLPC_MODE), tr32(RCVLPC_STATUS));
7061         printk("       RCVLPC_STATSCTRL[%08x]\n",
7062                tr32(RCVLPC_STATSCTRL));
7063
7064         /* Receive data and receive BD initiator control block */
7065         printk("DEBUG: RCVDBDI_MODE[%08x] RCVDBDI_STATUS[%08x]\n",
7066                tr32(RCVDBDI_MODE), tr32(RCVDBDI_STATUS));
7067
7068         /* Receive data completion control block */
7069         printk("DEBUG: RCVDCC_MODE[%08x]\n",
7070                tr32(RCVDCC_MODE));
7071
7072         /* Receive BD initiator control block */
7073         printk("DEBUG: RCVBDI_MODE[%08x] RCVBDI_STATUS[%08x]\n",
7074                tr32(RCVBDI_MODE), tr32(RCVBDI_STATUS));
7075
7076         /* Receive BD completion control block */
7077         printk("DEBUG: RCVCC_MODE[%08x] RCVCC_STATUS[%08x]\n",
7078                tr32(RCVCC_MODE), tr32(RCVCC_STATUS));
7079
7080         /* Receive list selector control block */
7081         printk("DEBUG: RCVLSC_MODE[%08x] RCVLSC_STATUS[%08x]\n",
7082                tr32(RCVLSC_MODE), tr32(RCVLSC_STATUS));
7083
7084         /* Mbuf cluster free block */
7085         printk("DEBUG: MBFREE_MODE[%08x] MBFREE_STATUS[%08x]\n",
7086                tr32(MBFREE_MODE), tr32(MBFREE_STATUS));
7087
7088         /* Host coalescing control block */
7089         printk("DEBUG: HOSTCC_MODE[%08x] HOSTCC_STATUS[%08x]\n",
7090                tr32(HOSTCC_MODE), tr32(HOSTCC_STATUS));
7091         printk("DEBUG: HOSTCC_STATS_BLK_HOST_ADDR[%08x%08x]\n",
7092                tr32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH),
7093                tr32(HOSTCC_STATS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW));
7094         printk("DEBUG: HOSTCC_STATUS_BLK_HOST_ADDR[%08x%08x]\n",
7095                tr32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_HIGH),
7096                tr32(HOSTCC_STATUS_BLK_HOST_ADDR + TG3_64BIT_REG_LOW));
7097         printk("DEBUG: HOSTCC_STATS_BLK_NIC_ADDR[%08x]\n",
7098                tr32(HOSTCC_STATS_BLK_NIC_ADDR));
7099         printk("DEBUG: HOSTCC_STATUS_BLK_NIC_ADDR[%08x]\n",
7100                tr32(HOSTCC_STATUS_BLK_NIC_ADDR));
7101
7102         /* Memory arbiter control block */
7103         printk("DEBUG: MEMARB_MODE[%08x] MEMARB_STATUS[%08x]\n",
7104                tr32(MEMARB_MODE), tr32(MEMARB_STATUS));
7105
7106         /* Buffer manager control block */
7107         printk("DEBUG: BUFMGR_MODE[%08x] BUFMGR_STATUS[%08x]\n",
7108                tr32(BUFMGR_MODE), tr32(BUFMGR_STATUS));
7109         printk("DEBUG: BUFMGR_MB_POOL_ADDR[%08x] BUFMGR_MB_POOL_SIZE[%08x]\n",
7110                tr32(BUFMGR_MB_POOL_ADDR), tr32(BUFMGR_MB_POOL_SIZE));
7111         printk("DEBUG: BUFMGR_DMA_DESC_POOL_ADDR[%08x] "
7112                "BUFMGR_DMA_DESC_POOL_SIZE[%08x]\n",
7113                tr32(BUFMGR_DMA_DESC_POOL_ADDR),
7114                tr32(BUFMGR_DMA_DESC_POOL_SIZE));
7115
7116         /* Read DMA control block */
7117         printk("DEBUG: RDMAC_MODE[%08x] RDMAC_STATUS[%08x]\n",
7118                tr32(RDMAC_MODE), tr32(RDMAC_STATUS));
7119
7120         /* Write DMA control block */
7121         printk("DEBUG: WDMAC_MODE[%08x] WDMAC_STATUS[%08x]\n",
7122                tr32(WDMAC_MODE), tr32(WDMAC_STATUS));
7123
7124         /* DMA completion block */
7125         printk("DEBUG: DMAC_MODE[%08x]\n",
7126                tr32(DMAC_MODE));
7127
7128         /* GRC block */
7129         printk("DEBUG: GRC_MODE[%08x] GRC_MISC_CFG[%08x]\n",
7130                tr32(GRC_MODE), tr32(GRC_MISC_CFG));
7131         printk("DEBUG: GRC_LOCAL_CTRL[%08x]\n",
7132                tr32(GRC_LOCAL_CTRL));
7133
7134         /* TG3_BDINFOs */
7135         printk("DEBUG: RCVDBDI_JUMBO_BD[%08x%08x:%08x:%08x]\n",
7136                tr32(RCVDBDI_JUMBO_BD + 0x0),
7137                tr32(RCVDBDI_JUMBO_BD + 0x4),
7138                tr32(RCVDBDI_JUMBO_BD + 0x8),
7139                tr32(RCVDBDI_JUMBO_BD + 0xc));
7140         printk("DEBUG: RCVDBDI_STD_BD[%08x%08x:%08x:%08x]\n",
7141                tr32(RCVDBDI_STD_BD + 0x0),
7142                tr32(RCVDBDI_STD_BD + 0x4),
7143                tr32(RCVDBDI_STD_BD + 0x8),
7144                tr32(RCVDBDI_STD_BD + 0xc));
7145         printk("DEBUG: RCVDBDI_MINI_BD[%08x%08x:%08x:%08x]\n",
7146                tr32(RCVDBDI_MINI_BD + 0x0),
7147                tr32(RCVDBDI_MINI_BD + 0x4),
7148                tr32(RCVDBDI_MINI_BD + 0x8),
7149                tr32(RCVDBDI_MINI_BD + 0xc));
7150
7151         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x0, &val32);
7152         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x4, &val32_2);
7153         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0x8, &val32_3);
7154         tg3_read_mem(tp, NIC_SRAM_SEND_RCB + 0xc, &val32_4);
7155         printk("DEBUG: SRAM_SEND_RCB_0[%08x%08x:%08x:%08x]\n",
7156                val32, val32_2, val32_3, val32_4);
7157
7158         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x0, &val32);
7159         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x4, &val32_2);
7160         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0x8, &val32_3);
7161         tg3_read_mem(tp, NIC_SRAM_RCV_RET_RCB + 0xc, &val32_4);
7162         printk("DEBUG: SRAM_RCV_RET_RCB_0[%08x%08x:%08x:%08x]\n",
7163                val32, val32_2, val32_3, val32_4);
7164
7165         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x0, &val32);
7166         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x4, &val32_2);
7167         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x8, &val32_3);
7168         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0xc, &val32_4);
7169         tg3_read_mem(tp, NIC_SRAM_STATUS_BLK + 0x10, &val32_5);
7170         printk("DEBUG: SRAM_STATUS_BLK[%08x:%08x:%08x:%08x:%08x]\n",
7171                val32, val32_2, val32_3, val32_4, val32_5);
7172
7173         /* SW status block */
7174         printk("DEBUG: Host status block [%08x:%08x:(%04x:%04x:%04x):(%04x:%04x)]\n",
7175                tp->hw_status->status,
7176                tp->hw_status->status_tag,
7177                tp->hw_status->rx_jumbo_consumer,
7178                tp->hw_status->rx_consumer,
7179                tp->hw_status->rx_mini_consumer,
7180                tp->hw_status->idx[0].rx_producer,
7181                tp->hw_status->idx[0].tx_consumer);
7182
7183         /* SW statistics block */
7184         printk("DEBUG: Host statistics block [%08x:%08x:%08x:%08x]\n",
7185                ((u32 *)tp->hw_stats)[0],
7186                ((u32 *)tp->hw_stats)[1],
7187                ((u32 *)tp->hw_stats)[2],
7188                ((u32 *)tp->hw_stats)[3]);
7189
7190         /* Mailboxes */
7191         printk("DEBUG: SNDHOST_PROD[%08x%08x] SNDNIC_PROD[%08x%08x]\n",
7192                tr32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + 0x0),
7193                tr32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + 0x4),
7194                tr32_mailbox(MAILBOX_SNDNIC_PROD_IDX_0 + 0x0),
7195                tr32_mailbox(MAILBOX_SNDNIC_PROD_IDX_0 + 0x4));
7196
7197         /* NIC side send descriptors. */
7198         for (i = 0; i < 6; i++) {
7199                 unsigned long txd;
7200
7201                 txd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_TX_BUFFER_DESC
7202                         + (i * sizeof(struct tg3_tx_buffer_desc));
7203                 printk("DEBUG: NIC TXD(%d)[%08x:%08x:%08x:%08x]\n",
7204                        i,
7205                        readl(txd + 0x0), readl(txd + 0x4),
7206                        readl(txd + 0x8), readl(txd + 0xc));
7207         }
7208
7209         /* NIC side RX descriptors. */
7210         for (i = 0; i < 6; i++) {
7211                 unsigned long rxd;
7212
7213                 rxd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_RX_BUFFER_DESC
7214                         + (i * sizeof(struct tg3_rx_buffer_desc));
7215                 printk("DEBUG: NIC RXD_STD(%d)[0][%08x:%08x:%08x:%08x]\n",
7216                        i,
7217                        readl(rxd + 0x0), readl(rxd + 0x4),
7218                        readl(rxd + 0x8), readl(rxd + 0xc));
7219                 rxd += (4 * sizeof(u32));
7220                 printk("DEBUG: NIC RXD_STD(%d)[1][%08x:%08x:%08x:%08x]\n",
7221                        i,
7222                        readl(rxd + 0x0), readl(rxd + 0x4),
7223                        readl(rxd + 0x8), readl(rxd + 0xc));
7224         }
7225
7226         for (i = 0; i < 6; i++) {
7227                 unsigned long rxd;
7228
7229                 rxd = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_RX_JUMBO_BUFFER_DESC
7230                         + (i * sizeof(struct tg3_rx_buffer_desc));
7231                 printk("DEBUG: NIC RXD_JUMBO(%d)[0][%08x:%08x:%08x:%08x]\n",
7232                        i,
7233                        readl(rxd + 0x0), readl(rxd + 0x4),
7234                        readl(rxd + 0x8), readl(rxd + 0xc));
7235                 rxd += (4 * sizeof(u32));
7236                 printk("DEBUG: NIC RXD_JUMBO(%d)[1][%08x:%08x:%08x:%08x]\n",
7237                        i,
7238                        readl(rxd + 0x0), readl(rxd + 0x4),
7239                        readl(rxd + 0x8), readl(rxd + 0xc));
7240         }
7241 }
7242 #endif
7243
7244 static struct net_device_stats *tg3_get_stats(struct net_device *);
7245 static struct tg3_ethtool_stats *tg3_get_estats(struct tg3 *);
7246
7247 static int tg3_close(struct net_device *dev)
7248 {
7249         struct tg3 *tp = netdev_priv(dev);
7250
7251         /* Calling flush_scheduled_work() may deadlock because
7252          * linkwatch_event() may be on the workqueue and it will try to get
7253          * the rtnl_lock which we are holding.
7254          */
7255         while (tp->tg3_flags & TG3_FLAG_IN_RESET_TASK)
7256                 msleep(1);
7257
7258         netif_stop_queue(dev);
7259
7260         del_timer_sync(&tp->timer);
7261
7262         tg3_full_lock(tp, 1);
7263 #if 0
7264         tg3_dump_state(tp);
7265 #endif
7266
7267         tg3_disable_ints(tp);
7268
7269         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
7270         tg3_free_rings(tp);
7271         tp->tg3_flags &=
7272                 ~(TG3_FLAG_INIT_COMPLETE |
7273                   TG3_FLAG_GOT_SERDES_FLOWCTL);
7274
7275         tg3_full_unlock(tp);
7276
7277         free_irq(tp->pdev->irq, dev);
7278         if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
7279                 pci_disable_msi(tp->pdev);
7280                 tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
7281         }
7282
7283         memcpy(&tp->net_stats_prev, tg3_get_stats(tp->dev),
7284                sizeof(tp->net_stats_prev));
7285         memcpy(&tp->estats_prev, tg3_get_estats(tp),
7286                sizeof(tp->estats_prev));
7287
7288         tg3_free_consistent(tp);
7289
7290         tg3_set_power_state(tp, PCI_D3hot);
7291
7292         netif_carrier_off(tp->dev);
7293
7294         return 0;
7295 }
7296
7297 static inline unsigned long get_stat64(tg3_stat64_t *val)
7298 {
7299         unsigned long ret;
7300
7301 #if (BITS_PER_LONG == 32)
7302         ret = val->low;
7303 #else
7304         ret = ((u64)val->high << 32) | ((u64)val->low);
7305 #endif
7306         return ret;
7307 }
7308
7309 static unsigned long calc_crc_errors(struct tg3 *tp)
7310 {
7311         struct tg3_hw_stats *hw_stats = tp->hw_stats;
7312
7313         if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) &&
7314             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
7315              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
7316                 u32 val;
7317
7318                 spin_lock_bh(&tp->lock);
7319                 if (!tg3_readphy(tp, 0x1e, &val)) {
7320                         tg3_writephy(tp, 0x1e, val | 0x8000);
7321                         tg3_readphy(tp, 0x14, &val);
7322                 } else
7323                         val = 0;
7324                 spin_unlock_bh(&tp->lock);
7325
7326                 tp->phy_crc_errors += val;
7327
7328                 return tp->phy_crc_errors;
7329         }
7330
7331         return get_stat64(&hw_stats->rx_fcs_errors);
7332 }
7333
7334 #define ESTAT_ADD(member) \
7335         estats->member =        old_estats->member + \
7336                                 get_stat64(&hw_stats->member)
7337
7338 static struct tg3_ethtool_stats *tg3_get_estats(struct tg3 *tp)
7339 {
7340         struct tg3_ethtool_stats *estats = &tp->estats;
7341         struct tg3_ethtool_stats *old_estats = &tp->estats_prev;
7342         struct tg3_hw_stats *hw_stats = tp->hw_stats;
7343
7344         if (!hw_stats)
7345                 return old_estats;
7346
7347         ESTAT_ADD(rx_octets);
7348         ESTAT_ADD(rx_fragments);
7349         ESTAT_ADD(rx_ucast_packets);
7350         ESTAT_ADD(rx_mcast_packets);
7351         ESTAT_ADD(rx_bcast_packets);
7352         ESTAT_ADD(rx_fcs_errors);
7353         ESTAT_ADD(rx_align_errors);
7354         ESTAT_ADD(rx_xon_pause_rcvd);
7355         ESTAT_ADD(rx_xoff_pause_rcvd);
7356         ESTAT_ADD(rx_mac_ctrl_rcvd);
7357         ESTAT_ADD(rx_xoff_entered);
7358         ESTAT_ADD(rx_frame_too_long_errors);
7359         ESTAT_ADD(rx_jabbers);
7360         ESTAT_ADD(rx_undersize_packets);
7361         ESTAT_ADD(rx_in_length_errors);
7362         ESTAT_ADD(rx_out_length_errors);
7363         ESTAT_ADD(rx_64_or_less_octet_packets);
7364         ESTAT_ADD(rx_65_to_127_octet_packets);
7365         ESTAT_ADD(rx_128_to_255_octet_packets);
7366         ESTAT_ADD(rx_256_to_511_octet_packets);
7367         ESTAT_ADD(rx_512_to_1023_octet_packets);
7368         ESTAT_ADD(rx_1024_to_1522_octet_packets);
7369         ESTAT_ADD(rx_1523_to_2047_octet_packets);
7370         ESTAT_ADD(rx_2048_to_4095_octet_packets);
7371         ESTAT_ADD(rx_4096_to_8191_octet_packets);
7372         ESTAT_ADD(rx_8192_to_9022_octet_packets);
7373
7374         ESTAT_ADD(tx_octets);
7375         ESTAT_ADD(tx_collisions);
7376         ESTAT_ADD(tx_xon_sent);
7377         ESTAT_ADD(tx_xoff_sent);
7378         ESTAT_ADD(tx_flow_control);
7379         ESTAT_ADD(tx_mac_errors);
7380         ESTAT_ADD(tx_single_collisions);
7381         ESTAT_ADD(tx_mult_collisions);
7382         ESTAT_ADD(tx_deferred);
7383         ESTAT_ADD(tx_excessive_collisions);
7384         ESTAT_ADD(tx_late_collisions);
7385         ESTAT_ADD(tx_collide_2times);
7386         ESTAT_ADD(tx_collide_3times);
7387         ESTAT_ADD(tx_collide_4times);
7388         ESTAT_ADD(tx_collide_5times);
7389         ESTAT_ADD(tx_collide_6times);
7390         ESTAT_ADD(tx_collide_7times);
7391         ESTAT_ADD(tx_collide_8times);
7392         ESTAT_ADD(tx_collide_9times);
7393         ESTAT_ADD(tx_collide_10times);
7394         ESTAT_ADD(tx_collide_11times);
7395         ESTAT_ADD(tx_collide_12times);
7396         ESTAT_ADD(tx_collide_13times);
7397         ESTAT_ADD(tx_collide_14times);
7398         ESTAT_ADD(tx_collide_15times);
7399         ESTAT_ADD(tx_ucast_packets);
7400         ESTAT_ADD(tx_mcast_packets);
7401         ESTAT_ADD(tx_bcast_packets);
7402         ESTAT_ADD(tx_carrier_sense_errors);
7403         ESTAT_ADD(tx_discards);
7404         ESTAT_ADD(tx_errors);
7405
7406         ESTAT_ADD(dma_writeq_full);
7407         ESTAT_ADD(dma_write_prioq_full);
7408         ESTAT_ADD(rxbds_empty);
7409         ESTAT_ADD(rx_discards);
7410         ESTAT_ADD(rx_errors);
7411         ESTAT_ADD(rx_threshold_hit);
7412
7413         ESTAT_ADD(dma_readq_full);
7414         ESTAT_ADD(dma_read_prioq_full);
7415         ESTAT_ADD(tx_comp_queue_full);
7416
7417         ESTAT_ADD(ring_set_send_prod_index);
7418         ESTAT_ADD(ring_status_update);
7419         ESTAT_ADD(nic_irqs);
7420         ESTAT_ADD(nic_avoided_irqs);
7421         ESTAT_ADD(nic_tx_threshold_hit);
7422
7423         return estats;
7424 }
7425
7426 static struct net_device_stats *tg3_get_stats(struct net_device *dev)
7427 {
7428         struct tg3 *tp = netdev_priv(dev);
7429         struct net_device_stats *stats = &tp->net_stats;
7430         struct net_device_stats *old_stats = &tp->net_stats_prev;
7431         struct tg3_hw_stats *hw_stats = tp->hw_stats;
7432
7433         if (!hw_stats)
7434                 return old_stats;
7435
7436         stats->rx_packets = old_stats->rx_packets +
7437                 get_stat64(&hw_stats->rx_ucast_packets) +
7438                 get_stat64(&hw_stats->rx_mcast_packets) +
7439                 get_stat64(&hw_stats->rx_bcast_packets);
7440
7441         stats->tx_packets = old_stats->tx_packets +
7442                 get_stat64(&hw_stats->tx_ucast_packets) +
7443                 get_stat64(&hw_stats->tx_mcast_packets) +
7444                 get_stat64(&hw_stats->tx_bcast_packets);
7445
7446         stats->rx_bytes = old_stats->rx_bytes +
7447                 get_stat64(&hw_stats->rx_octets);
7448         stats->tx_bytes = old_stats->tx_bytes +
7449                 get_stat64(&hw_stats->tx_octets);
7450
7451         stats->rx_errors = old_stats->rx_errors +
7452                 get_stat64(&hw_stats->rx_errors);
7453         stats->tx_errors = old_stats->tx_errors +
7454                 get_stat64(&hw_stats->tx_errors) +
7455                 get_stat64(&hw_stats->tx_mac_errors) +
7456                 get_stat64(&hw_stats->tx_carrier_sense_errors) +
7457                 get_stat64(&hw_stats->tx_discards);
7458
7459         stats->multicast = old_stats->multicast +
7460                 get_stat64(&hw_stats->rx_mcast_packets);
7461         stats->collisions = old_stats->collisions +
7462                 get_stat64(&hw_stats->tx_collisions);
7463
7464         stats->rx_length_errors = old_stats->rx_length_errors +
7465                 get_stat64(&hw_stats->rx_frame_too_long_errors) +
7466                 get_stat64(&hw_stats->rx_undersize_packets);
7467
7468         stats->rx_over_errors = old_stats->rx_over_errors +
7469                 get_stat64(&hw_stats->rxbds_empty);
7470         stats->rx_frame_errors = old_stats->rx_frame_errors +
7471                 get_stat64(&hw_stats->rx_align_errors);
7472         stats->tx_aborted_errors = old_stats->tx_aborted_errors +
7473                 get_stat64(&hw_stats->tx_discards);
7474         stats->tx_carrier_errors = old_stats->tx_carrier_errors +
7475                 get_stat64(&hw_stats->tx_carrier_sense_errors);
7476
7477         stats->rx_crc_errors = old_stats->rx_crc_errors +
7478                 calc_crc_errors(tp);
7479
7480         stats->rx_missed_errors = old_stats->rx_missed_errors +
7481                 get_stat64(&hw_stats->rx_discards);
7482
7483         return stats;
7484 }
7485
7486 static inline u32 calc_crc(unsigned char *buf, int len)
7487 {
7488         u32 reg;
7489         u32 tmp;
7490         int j, k;
7491
7492         reg = 0xffffffff;
7493
7494         for (j = 0; j < len; j++) {
7495                 reg ^= buf[j];
7496
7497                 for (k = 0; k < 8; k++) {
7498                         tmp = reg & 0x01;
7499
7500                         reg >>= 1;
7501
7502                         if (tmp) {
7503                                 reg ^= 0xedb88320;
7504                         }
7505                 }
7506         }
7507
7508         return ~reg;
7509 }
7510
7511 static void tg3_set_multi(struct tg3 *tp, unsigned int accept_all)
7512 {
7513         /* accept or reject all multicast frames */
7514         tw32(MAC_HASH_REG_0, accept_all ? 0xffffffff : 0);
7515         tw32(MAC_HASH_REG_1, accept_all ? 0xffffffff : 0);
7516         tw32(MAC_HASH_REG_2, accept_all ? 0xffffffff : 0);
7517         tw32(MAC_HASH_REG_3, accept_all ? 0xffffffff : 0);
7518 }
7519
7520 static void __tg3_set_rx_mode(struct net_device *dev)
7521 {
7522         struct tg3 *tp = netdev_priv(dev);
7523         u32 rx_mode;
7524
7525         rx_mode = tp->rx_mode & ~(RX_MODE_PROMISC |
7526                                   RX_MODE_KEEP_VLAN_TAG);
7527
7528         /* When ASF is in use, we always keep the RX_MODE_KEEP_VLAN_TAG
7529          * flag clear.
7530          */
7531 #if TG3_VLAN_TAG_USED
7532         if (!tp->vlgrp &&
7533             !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
7534                 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
7535 #else
7536         /* By definition, VLAN is disabled always in this
7537          * case.
7538          */
7539         if (!(tp->tg3_flags & TG3_FLAG_ENABLE_ASF))
7540                 rx_mode |= RX_MODE_KEEP_VLAN_TAG;
7541 #endif
7542
7543         if (dev->flags & IFF_PROMISC) {
7544                 /* Promiscuous mode. */
7545                 rx_mode |= RX_MODE_PROMISC;
7546         } else if (dev->flags & IFF_ALLMULTI) {
7547                 /* Accept all multicast. */
7548                 tg3_set_multi (tp, 1);
7549         } else if (dev->mc_count < 1) {
7550                 /* Reject all multicast. */
7551                 tg3_set_multi (tp, 0);
7552         } else {
7553                 /* Accept one or more multicast(s). */
7554                 struct dev_mc_list *mclist;
7555                 unsigned int i;
7556                 u32 mc_filter[4] = { 0, };
7557                 u32 regidx;
7558                 u32 bit;
7559                 u32 crc;
7560
7561                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
7562                      i++, mclist = mclist->next) {
7563
7564                         crc = calc_crc (mclist->dmi_addr, ETH_ALEN);
7565                         bit = ~crc & 0x7f;
7566                         regidx = (bit & 0x60) >> 5;
7567                         bit &= 0x1f;
7568                         mc_filter[regidx] |= (1 << bit);
7569                 }
7570
7571                 tw32(MAC_HASH_REG_0, mc_filter[0]);
7572                 tw32(MAC_HASH_REG_1, mc_filter[1]);
7573                 tw32(MAC_HASH_REG_2, mc_filter[2]);
7574                 tw32(MAC_HASH_REG_3, mc_filter[3]);
7575         }
7576
7577         if (rx_mode != tp->rx_mode) {
7578                 tp->rx_mode = rx_mode;
7579                 tw32_f(MAC_RX_MODE, rx_mode);
7580                 udelay(10);
7581         }
7582 }
7583
7584 static void tg3_set_rx_mode(struct net_device *dev)
7585 {
7586         struct tg3 *tp = netdev_priv(dev);
7587
7588         if (!netif_running(dev))
7589                 return;
7590
7591         tg3_full_lock(tp, 0);
7592         __tg3_set_rx_mode(dev);
7593         tg3_full_unlock(tp);
7594 }
7595
7596 #define TG3_REGDUMP_LEN         (32 * 1024)
7597
7598 static int tg3_get_regs_len(struct net_device *dev)
7599 {
7600         return TG3_REGDUMP_LEN;
7601 }
7602
7603 static void tg3_get_regs(struct net_device *dev,
7604                 struct ethtool_regs *regs, void *_p)
7605 {
7606         u32 *p = _p;
7607         struct tg3 *tp = netdev_priv(dev);
7608         u8 *orig_p = _p;
7609         int i;
7610
7611         regs->version = 0;
7612
7613         memset(p, 0, TG3_REGDUMP_LEN);
7614
7615         if (tp->link_config.phy_is_low_power)
7616                 return;
7617
7618         tg3_full_lock(tp, 0);
7619
7620 #define __GET_REG32(reg)        (*(p)++ = tr32(reg))
7621 #define GET_REG32_LOOP(base,len)                \
7622 do {    p = (u32 *)(orig_p + (base));           \
7623         for (i = 0; i < len; i += 4)            \
7624                 __GET_REG32((base) + i);        \
7625 } while (0)
7626 #define GET_REG32_1(reg)                        \
7627 do {    p = (u32 *)(orig_p + (reg));            \
7628         __GET_REG32((reg));                     \
7629 } while (0)
7630
7631         GET_REG32_LOOP(TG3PCI_VENDOR, 0xb0);
7632         GET_REG32_LOOP(MAILBOX_INTERRUPT_0, 0x200);
7633         GET_REG32_LOOP(MAC_MODE, 0x4f0);
7634         GET_REG32_LOOP(SNDDATAI_MODE, 0xe0);
7635         GET_REG32_1(SNDDATAC_MODE);
7636         GET_REG32_LOOP(SNDBDS_MODE, 0x80);
7637         GET_REG32_LOOP(SNDBDI_MODE, 0x48);
7638         GET_REG32_1(SNDBDC_MODE);
7639         GET_REG32_LOOP(RCVLPC_MODE, 0x20);
7640         GET_REG32_LOOP(RCVLPC_SELLST_BASE, 0x15c);
7641         GET_REG32_LOOP(RCVDBDI_MODE, 0x0c);
7642         GET_REG32_LOOP(RCVDBDI_JUMBO_BD, 0x3c);
7643         GET_REG32_LOOP(RCVDBDI_BD_PROD_IDX_0, 0x44);
7644         GET_REG32_1(RCVDCC_MODE);
7645         GET_REG32_LOOP(RCVBDI_MODE, 0x20);
7646         GET_REG32_LOOP(RCVCC_MODE, 0x14);
7647         GET_REG32_LOOP(RCVLSC_MODE, 0x08);
7648         GET_REG32_1(MBFREE_MODE);
7649         GET_REG32_LOOP(HOSTCC_MODE, 0x100);
7650         GET_REG32_LOOP(MEMARB_MODE, 0x10);
7651         GET_REG32_LOOP(BUFMGR_MODE, 0x58);
7652         GET_REG32_LOOP(RDMAC_MODE, 0x08);
7653         GET_REG32_LOOP(WDMAC_MODE, 0x08);
7654         GET_REG32_1(RX_CPU_MODE);
7655         GET_REG32_1(RX_CPU_STATE);
7656         GET_REG32_1(RX_CPU_PGMCTR);
7657         GET_REG32_1(RX_CPU_HWBKPT);
7658         GET_REG32_1(TX_CPU_MODE);
7659         GET_REG32_1(TX_CPU_STATE);
7660         GET_REG32_1(TX_CPU_PGMCTR);
7661         GET_REG32_LOOP(GRCMBOX_INTERRUPT_0, 0x110);
7662         GET_REG32_LOOP(FTQ_RESET, 0x120);
7663         GET_REG32_LOOP(MSGINT_MODE, 0x0c);
7664         GET_REG32_1(DMAC_MODE);
7665         GET_REG32_LOOP(GRC_MODE, 0x4c);
7666         if (tp->tg3_flags & TG3_FLAG_NVRAM)
7667                 GET_REG32_LOOP(NVRAM_CMD, 0x24);
7668
7669 #undef __GET_REG32
7670 #undef GET_REG32_LOOP
7671 #undef GET_REG32_1
7672
7673         tg3_full_unlock(tp);
7674 }
7675
7676 static int tg3_get_eeprom_len(struct net_device *dev)
7677 {
7678         struct tg3 *tp = netdev_priv(dev);
7679
7680         return tp->nvram_size;
7681 }
7682
7683 static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val);
7684 static int tg3_nvram_read_swab(struct tg3 *tp, u32 offset, u32 *val);
7685
7686 static int tg3_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
7687 {
7688         struct tg3 *tp = netdev_priv(dev);
7689         int ret;
7690         u8  *pd;
7691         u32 i, offset, len, val, b_offset, b_count;
7692
7693         if (tp->link_config.phy_is_low_power)
7694                 return -EAGAIN;
7695
7696         offset = eeprom->offset;
7697         len = eeprom->len;
7698         eeprom->len = 0;
7699
7700         eeprom->magic = TG3_EEPROM_MAGIC;
7701
7702         if (offset & 3) {
7703                 /* adjustments to start on required 4 byte boundary */
7704                 b_offset = offset & 3;
7705                 b_count = 4 - b_offset;
7706                 if (b_count > len) {
7707                         /* i.e. offset=1 len=2 */
7708                         b_count = len;
7709                 }
7710                 ret = tg3_nvram_read(tp, offset-b_offset, &val);
7711                 if (ret)
7712                         return ret;
7713                 val = cpu_to_le32(val);
7714                 memcpy(data, ((char*)&val) + b_offset, b_count);
7715                 len -= b_count;
7716                 offset += b_count;
7717                 eeprom->len += b_count;
7718         }
7719
7720         /* read bytes upto the last 4 byte boundary */
7721         pd = &data[eeprom->len];
7722         for (i = 0; i < (len - (len & 3)); i += 4) {
7723                 ret = tg3_nvram_read(tp, offset + i, &val);
7724                 if (ret) {
7725                         eeprom->len += i;
7726                         return ret;
7727                 }
7728                 val = cpu_to_le32(val);
7729                 memcpy(pd + i, &val, 4);
7730         }
7731         eeprom->len += i;
7732
7733         if (len & 3) {
7734                 /* read last bytes not ending on 4 byte boundary */
7735                 pd = &data[eeprom->len];
7736                 b_count = len & 3;
7737                 b_offset = offset + len - b_count;
7738                 ret = tg3_nvram_read(tp, b_offset, &val);
7739                 if (ret)
7740                         return ret;
7741                 val = cpu_to_le32(val);
7742                 memcpy(pd, ((char*)&val), b_count);
7743                 eeprom->len += b_count;
7744         }
7745         return 0;
7746 }
7747
7748 static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf);
7749
7750 static int tg3_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, u8 *data)
7751 {
7752         struct tg3 *tp = netdev_priv(dev);
7753         int ret;
7754         u32 offset, len, b_offset, odd_len, start, end;
7755         u8 *buf;
7756
7757         if (tp->link_config.phy_is_low_power)
7758                 return -EAGAIN;
7759
7760         if (eeprom->magic != TG3_EEPROM_MAGIC)
7761                 return -EINVAL;
7762
7763         offset = eeprom->offset;
7764         len = eeprom->len;
7765
7766         if ((b_offset = (offset & 3))) {
7767                 /* adjustments to start on required 4 byte boundary */
7768                 ret = tg3_nvram_read(tp, offset-b_offset, &start);
7769                 if (ret)
7770                         return ret;
7771                 start = cpu_to_le32(start);
7772                 len += b_offset;
7773                 offset &= ~3;
7774                 if (len < 4)
7775                         len = 4;
7776         }
7777
7778         odd_len = 0;
7779         if (len & 3) {
7780                 /* adjustments to end on required 4 byte boundary */
7781                 odd_len = 1;
7782                 len = (len + 3) & ~3;
7783                 ret = tg3_nvram_read(tp, offset+len-4, &end);
7784                 if (ret)
7785                         return ret;
7786                 end = cpu_to_le32(end);
7787         }
7788
7789         buf = data;
7790         if (b_offset || odd_len) {
7791                 buf = kmalloc(len, GFP_KERNEL);
7792                 if (buf == 0)
7793                         return -ENOMEM;
7794                 if (b_offset)
7795                         memcpy(buf, &start, 4);
7796                 if (odd_len)
7797                         memcpy(buf+len-4, &end, 4);
7798                 memcpy(buf + b_offset, data, eeprom->len);
7799         }
7800
7801         ret = tg3_nvram_write_block(tp, offset, len, buf);
7802
7803         if (buf != data)
7804                 kfree(buf);
7805
7806         return ret;
7807 }
7808
7809 static int tg3_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7810 {
7811         struct tg3 *tp = netdev_priv(dev);
7812
7813         cmd->supported = (SUPPORTED_Autoneg);
7814
7815         if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
7816                 cmd->supported |= (SUPPORTED_1000baseT_Half |
7817                                    SUPPORTED_1000baseT_Full);
7818
7819         if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)) {
7820                 cmd->supported |= (SUPPORTED_100baseT_Half |
7821                                   SUPPORTED_100baseT_Full |
7822                                   SUPPORTED_10baseT_Half |
7823                                   SUPPORTED_10baseT_Full |
7824                                   SUPPORTED_MII);
7825                 cmd->port = PORT_TP;
7826         } else {
7827                 cmd->supported |= SUPPORTED_FIBRE;
7828                 cmd->port = PORT_FIBRE;
7829         }
7830
7831         cmd->advertising = tp->link_config.advertising;
7832         if (netif_running(dev)) {
7833                 cmd->speed = tp->link_config.active_speed;
7834                 cmd->duplex = tp->link_config.active_duplex;
7835         }
7836         cmd->phy_address = PHY_ADDR;
7837         cmd->transceiver = 0;
7838         cmd->autoneg = tp->link_config.autoneg;
7839         cmd->maxtxpkt = 0;
7840         cmd->maxrxpkt = 0;
7841         return 0;
7842 }
7843
7844 static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
7845 {
7846         struct tg3 *tp = netdev_priv(dev);
7847
7848         if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) {
7849                 /* These are the only valid advertisement bits allowed.  */
7850                 if (cmd->autoneg == AUTONEG_ENABLE &&
7851                     (cmd->advertising & ~(ADVERTISED_1000baseT_Half |
7852                                           ADVERTISED_1000baseT_Full |
7853                                           ADVERTISED_Autoneg |
7854                                           ADVERTISED_FIBRE)))
7855                         return -EINVAL;
7856                 /* Fiber can only do SPEED_1000.  */
7857                 else if ((cmd->autoneg != AUTONEG_ENABLE) &&
7858                          (cmd->speed != SPEED_1000))
7859                         return -EINVAL;
7860         /* Copper cannot force SPEED_1000.  */
7861         } else if ((cmd->autoneg != AUTONEG_ENABLE) &&
7862                    (cmd->speed == SPEED_1000))
7863                 return -EINVAL;
7864         else if ((cmd->speed == SPEED_1000) &&
7865                  (tp->tg3_flags2 & TG3_FLAG_10_100_ONLY))
7866                 return -EINVAL;
7867
7868         tg3_full_lock(tp, 0);
7869
7870         tp->link_config.autoneg = cmd->autoneg;
7871         if (cmd->autoneg == AUTONEG_ENABLE) {
7872                 tp->link_config.advertising = cmd->advertising;
7873                 tp->link_config.speed = SPEED_INVALID;
7874                 tp->link_config.duplex = DUPLEX_INVALID;
7875         } else {
7876                 tp->link_config.advertising = 0;
7877                 tp->link_config.speed = cmd->speed;
7878                 tp->link_config.duplex = cmd->duplex;
7879         }
7880
7881         if (netif_running(dev))
7882                 tg3_setup_phy(tp, 1);
7883
7884         tg3_full_unlock(tp);
7885
7886         return 0;
7887 }
7888
7889 static void tg3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
7890 {
7891         struct tg3 *tp = netdev_priv(dev);
7892
7893         strcpy(info->driver, DRV_MODULE_NAME);
7894         strcpy(info->version, DRV_MODULE_VERSION);
7895         strcpy(info->fw_version, tp->fw_ver);
7896         strcpy(info->bus_info, pci_name(tp->pdev));
7897 }
7898
7899 static void tg3_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7900 {
7901         struct tg3 *tp = netdev_priv(dev);
7902
7903         wol->supported = WAKE_MAGIC;
7904         wol->wolopts = 0;
7905         if (tp->tg3_flags & TG3_FLAG_WOL_ENABLE)
7906                 wol->wolopts = WAKE_MAGIC;
7907         memset(&wol->sopass, 0, sizeof(wol->sopass));
7908 }
7909
7910 static int tg3_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
7911 {
7912         struct tg3 *tp = netdev_priv(dev);
7913
7914         if (wol->wolopts & ~WAKE_MAGIC)
7915                 return -EINVAL;
7916         if ((wol->wolopts & WAKE_MAGIC) &&
7917             tp->tg3_flags2 & TG3_FLG2_PHY_SERDES &&
7918             !(tp->tg3_flags & TG3_FLAG_SERDES_WOL_CAP))
7919                 return -EINVAL;
7920
7921         spin_lock_bh(&tp->lock);
7922         if (wol->wolopts & WAKE_MAGIC)
7923                 tp->tg3_flags |= TG3_FLAG_WOL_ENABLE;
7924         else
7925                 tp->tg3_flags &= ~TG3_FLAG_WOL_ENABLE;
7926         spin_unlock_bh(&tp->lock);
7927
7928         return 0;
7929 }
7930
7931 static u32 tg3_get_msglevel(struct net_device *dev)
7932 {
7933         struct tg3 *tp = netdev_priv(dev);
7934         return tp->msg_enable;
7935 }
7936
7937 static void tg3_set_msglevel(struct net_device *dev, u32 value)
7938 {
7939         struct tg3 *tp = netdev_priv(dev);
7940         tp->msg_enable = value;
7941 }
7942
7943 #if TG3_TSO_SUPPORT != 0
7944 static int tg3_set_tso(struct net_device *dev, u32 value)
7945 {
7946         struct tg3 *tp = netdev_priv(dev);
7947
7948         if (!(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
7949                 if (value)
7950                         return -EINVAL;
7951                 return 0;
7952         }
7953         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) {
7954                 if (value)
7955                         dev->features |= NETIF_F_TSO6;
7956                 else
7957                         dev->features &= ~NETIF_F_TSO6;
7958         }
7959         return ethtool_op_set_tso(dev, value);
7960 }
7961 #endif
7962
7963 static int tg3_nway_reset(struct net_device *dev)
7964 {
7965         struct tg3 *tp = netdev_priv(dev);
7966         u32 bmcr;
7967         int r;
7968
7969         if (!netif_running(dev))
7970                 return -EAGAIN;
7971
7972         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
7973                 return -EINVAL;
7974
7975         spin_lock_bh(&tp->lock);
7976         r = -EINVAL;
7977         tg3_readphy(tp, MII_BMCR, &bmcr);
7978         if (!tg3_readphy(tp, MII_BMCR, &bmcr) &&
7979             ((bmcr & BMCR_ANENABLE) ||
7980              (tp->tg3_flags2 & TG3_FLG2_PARALLEL_DETECT))) {
7981                 tg3_writephy(tp, MII_BMCR, bmcr | BMCR_ANRESTART |
7982                                            BMCR_ANENABLE);
7983                 r = 0;
7984         }
7985         spin_unlock_bh(&tp->lock);
7986
7987         return r;
7988 }
7989
7990 static void tg3_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
7991 {
7992         struct tg3 *tp = netdev_priv(dev);
7993
7994         ering->rx_max_pending = TG3_RX_RING_SIZE - 1;
7995         ering->rx_mini_max_pending = 0;
7996         if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE)
7997                 ering->rx_jumbo_max_pending = TG3_RX_JUMBO_RING_SIZE - 1;
7998         else
7999                 ering->rx_jumbo_max_pending = 0;
8000
8001         ering->tx_max_pending = TG3_TX_RING_SIZE - 1;
8002
8003         ering->rx_pending = tp->rx_pending;
8004         ering->rx_mini_pending = 0;
8005         if (tp->tg3_flags & TG3_FLAG_JUMBO_RING_ENABLE)
8006                 ering->rx_jumbo_pending = tp->rx_jumbo_pending;
8007         else
8008                 ering->rx_jumbo_pending = 0;
8009
8010         ering->tx_pending = tp->tx_pending;
8011 }
8012
8013 static int tg3_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ering)
8014 {
8015         struct tg3 *tp = netdev_priv(dev);
8016         int irq_sync = 0, err = 0;
8017
8018         if ((ering->rx_pending > TG3_RX_RING_SIZE - 1) ||
8019             (ering->rx_jumbo_pending > TG3_RX_JUMBO_RING_SIZE - 1) ||
8020             (ering->tx_pending > TG3_TX_RING_SIZE - 1))
8021                 return -EINVAL;
8022
8023         if (netif_running(dev)) {
8024                 tg3_netif_stop(tp);
8025                 irq_sync = 1;
8026         }
8027
8028         tg3_full_lock(tp, irq_sync);
8029
8030         tp->rx_pending = ering->rx_pending;
8031
8032         if ((tp->tg3_flags2 & TG3_FLG2_MAX_RXPEND_64) &&
8033             tp->rx_pending > 63)
8034                 tp->rx_pending = 63;
8035         tp->rx_jumbo_pending = ering->rx_jumbo_pending;
8036         tp->tx_pending = ering->tx_pending;
8037
8038         if (netif_running(dev)) {
8039                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8040                 err = tg3_restart_hw(tp, 1);
8041                 if (!err)
8042                         tg3_netif_start(tp);
8043         }
8044
8045         tg3_full_unlock(tp);
8046
8047         return err;
8048 }
8049
8050 static void tg3_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
8051 {
8052         struct tg3 *tp = netdev_priv(dev);
8053
8054         epause->autoneg = (tp->tg3_flags & TG3_FLAG_PAUSE_AUTONEG) != 0;
8055         epause->rx_pause = (tp->tg3_flags & TG3_FLAG_RX_PAUSE) != 0;
8056         epause->tx_pause = (tp->tg3_flags & TG3_FLAG_TX_PAUSE) != 0;
8057 }
8058
8059 static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
8060 {
8061         struct tg3 *tp = netdev_priv(dev);
8062         int irq_sync = 0, err = 0;
8063
8064         if (netif_running(dev)) {
8065                 tg3_netif_stop(tp);
8066                 irq_sync = 1;
8067         }
8068
8069         tg3_full_lock(tp, irq_sync);
8070
8071         if (epause->autoneg)
8072                 tp->tg3_flags |= TG3_FLAG_PAUSE_AUTONEG;
8073         else
8074                 tp->tg3_flags &= ~TG3_FLAG_PAUSE_AUTONEG;
8075         if (epause->rx_pause)
8076                 tp->tg3_flags |= TG3_FLAG_RX_PAUSE;
8077         else
8078                 tp->tg3_flags &= ~TG3_FLAG_RX_PAUSE;
8079         if (epause->tx_pause)
8080                 tp->tg3_flags |= TG3_FLAG_TX_PAUSE;
8081         else
8082                 tp->tg3_flags &= ~TG3_FLAG_TX_PAUSE;
8083
8084         if (netif_running(dev)) {
8085                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8086                 err = tg3_restart_hw(tp, 1);
8087                 if (!err)
8088                         tg3_netif_start(tp);
8089         }
8090
8091         tg3_full_unlock(tp);
8092
8093         return err;
8094 }
8095
8096 static u32 tg3_get_rx_csum(struct net_device *dev)
8097 {
8098         struct tg3 *tp = netdev_priv(dev);
8099         return (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0;
8100 }
8101
8102 static int tg3_set_rx_csum(struct net_device *dev, u32 data)
8103 {
8104         struct tg3 *tp = netdev_priv(dev);
8105
8106         if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
8107                 if (data != 0)
8108                         return -EINVAL;
8109                 return 0;
8110         }
8111
8112         spin_lock_bh(&tp->lock);
8113         if (data)
8114                 tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
8115         else
8116                 tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
8117         spin_unlock_bh(&tp->lock);
8118
8119         return 0;
8120 }
8121
8122 static int tg3_set_tx_csum(struct net_device *dev, u32 data)
8123 {
8124         struct tg3 *tp = netdev_priv(dev);
8125
8126         if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
8127                 if (data != 0)
8128                         return -EINVAL;
8129                 return 0;
8130         }
8131
8132         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
8133             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
8134                 ethtool_op_set_tx_hw_csum(dev, data);
8135         else
8136                 ethtool_op_set_tx_csum(dev, data);
8137
8138         return 0;
8139 }
8140
8141 static int tg3_get_stats_count (struct net_device *dev)
8142 {
8143         return TG3_NUM_STATS;
8144 }
8145
8146 static int tg3_get_test_count (struct net_device *dev)
8147 {
8148         return TG3_NUM_TEST;
8149 }
8150
8151 static void tg3_get_strings (struct net_device *dev, u32 stringset, u8 *buf)
8152 {
8153         switch (stringset) {
8154         case ETH_SS_STATS:
8155                 memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
8156                 break;
8157         case ETH_SS_TEST:
8158                 memcpy(buf, &ethtool_test_keys, sizeof(ethtool_test_keys));
8159                 break;
8160         default:
8161                 WARN_ON(1);     /* we need a WARN() */
8162                 break;
8163         }
8164 }
8165
8166 static int tg3_phys_id(struct net_device *dev, u32 data)
8167 {
8168         struct tg3 *tp = netdev_priv(dev);
8169         int i;
8170
8171         if (!netif_running(tp->dev))
8172                 return -EAGAIN;
8173
8174         if (data == 0)
8175                 data = 2;
8176
8177         for (i = 0; i < (data * 2); i++) {
8178                 if ((i % 2) == 0)
8179                         tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
8180                                            LED_CTRL_1000MBPS_ON |
8181                                            LED_CTRL_100MBPS_ON |
8182                                            LED_CTRL_10MBPS_ON |
8183                                            LED_CTRL_TRAFFIC_OVERRIDE |
8184                                            LED_CTRL_TRAFFIC_BLINK |
8185                                            LED_CTRL_TRAFFIC_LED);
8186
8187                 else
8188                         tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
8189                                            LED_CTRL_TRAFFIC_OVERRIDE);
8190
8191                 if (msleep_interruptible(500))
8192                         break;
8193         }
8194         tw32(MAC_LED_CTRL, tp->led_ctrl);
8195         return 0;
8196 }
8197
8198 static void tg3_get_ethtool_stats (struct net_device *dev,
8199                                    struct ethtool_stats *estats, u64 *tmp_stats)
8200 {
8201         struct tg3 *tp = netdev_priv(dev);
8202         memcpy(tmp_stats, tg3_get_estats(tp), sizeof(tp->estats));
8203 }
8204
8205 #define NVRAM_TEST_SIZE 0x100
8206 #define NVRAM_SELFBOOT_FORMAT1_SIZE 0x14
8207
8208 static int tg3_test_nvram(struct tg3 *tp)
8209 {
8210         u32 *buf, csum, magic;
8211         int i, j, err = 0, size;
8212
8213         if (tg3_nvram_read_swab(tp, 0, &magic) != 0)
8214                 return -EIO;
8215
8216         if (magic == TG3_EEPROM_MAGIC)
8217                 size = NVRAM_TEST_SIZE;
8218         else if ((magic & 0xff000000) == 0xa5000000) {
8219                 if ((magic & 0xe00000) == 0x200000)
8220                         size = NVRAM_SELFBOOT_FORMAT1_SIZE;
8221                 else
8222                         return 0;
8223         } else
8224                 return -EIO;
8225
8226         buf = kmalloc(size, GFP_KERNEL);
8227         if (buf == NULL)
8228                 return -ENOMEM;
8229
8230         err = -EIO;
8231         for (i = 0, j = 0; i < size; i += 4, j++) {
8232                 u32 val;
8233
8234                 if ((err = tg3_nvram_read(tp, i, &val)) != 0)
8235                         break;
8236                 buf[j] = cpu_to_le32(val);
8237         }
8238         if (i < size)
8239                 goto out;
8240
8241         /* Selfboot format */
8242         if (cpu_to_be32(buf[0]) != TG3_EEPROM_MAGIC) {
8243                 u8 *buf8 = (u8 *) buf, csum8 = 0;
8244
8245                 for (i = 0; i < size; i++)
8246                         csum8 += buf8[i];
8247
8248                 if (csum8 == 0) {
8249                         err = 0;
8250                         goto out;
8251                 }
8252
8253                 err = -EIO;
8254                 goto out;
8255         }
8256
8257         /* Bootstrap checksum at offset 0x10 */
8258         csum = calc_crc((unsigned char *) buf, 0x10);
8259         if(csum != cpu_to_le32(buf[0x10/4]))
8260                 goto out;
8261
8262         /* Manufacturing block starts at offset 0x74, checksum at 0xfc */
8263         csum = calc_crc((unsigned char *) &buf[0x74/4], 0x88);
8264         if (csum != cpu_to_le32(buf[0xfc/4]))
8265                  goto out;
8266
8267         err = 0;
8268
8269 out:
8270         kfree(buf);
8271         return err;
8272 }
8273
8274 #define TG3_SERDES_TIMEOUT_SEC  2
8275 #define TG3_COPPER_TIMEOUT_SEC  6
8276
8277 static int tg3_test_link(struct tg3 *tp)
8278 {
8279         int i, max;
8280
8281         if (!netif_running(tp->dev))
8282                 return -ENODEV;
8283
8284         if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)
8285                 max = TG3_SERDES_TIMEOUT_SEC;
8286         else
8287                 max = TG3_COPPER_TIMEOUT_SEC;
8288
8289         for (i = 0; i < max; i++) {
8290                 if (netif_carrier_ok(tp->dev))
8291                         return 0;
8292
8293                 if (msleep_interruptible(1000))
8294                         break;
8295         }
8296
8297         return -EIO;
8298 }
8299
8300 /* Only test the commonly used registers */
8301 static int tg3_test_registers(struct tg3 *tp)
8302 {
8303         int i, is_5705;
8304         u32 offset, read_mask, write_mask, val, save_val, read_val;
8305         static struct {
8306                 u16 offset;
8307                 u16 flags;
8308 #define TG3_FL_5705     0x1
8309 #define TG3_FL_NOT_5705 0x2
8310 #define TG3_FL_NOT_5788 0x4
8311                 u32 read_mask;
8312                 u32 write_mask;
8313         } reg_tbl[] = {
8314                 /* MAC Control Registers */
8315                 { MAC_MODE, TG3_FL_NOT_5705,
8316                         0x00000000, 0x00ef6f8c },
8317                 { MAC_MODE, TG3_FL_5705,
8318                         0x00000000, 0x01ef6b8c },
8319                 { MAC_STATUS, TG3_FL_NOT_5705,
8320                         0x03800107, 0x00000000 },
8321                 { MAC_STATUS, TG3_FL_5705,
8322                         0x03800100, 0x00000000 },
8323                 { MAC_ADDR_0_HIGH, 0x0000,
8324                         0x00000000, 0x0000ffff },
8325                 { MAC_ADDR_0_LOW, 0x0000,
8326                         0x00000000, 0xffffffff },
8327                 { MAC_RX_MTU_SIZE, 0x0000,
8328                         0x00000000, 0x0000ffff },
8329                 { MAC_TX_MODE, 0x0000,
8330                         0x00000000, 0x00000070 },
8331                 { MAC_TX_LENGTHS, 0x0000,
8332                         0x00000000, 0x00003fff },
8333                 { MAC_RX_MODE, TG3_FL_NOT_5705,
8334                         0x00000000, 0x000007fc },
8335                 { MAC_RX_MODE, TG3_FL_5705,
8336                         0x00000000, 0x000007dc },
8337                 { MAC_HASH_REG_0, 0x0000,
8338                         0x00000000, 0xffffffff },
8339                 { MAC_HASH_REG_1, 0x0000,
8340                         0x00000000, 0xffffffff },
8341                 { MAC_HASH_REG_2, 0x0000,
8342                         0x00000000, 0xffffffff },
8343                 { MAC_HASH_REG_3, 0x0000,
8344                         0x00000000, 0xffffffff },
8345
8346                 /* Receive Data and Receive BD Initiator Control Registers. */
8347                 { RCVDBDI_JUMBO_BD+0, TG3_FL_NOT_5705,
8348                         0x00000000, 0xffffffff },
8349                 { RCVDBDI_JUMBO_BD+4, TG3_FL_NOT_5705,
8350                         0x00000000, 0xffffffff },
8351                 { RCVDBDI_JUMBO_BD+8, TG3_FL_NOT_5705,
8352                         0x00000000, 0x00000003 },
8353                 { RCVDBDI_JUMBO_BD+0xc, TG3_FL_NOT_5705,
8354                         0x00000000, 0xffffffff },
8355                 { RCVDBDI_STD_BD+0, 0x0000,
8356                         0x00000000, 0xffffffff },
8357                 { RCVDBDI_STD_BD+4, 0x0000,
8358                         0x00000000, 0xffffffff },
8359                 { RCVDBDI_STD_BD+8, 0x0000,
8360                         0x00000000, 0xffff0002 },
8361                 { RCVDBDI_STD_BD+0xc, 0x0000,
8362                         0x00000000, 0xffffffff },
8363
8364                 /* Receive BD Initiator Control Registers. */
8365                 { RCVBDI_STD_THRESH, TG3_FL_NOT_5705,
8366                         0x00000000, 0xffffffff },
8367                 { RCVBDI_STD_THRESH, TG3_FL_5705,
8368                         0x00000000, 0x000003ff },
8369                 { RCVBDI_JUMBO_THRESH, TG3_FL_NOT_5705,
8370                         0x00000000, 0xffffffff },
8371
8372                 /* Host Coalescing Control Registers. */
8373                 { HOSTCC_MODE, TG3_FL_NOT_5705,
8374                         0x00000000, 0x00000004 },
8375                 { HOSTCC_MODE, TG3_FL_5705,
8376                         0x00000000, 0x000000f6 },
8377                 { HOSTCC_RXCOL_TICKS, TG3_FL_NOT_5705,
8378                         0x00000000, 0xffffffff },
8379                 { HOSTCC_RXCOL_TICKS, TG3_FL_5705,
8380                         0x00000000, 0x000003ff },
8381                 { HOSTCC_TXCOL_TICKS, TG3_FL_NOT_5705,
8382                         0x00000000, 0xffffffff },
8383                 { HOSTCC_TXCOL_TICKS, TG3_FL_5705,
8384                         0x00000000, 0x000003ff },
8385                 { HOSTCC_RXMAX_FRAMES, TG3_FL_NOT_5705,
8386                         0x00000000, 0xffffffff },
8387                 { HOSTCC_RXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
8388                         0x00000000, 0x000000ff },
8389                 { HOSTCC_TXMAX_FRAMES, TG3_FL_NOT_5705,
8390                         0x00000000, 0xffffffff },
8391                 { HOSTCC_TXMAX_FRAMES, TG3_FL_5705 | TG3_FL_NOT_5788,
8392                         0x00000000, 0x000000ff },
8393                 { HOSTCC_RXCOAL_TICK_INT, TG3_FL_NOT_5705,
8394                         0x00000000, 0xffffffff },
8395                 { HOSTCC_TXCOAL_TICK_INT, TG3_FL_NOT_5705,
8396                         0x00000000, 0xffffffff },
8397                 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_NOT_5705,
8398                         0x00000000, 0xffffffff },
8399                 { HOSTCC_RXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
8400                         0x00000000, 0x000000ff },
8401                 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_NOT_5705,
8402                         0x00000000, 0xffffffff },
8403                 { HOSTCC_TXCOAL_MAXF_INT, TG3_FL_5705 | TG3_FL_NOT_5788,
8404                         0x00000000, 0x000000ff },
8405                 { HOSTCC_STAT_COAL_TICKS, TG3_FL_NOT_5705,
8406                         0x00000000, 0xffffffff },
8407                 { HOSTCC_STATS_BLK_HOST_ADDR, TG3_FL_NOT_5705,
8408                         0x00000000, 0xffffffff },
8409                 { HOSTCC_STATS_BLK_HOST_ADDR+4, TG3_FL_NOT_5705,
8410                         0x00000000, 0xffffffff },
8411                 { HOSTCC_STATUS_BLK_HOST_ADDR, 0x0000,
8412                         0x00000000, 0xffffffff },
8413                 { HOSTCC_STATUS_BLK_HOST_ADDR+4, 0x0000,
8414                         0x00000000, 0xffffffff },
8415                 { HOSTCC_STATS_BLK_NIC_ADDR, 0x0000,
8416                         0xffffffff, 0x00000000 },
8417                 { HOSTCC_STATUS_BLK_NIC_ADDR, 0x0000,
8418                         0xffffffff, 0x00000000 },
8419
8420                 /* Buffer Manager Control Registers. */
8421                 { BUFMGR_MB_POOL_ADDR, 0x0000,
8422                         0x00000000, 0x007fff80 },
8423                 { BUFMGR_MB_POOL_SIZE, 0x0000,
8424                         0x00000000, 0x007fffff },
8425                 { BUFMGR_MB_RDMA_LOW_WATER, 0x0000,
8426                         0x00000000, 0x0000003f },
8427                 { BUFMGR_MB_MACRX_LOW_WATER, 0x0000,
8428                         0x00000000, 0x000001ff },
8429                 { BUFMGR_MB_HIGH_WATER, 0x0000,
8430                         0x00000000, 0x000001ff },
8431                 { BUFMGR_DMA_DESC_POOL_ADDR, TG3_FL_NOT_5705,
8432                         0xffffffff, 0x00000000 },
8433                 { BUFMGR_DMA_DESC_POOL_SIZE, TG3_FL_NOT_5705,
8434                         0xffffffff, 0x00000000 },
8435
8436                 /* Mailbox Registers */
8437                 { GRCMBOX_RCVSTD_PROD_IDX+4, 0x0000,
8438                         0x00000000, 0x000001ff },
8439                 { GRCMBOX_RCVJUMBO_PROD_IDX+4, TG3_FL_NOT_5705,
8440                         0x00000000, 0x000001ff },
8441                 { GRCMBOX_RCVRET_CON_IDX_0+4, 0x0000,
8442                         0x00000000, 0x000007ff },
8443                 { GRCMBOX_SNDHOST_PROD_IDX_0+4, 0x0000,
8444                         0x00000000, 0x000001ff },
8445
8446                 { 0xffff, 0x0000, 0x00000000, 0x00000000 },
8447         };
8448
8449         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
8450                 is_5705 = 1;
8451         else
8452                 is_5705 = 0;
8453
8454         for (i = 0; reg_tbl[i].offset != 0xffff; i++) {
8455                 if (is_5705 && (reg_tbl[i].flags & TG3_FL_NOT_5705))
8456                         continue;
8457
8458                 if (!is_5705 && (reg_tbl[i].flags & TG3_FL_5705))
8459                         continue;
8460
8461                 if ((tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
8462                     (reg_tbl[i].flags & TG3_FL_NOT_5788))
8463                         continue;
8464
8465                 offset = (u32) reg_tbl[i].offset;
8466                 read_mask = reg_tbl[i].read_mask;
8467                 write_mask = reg_tbl[i].write_mask;
8468
8469                 /* Save the original register content */
8470                 save_val = tr32(offset);
8471
8472                 /* Determine the read-only value. */
8473                 read_val = save_val & read_mask;
8474
8475                 /* Write zero to the register, then make sure the read-only bits
8476                  * are not changed and the read/write bits are all zeros.
8477                  */
8478                 tw32(offset, 0);
8479
8480                 val = tr32(offset);
8481
8482                 /* Test the read-only and read/write bits. */
8483                 if (((val & read_mask) != read_val) || (val & write_mask))
8484                         goto out;
8485
8486                 /* Write ones to all the bits defined by RdMask and WrMask, then
8487                  * make sure the read-only bits are not changed and the
8488                  * read/write bits are all ones.
8489                  */
8490                 tw32(offset, read_mask | write_mask);
8491
8492                 val = tr32(offset);
8493
8494                 /* Test the read-only bits. */
8495                 if ((val & read_mask) != read_val)
8496                         goto out;
8497
8498                 /* Test the read/write bits. */
8499                 if ((val & write_mask) != write_mask)
8500                         goto out;
8501
8502                 tw32(offset, save_val);
8503         }
8504
8505         return 0;
8506
8507 out:
8508         printk(KERN_ERR PFX "Register test failed at offset %x\n", offset);
8509         tw32(offset, save_val);
8510         return -EIO;
8511 }
8512
8513 static int tg3_do_mem_test(struct tg3 *tp, u32 offset, u32 len)
8514 {
8515         static const u32 test_pattern[] = { 0x00000000, 0xffffffff, 0xaa55a55a };
8516         int i;
8517         u32 j;
8518
8519         for (i = 0; i < sizeof(test_pattern)/sizeof(u32); i++) {
8520                 for (j = 0; j < len; j += 4) {
8521                         u32 val;
8522
8523                         tg3_write_mem(tp, offset + j, test_pattern[i]);
8524                         tg3_read_mem(tp, offset + j, &val);
8525                         if (val != test_pattern[i])
8526                                 return -EIO;
8527                 }
8528         }
8529         return 0;
8530 }
8531
8532 static int tg3_test_memory(struct tg3 *tp)
8533 {
8534         static struct mem_entry {
8535                 u32 offset;
8536                 u32 len;
8537         } mem_tbl_570x[] = {
8538                 { 0x00000000, 0x00b50},
8539                 { 0x00002000, 0x1c000},
8540                 { 0xffffffff, 0x00000}
8541         }, mem_tbl_5705[] = {
8542                 { 0x00000100, 0x0000c},
8543                 { 0x00000200, 0x00008},
8544                 { 0x00004000, 0x00800},
8545                 { 0x00006000, 0x01000},
8546                 { 0x00008000, 0x02000},
8547                 { 0x00010000, 0x0e000},
8548                 { 0xffffffff, 0x00000}
8549         }, mem_tbl_5755[] = {
8550                 { 0x00000200, 0x00008},
8551                 { 0x00004000, 0x00800},
8552                 { 0x00006000, 0x00800},
8553                 { 0x00008000, 0x02000},
8554                 { 0x00010000, 0x0c000},
8555                 { 0xffffffff, 0x00000}
8556         };
8557         struct mem_entry *mem_tbl;
8558         int err = 0;
8559         int i;
8560
8561         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
8562                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
8563                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
8564                         mem_tbl = mem_tbl_5755;
8565                 else
8566                         mem_tbl = mem_tbl_5705;
8567         } else
8568                 mem_tbl = mem_tbl_570x;
8569
8570         for (i = 0; mem_tbl[i].offset != 0xffffffff; i++) {
8571                 if ((err = tg3_do_mem_test(tp, mem_tbl[i].offset,
8572                     mem_tbl[i].len)) != 0)
8573                         break;
8574         }
8575
8576         return err;
8577 }
8578
8579 #define TG3_MAC_LOOPBACK        0
8580 #define TG3_PHY_LOOPBACK        1
8581
8582 static int tg3_run_loopback(struct tg3 *tp, int loopback_mode)
8583 {
8584         u32 mac_mode, rx_start_idx, rx_idx, tx_idx, opaque_key;
8585         u32 desc_idx;
8586         struct sk_buff *skb, *rx_skb;
8587         u8 *tx_data;
8588         dma_addr_t map;
8589         int num_pkts, tx_len, rx_len, i, err;
8590         struct tg3_rx_buffer_desc *desc;
8591
8592         if (loopback_mode == TG3_MAC_LOOPBACK) {
8593                 /* HW errata - mac loopback fails in some cases on 5780.
8594                  * Normal traffic and PHY loopback are not affected by
8595                  * errata.
8596                  */
8597                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780)
8598                         return 0;
8599
8600                 mac_mode = (tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK) |
8601                            MAC_MODE_PORT_INT_LPBACK | MAC_MODE_LINK_POLARITY |
8602                            MAC_MODE_PORT_MODE_GMII;
8603                 tw32(MAC_MODE, mac_mode);
8604         } else if (loopback_mode == TG3_PHY_LOOPBACK) {
8605                 tg3_writephy(tp, MII_BMCR, BMCR_LOOPBACK | BMCR_FULLDPLX |
8606                                            BMCR_SPEED1000);
8607                 udelay(40);
8608                 /* reset to prevent losing 1st rx packet intermittently */
8609                 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES) {
8610                         tw32_f(MAC_RX_MODE, RX_MODE_RESET);
8611                         udelay(10);
8612                         tw32_f(MAC_RX_MODE, tp->rx_mode);
8613                 }
8614                 mac_mode = (tp->mac_mode & ~MAC_MODE_PORT_MODE_MASK) |
8615                            MAC_MODE_LINK_POLARITY | MAC_MODE_PORT_MODE_GMII;
8616                 if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
8617                         mac_mode &= ~MAC_MODE_LINK_POLARITY;
8618                         tg3_writephy(tp, MII_TG3_EXT_CTRL,
8619                                      MII_TG3_EXT_CTRL_LNK3_LED_MODE);
8620                 }
8621                 tw32(MAC_MODE, mac_mode);
8622         }
8623         else
8624                 return -EINVAL;
8625
8626         err = -EIO;
8627
8628         tx_len = 1514;
8629         skb = netdev_alloc_skb(tp->dev, tx_len);
8630         if (!skb)
8631                 return -ENOMEM;
8632
8633         tx_data = skb_put(skb, tx_len);
8634         memcpy(tx_data, tp->dev->dev_addr, 6);
8635         memset(tx_data + 6, 0x0, 8);
8636
8637         tw32(MAC_RX_MTU_SIZE, tx_len + 4);
8638
8639         for (i = 14; i < tx_len; i++)
8640                 tx_data[i] = (u8) (i & 0xff);
8641
8642         map = pci_map_single(tp->pdev, skb->data, tx_len, PCI_DMA_TODEVICE);
8643
8644         tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
8645              HOSTCC_MODE_NOW);
8646
8647         udelay(10);
8648
8649         rx_start_idx = tp->hw_status->idx[0].rx_producer;
8650
8651         num_pkts = 0;
8652
8653         tg3_set_txd(tp, tp->tx_prod, map, tx_len, 0, 1);
8654
8655         tp->tx_prod++;
8656         num_pkts++;
8657
8658         tw32_tx_mbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW,
8659                      tp->tx_prod);
8660         tr32_mailbox(MAILBOX_SNDHOST_PROD_IDX_0 + TG3_64BIT_REG_LOW);
8661
8662         udelay(10);
8663
8664         for (i = 0; i < 10; i++) {
8665                 tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
8666                        HOSTCC_MODE_NOW);
8667
8668                 udelay(10);
8669
8670                 tx_idx = tp->hw_status->idx[0].tx_consumer;
8671                 rx_idx = tp->hw_status->idx[0].rx_producer;
8672                 if ((tx_idx == tp->tx_prod) &&
8673                     (rx_idx == (rx_start_idx + num_pkts)))
8674                         break;
8675         }
8676
8677         pci_unmap_single(tp->pdev, map, tx_len, PCI_DMA_TODEVICE);
8678         dev_kfree_skb(skb);
8679
8680         if (tx_idx != tp->tx_prod)
8681                 goto out;
8682
8683         if (rx_idx != rx_start_idx + num_pkts)
8684                 goto out;
8685
8686         desc = &tp->rx_rcb[rx_start_idx];
8687         desc_idx = desc->opaque & RXD_OPAQUE_INDEX_MASK;
8688         opaque_key = desc->opaque & RXD_OPAQUE_RING_MASK;
8689         if (opaque_key != RXD_OPAQUE_RING_STD)
8690                 goto out;
8691
8692         if ((desc->err_vlan & RXD_ERR_MASK) != 0 &&
8693             (desc->err_vlan != RXD_ERR_ODD_NIBBLE_RCVD_MII))
8694                 goto out;
8695
8696         rx_len = ((desc->idx_len & RXD_LEN_MASK) >> RXD_LEN_SHIFT) - 4;
8697         if (rx_len != tx_len)
8698                 goto out;
8699
8700         rx_skb = tp->rx_std_buffers[desc_idx].skb;
8701
8702         map = pci_unmap_addr(&tp->rx_std_buffers[desc_idx], mapping);
8703         pci_dma_sync_single_for_cpu(tp->pdev, map, rx_len, PCI_DMA_FROMDEVICE);
8704
8705         for (i = 14; i < tx_len; i++) {
8706                 if (*(rx_skb->data + i) != (u8) (i & 0xff))
8707                         goto out;
8708         }
8709         err = 0;
8710
8711         /* tg3_free_rings will unmap and free the rx_skb */
8712 out:
8713         return err;
8714 }
8715
8716 #define TG3_MAC_LOOPBACK_FAILED         1
8717 #define TG3_PHY_LOOPBACK_FAILED         2
8718 #define TG3_LOOPBACK_FAILED             (TG3_MAC_LOOPBACK_FAILED |      \
8719                                          TG3_PHY_LOOPBACK_FAILED)
8720
8721 static int tg3_test_loopback(struct tg3 *tp)
8722 {
8723         int err = 0;
8724
8725         if (!netif_running(tp->dev))
8726                 return TG3_LOOPBACK_FAILED;
8727
8728         err = tg3_reset_hw(tp, 1);
8729         if (err)
8730                 return TG3_LOOPBACK_FAILED;
8731
8732         if (tg3_run_loopback(tp, TG3_MAC_LOOPBACK))
8733                 err |= TG3_MAC_LOOPBACK_FAILED;
8734         if (!(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
8735                 if (tg3_run_loopback(tp, TG3_PHY_LOOPBACK))
8736                         err |= TG3_PHY_LOOPBACK_FAILED;
8737         }
8738
8739         return err;
8740 }
8741
8742 static void tg3_self_test(struct net_device *dev, struct ethtool_test *etest,
8743                           u64 *data)
8744 {
8745         struct tg3 *tp = netdev_priv(dev);
8746
8747         if (tp->link_config.phy_is_low_power)
8748                 tg3_set_power_state(tp, PCI_D0);
8749
8750         memset(data, 0, sizeof(u64) * TG3_NUM_TEST);
8751
8752         if (tg3_test_nvram(tp) != 0) {
8753                 etest->flags |= ETH_TEST_FL_FAILED;
8754                 data[0] = 1;
8755         }
8756         if (tg3_test_link(tp) != 0) {
8757                 etest->flags |= ETH_TEST_FL_FAILED;
8758                 data[1] = 1;
8759         }
8760         if (etest->flags & ETH_TEST_FL_OFFLINE) {
8761                 int err, irq_sync = 0;
8762
8763                 if (netif_running(dev)) {
8764                         tg3_netif_stop(tp);
8765                         irq_sync = 1;
8766                 }
8767
8768                 tg3_full_lock(tp, irq_sync);
8769
8770                 tg3_halt(tp, RESET_KIND_SUSPEND, 1);
8771                 err = tg3_nvram_lock(tp);
8772                 tg3_halt_cpu(tp, RX_CPU_BASE);
8773                 if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
8774                         tg3_halt_cpu(tp, TX_CPU_BASE);
8775                 if (!err)
8776                         tg3_nvram_unlock(tp);
8777
8778                 if (tp->tg3_flags2 & TG3_FLG2_MII_SERDES)
8779                         tg3_phy_reset(tp);
8780
8781                 if (tg3_test_registers(tp) != 0) {
8782                         etest->flags |= ETH_TEST_FL_FAILED;
8783                         data[2] = 1;
8784                 }
8785                 if (tg3_test_memory(tp) != 0) {
8786                         etest->flags |= ETH_TEST_FL_FAILED;
8787                         data[3] = 1;
8788                 }
8789                 if ((data[4] = tg3_test_loopback(tp)) != 0)
8790                         etest->flags |= ETH_TEST_FL_FAILED;
8791
8792                 tg3_full_unlock(tp);
8793
8794                 if (tg3_test_interrupt(tp) != 0) {
8795                         etest->flags |= ETH_TEST_FL_FAILED;
8796                         data[5] = 1;
8797                 }
8798
8799                 tg3_full_lock(tp, 0);
8800
8801                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
8802                 if (netif_running(dev)) {
8803                         tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
8804                         if (!tg3_restart_hw(tp, 1))
8805                                 tg3_netif_start(tp);
8806                 }
8807
8808                 tg3_full_unlock(tp);
8809         }
8810         if (tp->link_config.phy_is_low_power)
8811                 tg3_set_power_state(tp, PCI_D3hot);
8812
8813 }
8814
8815 static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
8816 {
8817         struct mii_ioctl_data *data = if_mii(ifr);
8818         struct tg3 *tp = netdev_priv(dev);
8819         int err;
8820
8821         switch(cmd) {
8822         case SIOCGMIIPHY:
8823                 data->phy_id = PHY_ADDR;
8824
8825                 /* fallthru */
8826         case SIOCGMIIREG: {
8827                 u32 mii_regval;
8828
8829                 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
8830                         break;                  /* We have no PHY */
8831
8832                 if (tp->link_config.phy_is_low_power)
8833                         return -EAGAIN;
8834
8835                 spin_lock_bh(&tp->lock);
8836                 err = tg3_readphy(tp, data->reg_num & 0x1f, &mii_regval);
8837                 spin_unlock_bh(&tp->lock);
8838
8839                 data->val_out = mii_regval;
8840
8841                 return err;
8842         }
8843
8844         case SIOCSMIIREG:
8845                 if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
8846                         break;                  /* We have no PHY */
8847
8848                 if (!capable(CAP_NET_ADMIN))
8849                         return -EPERM;
8850
8851                 if (tp->link_config.phy_is_low_power)
8852                         return -EAGAIN;
8853
8854                 spin_lock_bh(&tp->lock);
8855                 err = tg3_writephy(tp, data->reg_num & 0x1f, data->val_in);
8856                 spin_unlock_bh(&tp->lock);
8857
8858                 return err;
8859
8860         default:
8861                 /* do nothing */
8862                 break;
8863         }
8864         return -EOPNOTSUPP;
8865 }
8866
8867 #if TG3_VLAN_TAG_USED
8868 static void tg3_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
8869 {
8870         struct tg3 *tp = netdev_priv(dev);
8871
8872         if (netif_running(dev))
8873                 tg3_netif_stop(tp);
8874
8875         tg3_full_lock(tp, 0);
8876
8877         tp->vlgrp = grp;
8878
8879         /* Update RX_MODE_KEEP_VLAN_TAG bit in RX_MODE register. */
8880         __tg3_set_rx_mode(dev);
8881
8882         tg3_full_unlock(tp);
8883
8884         if (netif_running(dev))
8885                 tg3_netif_start(tp);
8886 }
8887
8888 static void tg3_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
8889 {
8890         struct tg3 *tp = netdev_priv(dev);
8891
8892         if (netif_running(dev))
8893                 tg3_netif_stop(tp);
8894
8895         tg3_full_lock(tp, 0);
8896         if (tp->vlgrp)
8897                 tp->vlgrp->vlan_devices[vid] = NULL;
8898         tg3_full_unlock(tp);
8899
8900         if (netif_running(dev))
8901                 tg3_netif_start(tp);
8902 }
8903 #endif
8904
8905 static int tg3_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
8906 {
8907         struct tg3 *tp = netdev_priv(dev);
8908
8909         memcpy(ec, &tp->coal, sizeof(*ec));
8910         return 0;
8911 }
8912
8913 static int tg3_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
8914 {
8915         struct tg3 *tp = netdev_priv(dev);
8916         u32 max_rxcoal_tick_int = 0, max_txcoal_tick_int = 0;
8917         u32 max_stat_coal_ticks = 0, min_stat_coal_ticks = 0;
8918
8919         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
8920                 max_rxcoal_tick_int = MAX_RXCOAL_TICK_INT;
8921                 max_txcoal_tick_int = MAX_TXCOAL_TICK_INT;
8922                 max_stat_coal_ticks = MAX_STAT_COAL_TICKS;
8923                 min_stat_coal_ticks = MIN_STAT_COAL_TICKS;
8924         }
8925
8926         if ((ec->rx_coalesce_usecs > MAX_RXCOL_TICKS) ||
8927             (ec->tx_coalesce_usecs > MAX_TXCOL_TICKS) ||
8928             (ec->rx_max_coalesced_frames > MAX_RXMAX_FRAMES) ||
8929             (ec->tx_max_coalesced_frames > MAX_TXMAX_FRAMES) ||
8930             (ec->rx_coalesce_usecs_irq > max_rxcoal_tick_int) ||
8931             (ec->tx_coalesce_usecs_irq > max_txcoal_tick_int) ||
8932             (ec->rx_max_coalesced_frames_irq > MAX_RXCOAL_MAXF_INT) ||
8933             (ec->tx_max_coalesced_frames_irq > MAX_TXCOAL_MAXF_INT) ||
8934             (ec->stats_block_coalesce_usecs > max_stat_coal_ticks) ||
8935             (ec->stats_block_coalesce_usecs < min_stat_coal_ticks))
8936                 return -EINVAL;
8937
8938         /* No rx interrupts will be generated if both are zero */
8939         if ((ec->rx_coalesce_usecs == 0) &&
8940             (ec->rx_max_coalesced_frames == 0))
8941                 return -EINVAL;
8942
8943         /* No tx interrupts will be generated if both are zero */
8944         if ((ec->tx_coalesce_usecs == 0) &&
8945             (ec->tx_max_coalesced_frames == 0))
8946                 return -EINVAL;
8947
8948         /* Only copy relevant parameters, ignore all others. */
8949         tp->coal.rx_coalesce_usecs = ec->rx_coalesce_usecs;
8950         tp->coal.tx_coalesce_usecs = ec->tx_coalesce_usecs;
8951         tp->coal.rx_max_coalesced_frames = ec->rx_max_coalesced_frames;
8952         tp->coal.tx_max_coalesced_frames = ec->tx_max_coalesced_frames;
8953         tp->coal.rx_coalesce_usecs_irq = ec->rx_coalesce_usecs_irq;
8954         tp->coal.tx_coalesce_usecs_irq = ec->tx_coalesce_usecs_irq;
8955         tp->coal.rx_max_coalesced_frames_irq = ec->rx_max_coalesced_frames_irq;
8956         tp->coal.tx_max_coalesced_frames_irq = ec->tx_max_coalesced_frames_irq;
8957         tp->coal.stats_block_coalesce_usecs = ec->stats_block_coalesce_usecs;
8958
8959         if (netif_running(dev)) {
8960                 tg3_full_lock(tp, 0);
8961                 __tg3_set_coalesce(tp, &tp->coal);
8962                 tg3_full_unlock(tp);
8963         }
8964         return 0;
8965 }
8966
8967 static struct ethtool_ops tg3_ethtool_ops = {
8968         .get_settings           = tg3_get_settings,
8969         .set_settings           = tg3_set_settings,
8970         .get_drvinfo            = tg3_get_drvinfo,
8971         .get_regs_len           = tg3_get_regs_len,
8972         .get_regs               = tg3_get_regs,
8973         .get_wol                = tg3_get_wol,
8974         .set_wol                = tg3_set_wol,
8975         .get_msglevel           = tg3_get_msglevel,
8976         .set_msglevel           = tg3_set_msglevel,
8977         .nway_reset             = tg3_nway_reset,
8978         .get_link               = ethtool_op_get_link,
8979         .get_eeprom_len         = tg3_get_eeprom_len,
8980         .get_eeprom             = tg3_get_eeprom,
8981         .set_eeprom             = tg3_set_eeprom,
8982         .get_ringparam          = tg3_get_ringparam,
8983         .set_ringparam          = tg3_set_ringparam,
8984         .get_pauseparam         = tg3_get_pauseparam,
8985         .set_pauseparam         = tg3_set_pauseparam,
8986         .get_rx_csum            = tg3_get_rx_csum,
8987         .set_rx_csum            = tg3_set_rx_csum,
8988         .get_tx_csum            = ethtool_op_get_tx_csum,
8989         .set_tx_csum            = tg3_set_tx_csum,
8990         .get_sg                 = ethtool_op_get_sg,
8991         .set_sg                 = ethtool_op_set_sg,
8992 #if TG3_TSO_SUPPORT != 0
8993         .get_tso                = ethtool_op_get_tso,
8994         .set_tso                = tg3_set_tso,
8995 #endif
8996         .self_test_count        = tg3_get_test_count,
8997         .self_test              = tg3_self_test,
8998         .get_strings            = tg3_get_strings,
8999         .phys_id                = tg3_phys_id,
9000         .get_stats_count        = tg3_get_stats_count,
9001         .get_ethtool_stats      = tg3_get_ethtool_stats,
9002         .get_coalesce           = tg3_get_coalesce,
9003         .set_coalesce           = tg3_set_coalesce,
9004         .get_perm_addr          = ethtool_op_get_perm_addr,
9005 };
9006
9007 static void __devinit tg3_get_eeprom_size(struct tg3 *tp)
9008 {
9009         u32 cursize, val, magic;
9010
9011         tp->nvram_size = EEPROM_CHIP_SIZE;
9012
9013         if (tg3_nvram_read_swab(tp, 0, &magic) != 0)
9014                 return;
9015
9016         if ((magic != TG3_EEPROM_MAGIC) && ((magic & 0xff000000) != 0xa5000000))
9017                 return;
9018
9019         /*
9020          * Size the chip by reading offsets at increasing powers of two.
9021          * When we encounter our validation signature, we know the addressing
9022          * has wrapped around, and thus have our chip size.
9023          */
9024         cursize = 0x10;
9025
9026         while (cursize < tp->nvram_size) {
9027                 if (tg3_nvram_read_swab(tp, cursize, &val) != 0)
9028                         return;
9029
9030                 if (val == magic)
9031                         break;
9032
9033                 cursize <<= 1;
9034         }
9035
9036         tp->nvram_size = cursize;
9037 }
9038
9039 static void __devinit tg3_get_nvram_size(struct tg3 *tp)
9040 {
9041         u32 val;
9042
9043         if (tg3_nvram_read_swab(tp, 0, &val) != 0)
9044                 return;
9045
9046         /* Selfboot format */
9047         if (val != TG3_EEPROM_MAGIC) {
9048                 tg3_get_eeprom_size(tp);
9049                 return;
9050         }
9051
9052         if (tg3_nvram_read(tp, 0xf0, &val) == 0) {
9053                 if (val != 0) {
9054                         tp->nvram_size = (val >> 16) * 1024;
9055                         return;
9056                 }
9057         }
9058         tp->nvram_size = 0x20000;
9059 }
9060
9061 static void __devinit tg3_get_nvram_info(struct tg3 *tp)
9062 {
9063         u32 nvcfg1;
9064
9065         nvcfg1 = tr32(NVRAM_CFG1);
9066         if (nvcfg1 & NVRAM_CFG1_FLASHIF_ENAB) {
9067                 tp->tg3_flags2 |= TG3_FLG2_FLASH;
9068         }
9069         else {
9070                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
9071                 tw32(NVRAM_CFG1, nvcfg1);
9072         }
9073
9074         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) ||
9075             (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
9076                 switch (nvcfg1 & NVRAM_CFG1_VENDOR_MASK) {
9077                         case FLASH_VENDOR_ATMEL_FLASH_BUFFERED:
9078                                 tp->nvram_jedecnum = JEDEC_ATMEL;
9079                                 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
9080                                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9081                                 break;
9082                         case FLASH_VENDOR_ATMEL_FLASH_UNBUFFERED:
9083                                 tp->nvram_jedecnum = JEDEC_ATMEL;
9084                                 tp->nvram_pagesize = ATMEL_AT25F512_PAGE_SIZE;
9085                                 break;
9086                         case FLASH_VENDOR_ATMEL_EEPROM:
9087                                 tp->nvram_jedecnum = JEDEC_ATMEL;
9088                                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
9089                                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9090                                 break;
9091                         case FLASH_VENDOR_ST:
9092                                 tp->nvram_jedecnum = JEDEC_ST;
9093                                 tp->nvram_pagesize = ST_M45PEX0_PAGE_SIZE;
9094                                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9095                                 break;
9096                         case FLASH_VENDOR_SAIFUN:
9097                                 tp->nvram_jedecnum = JEDEC_SAIFUN;
9098                                 tp->nvram_pagesize = SAIFUN_SA25F0XX_PAGE_SIZE;
9099                                 break;
9100                         case FLASH_VENDOR_SST_SMALL:
9101                         case FLASH_VENDOR_SST_LARGE:
9102                                 tp->nvram_jedecnum = JEDEC_SST;
9103                                 tp->nvram_pagesize = SST_25VF0X0_PAGE_SIZE;
9104                                 break;
9105                 }
9106         }
9107         else {
9108                 tp->nvram_jedecnum = JEDEC_ATMEL;
9109                 tp->nvram_pagesize = ATMEL_AT45DB0X1B_PAGE_SIZE;
9110                 tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9111         }
9112 }
9113
9114 static void __devinit tg3_get_5752_nvram_info(struct tg3 *tp)
9115 {
9116         u32 nvcfg1;
9117
9118         nvcfg1 = tr32(NVRAM_CFG1);
9119
9120         /* NVRAM protection for TPM */
9121         if (nvcfg1 & (1 << 27))
9122                 tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
9123
9124         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
9125                 case FLASH_5752VENDOR_ATMEL_EEPROM_64KHZ:
9126                 case FLASH_5752VENDOR_ATMEL_EEPROM_376KHZ:
9127                         tp->nvram_jedecnum = JEDEC_ATMEL;
9128                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9129                         break;
9130                 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
9131                         tp->nvram_jedecnum = JEDEC_ATMEL;
9132                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9133                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
9134                         break;
9135                 case FLASH_5752VENDOR_ST_M45PE10:
9136                 case FLASH_5752VENDOR_ST_M45PE20:
9137                 case FLASH_5752VENDOR_ST_M45PE40:
9138                         tp->nvram_jedecnum = JEDEC_ST;
9139                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9140                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
9141                         break;
9142         }
9143
9144         if (tp->tg3_flags2 & TG3_FLG2_FLASH) {
9145                 switch (nvcfg1 & NVRAM_CFG1_5752PAGE_SIZE_MASK) {
9146                         case FLASH_5752PAGE_SIZE_256:
9147                                 tp->nvram_pagesize = 256;
9148                                 break;
9149                         case FLASH_5752PAGE_SIZE_512:
9150                                 tp->nvram_pagesize = 512;
9151                                 break;
9152                         case FLASH_5752PAGE_SIZE_1K:
9153                                 tp->nvram_pagesize = 1024;
9154                                 break;
9155                         case FLASH_5752PAGE_SIZE_2K:
9156                                 tp->nvram_pagesize = 2048;
9157                                 break;
9158                         case FLASH_5752PAGE_SIZE_4K:
9159                                 tp->nvram_pagesize = 4096;
9160                                 break;
9161                         case FLASH_5752PAGE_SIZE_264:
9162                                 tp->nvram_pagesize = 264;
9163                                 break;
9164                 }
9165         }
9166         else {
9167                 /* For eeprom, set pagesize to maximum eeprom size */
9168                 tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
9169
9170                 nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
9171                 tw32(NVRAM_CFG1, nvcfg1);
9172         }
9173 }
9174
9175 static void __devinit tg3_get_5755_nvram_info(struct tg3 *tp)
9176 {
9177         u32 nvcfg1;
9178
9179         nvcfg1 = tr32(NVRAM_CFG1);
9180
9181         /* NVRAM protection for TPM */
9182         if (nvcfg1 & (1 << 27))
9183                 tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
9184
9185         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
9186                 case FLASH_5755VENDOR_ATMEL_EEPROM_64KHZ:
9187                 case FLASH_5755VENDOR_ATMEL_EEPROM_376KHZ:
9188                         tp->nvram_jedecnum = JEDEC_ATMEL;
9189                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9190                         tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
9191
9192                         nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
9193                         tw32(NVRAM_CFG1, nvcfg1);
9194                         break;
9195                 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
9196                 case FLASH_5755VENDOR_ATMEL_FLASH_1:
9197                 case FLASH_5755VENDOR_ATMEL_FLASH_2:
9198                 case FLASH_5755VENDOR_ATMEL_FLASH_3:
9199                 case FLASH_5755VENDOR_ATMEL_FLASH_4:
9200                         tp->nvram_jedecnum = JEDEC_ATMEL;
9201                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9202                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
9203                         tp->nvram_pagesize = 264;
9204                         break;
9205                 case FLASH_5752VENDOR_ST_M45PE10:
9206                 case FLASH_5752VENDOR_ST_M45PE20:
9207                 case FLASH_5752VENDOR_ST_M45PE40:
9208                         tp->nvram_jedecnum = JEDEC_ST;
9209                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9210                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
9211                         tp->nvram_pagesize = 256;
9212                         break;
9213         }
9214 }
9215
9216 static void __devinit tg3_get_5787_nvram_info(struct tg3 *tp)
9217 {
9218         u32 nvcfg1;
9219
9220         nvcfg1 = tr32(NVRAM_CFG1);
9221
9222         switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
9223                 case FLASH_5787VENDOR_ATMEL_EEPROM_64KHZ:
9224                 case FLASH_5787VENDOR_ATMEL_EEPROM_376KHZ:
9225                 case FLASH_5787VENDOR_MICRO_EEPROM_64KHZ:
9226                 case FLASH_5787VENDOR_MICRO_EEPROM_376KHZ:
9227                         tp->nvram_jedecnum = JEDEC_ATMEL;
9228                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9229                         tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
9230
9231                         nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
9232                         tw32(NVRAM_CFG1, nvcfg1);
9233                         break;
9234                 case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
9235                 case FLASH_5755VENDOR_ATMEL_FLASH_1:
9236                 case FLASH_5755VENDOR_ATMEL_FLASH_2:
9237                 case FLASH_5755VENDOR_ATMEL_FLASH_3:
9238                         tp->nvram_jedecnum = JEDEC_ATMEL;
9239                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9240                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
9241                         tp->nvram_pagesize = 264;
9242                         break;
9243                 case FLASH_5752VENDOR_ST_M45PE10:
9244                 case FLASH_5752VENDOR_ST_M45PE20:
9245                 case FLASH_5752VENDOR_ST_M45PE40:
9246                         tp->nvram_jedecnum = JEDEC_ST;
9247                         tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
9248                         tp->tg3_flags2 |= TG3_FLG2_FLASH;
9249                         tp->nvram_pagesize = 256;
9250                         break;
9251         }
9252 }
9253
9254 /* Chips other than 5700/5701 use the NVRAM for fetching info. */
9255 static void __devinit tg3_nvram_init(struct tg3 *tp)
9256 {
9257         int j;
9258
9259         tw32_f(GRC_EEPROM_ADDR,
9260              (EEPROM_ADDR_FSM_RESET |
9261               (EEPROM_DEFAULT_CLOCK_PERIOD <<
9262                EEPROM_ADDR_CLKPERD_SHIFT)));
9263
9264         /* XXX schedule_timeout() ... */
9265         for (j = 0; j < 100; j++)
9266                 udelay(10);
9267
9268         /* Enable seeprom accesses. */
9269         tw32_f(GRC_LOCAL_CTRL,
9270              tr32(GRC_LOCAL_CTRL) | GRC_LCLCTRL_AUTO_SEEPROM);
9271         udelay(100);
9272
9273         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
9274             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) {
9275                 tp->tg3_flags |= TG3_FLAG_NVRAM;
9276
9277                 if (tg3_nvram_lock(tp)) {
9278                         printk(KERN_WARNING PFX "%s: Cannot get nvarm lock, "
9279                                "tg3_nvram_init failed.\n", tp->dev->name);
9280                         return;
9281                 }
9282                 tg3_enable_nvram_access(tp);
9283
9284                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
9285                         tg3_get_5752_nvram_info(tp);
9286                 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
9287                         tg3_get_5755_nvram_info(tp);
9288                 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
9289                         tg3_get_5787_nvram_info(tp);
9290                 else
9291                         tg3_get_nvram_info(tp);
9292
9293                 tg3_get_nvram_size(tp);
9294
9295                 tg3_disable_nvram_access(tp);
9296                 tg3_nvram_unlock(tp);
9297
9298         } else {
9299                 tp->tg3_flags &= ~(TG3_FLAG_NVRAM | TG3_FLAG_NVRAM_BUFFERED);
9300
9301                 tg3_get_eeprom_size(tp);
9302         }
9303 }
9304
9305 static int tg3_nvram_read_using_eeprom(struct tg3 *tp,
9306                                         u32 offset, u32 *val)
9307 {
9308         u32 tmp;
9309         int i;
9310
9311         if (offset > EEPROM_ADDR_ADDR_MASK ||
9312             (offset % 4) != 0)
9313                 return -EINVAL;
9314
9315         tmp = tr32(GRC_EEPROM_ADDR) & ~(EEPROM_ADDR_ADDR_MASK |
9316                                         EEPROM_ADDR_DEVID_MASK |
9317                                         EEPROM_ADDR_READ);
9318         tw32(GRC_EEPROM_ADDR,
9319              tmp |
9320              (0 << EEPROM_ADDR_DEVID_SHIFT) |
9321              ((offset << EEPROM_ADDR_ADDR_SHIFT) &
9322               EEPROM_ADDR_ADDR_MASK) |
9323              EEPROM_ADDR_READ | EEPROM_ADDR_START);
9324
9325         for (i = 0; i < 10000; i++) {
9326                 tmp = tr32(GRC_EEPROM_ADDR);
9327
9328                 if (tmp & EEPROM_ADDR_COMPLETE)
9329                         break;
9330                 udelay(100);
9331         }
9332         if (!(tmp & EEPROM_ADDR_COMPLETE))
9333                 return -EBUSY;
9334
9335         *val = tr32(GRC_EEPROM_DATA);
9336         return 0;
9337 }
9338
9339 #define NVRAM_CMD_TIMEOUT 10000
9340
9341 static int tg3_nvram_exec_cmd(struct tg3 *tp, u32 nvram_cmd)
9342 {
9343         int i;
9344
9345         tw32(NVRAM_CMD, nvram_cmd);
9346         for (i = 0; i < NVRAM_CMD_TIMEOUT; i++) {
9347                 udelay(10);
9348                 if (tr32(NVRAM_CMD) & NVRAM_CMD_DONE) {
9349                         udelay(10);
9350                         break;
9351                 }
9352         }
9353         if (i == NVRAM_CMD_TIMEOUT) {
9354                 return -EBUSY;
9355         }
9356         return 0;
9357 }
9358
9359 static u32 tg3_nvram_phys_addr(struct tg3 *tp, u32 addr)
9360 {
9361         if ((tp->tg3_flags & TG3_FLAG_NVRAM) &&
9362             (tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) &&
9363             (tp->tg3_flags2 & TG3_FLG2_FLASH) &&
9364             (tp->nvram_jedecnum == JEDEC_ATMEL))
9365
9366                 addr = ((addr / tp->nvram_pagesize) <<
9367                         ATMEL_AT45DB0X1B_PAGE_POS) +
9368                        (addr % tp->nvram_pagesize);
9369
9370         return addr;
9371 }
9372
9373 static u32 tg3_nvram_logical_addr(struct tg3 *tp, u32 addr)
9374 {
9375         if ((tp->tg3_flags & TG3_FLAG_NVRAM) &&
9376             (tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) &&
9377             (tp->tg3_flags2 & TG3_FLG2_FLASH) &&
9378             (tp->nvram_jedecnum == JEDEC_ATMEL))
9379
9380                 addr = ((addr >> ATMEL_AT45DB0X1B_PAGE_POS) *
9381                         tp->nvram_pagesize) +
9382                        (addr & ((1 << ATMEL_AT45DB0X1B_PAGE_POS) - 1));
9383
9384         return addr;
9385 }
9386
9387 static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
9388 {
9389         int ret;
9390
9391         if (!(tp->tg3_flags & TG3_FLAG_NVRAM))
9392                 return tg3_nvram_read_using_eeprom(tp, offset, val);
9393
9394         offset = tg3_nvram_phys_addr(tp, offset);
9395
9396         if (offset > NVRAM_ADDR_MSK)
9397                 return -EINVAL;
9398
9399         ret = tg3_nvram_lock(tp);
9400         if (ret)
9401                 return ret;
9402
9403         tg3_enable_nvram_access(tp);
9404
9405         tw32(NVRAM_ADDR, offset);
9406         ret = tg3_nvram_exec_cmd(tp, NVRAM_CMD_RD | NVRAM_CMD_GO |
9407                 NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_DONE);
9408
9409         if (ret == 0)
9410                 *val = swab32(tr32(NVRAM_RDDATA));
9411
9412         tg3_disable_nvram_access(tp);
9413
9414         tg3_nvram_unlock(tp);
9415
9416         return ret;
9417 }
9418
9419 static int tg3_nvram_read_swab(struct tg3 *tp, u32 offset, u32 *val)
9420 {
9421         int err;
9422         u32 tmp;
9423
9424         err = tg3_nvram_read(tp, offset, &tmp);
9425         *val = swab32(tmp);
9426         return err;
9427 }
9428
9429 static int tg3_nvram_write_block_using_eeprom(struct tg3 *tp,
9430                                     u32 offset, u32 len, u8 *buf)
9431 {
9432         int i, j, rc = 0;
9433         u32 val;
9434
9435         for (i = 0; i < len; i += 4) {
9436                 u32 addr, data;
9437
9438                 addr = offset + i;
9439
9440                 memcpy(&data, buf + i, 4);
9441
9442                 tw32(GRC_EEPROM_DATA, cpu_to_le32(data));
9443
9444                 val = tr32(GRC_EEPROM_ADDR);
9445                 tw32(GRC_EEPROM_ADDR, val | EEPROM_ADDR_COMPLETE);
9446
9447                 val &= ~(EEPROM_ADDR_ADDR_MASK | EEPROM_ADDR_DEVID_MASK |
9448                         EEPROM_ADDR_READ);
9449                 tw32(GRC_EEPROM_ADDR, val |
9450                         (0 << EEPROM_ADDR_DEVID_SHIFT) |
9451                         (addr & EEPROM_ADDR_ADDR_MASK) |
9452                         EEPROM_ADDR_START |
9453                         EEPROM_ADDR_WRITE);
9454
9455                 for (j = 0; j < 10000; j++) {
9456                         val = tr32(GRC_EEPROM_ADDR);
9457
9458                         if (val & EEPROM_ADDR_COMPLETE)
9459                                 break;
9460                         udelay(100);
9461                 }
9462                 if (!(val & EEPROM_ADDR_COMPLETE)) {
9463                         rc = -EBUSY;
9464                         break;
9465                 }
9466         }
9467
9468         return rc;
9469 }
9470
9471 /* offset and length are dword aligned */
9472 static int tg3_nvram_write_block_unbuffered(struct tg3 *tp, u32 offset, u32 len,
9473                 u8 *buf)
9474 {
9475         int ret = 0;
9476         u32 pagesize = tp->nvram_pagesize;
9477         u32 pagemask = pagesize - 1;
9478         u32 nvram_cmd;
9479         u8 *tmp;
9480
9481         tmp = kmalloc(pagesize, GFP_KERNEL);
9482         if (tmp == NULL)
9483                 return -ENOMEM;
9484
9485         while (len) {
9486                 int j;
9487                 u32 phy_addr, page_off, size;
9488
9489                 phy_addr = offset & ~pagemask;
9490
9491                 for (j = 0; j < pagesize; j += 4) {
9492                         if ((ret = tg3_nvram_read(tp, phy_addr + j,
9493                                                 (u32 *) (tmp + j))))
9494                                 break;
9495                 }
9496                 if (ret)
9497                         break;
9498
9499                 page_off = offset & pagemask;
9500                 size = pagesize;
9501                 if (len < size)
9502                         size = len;
9503
9504                 len -= size;
9505
9506                 memcpy(tmp + page_off, buf, size);
9507
9508                 offset = offset + (pagesize - page_off);
9509
9510                 tg3_enable_nvram_access(tp);
9511
9512                 /*
9513                  * Before we can erase the flash page, we need
9514                  * to issue a special "write enable" command.
9515                  */
9516                 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
9517
9518                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
9519                         break;
9520
9521                 /* Erase the target page */
9522                 tw32(NVRAM_ADDR, phy_addr);
9523
9524                 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR |
9525                         NVRAM_CMD_FIRST | NVRAM_CMD_LAST | NVRAM_CMD_ERASE;
9526
9527                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
9528                         break;
9529
9530                 /* Issue another write enable to start the write. */
9531                 nvram_cmd = NVRAM_CMD_WREN | NVRAM_CMD_GO | NVRAM_CMD_DONE;
9532
9533                 if (tg3_nvram_exec_cmd(tp, nvram_cmd))
9534                         break;
9535
9536                 for (j = 0; j < pagesize; j += 4) {
9537                         u32 data;
9538
9539                         data = *((u32 *) (tmp + j));
9540                         tw32(NVRAM_WRDATA, cpu_to_be32(data));
9541
9542                         tw32(NVRAM_ADDR, phy_addr + j);
9543
9544                         nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE |
9545                                 NVRAM_CMD_WR;
9546
9547                         if (j == 0)
9548                                 nvram_cmd |= NVRAM_CMD_FIRST;
9549                         else if (j == (pagesize - 4))
9550                                 nvram_cmd |= NVRAM_CMD_LAST;
9551
9552                         if ((ret = tg3_nvram_exec_cmd(tp, nvram_cmd)))
9553                                 break;
9554                 }
9555                 if (ret)
9556                         break;
9557         }
9558
9559         nvram_cmd = NVRAM_CMD_WRDI | NVRAM_CMD_GO | NVRAM_CMD_DONE;
9560         tg3_nvram_exec_cmd(tp, nvram_cmd);
9561
9562         kfree(tmp);
9563
9564         return ret;
9565 }
9566
9567 /* offset and length are dword aligned */
9568 static int tg3_nvram_write_block_buffered(struct tg3 *tp, u32 offset, u32 len,
9569                 u8 *buf)
9570 {
9571         int i, ret = 0;
9572
9573         for (i = 0; i < len; i += 4, offset += 4) {
9574                 u32 data, page_off, phy_addr, nvram_cmd;
9575
9576                 memcpy(&data, buf + i, 4);
9577                 tw32(NVRAM_WRDATA, cpu_to_be32(data));
9578
9579                 page_off = offset % tp->nvram_pagesize;
9580
9581                 phy_addr = tg3_nvram_phys_addr(tp, offset);
9582
9583                 tw32(NVRAM_ADDR, phy_addr);
9584
9585                 nvram_cmd = NVRAM_CMD_GO | NVRAM_CMD_DONE | NVRAM_CMD_WR;
9586
9587                 if ((page_off == 0) || (i == 0))
9588                         nvram_cmd |= NVRAM_CMD_FIRST;
9589                 if (page_off == (tp->nvram_pagesize - 4))
9590                         nvram_cmd |= NVRAM_CMD_LAST;
9591
9592                 if (i == (len - 4))
9593                         nvram_cmd |= NVRAM_CMD_LAST;
9594
9595                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752) &&
9596                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755) &&
9597                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787) &&
9598                     (tp->nvram_jedecnum == JEDEC_ST) &&
9599                     (nvram_cmd & NVRAM_CMD_FIRST)) {
9600
9601                         if ((ret = tg3_nvram_exec_cmd(tp,
9602                                 NVRAM_CMD_WREN | NVRAM_CMD_GO |
9603                                 NVRAM_CMD_DONE)))
9604
9605                                 break;
9606                 }
9607                 if (!(tp->tg3_flags2 & TG3_FLG2_FLASH)) {
9608                         /* We always do complete word writes to eeprom. */
9609                         nvram_cmd |= (NVRAM_CMD_FIRST | NVRAM_CMD_LAST);
9610                 }
9611
9612                 if ((ret = tg3_nvram_exec_cmd(tp, nvram_cmd)))
9613                         break;
9614         }
9615         return ret;
9616 }
9617
9618 /* offset and length are dword aligned */
9619 static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
9620 {
9621         int ret;
9622
9623         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
9624                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl &
9625                        ~GRC_LCLCTRL_GPIO_OUTPUT1);
9626                 udelay(40);
9627         }
9628
9629         if (!(tp->tg3_flags & TG3_FLAG_NVRAM)) {
9630                 ret = tg3_nvram_write_block_using_eeprom(tp, offset, len, buf);
9631         }
9632         else {
9633                 u32 grc_mode;
9634
9635                 ret = tg3_nvram_lock(tp);
9636                 if (ret)
9637                         return ret;
9638
9639                 tg3_enable_nvram_access(tp);
9640                 if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
9641                     !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM))
9642                         tw32(NVRAM_WRITE1, 0x406);
9643
9644                 grc_mode = tr32(GRC_MODE);
9645                 tw32(GRC_MODE, grc_mode | GRC_MODE_NVRAM_WR_ENABLE);
9646
9647                 if ((tp->tg3_flags & TG3_FLAG_NVRAM_BUFFERED) ||
9648                         !(tp->tg3_flags2 & TG3_FLG2_FLASH)) {
9649
9650                         ret = tg3_nvram_write_block_buffered(tp, offset, len,
9651                                 buf);
9652                 }
9653                 else {
9654                         ret = tg3_nvram_write_block_unbuffered(tp, offset, len,
9655                                 buf);
9656                 }
9657
9658                 grc_mode = tr32(GRC_MODE);
9659                 tw32(GRC_MODE, grc_mode & ~GRC_MODE_NVRAM_WR_ENABLE);
9660
9661                 tg3_disable_nvram_access(tp);
9662                 tg3_nvram_unlock(tp);
9663         }
9664
9665         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
9666                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
9667                 udelay(40);
9668         }
9669
9670         return ret;
9671 }
9672
9673 struct subsys_tbl_ent {
9674         u16 subsys_vendor, subsys_devid;
9675         u32 phy_id;
9676 };
9677
9678 static struct subsys_tbl_ent subsys_id_to_phy_id[] = {
9679         /* Broadcom boards. */
9680         { PCI_VENDOR_ID_BROADCOM, 0x1644, PHY_ID_BCM5401 }, /* BCM95700A6 */
9681         { PCI_VENDOR_ID_BROADCOM, 0x0001, PHY_ID_BCM5701 }, /* BCM95701A5 */
9682         { PCI_VENDOR_ID_BROADCOM, 0x0002, PHY_ID_BCM8002 }, /* BCM95700T6 */
9683         { PCI_VENDOR_ID_BROADCOM, 0x0003, 0 },              /* BCM95700A9 */
9684         { PCI_VENDOR_ID_BROADCOM, 0x0005, PHY_ID_BCM5701 }, /* BCM95701T1 */
9685         { PCI_VENDOR_ID_BROADCOM, 0x0006, PHY_ID_BCM5701 }, /* BCM95701T8 */
9686         { PCI_VENDOR_ID_BROADCOM, 0x0007, 0 },              /* BCM95701A7 */
9687         { PCI_VENDOR_ID_BROADCOM, 0x0008, PHY_ID_BCM5701 }, /* BCM95701A10 */
9688         { PCI_VENDOR_ID_BROADCOM, 0x8008, PHY_ID_BCM5701 }, /* BCM95701A12 */
9689         { PCI_VENDOR_ID_BROADCOM, 0x0009, PHY_ID_BCM5703 }, /* BCM95703Ax1 */
9690         { PCI_VENDOR_ID_BROADCOM, 0x8009, PHY_ID_BCM5703 }, /* BCM95703Ax2 */
9691
9692         /* 3com boards. */
9693         { PCI_VENDOR_ID_3COM, 0x1000, PHY_ID_BCM5401 }, /* 3C996T */
9694         { PCI_VENDOR_ID_3COM, 0x1006, PHY_ID_BCM5701 }, /* 3C996BT */
9695         { PCI_VENDOR_ID_3COM, 0x1004, 0 },              /* 3C996SX */
9696         { PCI_VENDOR_ID_3COM, 0x1007, PHY_ID_BCM5701 }, /* 3C1000T */
9697         { PCI_VENDOR_ID_3COM, 0x1008, PHY_ID_BCM5701 }, /* 3C940BR01 */
9698
9699         /* DELL boards. */
9700         { PCI_VENDOR_ID_DELL, 0x00d1, PHY_ID_BCM5401 }, /* VIPER */
9701         { PCI_VENDOR_ID_DELL, 0x0106, PHY_ID_BCM5401 }, /* JAGUAR */
9702         { PCI_VENDOR_ID_DELL, 0x0109, PHY_ID_BCM5411 }, /* MERLOT */
9703         { PCI_VENDOR_ID_DELL, 0x010a, PHY_ID_BCM5411 }, /* SLIM_MERLOT */
9704
9705         /* Compaq boards. */
9706         { PCI_VENDOR_ID_COMPAQ, 0x007c, PHY_ID_BCM5701 }, /* BANSHEE */
9707         { PCI_VENDOR_ID_COMPAQ, 0x009a, PHY_ID_BCM5701 }, /* BANSHEE_2 */
9708         { PCI_VENDOR_ID_COMPAQ, 0x007d, 0 },              /* CHANGELING */
9709         { PCI_VENDOR_ID_COMPAQ, 0x0085, PHY_ID_BCM5701 }, /* NC7780 */
9710         { PCI_VENDOR_ID_COMPAQ, 0x0099, PHY_ID_BCM5701 }, /* NC7780_2 */
9711
9712         /* IBM boards. */
9713         { PCI_VENDOR_ID_IBM, 0x0281, 0 } /* IBM??? */
9714 };
9715
9716 static inline struct subsys_tbl_ent *lookup_by_subsys(struct tg3 *tp)
9717 {
9718         int i;
9719
9720         for (i = 0; i < ARRAY_SIZE(subsys_id_to_phy_id); i++) {
9721                 if ((subsys_id_to_phy_id[i].subsys_vendor ==
9722                      tp->pdev->subsystem_vendor) &&
9723                     (subsys_id_to_phy_id[i].subsys_devid ==
9724                      tp->pdev->subsystem_device))
9725                         return &subsys_id_to_phy_id[i];
9726         }
9727         return NULL;
9728 }
9729
9730 static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
9731 {
9732         u32 val;
9733         u16 pmcsr;
9734
9735         /* On some early chips the SRAM cannot be accessed in D3hot state,
9736          * so need make sure we're in D0.
9737          */
9738         pci_read_config_word(tp->pdev, tp->pm_cap + PCI_PM_CTRL, &pmcsr);
9739         pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
9740         pci_write_config_word(tp->pdev, tp->pm_cap + PCI_PM_CTRL, pmcsr);
9741         msleep(1);
9742
9743         /* Make sure register accesses (indirect or otherwise)
9744          * will function correctly.
9745          */
9746         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
9747                                tp->misc_host_ctrl);
9748
9749         /* The memory arbiter has to be enabled in order for SRAM accesses
9750          * to succeed.  Normally on powerup the tg3 chip firmware will make
9751          * sure it is enabled, but other entities such as system netboot
9752          * code might disable it.
9753          */
9754         val = tr32(MEMARB_MODE);
9755         tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
9756
9757         tp->phy_id = PHY_ID_INVALID;
9758         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
9759
9760         /* Assume an onboard device by default.  */
9761         tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
9762
9763         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
9764         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
9765                 u32 nic_cfg, led_cfg;
9766                 u32 nic_phy_id, ver, cfg2 = 0, eeprom_phy_id;
9767                 int eeprom_phy_serdes = 0;
9768
9769                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
9770                 tp->nic_sram_data_cfg = nic_cfg;
9771
9772                 tg3_read_mem(tp, NIC_SRAM_DATA_VER, &ver);
9773                 ver >>= NIC_SRAM_DATA_VER_SHIFT;
9774                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700) &&
9775                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) &&
9776                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5703) &&
9777                     (ver > 0) && (ver < 0x100))
9778                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_2, &cfg2);
9779
9780                 if ((nic_cfg & NIC_SRAM_DATA_CFG_PHY_TYPE_MASK) ==
9781                     NIC_SRAM_DATA_CFG_PHY_TYPE_FIBER)
9782                         eeprom_phy_serdes = 1;
9783
9784                 tg3_read_mem(tp, NIC_SRAM_DATA_PHY_ID, &nic_phy_id);
9785                 if (nic_phy_id != 0) {
9786                         u32 id1 = nic_phy_id & NIC_SRAM_DATA_PHY_ID1_MASK;
9787                         u32 id2 = nic_phy_id & NIC_SRAM_DATA_PHY_ID2_MASK;
9788
9789                         eeprom_phy_id  = (id1 >> 16) << 10;
9790                         eeprom_phy_id |= (id2 & 0xfc00) << 16;
9791                         eeprom_phy_id |= (id2 & 0x03ff) <<  0;
9792                 } else
9793                         eeprom_phy_id = 0;
9794
9795                 tp->phy_id = eeprom_phy_id;
9796                 if (eeprom_phy_serdes) {
9797                         if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
9798                                 tp->tg3_flags2 |= TG3_FLG2_MII_SERDES;
9799                         else
9800                                 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
9801                 }
9802
9803                 if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
9804                         led_cfg = cfg2 & (NIC_SRAM_DATA_CFG_LED_MODE_MASK |
9805                                     SHASTA_EXT_LED_MODE_MASK);
9806                 else
9807                         led_cfg = nic_cfg & NIC_SRAM_DATA_CFG_LED_MODE_MASK;
9808
9809                 switch (led_cfg) {
9810                 default:
9811                 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_1:
9812                         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
9813                         break;
9814
9815                 case NIC_SRAM_DATA_CFG_LED_MODE_PHY_2:
9816                         tp->led_ctrl = LED_CTRL_MODE_PHY_2;
9817                         break;
9818
9819                 case NIC_SRAM_DATA_CFG_LED_MODE_MAC:
9820                         tp->led_ctrl = LED_CTRL_MODE_MAC;
9821
9822                         /* Default to PHY_1_MODE if 0 (MAC_MODE) is
9823                          * read on some older 5700/5701 bootcode.
9824                          */
9825                         if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
9826                             ASIC_REV_5700 ||
9827                             GET_ASIC_REV(tp->pci_chip_rev_id) ==
9828                             ASIC_REV_5701)
9829                                 tp->led_ctrl = LED_CTRL_MODE_PHY_1;
9830
9831                         break;
9832
9833                 case SHASTA_EXT_LED_SHARED:
9834                         tp->led_ctrl = LED_CTRL_MODE_SHARED;
9835                         if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0 &&
9836                             tp->pci_chip_rev_id != CHIPREV_ID_5750_A1)
9837                                 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
9838                                                  LED_CTRL_MODE_PHY_2);
9839                         break;
9840
9841                 case SHASTA_EXT_LED_MAC:
9842                         tp->led_ctrl = LED_CTRL_MODE_SHASTA_MAC;
9843                         break;
9844
9845                 case SHASTA_EXT_LED_COMBO:
9846                         tp->led_ctrl = LED_CTRL_MODE_COMBO;
9847                         if (tp->pci_chip_rev_id != CHIPREV_ID_5750_A0)
9848                                 tp->led_ctrl |= (LED_CTRL_MODE_PHY_1 |
9849                                                  LED_CTRL_MODE_PHY_2);
9850                         break;
9851
9852                 };
9853
9854                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
9855                      GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) &&
9856                     tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL)
9857                         tp->led_ctrl = LED_CTRL_MODE_PHY_2;
9858
9859                 if (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP)
9860                         tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
9861                 else
9862                         tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT;
9863
9864                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
9865                         tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
9866                         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
9867                                 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
9868                 }
9869                 if (nic_cfg & NIC_SRAM_DATA_CFG_FIBER_WOL)
9870                         tp->tg3_flags |= TG3_FLAG_SERDES_WOL_CAP;
9871
9872                 if (cfg2 & (1 << 17))
9873                         tp->tg3_flags2 |= TG3_FLG2_CAPACITIVE_COUPLING;
9874
9875                 /* serdes signal pre-emphasis in register 0x590 set by */
9876                 /* bootcode if bit 18 is set */
9877                 if (cfg2 & (1 << 18))
9878                         tp->tg3_flags2 |= TG3_FLG2_SERDES_PREEMPHASIS;
9879         }
9880 }
9881
9882 static int __devinit tg3_phy_probe(struct tg3 *tp)
9883 {
9884         u32 hw_phy_id_1, hw_phy_id_2;
9885         u32 hw_phy_id, hw_phy_id_masked;
9886         int err;
9887
9888         /* Reading the PHY ID register can conflict with ASF
9889          * firwmare access to the PHY hardware.
9890          */
9891         err = 0;
9892         if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) {
9893                 hw_phy_id = hw_phy_id_masked = PHY_ID_INVALID;
9894         } else {
9895                 /* Now read the physical PHY_ID from the chip and verify
9896                  * that it is sane.  If it doesn't look good, we fall back
9897                  * to either the hard-coded table based PHY_ID and failing
9898                  * that the value found in the eeprom area.
9899                  */
9900                 err |= tg3_readphy(tp, MII_PHYSID1, &hw_phy_id_1);
9901                 err |= tg3_readphy(tp, MII_PHYSID2, &hw_phy_id_2);
9902
9903                 hw_phy_id  = (hw_phy_id_1 & 0xffff) << 10;
9904                 hw_phy_id |= (hw_phy_id_2 & 0xfc00) << 16;
9905                 hw_phy_id |= (hw_phy_id_2 & 0x03ff) <<  0;
9906
9907                 hw_phy_id_masked = hw_phy_id & PHY_ID_MASK;
9908         }
9909
9910         if (!err && KNOWN_PHY_ID(hw_phy_id_masked)) {
9911                 tp->phy_id = hw_phy_id;
9912                 if (hw_phy_id_masked == PHY_ID_BCM8002)
9913                         tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
9914                 else
9915                         tp->tg3_flags2 &= ~TG3_FLG2_PHY_SERDES;
9916         } else {
9917                 if (tp->phy_id != PHY_ID_INVALID) {
9918                         /* Do nothing, phy ID already set up in
9919                          * tg3_get_eeprom_hw_cfg().
9920                          */
9921                 } else {
9922                         struct subsys_tbl_ent *p;
9923
9924                         /* No eeprom signature?  Try the hardcoded
9925                          * subsys device table.
9926                          */
9927                         p = lookup_by_subsys(tp);
9928                         if (!p)
9929                                 return -ENODEV;
9930
9931                         tp->phy_id = p->phy_id;
9932                         if (!tp->phy_id ||
9933                             tp->phy_id == PHY_ID_BCM8002)
9934                                 tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
9935                 }
9936         }
9937
9938         if (!(tp->tg3_flags2 & TG3_FLG2_ANY_SERDES) &&
9939             !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) {
9940                 u32 bmsr, adv_reg, tg3_ctrl;
9941
9942                 tg3_readphy(tp, MII_BMSR, &bmsr);
9943                 if (!tg3_readphy(tp, MII_BMSR, &bmsr) &&
9944                     (bmsr & BMSR_LSTATUS))
9945                         goto skip_phy_reset;
9946
9947                 err = tg3_phy_reset(tp);
9948                 if (err)
9949                         return err;
9950
9951                 adv_reg = (ADVERTISE_10HALF | ADVERTISE_10FULL |
9952                            ADVERTISE_100HALF | ADVERTISE_100FULL |
9953                            ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
9954                 tg3_ctrl = 0;
9955                 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY)) {
9956                         tg3_ctrl = (MII_TG3_CTRL_ADV_1000_HALF |
9957                                     MII_TG3_CTRL_ADV_1000_FULL);
9958                         if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
9959                             tp->pci_chip_rev_id == CHIPREV_ID_5701_B0)
9960                                 tg3_ctrl |= (MII_TG3_CTRL_AS_MASTER |
9961                                              MII_TG3_CTRL_ENABLE_AS_MASTER);
9962                 }
9963
9964                 if (!tg3_copper_is_advertising_all(tp)) {
9965                         tg3_writephy(tp, MII_ADVERTISE, adv_reg);
9966
9967                         if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
9968                                 tg3_writephy(tp, MII_TG3_CTRL, tg3_ctrl);
9969
9970                         tg3_writephy(tp, MII_BMCR,
9971                                      BMCR_ANENABLE | BMCR_ANRESTART);
9972                 }
9973                 tg3_phy_set_wirespeed(tp);
9974
9975                 tg3_writephy(tp, MII_ADVERTISE, adv_reg);
9976                 if (!(tp->tg3_flags & TG3_FLAG_10_100_ONLY))
9977                         tg3_writephy(tp, MII_TG3_CTRL, tg3_ctrl);
9978         }
9979
9980 skip_phy_reset:
9981         if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
9982                 err = tg3_init_5401phy_dsp(tp);
9983                 if (err)
9984                         return err;
9985         }
9986
9987         if (!err && ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401)) {
9988                 err = tg3_init_5401phy_dsp(tp);
9989         }
9990
9991         if (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES)
9992                 tp->link_config.advertising =
9993                         (ADVERTISED_1000baseT_Half |
9994                          ADVERTISED_1000baseT_Full |
9995                          ADVERTISED_Autoneg |
9996                          ADVERTISED_FIBRE);
9997         if (tp->tg3_flags & TG3_FLAG_10_100_ONLY)
9998                 tp->link_config.advertising &=
9999                         ~(ADVERTISED_1000baseT_Half |
10000                           ADVERTISED_1000baseT_Full);
10001
10002         return err;
10003 }
10004
10005 static void __devinit tg3_read_partno(struct tg3 *tp)
10006 {
10007         unsigned char vpd_data[256];
10008         int i;
10009         u32 magic;
10010
10011         if (tg3_nvram_read_swab(tp, 0x0, &magic))
10012                 goto out_not_found;
10013
10014         if (magic == TG3_EEPROM_MAGIC) {
10015                 for (i = 0; i < 256; i += 4) {
10016                         u32 tmp;
10017
10018                         if (tg3_nvram_read(tp, 0x100 + i, &tmp))
10019                                 goto out_not_found;
10020
10021                         vpd_data[i + 0] = ((tmp >>  0) & 0xff);
10022                         vpd_data[i + 1] = ((tmp >>  8) & 0xff);
10023                         vpd_data[i + 2] = ((tmp >> 16) & 0xff);
10024                         vpd_data[i + 3] = ((tmp >> 24) & 0xff);
10025                 }
10026         } else {
10027                 int vpd_cap;
10028
10029                 vpd_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_VPD);
10030                 for (i = 0; i < 256; i += 4) {
10031                         u32 tmp, j = 0;
10032                         u16 tmp16;
10033
10034                         pci_write_config_word(tp->pdev, vpd_cap + PCI_VPD_ADDR,
10035                                               i);
10036                         while (j++ < 100) {
10037                                 pci_read_config_word(tp->pdev, vpd_cap +
10038                                                      PCI_VPD_ADDR, &tmp16);
10039                                 if (tmp16 & 0x8000)
10040                                         break;
10041                                 msleep(1);
10042                         }
10043                         if (!(tmp16 & 0x8000))
10044                                 goto out_not_found;
10045
10046                         pci_read_config_dword(tp->pdev, vpd_cap + PCI_VPD_DATA,
10047                                               &tmp);
10048                         tmp = cpu_to_le32(tmp);
10049                         memcpy(&vpd_data[i], &tmp, 4);
10050                 }
10051         }
10052
10053         /* Now parse and find the part number. */
10054         for (i = 0; i < 256; ) {
10055                 unsigned char val = vpd_data[i];
10056                 int block_end;
10057
10058                 if (val == 0x82 || val == 0x91) {
10059                         i = (i + 3 +
10060                              (vpd_data[i + 1] +
10061                               (vpd_data[i + 2] << 8)));
10062                         continue;
10063                 }
10064
10065                 if (val != 0x90)
10066                         goto out_not_found;
10067
10068                 block_end = (i + 3 +
10069                              (vpd_data[i + 1] +
10070                               (vpd_data[i + 2] << 8)));
10071                 i += 3;
10072                 while (i < block_end) {
10073                         if (vpd_data[i + 0] == 'P' &&
10074                             vpd_data[i + 1] == 'N') {
10075                                 int partno_len = vpd_data[i + 2];
10076
10077                                 if (partno_len > 24)
10078                                         goto out_not_found;
10079
10080                                 memcpy(tp->board_part_number,
10081                                        &vpd_data[i + 3],
10082                                        partno_len);
10083
10084                                 /* Success. */
10085                                 return;
10086                         }
10087                 }
10088
10089                 /* Part number not found. */
10090                 goto out_not_found;
10091         }
10092
10093 out_not_found:
10094         strcpy(tp->board_part_number, "none");
10095 }
10096
10097 static void __devinit tg3_read_fw_ver(struct tg3 *tp)
10098 {
10099         u32 val, offset, start;
10100
10101         if (tg3_nvram_read_swab(tp, 0, &val))
10102                 return;
10103
10104         if (val != TG3_EEPROM_MAGIC)
10105                 return;
10106
10107         if (tg3_nvram_read_swab(tp, 0xc, &offset) ||
10108             tg3_nvram_read_swab(tp, 0x4, &start))
10109                 return;
10110
10111         offset = tg3_nvram_logical_addr(tp, offset);
10112         if (tg3_nvram_read_swab(tp, offset, &val))
10113                 return;
10114
10115         if ((val & 0xfc000000) == 0x0c000000) {
10116                 u32 ver_offset, addr;
10117                 int i;
10118
10119                 if (tg3_nvram_read_swab(tp, offset + 4, &val) ||
10120                     tg3_nvram_read_swab(tp, offset + 8, &ver_offset))
10121                         return;
10122
10123                 if (val != 0)
10124                         return;
10125
10126                 addr = offset + ver_offset - start;
10127                 for (i = 0; i < 16; i += 4) {
10128                         if (tg3_nvram_read(tp, addr + i, &val))
10129                                 return;
10130
10131                         val = cpu_to_le32(val);
10132                         memcpy(tp->fw_ver + i, &val, 4);
10133                 }
10134         }
10135 }
10136
10137 static int __devinit tg3_get_invariants(struct tg3 *tp)
10138 {
10139         static struct pci_device_id write_reorder_chipsets[] = {
10140                 { PCI_DEVICE(PCI_VENDOR_ID_AMD,
10141                              PCI_DEVICE_ID_AMD_FE_GATE_700C) },
10142                 { PCI_DEVICE(PCI_VENDOR_ID_AMD,
10143                              PCI_DEVICE_ID_AMD_8131_BRIDGE) },
10144                 { PCI_DEVICE(PCI_VENDOR_ID_VIA,
10145                              PCI_DEVICE_ID_VIA_8385_0) },
10146                 { },
10147         };
10148         u32 misc_ctrl_reg;
10149         u32 cacheline_sz_reg;
10150         u32 pci_state_reg, grc_misc_cfg;
10151         u32 val;
10152         u16 pci_cmd;
10153         int err;
10154
10155         /* Force memory write invalidate off.  If we leave it on,
10156          * then on 5700_BX chips we have to enable a workaround.
10157          * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary
10158          * to match the cacheline size.  The Broadcom driver have this
10159          * workaround but turns MWI off all the times so never uses
10160          * it.  This seems to suggest that the workaround is insufficient.
10161          */
10162         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
10163         pci_cmd &= ~PCI_COMMAND_INVALIDATE;
10164         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
10165
10166         /* It is absolutely critical that TG3PCI_MISC_HOST_CTRL
10167          * has the register indirect write enable bit set before
10168          * we try to access any of the MMIO registers.  It is also
10169          * critical that the PCI-X hw workaround situation is decided
10170          * before that as well.
10171          */
10172         pci_read_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
10173                               &misc_ctrl_reg);
10174
10175         tp->pci_chip_rev_id = (misc_ctrl_reg >>
10176                                MISC_HOST_CTRL_CHIPREV_SHIFT);
10177
10178         /* Wrong chip ID in 5752 A0. This code can be removed later
10179          * as A0 is not in production.
10180          */
10181         if (tp->pci_chip_rev_id == CHIPREV_ID_5752_A0_HW)
10182                 tp->pci_chip_rev_id = CHIPREV_ID_5752_A0;
10183
10184         /* If we have 5702/03 A1 or A2 on certain ICH chipsets,
10185          * we need to disable memory and use config. cycles
10186          * only to access all registers. The 5702/03 chips
10187          * can mistakenly decode the special cycles from the
10188          * ICH chipsets as memory write cycles, causing corruption
10189          * of register and memory space. Only certain ICH bridges
10190          * will drive special cycles with non-zero data during the
10191          * address phase which can fall within the 5703's address
10192          * range. This is not an ICH bug as the PCI spec allows
10193          * non-zero address during special cycles. However, only
10194          * these ICH bridges are known to drive non-zero addresses
10195          * during special cycles.
10196          *
10197          * Since special cycles do not cross PCI bridges, we only
10198          * enable this workaround if the 5703 is on the secondary
10199          * bus of these ICH bridges.
10200          */
10201         if ((tp->pci_chip_rev_id == CHIPREV_ID_5703_A1) ||
10202             (tp->pci_chip_rev_id == CHIPREV_ID_5703_A2)) {
10203                 static struct tg3_dev_id {
10204                         u32     vendor;
10205                         u32     device;
10206                         u32     rev;
10207                 } ich_chipsets[] = {
10208                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_8,
10209                           PCI_ANY_ID },
10210                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_8,
10211                           PCI_ANY_ID },
10212                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_11,
10213                           0xa },
10214                         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_6,
10215                           PCI_ANY_ID },
10216                         { },
10217                 };
10218                 struct tg3_dev_id *pci_id = &ich_chipsets[0];
10219                 struct pci_dev *bridge = NULL;
10220
10221                 while (pci_id->vendor != 0) {
10222                         bridge = pci_get_device(pci_id->vendor, pci_id->device,
10223                                                 bridge);
10224                         if (!bridge) {
10225                                 pci_id++;
10226                                 continue;
10227                         }
10228                         if (pci_id->rev != PCI_ANY_ID) {
10229                                 u8 rev;
10230
10231                                 pci_read_config_byte(bridge, PCI_REVISION_ID,
10232                                                      &rev);
10233                                 if (rev > pci_id->rev)
10234                                         continue;
10235                         }
10236                         if (bridge->subordinate &&
10237                             (bridge->subordinate->number ==
10238                              tp->pdev->bus->number)) {
10239
10240                                 tp->tg3_flags2 |= TG3_FLG2_ICH_WORKAROUND;
10241                                 pci_dev_put(bridge);
10242                                 break;
10243                         }
10244                 }
10245         }
10246
10247         /* The EPB bridge inside 5714, 5715, and 5780 cannot support
10248          * DMA addresses > 40-bit. This bridge may have other additional
10249          * 57xx devices behind it in some 4-port NIC designs for example.
10250          * Any tg3 device found behind the bridge will also need the 40-bit
10251          * DMA workaround.
10252          */
10253         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 ||
10254             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
10255                 tp->tg3_flags2 |= TG3_FLG2_5780_CLASS;
10256                 tp->tg3_flags |= TG3_FLAG_40BIT_DMA_BUG;
10257                 tp->msi_cap = pci_find_capability(tp->pdev, PCI_CAP_ID_MSI);
10258         }
10259         else {
10260                 struct pci_dev *bridge = NULL;
10261
10262                 do {
10263                         bridge = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
10264                                                 PCI_DEVICE_ID_SERVERWORKS_EPB,
10265                                                 bridge);
10266                         if (bridge && bridge->subordinate &&
10267                             (bridge->subordinate->number <=
10268                              tp->pdev->bus->number) &&
10269                             (bridge->subordinate->subordinate >=
10270                              tp->pdev->bus->number)) {
10271                                 tp->tg3_flags |= TG3_FLAG_40BIT_DMA_BUG;
10272                                 pci_dev_put(bridge);
10273                                 break;
10274                         }
10275                 } while (bridge);
10276         }
10277
10278         /* Initialize misc host control in PCI block. */
10279         tp->misc_host_ctrl |= (misc_ctrl_reg &
10280                                MISC_HOST_CTRL_CHIPREV);
10281         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
10282                                tp->misc_host_ctrl);
10283
10284         pci_read_config_dword(tp->pdev, TG3PCI_CACHELINESZ,
10285                               &cacheline_sz_reg);
10286
10287         tp->pci_cacheline_sz = (cacheline_sz_reg >>  0) & 0xff;
10288         tp->pci_lat_timer    = (cacheline_sz_reg >>  8) & 0xff;
10289         tp->pci_hdr_type     = (cacheline_sz_reg >> 16) & 0xff;
10290         tp->pci_bist         = (cacheline_sz_reg >> 24) & 0xff;
10291
10292         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
10293             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
10294             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
10295             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
10296             (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
10297                 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
10298
10299         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) ||
10300             (tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
10301                 tp->tg3_flags2 |= TG3_FLG2_5705_PLUS;
10302
10303         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
10304                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
10305                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787) {
10306                         tp->tg3_flags2 |= TG3_FLG2_HW_TSO_2;
10307                         tp->tg3_flags2 |= TG3_FLG2_1SHOT_MSI;
10308                 } else {
10309                         tp->tg3_flags2 |= TG3_FLG2_HW_TSO_1 |
10310                                           TG3_FLG2_HW_TSO_1_BUG;
10311                         if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
10312                                 ASIC_REV_5750 &&
10313                             tp->pci_chip_rev_id >= CHIPREV_ID_5750_C2)
10314                                 tp->tg3_flags2 &= ~TG3_FLG2_HW_TSO_1_BUG;
10315                 }
10316         }
10317
10318         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 &&
10319             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750 &&
10320             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752 &&
10321             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755 &&
10322             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787)
10323                 tp->tg3_flags2 |= TG3_FLG2_JUMBO_CAPABLE;
10324
10325         if (pci_find_capability(tp->pdev, PCI_CAP_ID_EXP) != 0)
10326                 tp->tg3_flags2 |= TG3_FLG2_PCI_EXPRESS;
10327
10328         /* If we have an AMD 762 or VIA K8T800 chipset, write
10329          * reordering to the mailbox registers done by the host
10330          * controller can cause major troubles.  We read back from
10331          * every mailbox register write to force the writes to be
10332          * posted to the chip in order.
10333          */
10334         if (pci_dev_present(write_reorder_chipsets) &&
10335             !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
10336                 tp->tg3_flags |= TG3_FLAG_MBOX_WRITE_REORDER;
10337
10338         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 &&
10339             tp->pci_lat_timer < 64) {
10340                 tp->pci_lat_timer = 64;
10341
10342                 cacheline_sz_reg  = ((tp->pci_cacheline_sz & 0xff) <<  0);
10343                 cacheline_sz_reg |= ((tp->pci_lat_timer    & 0xff) <<  8);
10344                 cacheline_sz_reg |= ((tp->pci_hdr_type     & 0xff) << 16);
10345                 cacheline_sz_reg |= ((tp->pci_bist         & 0xff) << 24);
10346
10347                 pci_write_config_dword(tp->pdev, TG3PCI_CACHELINESZ,
10348                                        cacheline_sz_reg);
10349         }
10350
10351         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
10352                               &pci_state_reg);
10353
10354         if ((pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0) {
10355                 tp->tg3_flags |= TG3_FLAG_PCIX_MODE;
10356
10357                 /* If this is a 5700 BX chipset, and we are in PCI-X
10358                  * mode, enable register write workaround.
10359                  *
10360                  * The workaround is to use indirect register accesses
10361                  * for all chip writes not to mailbox registers.
10362                  */
10363                 if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5700_BX) {
10364                         u32 pm_reg;
10365                         u16 pci_cmd;
10366
10367                         tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
10368
10369                         /* The chip can have it's power management PCI config
10370                          * space registers clobbered due to this bug.
10371                          * So explicitly force the chip into D0 here.
10372                          */
10373                         pci_read_config_dword(tp->pdev, TG3PCI_PM_CTRL_STAT,
10374                                               &pm_reg);
10375                         pm_reg &= ~PCI_PM_CTRL_STATE_MASK;
10376                         pm_reg |= PCI_PM_CTRL_PME_ENABLE | 0 /* D0 */;
10377                         pci_write_config_dword(tp->pdev, TG3PCI_PM_CTRL_STAT,
10378                                                pm_reg);
10379
10380                         /* Also, force SERR#/PERR# in PCI command. */
10381                         pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
10382                         pci_cmd |= PCI_COMMAND_PARITY | PCI_COMMAND_SERR;
10383                         pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
10384                 }
10385         }
10386
10387         /* 5700 BX chips need to have their TX producer index mailboxes
10388          * written twice to workaround a bug.
10389          */
10390         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5700_BX)
10391                 tp->tg3_flags |= TG3_FLAG_TXD_MBOX_HWBUG;
10392
10393         /* Back to back register writes can cause problems on this chip,
10394          * the workaround is to read back all reg writes except those to
10395          * mailbox regs.  See tg3_write_indirect_reg32().
10396          *
10397          * PCI Express 5750_A0 rev chips need this workaround too.
10398          */
10399         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 ||
10400             ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
10401              tp->pci_chip_rev_id == CHIPREV_ID_5750_A0))
10402                 tp->tg3_flags |= TG3_FLAG_5701_REG_WRITE_BUG;
10403
10404         if ((pci_state_reg & PCISTATE_BUS_SPEED_HIGH) != 0)
10405                 tp->tg3_flags |= TG3_FLAG_PCI_HIGH_SPEED;
10406         if ((pci_state_reg & PCISTATE_BUS_32BIT) != 0)
10407                 tp->tg3_flags |= TG3_FLAG_PCI_32BIT;
10408
10409         /* Chip-specific fixup from Broadcom driver */
10410         if ((tp->pci_chip_rev_id == CHIPREV_ID_5704_A0) &&
10411             (!(pci_state_reg & PCISTATE_RETRY_SAME_DMA))) {
10412                 pci_state_reg |= PCISTATE_RETRY_SAME_DMA;
10413                 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, pci_state_reg);
10414         }
10415
10416         /* Default fast path register access methods */
10417         tp->read32 = tg3_read32;
10418         tp->write32 = tg3_write32;
10419         tp->read32_mbox = tg3_read32;
10420         tp->write32_mbox = tg3_write32;
10421         tp->write32_tx_mbox = tg3_write32;
10422         tp->write32_rx_mbox = tg3_write32;
10423
10424         /* Various workaround register access methods */
10425         if (tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG)
10426                 tp->write32 = tg3_write_indirect_reg32;
10427         else if (tp->tg3_flags & TG3_FLAG_5701_REG_WRITE_BUG)
10428                 tp->write32 = tg3_write_flush_reg32;
10429
10430         if ((tp->tg3_flags & TG3_FLAG_TXD_MBOX_HWBUG) ||
10431             (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)) {
10432                 tp->write32_tx_mbox = tg3_write32_tx_mbox;
10433                 if (tp->tg3_flags & TG3_FLAG_MBOX_WRITE_REORDER)
10434                         tp->write32_rx_mbox = tg3_write_flush_reg32;
10435         }
10436
10437         if (tp->tg3_flags2 & TG3_FLG2_ICH_WORKAROUND) {
10438                 tp->read32 = tg3_read_indirect_reg32;
10439                 tp->write32 = tg3_write_indirect_reg32;
10440                 tp->read32_mbox = tg3_read_indirect_mbox;
10441                 tp->write32_mbox = tg3_write_indirect_mbox;
10442                 tp->write32_tx_mbox = tg3_write_indirect_mbox;
10443                 tp->write32_rx_mbox = tg3_write_indirect_mbox;
10444
10445                 iounmap(tp->regs);
10446                 tp->regs = NULL;
10447
10448                 pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
10449                 pci_cmd &= ~PCI_COMMAND_MEMORY;
10450                 pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
10451         }
10452
10453         if (tp->write32 == tg3_write_indirect_reg32 ||
10454             ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
10455              (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
10456               GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)))
10457                 tp->tg3_flags |= TG3_FLAG_SRAM_USE_CONFIG;
10458
10459         /* Get eeprom hw config before calling tg3_set_power_state().
10460          * In particular, the TG3_FLAG_EEPROM_WRITE_PROT flag must be
10461          * determined before calling tg3_set_power_state() so that
10462          * we know whether or not to switch out of Vaux power.
10463          * When the flag is set, it means that GPIO1 is used for eeprom
10464          * write protect and also implies that it is a LOM where GPIOs
10465          * are not used to switch power.
10466          */
10467         tg3_get_eeprom_hw_cfg(tp);
10468
10469         /* Set up tp->grc_local_ctrl before calling tg3_set_power_state().
10470          * GPIO1 driven high will bring 5700's external PHY out of reset.
10471          * It is also used as eeprom write protect on LOMs.
10472          */
10473         tp->grc_local_ctrl = GRC_LCLCTRL_INT_ON_ATTN | GRC_LCLCTRL_AUTO_SEEPROM;
10474         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
10475             (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT))
10476                 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
10477                                        GRC_LCLCTRL_GPIO_OUTPUT1);
10478         /* Unused GPIO3 must be driven as output on 5752 because there
10479          * are no pull-up resistors on unused GPIO pins.
10480          */
10481         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
10482                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
10483
10484         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
10485                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
10486
10487         /* Force the chip into D0. */
10488         err = tg3_set_power_state(tp, PCI_D0);
10489         if (err) {
10490                 printk(KERN_ERR PFX "(%s) transition to D0 failed\n",
10491                        pci_name(tp->pdev));
10492                 return err;
10493         }
10494
10495         /* 5700 B0 chips do not support checksumming correctly due
10496          * to hardware bugs.
10497          */
10498         if (tp->pci_chip_rev_id == CHIPREV_ID_5700_B0)
10499                 tp->tg3_flags |= TG3_FLAG_BROKEN_CHECKSUMS;
10500
10501         /* Derive initial jumbo mode from MTU assigned in
10502          * ether_setup() via the alloc_etherdev() call
10503          */
10504         if (tp->dev->mtu > ETH_DATA_LEN &&
10505             !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
10506                 tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
10507
10508         /* Determine WakeOnLan speed to use. */
10509         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
10510             tp->pci_chip_rev_id == CHIPREV_ID_5701_A0 ||
10511             tp->pci_chip_rev_id == CHIPREV_ID_5701_B0 ||
10512             tp->pci_chip_rev_id == CHIPREV_ID_5701_B2) {
10513                 tp->tg3_flags &= ~(TG3_FLAG_WOL_SPEED_100MB);
10514         } else {
10515                 tp->tg3_flags |= TG3_FLAG_WOL_SPEED_100MB;
10516         }
10517
10518         /* A few boards don't want Ethernet@WireSpeed phy feature */
10519         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
10520             ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) &&
10521              (tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) &&
10522              (tp->pci_chip_rev_id != CHIPREV_ID_5705_A1)) ||
10523             (tp->tg3_flags2 & TG3_FLG2_ANY_SERDES))
10524                 tp->tg3_flags2 |= TG3_FLG2_NO_ETH_WIRE_SPEED;
10525
10526         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5703_AX ||
10527             GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5704_AX)
10528                 tp->tg3_flags2 |= TG3_FLG2_PHY_ADC_BUG;
10529         if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0)
10530                 tp->tg3_flags2 |= TG3_FLG2_PHY_5704_A0_BUG;
10531
10532         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
10533                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
10534                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
10535                         tp->tg3_flags2 |= TG3_FLG2_PHY_JITTER_BUG;
10536                 else
10537                         tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
10538         }
10539
10540         tp->coalesce_mode = 0;
10541         if (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_AX &&
10542             GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_BX)
10543                 tp->coalesce_mode |= HOSTCC_MODE_32BYTE;
10544
10545         /* Initialize MAC MI mode, polling disabled. */
10546         tw32_f(MAC_MI_MODE, tp->mi_mode);
10547         udelay(80);
10548
10549         /* Initialize data/descriptor byte/word swapping. */
10550         val = tr32(GRC_MODE);
10551         val &= GRC_MODE_HOST_STACKUP;
10552         tw32(GRC_MODE, val | tp->grc_mode);
10553
10554         tg3_switch_clocks(tp);
10555
10556         /* Clear this out for sanity. */
10557         tw32(TG3PCI_MEM_WIN_BASE_ADDR, 0);
10558
10559         pci_read_config_dword(tp->pdev, TG3PCI_PCISTATE,
10560                               &pci_state_reg);
10561         if ((pci_state_reg & PCISTATE_CONV_PCI_MODE) == 0 &&
10562             (tp->tg3_flags & TG3_FLAG_PCIX_TARGET_HWBUG) == 0) {
10563                 u32 chiprevid = GET_CHIP_REV_ID(tp->misc_host_ctrl);
10564
10565                 if (chiprevid == CHIPREV_ID_5701_A0 ||
10566                     chiprevid == CHIPREV_ID_5701_B0 ||
10567                     chiprevid == CHIPREV_ID_5701_B2 ||
10568                     chiprevid == CHIPREV_ID_5701_B5) {
10569                         void __iomem *sram_base;
10570
10571                         /* Write some dummy words into the SRAM status block
10572                          * area, see if it reads back correctly.  If the return
10573                          * value is bad, force enable the PCIX workaround.
10574                          */
10575                         sram_base = tp->regs + NIC_SRAM_WIN_BASE + NIC_SRAM_STATS_BLK;
10576
10577                         writel(0x00000000, sram_base);
10578                         writel(0x00000000, sram_base + 4);
10579                         writel(0xffffffff, sram_base + 4);
10580                         if (readl(sram_base) != 0x00000000)
10581                                 tp->tg3_flags |= TG3_FLAG_PCIX_TARGET_HWBUG;
10582                 }
10583         }
10584
10585         udelay(50);
10586         tg3_nvram_init(tp);
10587
10588         grc_misc_cfg = tr32(GRC_MISC_CFG);
10589         grc_misc_cfg &= GRC_MISC_CFG_BOARD_ID_MASK;
10590
10591         /* Broadcom's driver says that CIOBE multisplit has a bug */
10592 #if 0
10593         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
10594             grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5704CIOBE) {
10595                 tp->tg3_flags |= TG3_FLAG_SPLIT_MODE;
10596                 tp->split_mode_max_reqs = SPLIT_MODE_5704_MAX_REQ;
10597         }
10598 #endif
10599         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
10600             (grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788 ||
10601              grc_misc_cfg == GRC_MISC_CFG_BOARD_ID_5788M))
10602                 tp->tg3_flags2 |= TG3_FLG2_IS_5788;
10603
10604         if (!(tp->tg3_flags2 & TG3_FLG2_IS_5788) &&
10605             (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700))
10606                 tp->tg3_flags |= TG3_FLAG_TAGGED_STATUS;
10607         if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS) {
10608                 tp->coalesce_mode |= (HOSTCC_MODE_CLRTICK_RXBD |
10609                                       HOSTCC_MODE_CLRTICK_TXBD);
10610
10611                 tp->misc_host_ctrl |= MISC_HOST_CTRL_TAGGED_STATUS;
10612                 pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
10613                                        tp->misc_host_ctrl);
10614         }
10615
10616         /* these are limited to 10/100 only */
10617         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 &&
10618              (grc_misc_cfg == 0x8000 || grc_misc_cfg == 0x4000)) ||
10619             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
10620              tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
10621              (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5901 ||
10622               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5901_2 ||
10623               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5705F)) ||
10624             (tp->pdev->vendor == PCI_VENDOR_ID_BROADCOM &&
10625              (tp->pdev->device == PCI_DEVICE_ID_TIGON3_5751F ||
10626               tp->pdev->device == PCI_DEVICE_ID_TIGON3_5753F)))
10627                 tp->tg3_flags |= TG3_FLAG_10_100_ONLY;
10628
10629         err = tg3_phy_probe(tp);
10630         if (err) {
10631                 printk(KERN_ERR PFX "(%s) phy probe failed, err %d\n",
10632                        pci_name(tp->pdev), err);
10633                 /* ... but do not return immediately ... */
10634         }
10635
10636         tg3_read_partno(tp);
10637         tg3_read_fw_ver(tp);
10638
10639         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES) {
10640                 tp->tg3_flags &= ~TG3_FLAG_USE_MI_INTERRUPT;
10641         } else {
10642                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
10643                         tp->tg3_flags |= TG3_FLAG_USE_MI_INTERRUPT;
10644                 else
10645                         tp->tg3_flags &= ~TG3_FLAG_USE_MI_INTERRUPT;
10646         }
10647
10648         /* 5700 {AX,BX} chips have a broken status block link
10649          * change bit implementation, so we must use the
10650          * status register in those cases.
10651          */
10652         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
10653                 tp->tg3_flags |= TG3_FLAG_USE_LINKCHG_REG;
10654         else
10655                 tp->tg3_flags &= ~TG3_FLAG_USE_LINKCHG_REG;
10656
10657         /* The led_ctrl is set during tg3_phy_probe, here we might
10658          * have to force the link status polling mechanism based
10659          * upon subsystem IDs.
10660          */
10661         if (tp->pdev->subsystem_vendor == PCI_VENDOR_ID_DELL &&
10662             !(tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)) {
10663                 tp->tg3_flags |= (TG3_FLAG_USE_MI_INTERRUPT |
10664                                   TG3_FLAG_USE_LINKCHG_REG);
10665         }
10666
10667         /* For all SERDES we poll the MAC status register. */
10668         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
10669                 tp->tg3_flags |= TG3_FLAG_POLL_SERDES;
10670         else
10671                 tp->tg3_flags &= ~TG3_FLAG_POLL_SERDES;
10672
10673         /* All chips before 5787 can get confused if TX buffers
10674          * straddle the 4GB address boundary in some cases.
10675          */
10676         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
10677             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
10678                 tp->dev->hard_start_xmit = tg3_start_xmit;
10679         else
10680                 tp->dev->hard_start_xmit = tg3_start_xmit_dma_bug;
10681
10682         tp->rx_offset = 2;
10683         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 &&
10684             (tp->tg3_flags & TG3_FLAG_PCIX_MODE) != 0)
10685                 tp->rx_offset = 0;
10686
10687         tp->rx_std_max_post = TG3_RX_RING_SIZE;
10688
10689         /* Increment the rx prod index on the rx std ring by at most
10690          * 8 for these chips to workaround hw errata.
10691          */
10692         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
10693             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
10694             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
10695                 tp->rx_std_max_post = 8;
10696
10697         /* By default, disable wake-on-lan.  User can change this
10698          * using ETHTOOL_SWOL.
10699          */
10700         tp->tg3_flags &= ~TG3_FLAG_WOL_ENABLE;
10701
10702         return err;
10703 }
10704
10705 #ifdef CONFIG_SPARC64
10706 static int __devinit tg3_get_macaddr_sparc(struct tg3 *tp)
10707 {
10708         struct net_device *dev = tp->dev;
10709         struct pci_dev *pdev = tp->pdev;
10710         struct pcidev_cookie *pcp = pdev->sysdata;
10711
10712         if (pcp != NULL) {
10713                 unsigned char *addr;
10714                 int len;
10715
10716                 addr = of_get_property(pcp->prom_node, "local-mac-address",
10717                                         &len);
10718                 if (addr && len == 6) {
10719                         memcpy(dev->dev_addr, addr, 6);
10720                         memcpy(dev->perm_addr, dev->dev_addr, 6);
10721                         return 0;
10722                 }
10723         }
10724         return -ENODEV;
10725 }
10726
10727 static int __devinit tg3_get_default_macaddr_sparc(struct tg3 *tp)
10728 {
10729         struct net_device *dev = tp->dev;
10730
10731         memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
10732         memcpy(dev->perm_addr, idprom->id_ethaddr, 6);
10733         return 0;
10734 }
10735 #endif
10736
10737 static int __devinit tg3_get_device_address(struct tg3 *tp)
10738 {
10739         struct net_device *dev = tp->dev;
10740         u32 hi, lo, mac_offset;
10741         int addr_ok = 0;
10742
10743 #ifdef CONFIG_SPARC64
10744         if (!tg3_get_macaddr_sparc(tp))
10745                 return 0;
10746 #endif
10747
10748         mac_offset = 0x7c;
10749         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) ||
10750             (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
10751                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
10752                         mac_offset = 0xcc;
10753                 if (tg3_nvram_lock(tp))
10754                         tw32_f(NVRAM_CMD, NVRAM_CMD_RESET);
10755                 else
10756                         tg3_nvram_unlock(tp);
10757         }
10758
10759         /* First try to get it from MAC address mailbox. */
10760         tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_HIGH_MBOX, &hi);
10761         if ((hi >> 16) == 0x484b) {
10762                 dev->dev_addr[0] = (hi >>  8) & 0xff;
10763                 dev->dev_addr[1] = (hi >>  0) & 0xff;
10764
10765                 tg3_read_mem(tp, NIC_SRAM_MAC_ADDR_LOW_MBOX, &lo);
10766                 dev->dev_addr[2] = (lo >> 24) & 0xff;
10767                 dev->dev_addr[3] = (lo >> 16) & 0xff;
10768                 dev->dev_addr[4] = (lo >>  8) & 0xff;
10769                 dev->dev_addr[5] = (lo >>  0) & 0xff;
10770
10771                 /* Some old bootcode may report a 0 MAC address in SRAM */
10772                 addr_ok = is_valid_ether_addr(&dev->dev_addr[0]);
10773         }
10774         if (!addr_ok) {
10775                 /* Next, try NVRAM. */
10776                 if (!tg3_nvram_read(tp, mac_offset + 0, &hi) &&
10777                     !tg3_nvram_read(tp, mac_offset + 4, &lo)) {
10778                         dev->dev_addr[0] = ((hi >> 16) & 0xff);
10779                         dev->dev_addr[1] = ((hi >> 24) & 0xff);
10780                         dev->dev_addr[2] = ((lo >>  0) & 0xff);
10781                         dev->dev_addr[3] = ((lo >>  8) & 0xff);
10782                         dev->dev_addr[4] = ((lo >> 16) & 0xff);
10783                         dev->dev_addr[5] = ((lo >> 24) & 0xff);
10784                 }
10785                 /* Finally just fetch it out of the MAC control regs. */
10786                 else {
10787                         hi = tr32(MAC_ADDR_0_HIGH);
10788                         lo = tr32(MAC_ADDR_0_LOW);
10789
10790                         dev->dev_addr[5] = lo & 0xff;
10791                         dev->dev_addr[4] = (lo >> 8) & 0xff;
10792                         dev->dev_addr[3] = (lo >> 16) & 0xff;
10793                         dev->dev_addr[2] = (lo >> 24) & 0xff;
10794                         dev->dev_addr[1] = hi & 0xff;
10795                         dev->dev_addr[0] = (hi >> 8) & 0xff;
10796                 }
10797         }
10798
10799         if (!is_valid_ether_addr(&dev->dev_addr[0])) {
10800 #ifdef CONFIG_SPARC64
10801                 if (!tg3_get_default_macaddr_sparc(tp))
10802                         return 0;
10803 #endif
10804                 return -EINVAL;
10805         }
10806         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
10807         return 0;
10808 }
10809
10810 #define BOUNDARY_SINGLE_CACHELINE       1
10811 #define BOUNDARY_MULTI_CACHELINE        2
10812
10813 static u32 __devinit tg3_calc_dma_bndry(struct tg3 *tp, u32 val)
10814 {
10815         int cacheline_size;
10816         u8 byte;
10817         int goal;
10818
10819         pci_read_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE, &byte);
10820         if (byte == 0)
10821                 cacheline_size = 1024;
10822         else
10823                 cacheline_size = (int) byte * 4;
10824
10825         /* On 5703 and later chips, the boundary bits have no
10826          * effect.
10827          */
10828         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
10829             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701 &&
10830             !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS))
10831                 goto out;
10832
10833 #if defined(CONFIG_PPC64) || defined(CONFIG_IA64) || defined(CONFIG_PARISC)
10834         goal = BOUNDARY_MULTI_CACHELINE;
10835 #else
10836 #if defined(CONFIG_SPARC64) || defined(CONFIG_ALPHA)
10837         goal = BOUNDARY_SINGLE_CACHELINE;
10838 #else
10839         goal = 0;
10840 #endif
10841 #endif
10842
10843         if (!goal)
10844                 goto out;
10845
10846         /* PCI controllers on most RISC systems tend to disconnect
10847          * when a device tries to burst across a cache-line boundary.
10848          * Therefore, letting tg3 do so just wastes PCI bandwidth.
10849          *
10850          * Unfortunately, for PCI-E there are only limited
10851          * write-side controls for this, and thus for reads
10852          * we will still get the disconnects.  We'll also waste
10853          * these PCI cycles for both read and write for chips
10854          * other than 5700 and 5701 which do not implement the
10855          * boundary bits.
10856          */
10857         if ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
10858             !(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)) {
10859                 switch (cacheline_size) {
10860                 case 16:
10861                 case 32:
10862                 case 64:
10863                 case 128:
10864                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
10865                                 val |= (DMA_RWCTRL_READ_BNDRY_128_PCIX |
10866                                         DMA_RWCTRL_WRITE_BNDRY_128_PCIX);
10867                         } else {
10868                                 val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
10869                                         DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
10870                         }
10871                         break;
10872
10873                 case 256:
10874                         val |= (DMA_RWCTRL_READ_BNDRY_256_PCIX |
10875                                 DMA_RWCTRL_WRITE_BNDRY_256_PCIX);
10876                         break;
10877
10878                 default:
10879                         val |= (DMA_RWCTRL_READ_BNDRY_384_PCIX |
10880                                 DMA_RWCTRL_WRITE_BNDRY_384_PCIX);
10881                         break;
10882                 };
10883         } else if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
10884                 switch (cacheline_size) {
10885                 case 16:
10886                 case 32:
10887                 case 64:
10888                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
10889                                 val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
10890                                 val |= DMA_RWCTRL_WRITE_BNDRY_64_PCIE;
10891                                 break;
10892                         }
10893                         /* fallthrough */
10894                 case 128:
10895                 default:
10896                         val &= ~DMA_RWCTRL_WRITE_BNDRY_DISAB_PCIE;
10897                         val |= DMA_RWCTRL_WRITE_BNDRY_128_PCIE;
10898                         break;
10899                 };
10900         } else {
10901                 switch (cacheline_size) {
10902                 case 16:
10903                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
10904                                 val |= (DMA_RWCTRL_READ_BNDRY_16 |
10905                                         DMA_RWCTRL_WRITE_BNDRY_16);
10906                                 break;
10907                         }
10908                         /* fallthrough */
10909                 case 32:
10910                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
10911                                 val |= (DMA_RWCTRL_READ_BNDRY_32 |
10912                                         DMA_RWCTRL_WRITE_BNDRY_32);
10913                                 break;
10914                         }
10915                         /* fallthrough */
10916                 case 64:
10917                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
10918                                 val |= (DMA_RWCTRL_READ_BNDRY_64 |
10919                                         DMA_RWCTRL_WRITE_BNDRY_64);
10920                                 break;
10921                         }
10922                         /* fallthrough */
10923                 case 128:
10924                         if (goal == BOUNDARY_SINGLE_CACHELINE) {
10925                                 val |= (DMA_RWCTRL_READ_BNDRY_128 |
10926                                         DMA_RWCTRL_WRITE_BNDRY_128);
10927                                 break;
10928                         }
10929                         /* fallthrough */
10930                 case 256:
10931                         val |= (DMA_RWCTRL_READ_BNDRY_256 |
10932                                 DMA_RWCTRL_WRITE_BNDRY_256);
10933                         break;
10934                 case 512:
10935                         val |= (DMA_RWCTRL_READ_BNDRY_512 |
10936                                 DMA_RWCTRL_WRITE_BNDRY_512);
10937                         break;
10938                 case 1024:
10939                 default:
10940                         val |= (DMA_RWCTRL_READ_BNDRY_1024 |
10941                                 DMA_RWCTRL_WRITE_BNDRY_1024);
10942                         break;
10943                 };
10944         }
10945
10946 out:
10947         return val;
10948 }
10949
10950 static int __devinit tg3_do_test_dma(struct tg3 *tp, u32 *buf, dma_addr_t buf_dma, int size, int to_device)
10951 {
10952         struct tg3_internal_buffer_desc test_desc;
10953         u32 sram_dma_descs;
10954         int i, ret;
10955
10956         sram_dma_descs = NIC_SRAM_DMA_DESC_POOL_BASE;
10957
10958         tw32(FTQ_RCVBD_COMP_FIFO_ENQDEQ, 0);
10959         tw32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ, 0);
10960         tw32(RDMAC_STATUS, 0);
10961         tw32(WDMAC_STATUS, 0);
10962
10963         tw32(BUFMGR_MODE, 0);
10964         tw32(FTQ_RESET, 0);
10965
10966         test_desc.addr_hi = ((u64) buf_dma) >> 32;
10967         test_desc.addr_lo = buf_dma & 0xffffffff;
10968         test_desc.nic_mbuf = 0x00002100;
10969         test_desc.len = size;
10970
10971         /*
10972          * HP ZX1 was seeing test failures for 5701 cards running at 33Mhz
10973          * the *second* time the tg3 driver was getting loaded after an
10974          * initial scan.
10975          *
10976          * Broadcom tells me:
10977          *   ...the DMA engine is connected to the GRC block and a DMA
10978          *   reset may affect the GRC block in some unpredictable way...
10979          *   The behavior of resets to individual blocks has not been tested.
10980          *
10981          * Broadcom noted the GRC reset will also reset all sub-components.
10982          */
10983         if (to_device) {
10984                 test_desc.cqid_sqid = (13 << 8) | 2;
10985
10986                 tw32_f(RDMAC_MODE, RDMAC_MODE_ENABLE);
10987                 udelay(40);
10988         } else {
10989                 test_desc.cqid_sqid = (16 << 8) | 7;
10990
10991                 tw32_f(WDMAC_MODE, WDMAC_MODE_ENABLE);
10992                 udelay(40);
10993         }
10994         test_desc.flags = 0x00000005;
10995
10996         for (i = 0; i < (sizeof(test_desc) / sizeof(u32)); i++) {
10997                 u32 val;
10998
10999                 val = *(((u32 *)&test_desc) + i);
11000                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR,
11001                                        sram_dma_descs + (i * sizeof(u32)));
11002                 pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
11003         }
11004         pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
11005
11006         if (to_device) {
11007                 tw32(FTQ_DMA_HIGH_READ_FIFO_ENQDEQ, sram_dma_descs);
11008         } else {
11009                 tw32(FTQ_DMA_HIGH_WRITE_FIFO_ENQDEQ, sram_dma_descs);
11010         }
11011
11012         ret = -ENODEV;
11013         for (i = 0; i < 40; i++) {
11014                 u32 val;
11015
11016                 if (to_device)
11017                         val = tr32(FTQ_RCVBD_COMP_FIFO_ENQDEQ);
11018                 else
11019                         val = tr32(FTQ_RCVDATA_COMP_FIFO_ENQDEQ);
11020                 if ((val & 0xffff) == sram_dma_descs) {
11021                         ret = 0;
11022                         break;
11023                 }
11024
11025                 udelay(100);
11026         }
11027
11028         return ret;
11029 }
11030
11031 #define TEST_BUFFER_SIZE        0x2000
11032
11033 static int __devinit tg3_test_dma(struct tg3 *tp)
11034 {
11035         dma_addr_t buf_dma;
11036         u32 *buf, saved_dma_rwctrl;
11037         int ret;
11038
11039         buf = pci_alloc_consistent(tp->pdev, TEST_BUFFER_SIZE, &buf_dma);
11040         if (!buf) {
11041                 ret = -ENOMEM;
11042                 goto out_nofree;
11043         }
11044
11045         tp->dma_rwctrl = ((0x7 << DMA_RWCTRL_PCI_WRITE_CMD_SHIFT) |
11046                           (0x6 << DMA_RWCTRL_PCI_READ_CMD_SHIFT));
11047
11048         tp->dma_rwctrl = tg3_calc_dma_bndry(tp, tp->dma_rwctrl);
11049
11050         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
11051                 /* DMA read watermark not used on PCIE */
11052                 tp->dma_rwctrl |= 0x00180000;
11053         } else if (!(tp->tg3_flags & TG3_FLAG_PCIX_MODE)) {
11054                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 ||
11055                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
11056                         tp->dma_rwctrl |= 0x003f0000;
11057                 else
11058                         tp->dma_rwctrl |= 0x003f000f;
11059         } else {
11060                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
11061                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) {
11062                         u32 ccval = (tr32(TG3PCI_CLOCK_CTRL) & 0x1f);
11063
11064                         /* If the 5704 is behind the EPB bridge, we can
11065                          * do the less restrictive ONE_DMA workaround for
11066                          * better performance.
11067                          */
11068                         if ((tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG) &&
11069                             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
11070                                 tp->dma_rwctrl |= 0x8000;
11071                         else if (ccval == 0x6 || ccval == 0x7)
11072                                 tp->dma_rwctrl |= DMA_RWCTRL_ONE_DMA;
11073
11074                         /* Set bit 23 to enable PCIX hw bug fix */
11075                         tp->dma_rwctrl |= 0x009f0000;
11076                 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780) {
11077                         /* 5780 always in PCIX mode */
11078                         tp->dma_rwctrl |= 0x00144000;
11079                 } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714) {
11080                         /* 5714 always in PCIX mode */
11081                         tp->dma_rwctrl |= 0x00148000;
11082                 } else {
11083                         tp->dma_rwctrl |= 0x001b000f;
11084                 }
11085         }
11086
11087         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5703 ||
11088             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704)
11089                 tp->dma_rwctrl &= 0xfffffff0;
11090
11091         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
11092             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701) {
11093                 /* Remove this if it causes problems for some boards. */
11094                 tp->dma_rwctrl |= DMA_RWCTRL_USE_MEM_READ_MULT;
11095
11096                 /* On 5700/5701 chips, we need to set this bit.
11097                  * Otherwise the chip will issue cacheline transactions
11098                  * to streamable DMA memory with not all the byte
11099                  * enables turned on.  This is an error on several
11100                  * RISC PCI controllers, in particular sparc64.
11101                  *
11102                  * On 5703/5704 chips, this bit has been reassigned
11103                  * a different meaning.  In particular, it is used
11104                  * on those chips to enable a PCI-X workaround.
11105                  */
11106                 tp->dma_rwctrl |= DMA_RWCTRL_ASSERT_ALL_BE;
11107         }
11108
11109         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
11110
11111 #if 0
11112         /* Unneeded, already done by tg3_get_invariants.  */
11113         tg3_switch_clocks(tp);
11114 #endif
11115
11116         ret = 0;
11117         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5700 &&
11118             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701)
11119                 goto out;
11120
11121         /* It is best to perform DMA test with maximum write burst size
11122          * to expose the 5700/5701 write DMA bug.
11123          */
11124         saved_dma_rwctrl = tp->dma_rwctrl;
11125         tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
11126         tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
11127
11128         while (1) {
11129                 u32 *p = buf, i;
11130
11131                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++)
11132                         p[i] = i;
11133
11134                 /* Send the buffer to the chip. */
11135                 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, 1);
11136                 if (ret) {
11137                         printk(KERN_ERR "tg3_test_dma() Write the buffer failed %d\n", ret);
11138                         break;
11139                 }
11140
11141 #if 0
11142                 /* validate data reached card RAM correctly. */
11143                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
11144                         u32 val;
11145                         tg3_read_mem(tp, 0x2100 + (i*4), &val);
11146                         if (le32_to_cpu(val) != p[i]) {
11147                                 printk(KERN_ERR "  tg3_test_dma()  Card buffer corrupted on write! (%d != %d)\n", val, i);
11148                                 /* ret = -ENODEV here? */
11149                         }
11150                         p[i] = 0;
11151                 }
11152 #endif
11153                 /* Now read it back. */
11154                 ret = tg3_do_test_dma(tp, buf, buf_dma, TEST_BUFFER_SIZE, 0);
11155                 if (ret) {
11156                         printk(KERN_ERR "tg3_test_dma() Read the buffer failed %d\n", ret);
11157
11158                         break;
11159                 }
11160
11161                 /* Verify it. */
11162                 for (i = 0; i < TEST_BUFFER_SIZE / sizeof(u32); i++) {
11163                         if (p[i] == i)
11164                                 continue;
11165
11166                         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
11167                             DMA_RWCTRL_WRITE_BNDRY_16) {
11168                                 tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
11169                                 tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
11170                                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
11171                                 break;
11172                         } else {
11173                                 printk(KERN_ERR "tg3_test_dma() buffer corrupted on read back! (%d != %d)\n", p[i], i);
11174                                 ret = -ENODEV;
11175                                 goto out;
11176                         }
11177                 }
11178
11179                 if (i == (TEST_BUFFER_SIZE / sizeof(u32))) {
11180                         /* Success. */
11181                         ret = 0;
11182                         break;
11183                 }
11184         }
11185         if ((tp->dma_rwctrl & DMA_RWCTRL_WRITE_BNDRY_MASK) !=
11186             DMA_RWCTRL_WRITE_BNDRY_16) {
11187                 static struct pci_device_id dma_wait_state_chipsets[] = {
11188                         { PCI_DEVICE(PCI_VENDOR_ID_APPLE,
11189                                      PCI_DEVICE_ID_APPLE_UNI_N_PCI15) },
11190                         { },
11191                 };
11192
11193                 /* DMA test passed without adjusting DMA boundary,
11194                  * now look for chipsets that are known to expose the
11195                  * DMA bug without failing the test.
11196                  */
11197                 if (pci_dev_present(dma_wait_state_chipsets)) {
11198                         tp->dma_rwctrl &= ~DMA_RWCTRL_WRITE_BNDRY_MASK;
11199                         tp->dma_rwctrl |= DMA_RWCTRL_WRITE_BNDRY_16;
11200                 }
11201                 else
11202                         /* Safe to use the calculated DMA boundary. */
11203                         tp->dma_rwctrl = saved_dma_rwctrl;
11204
11205                 tw32(TG3PCI_DMA_RW_CTRL, tp->dma_rwctrl);
11206         }
11207
11208 out:
11209         pci_free_consistent(tp->pdev, TEST_BUFFER_SIZE, buf, buf_dma);
11210 out_nofree:
11211         return ret;
11212 }
11213
11214 static void __devinit tg3_init_link_config(struct tg3 *tp)
11215 {
11216         tp->link_config.advertising =
11217                 (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
11218                  ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full |
11219                  ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full |
11220                  ADVERTISED_Autoneg | ADVERTISED_MII);
11221         tp->link_config.speed = SPEED_INVALID;
11222         tp->link_config.duplex = DUPLEX_INVALID;
11223         tp->link_config.autoneg = AUTONEG_ENABLE;
11224         tp->link_config.active_speed = SPEED_INVALID;
11225         tp->link_config.active_duplex = DUPLEX_INVALID;
11226         tp->link_config.phy_is_low_power = 0;
11227         tp->link_config.orig_speed = SPEED_INVALID;
11228         tp->link_config.orig_duplex = DUPLEX_INVALID;
11229         tp->link_config.orig_autoneg = AUTONEG_INVALID;
11230 }
11231
11232 static void __devinit tg3_init_bufmgr_config(struct tg3 *tp)
11233 {
11234         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
11235                 tp->bufmgr_config.mbuf_read_dma_low_water =
11236                         DEFAULT_MB_RDMA_LOW_WATER_5705;
11237                 tp->bufmgr_config.mbuf_mac_rx_low_water =
11238                         DEFAULT_MB_MACRX_LOW_WATER_5705;
11239                 tp->bufmgr_config.mbuf_high_water =
11240                         DEFAULT_MB_HIGH_WATER_5705;
11241
11242                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
11243                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO_5780;
11244                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
11245                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO_5780;
11246                 tp->bufmgr_config.mbuf_high_water_jumbo =
11247                         DEFAULT_MB_HIGH_WATER_JUMBO_5780;
11248         } else {
11249                 tp->bufmgr_config.mbuf_read_dma_low_water =
11250                         DEFAULT_MB_RDMA_LOW_WATER;
11251                 tp->bufmgr_config.mbuf_mac_rx_low_water =
11252                         DEFAULT_MB_MACRX_LOW_WATER;
11253                 tp->bufmgr_config.mbuf_high_water =
11254                         DEFAULT_MB_HIGH_WATER;
11255
11256                 tp->bufmgr_config.mbuf_read_dma_low_water_jumbo =
11257                         DEFAULT_MB_RDMA_LOW_WATER_JUMBO;
11258                 tp->bufmgr_config.mbuf_mac_rx_low_water_jumbo =
11259                         DEFAULT_MB_MACRX_LOW_WATER_JUMBO;
11260                 tp->bufmgr_config.mbuf_high_water_jumbo =
11261                         DEFAULT_MB_HIGH_WATER_JUMBO;
11262         }
11263
11264         tp->bufmgr_config.dma_low_water = DEFAULT_DMA_LOW_WATER;
11265         tp->bufmgr_config.dma_high_water = DEFAULT_DMA_HIGH_WATER;
11266 }
11267
11268 static char * __devinit tg3_phy_string(struct tg3 *tp)
11269 {
11270         switch (tp->phy_id & PHY_ID_MASK) {
11271         case PHY_ID_BCM5400:    return "5400";
11272         case PHY_ID_BCM5401:    return "5401";
11273         case PHY_ID_BCM5411:    return "5411";
11274         case PHY_ID_BCM5701:    return "5701";
11275         case PHY_ID_BCM5703:    return "5703";
11276         case PHY_ID_BCM5704:    return "5704";
11277         case PHY_ID_BCM5705:    return "5705";
11278         case PHY_ID_BCM5750:    return "5750";
11279         case PHY_ID_BCM5752:    return "5752";
11280         case PHY_ID_BCM5714:    return "5714";
11281         case PHY_ID_BCM5780:    return "5780";
11282         case PHY_ID_BCM5755:    return "5755";
11283         case PHY_ID_BCM5787:    return "5787";
11284         case PHY_ID_BCM8002:    return "8002/serdes";
11285         case 0:                 return "serdes";
11286         default:                return "unknown";
11287         };
11288 }
11289
11290 static char * __devinit tg3_bus_string(struct tg3 *tp, char *str)
11291 {
11292         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
11293                 strcpy(str, "PCI Express");
11294                 return str;
11295         } else if (tp->tg3_flags & TG3_FLAG_PCIX_MODE) {
11296                 u32 clock_ctrl = tr32(TG3PCI_CLOCK_CTRL) & 0x1f;
11297
11298                 strcpy(str, "PCIX:");
11299
11300                 if ((clock_ctrl == 7) ||
11301                     ((tr32(GRC_MISC_CFG) & GRC_MISC_CFG_BOARD_ID_MASK) ==
11302                      GRC_MISC_CFG_BOARD_ID_5704CIOBE))
11303                         strcat(str, "133MHz");
11304                 else if (clock_ctrl == 0)
11305                         strcat(str, "33MHz");
11306                 else if (clock_ctrl == 2)
11307                         strcat(str, "50MHz");
11308                 else if (clock_ctrl == 4)
11309                         strcat(str, "66MHz");
11310                 else if (clock_ctrl == 6)
11311                         strcat(str, "100MHz");
11312         } else {
11313                 strcpy(str, "PCI:");
11314                 if (tp->tg3_flags & TG3_FLAG_PCI_HIGH_SPEED)
11315                         strcat(str, "66MHz");
11316                 else
11317                         strcat(str, "33MHz");
11318         }
11319         if (tp->tg3_flags & TG3_FLAG_PCI_32BIT)
11320                 strcat(str, ":32-bit");
11321         else
11322                 strcat(str, ":64-bit");
11323         return str;
11324 }
11325
11326 static struct pci_dev * __devinit tg3_find_peer(struct tg3 *tp)
11327 {
11328         struct pci_dev *peer;
11329         unsigned int func, devnr = tp->pdev->devfn & ~7;
11330
11331         for (func = 0; func < 8; func++) {
11332                 peer = pci_get_slot(tp->pdev->bus, devnr | func);
11333                 if (peer && peer != tp->pdev)
11334                         break;
11335                 pci_dev_put(peer);
11336         }
11337         /* 5704 can be configured in single-port mode, set peer to
11338          * tp->pdev in that case.
11339          */
11340         if (!peer) {
11341                 peer = tp->pdev;
11342                 return peer;
11343         }
11344
11345         /*
11346          * We don't need to keep the refcount elevated; there's no way
11347          * to remove one half of this device without removing the other
11348          */
11349         pci_dev_put(peer);
11350
11351         return peer;
11352 }
11353
11354 static void __devinit tg3_init_coal(struct tg3 *tp)
11355 {
11356         struct ethtool_coalesce *ec = &tp->coal;
11357
11358         memset(ec, 0, sizeof(*ec));
11359         ec->cmd = ETHTOOL_GCOALESCE;
11360         ec->rx_coalesce_usecs = LOW_RXCOL_TICKS;
11361         ec->tx_coalesce_usecs = LOW_TXCOL_TICKS;
11362         ec->rx_max_coalesced_frames = LOW_RXMAX_FRAMES;
11363         ec->tx_max_coalesced_frames = LOW_TXMAX_FRAMES;
11364         ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT;
11365         ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT;
11366         ec->rx_max_coalesced_frames_irq = DEFAULT_RXCOAL_MAXF_INT;
11367         ec->tx_max_coalesced_frames_irq = DEFAULT_TXCOAL_MAXF_INT;
11368         ec->stats_block_coalesce_usecs = DEFAULT_STAT_COAL_TICKS;
11369
11370         if (tp->coalesce_mode & (HOSTCC_MODE_CLRTICK_RXBD |
11371                                  HOSTCC_MODE_CLRTICK_TXBD)) {
11372                 ec->rx_coalesce_usecs = LOW_RXCOL_TICKS_CLRTCKS;
11373                 ec->rx_coalesce_usecs_irq = DEFAULT_RXCOAL_TICK_INT_CLRTCKS;
11374                 ec->tx_coalesce_usecs = LOW_TXCOL_TICKS_CLRTCKS;
11375                 ec->tx_coalesce_usecs_irq = DEFAULT_TXCOAL_TICK_INT_CLRTCKS;
11376         }
11377
11378         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
11379                 ec->rx_coalesce_usecs_irq = 0;
11380                 ec->tx_coalesce_usecs_irq = 0;
11381                 ec->stats_block_coalesce_usecs = 0;
11382         }
11383 }
11384
11385 static int __devinit tg3_init_one(struct pci_dev *pdev,
11386                                   const struct pci_device_id *ent)
11387 {
11388         static int tg3_version_printed = 0;
11389         unsigned long tg3reg_base, tg3reg_len;
11390         struct net_device *dev;
11391         struct tg3 *tp;
11392         int i, err, pm_cap;
11393         char str[40];
11394         u64 dma_mask, persist_dma_mask;
11395
11396         if (tg3_version_printed++ == 0)
11397                 printk(KERN_INFO "%s", version);
11398
11399         err = pci_enable_device(pdev);
11400         if (err) {
11401                 printk(KERN_ERR PFX "Cannot enable PCI device, "
11402                        "aborting.\n");
11403                 return err;
11404         }
11405
11406         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
11407                 printk(KERN_ERR PFX "Cannot find proper PCI device "
11408                        "base address, aborting.\n");
11409                 err = -ENODEV;
11410                 goto err_out_disable_pdev;
11411         }
11412
11413         err = pci_request_regions(pdev, DRV_MODULE_NAME);
11414         if (err) {
11415                 printk(KERN_ERR PFX "Cannot obtain PCI resources, "
11416                        "aborting.\n");
11417                 goto err_out_disable_pdev;
11418         }
11419
11420         pci_set_master(pdev);
11421
11422         /* Find power-management capability. */
11423         pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM);
11424         if (pm_cap == 0) {
11425                 printk(KERN_ERR PFX "Cannot find PowerManagement capability, "
11426                        "aborting.\n");
11427                 err = -EIO;
11428                 goto err_out_free_res;
11429         }
11430
11431         tg3reg_base = pci_resource_start(pdev, 0);
11432         tg3reg_len = pci_resource_len(pdev, 0);
11433
11434         dev = alloc_etherdev(sizeof(*tp));
11435         if (!dev) {
11436                 printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
11437                 err = -ENOMEM;
11438                 goto err_out_free_res;
11439         }
11440
11441         SET_MODULE_OWNER(dev);
11442         SET_NETDEV_DEV(dev, &pdev->dev);
11443
11444 #if TG3_VLAN_TAG_USED
11445         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
11446         dev->vlan_rx_register = tg3_vlan_rx_register;
11447         dev->vlan_rx_kill_vid = tg3_vlan_rx_kill_vid;
11448 #endif
11449
11450         tp = netdev_priv(dev);
11451         tp->pdev = pdev;
11452         tp->dev = dev;
11453         tp->pm_cap = pm_cap;
11454         tp->mac_mode = TG3_DEF_MAC_MODE;
11455         tp->rx_mode = TG3_DEF_RX_MODE;
11456         tp->tx_mode = TG3_DEF_TX_MODE;
11457         tp->mi_mode = MAC_MI_MODE_BASE;
11458         if (tg3_debug > 0)
11459                 tp->msg_enable = tg3_debug;
11460         else
11461                 tp->msg_enable = TG3_DEF_MSG_ENABLE;
11462
11463         /* The word/byte swap controls here control register access byte
11464          * swapping.  DMA data byte swapping is controlled in the GRC_MODE
11465          * setting below.
11466          */
11467         tp->misc_host_ctrl =
11468                 MISC_HOST_CTRL_MASK_PCI_INT |
11469                 MISC_HOST_CTRL_WORD_SWAP |
11470                 MISC_HOST_CTRL_INDIR_ACCESS |
11471                 MISC_HOST_CTRL_PCISTATE_RW;
11472
11473         /* The NONFRM (non-frame) byte/word swap controls take effect
11474          * on descriptor entries, anything which isn't packet data.
11475          *
11476          * The StrongARM chips on the board (one for tx, one for rx)
11477          * are running in big-endian mode.
11478          */
11479         tp->grc_mode = (GRC_MODE_WSWAP_DATA | GRC_MODE_BSWAP_DATA |
11480                         GRC_MODE_WSWAP_NONFRM_DATA);
11481 #ifdef __BIG_ENDIAN
11482         tp->grc_mode |= GRC_MODE_BSWAP_NONFRM_DATA;
11483 #endif
11484         spin_lock_init(&tp->lock);
11485         spin_lock_init(&tp->indirect_lock);
11486         INIT_WORK(&tp->reset_task, tg3_reset_task, tp);
11487
11488         tp->regs = ioremap_nocache(tg3reg_base, tg3reg_len);
11489         if (tp->regs == 0UL) {
11490                 printk(KERN_ERR PFX "Cannot map device registers, "
11491                        "aborting.\n");
11492                 err = -ENOMEM;
11493                 goto err_out_free_dev;
11494         }
11495
11496         tg3_init_link_config(tp);
11497
11498         tp->rx_pending = TG3_DEF_RX_RING_PENDING;
11499         tp->rx_jumbo_pending = TG3_DEF_RX_JUMBO_RING_PENDING;
11500         tp->tx_pending = TG3_DEF_TX_RING_PENDING;
11501
11502         dev->open = tg3_open;
11503         dev->stop = tg3_close;
11504         dev->get_stats = tg3_get_stats;
11505         dev->set_multicast_list = tg3_set_rx_mode;
11506         dev->set_mac_address = tg3_set_mac_addr;
11507         dev->do_ioctl = tg3_ioctl;
11508         dev->tx_timeout = tg3_tx_timeout;
11509         dev->poll = tg3_poll;
11510         dev->ethtool_ops = &tg3_ethtool_ops;
11511         dev->weight = 64;
11512         dev->watchdog_timeo = TG3_TX_TIMEOUT;
11513         dev->change_mtu = tg3_change_mtu;
11514         dev->irq = pdev->irq;
11515 #ifdef CONFIG_NET_POLL_CONTROLLER
11516         dev->poll_controller = tg3_poll_controller;
11517 #endif
11518
11519         err = tg3_get_invariants(tp);
11520         if (err) {
11521                 printk(KERN_ERR PFX "Problem fetching invariants of chip, "
11522                        "aborting.\n");
11523                 goto err_out_iounmap;
11524         }
11525
11526         /* The EPB bridge inside 5714, 5715, and 5780 and any
11527          * device behind the EPB cannot support DMA addresses > 40-bit.
11528          * On 64-bit systems with IOMMU, use 40-bit dma_mask.
11529          * On 64-bit systems without IOMMU, use 64-bit dma_mask and
11530          * do DMA address check in tg3_start_xmit().
11531          */
11532         if (tp->tg3_flags2 & TG3_FLG2_IS_5788)
11533                 persist_dma_mask = dma_mask = DMA_32BIT_MASK;
11534         else if (tp->tg3_flags & TG3_FLAG_40BIT_DMA_BUG) {
11535                 persist_dma_mask = dma_mask = DMA_40BIT_MASK;
11536 #ifdef CONFIG_HIGHMEM
11537                 dma_mask = DMA_64BIT_MASK;
11538 #endif
11539         } else
11540                 persist_dma_mask = dma_mask = DMA_64BIT_MASK;
11541
11542         /* Configure DMA attributes. */
11543         if (dma_mask > DMA_32BIT_MASK) {
11544                 err = pci_set_dma_mask(pdev, dma_mask);
11545                 if (!err) {
11546                         dev->features |= NETIF_F_HIGHDMA;
11547                         err = pci_set_consistent_dma_mask(pdev,
11548                                                           persist_dma_mask);
11549                         if (err < 0) {
11550                                 printk(KERN_ERR PFX "Unable to obtain 64 bit "
11551                                        "DMA for consistent allocations\n");
11552                                 goto err_out_iounmap;
11553                         }
11554                 }
11555         }
11556         if (err || dma_mask == DMA_32BIT_MASK) {
11557                 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
11558                 if (err) {
11559                         printk(KERN_ERR PFX "No usable DMA configuration, "
11560                                "aborting.\n");
11561                         goto err_out_iounmap;
11562                 }
11563         }
11564
11565         tg3_init_bufmgr_config(tp);
11566
11567 #if TG3_TSO_SUPPORT != 0
11568         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
11569                 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
11570         }
11571         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
11572             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701 ||
11573             tp->pci_chip_rev_id == CHIPREV_ID_5705_A0 ||
11574             (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0) {
11575                 tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
11576         } else {
11577                 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
11578         }
11579
11580         /* TSO is on by default on chips that support hardware TSO.
11581          * Firmware TSO on older chips gives lower performance, so it
11582          * is off by default, but can be enabled using ethtool.
11583          */
11584         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
11585                 dev->features |= NETIF_F_TSO;
11586                 if (tp->tg3_flags2 & TG3_FLG2_HW_TSO_2)
11587                         dev->features |= NETIF_F_TSO6;
11588         }
11589
11590 #endif
11591
11592         if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 &&
11593             !(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) &&
11594             !(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH)) {
11595                 tp->tg3_flags2 |= TG3_FLG2_MAX_RXPEND_64;
11596                 tp->rx_pending = 63;
11597         }
11598
11599         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) ||
11600             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714))
11601                 tp->pdev_peer = tg3_find_peer(tp);
11602
11603         err = tg3_get_device_address(tp);
11604         if (err) {
11605                 printk(KERN_ERR PFX "Could not obtain valid ethernet address, "
11606                        "aborting.\n");
11607                 goto err_out_iounmap;
11608         }
11609
11610         /*
11611          * Reset chip in case UNDI or EFI driver did not shutdown
11612          * DMA self test will enable WDMAC and we'll see (spurious)
11613          * pending DMA on the PCI bus at that point.
11614          */
11615         if ((tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE) ||
11616             (tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
11617                 pci_save_state(tp->pdev);
11618                 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
11619                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
11620         }
11621
11622         err = tg3_test_dma(tp);
11623         if (err) {
11624                 printk(KERN_ERR PFX "DMA engine test failed, aborting.\n");
11625                 goto err_out_iounmap;
11626         }
11627
11628         /* Tigon3 can do ipv4 only... and some chips have buggy
11629          * checksumming.
11630          */
11631         if ((tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) == 0) {
11632                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
11633                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
11634                         dev->features |= NETIF_F_HW_CSUM;
11635                 else
11636                         dev->features |= NETIF_F_IP_CSUM;
11637                 dev->features |= NETIF_F_SG;
11638                 tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
11639         } else
11640                 tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
11641
11642         /* flow control autonegotiation is default behavior */
11643         tp->tg3_flags |= TG3_FLAG_PAUSE_AUTONEG;
11644
11645         tg3_init_coal(tp);
11646
11647         /* Now that we have fully setup the chip, save away a snapshot
11648          * of the PCI config space.  We need to restore this after
11649          * GRC_MISC_CFG core clock resets and some resume events.
11650          */
11651         pci_save_state(tp->pdev);
11652
11653         err = register_netdev(dev);
11654         if (err) {
11655                 printk(KERN_ERR PFX "Cannot register net device, "
11656                        "aborting.\n");
11657                 goto err_out_iounmap;
11658         }
11659
11660         pci_set_drvdata(pdev, dev);
11661
11662         printk(KERN_INFO "%s: Tigon3 [partno(%s) rev %04x PHY(%s)] (%s) %sBaseT Ethernet ",
11663                dev->name,
11664                tp->board_part_number,
11665                tp->pci_chip_rev_id,
11666                tg3_phy_string(tp),
11667                tg3_bus_string(tp, str),
11668                (tp->tg3_flags & TG3_FLAG_10_100_ONLY) ? "10/100" : "10/100/1000");
11669
11670         for (i = 0; i < 6; i++)
11671                 printk("%2.2x%c", dev->dev_addr[i],
11672                        i == 5 ? '\n' : ':');
11673
11674         printk(KERN_INFO "%s: RXcsums[%d] LinkChgREG[%d] "
11675                "MIirq[%d] ASF[%d] Split[%d] WireSpeed[%d] "
11676                "TSOcap[%d] \n",
11677                dev->name,
11678                (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0,
11679                (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) != 0,
11680                (tp->tg3_flags & TG3_FLAG_USE_MI_INTERRUPT) != 0,
11681                (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0,
11682                (tp->tg3_flags & TG3_FLAG_SPLIT_MODE) != 0,
11683                (tp->tg3_flags2 & TG3_FLG2_NO_ETH_WIRE_SPEED) == 0,
11684                (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) != 0);
11685         printk(KERN_INFO "%s: dma_rwctrl[%08x] dma_mask[%d-bit]\n",
11686                dev->name, tp->dma_rwctrl,
11687                (pdev->dma_mask == DMA_32BIT_MASK) ? 32 :
11688                 (((u64) pdev->dma_mask == DMA_40BIT_MASK) ? 40 : 64));
11689
11690         netif_carrier_off(tp->dev);
11691
11692         return 0;
11693
11694 err_out_iounmap:
11695         if (tp->regs) {
11696                 iounmap(tp->regs);
11697                 tp->regs = NULL;
11698         }
11699
11700 err_out_free_dev:
11701         free_netdev(dev);
11702
11703 err_out_free_res:
11704         pci_release_regions(pdev);
11705
11706 err_out_disable_pdev:
11707         pci_disable_device(pdev);
11708         pci_set_drvdata(pdev, NULL);
11709         return err;
11710 }
11711
11712 static void __devexit tg3_remove_one(struct pci_dev *pdev)
11713 {
11714         struct net_device *dev = pci_get_drvdata(pdev);
11715
11716         if (dev) {
11717                 struct tg3 *tp = netdev_priv(dev);
11718
11719                 flush_scheduled_work();
11720                 unregister_netdev(dev);
11721                 if (tp->regs) {
11722                         iounmap(tp->regs);
11723                         tp->regs = NULL;
11724                 }
11725                 free_netdev(dev);
11726                 pci_release_regions(pdev);
11727                 pci_disable_device(pdev);
11728                 pci_set_drvdata(pdev, NULL);
11729         }
11730 }
11731
11732 static int tg3_suspend(struct pci_dev *pdev, pm_message_t state)
11733 {
11734         struct net_device *dev = pci_get_drvdata(pdev);
11735         struct tg3 *tp = netdev_priv(dev);
11736         int err;
11737
11738         if (!netif_running(dev))
11739                 return 0;
11740
11741         flush_scheduled_work();
11742         tg3_netif_stop(tp);
11743
11744         del_timer_sync(&tp->timer);
11745
11746         tg3_full_lock(tp, 1);
11747         tg3_disable_ints(tp);
11748         tg3_full_unlock(tp);
11749
11750         netif_device_detach(dev);
11751
11752         tg3_full_lock(tp, 0);
11753         tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
11754         tp->tg3_flags &= ~TG3_FLAG_INIT_COMPLETE;
11755         tg3_full_unlock(tp);
11756
11757         err = tg3_set_power_state(tp, pci_choose_state(pdev, state));
11758         if (err) {
11759                 tg3_full_lock(tp, 0);
11760
11761                 tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
11762                 if (tg3_restart_hw(tp, 1))
11763                         goto out;
11764
11765                 tp->timer.expires = jiffies + tp->timer_offset;
11766                 add_timer(&tp->timer);
11767
11768                 netif_device_attach(dev);
11769                 tg3_netif_start(tp);
11770
11771 out:
11772                 tg3_full_unlock(tp);
11773         }
11774
11775         return err;
11776 }
11777
11778 static int tg3_resume(struct pci_dev *pdev)
11779 {
11780         struct net_device *dev = pci_get_drvdata(pdev);
11781         struct tg3 *tp = netdev_priv(dev);
11782         int err;
11783
11784         if (!netif_running(dev))
11785                 return 0;
11786
11787         pci_restore_state(tp->pdev);
11788
11789         err = tg3_set_power_state(tp, PCI_D0);
11790         if (err)
11791                 return err;
11792
11793         netif_device_attach(dev);
11794
11795         tg3_full_lock(tp, 0);
11796
11797         tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
11798         err = tg3_restart_hw(tp, 1);
11799         if (err)
11800                 goto out;
11801
11802         tp->timer.expires = jiffies + tp->timer_offset;
11803         add_timer(&tp->timer);
11804
11805         tg3_netif_start(tp);
11806
11807 out:
11808         tg3_full_unlock(tp);
11809
11810         return err;
11811 }
11812
11813 static struct pci_driver tg3_driver = {
11814         .name           = DRV_MODULE_NAME,
11815         .id_table       = tg3_pci_tbl,
11816         .probe          = tg3_init_one,
11817         .remove         = __devexit_p(tg3_remove_one),
11818         .suspend        = tg3_suspend,
11819         .resume         = tg3_resume
11820 };
11821
11822 static int __init tg3_init(void)
11823 {
11824         return pci_module_init(&tg3_driver);
11825 }
11826
11827 static void __exit tg3_cleanup(void)
11828 {
11829         pci_unregister_driver(&tg3_driver);
11830 }
11831
11832 module_init(tg3_init);
11833 module_exit(tg3_cleanup);