drivers/net/8139too.c

   1 /*
   2
   3         8139too.c: A RealTek RTL-8139 Fast Ethernet driver for Linux.
   4
   5         Maintained by Jeff Garzik <jgarzik@pobox.com>
   6         Copyright 2000-2002 Jeff Garzik
   7
   8         Much code comes from Donald Becker's rtl8139.c driver,
   9         versions 1.13 and older.  This driver was originally based
  10         on rtl8139.c version 1.07.  Header of rtl8139.c version 1.13:
  11
  12         -----<snip>-----
  13
  14                 Written 1997-2001 by Donald Becker.
  15                 This software may be used and distributed according to the
  16                 terms of the GNU General Public License (GPL), incorporated
  17                 herein by reference.  Drivers based on or derived from this
  18                 code fall under the GPL and must retain the authorship,
  19                 copyright and license notice.  This file is not a complete
  20                 program and may only be used when the entire operating
  21                 system is licensed under the GPL.
  22
  23                 This driver is for boards based on the RTL8129 and RTL8139
  24                 PCI ethernet chips.
  25
  26                 The author may be reached as becker@scyld.com, or C/O Scyld
  27                 Computing Corporation 410 Severn Ave., Suite 210 Annapolis
  28                 MD 21403
  29
  30                 Support and updates available at
  31                 http://www.scyld.com/network/rtl8139.html
  32
  33                 Twister-tuning table provided by Kinston
  34                 <shangh@realtek.com.tw>.
  35
  36         -----<snip>-----
  37
  38         This software may be used and distributed according to the terms
  39         of the GNU General Public License, incorporated herein by reference.
  40
  41         Contributors:
  42
  43                 Donald Becker - he wrote the original driver, kudos to him!
  44                 (but please don't e-mail him for support, this isn't his driver)
  45
  46                 Tigran Aivazian - bug fixes, skbuff free cleanup
  47
  48                 Martin Mares - suggestions for PCI cleanup
  49
  50                 David S. Miller - PCI DMA and softnet updates
  51
  52                 Ernst Gill - fixes ported from BSD driver
  53
  54                 Daniel Kobras - identified specific locations of
  55                         posted MMIO write bugginess
  56
  57                 Gerard Sharp - bug fix, testing and feedback
  58
  59                 David Ford - Rx ring wrap fix
  60
  61                 Dan DeMaggio - swapped RTL8139 cards with me, and allowed me
  62                 to find and fix a crucial bug on older chipsets.
  63
  64                 Donald Becker/Chris Butterworth/Marcus Westergren -
  65                 Noticed various Rx packet size-related buglets.
  66
  67                 Santiago Garcia Mantinan - testing and feedback
  68
  69                 Jens David - 2.2.x kernel backports
  70
  71                 Martin Dennett - incredibly helpful insight on undocumented
  72                 features of the 8139 chips
  73
  74                 Jean-Jacques Michel - bug fix
  75
  76                 Tobias Ringström - Rx interrupt status checking suggestion
  77
  78                 Andrew Morton - Clear blocked signals, avoid
  79                 buffer overrun setting current->comm.
  80
  81                 Kalle Olavi Niemitalo - Wake-on-LAN ioctls
  82
  83                 Robert Kuebel - Save kernel thread from dying on any signal.
  84
  85         Submitting bug reports:
  86
  87                 "rtl8139-diag -mmmaaavvveefN" output
  88                 enable RTL8139_DEBUG below, and look at 'dmesg' or kernel log
  89
  90 */
  91
  92 #define DRV_NAME        "8139too"
  93 #define DRV_VERSION     "0.9.27"
  94
  95
  96 #include <linux/config.h>
  97 #include <linux/module.h>
  98 #include <linux/kernel.h>
  99 #include <linux/compiler.h>
 100 #include <linux/pci.h>
 101 #include <linux/init.h>
 102 #include <linux/ioport.h>
 103 #include <linux/netdevice.h>
 104 #include <linux/etherdevice.h>
 105 #include <linux/rtnetlink.h>
 106 #include <linux/delay.h>
 107 #include <linux/ethtool.h>
 108 #include <linux/mii.h>
 109 #include <linux/completion.h>
 110 #include <linux/crc32.h>
 111 #include <asm/io.h>
 112 #include <asm/uaccess.h>
 113 #include <asm/irq.h>
 114
 115 #define RTL8139_DRIVER_NAME   DRV_NAME " Fast Ethernet driver " DRV_VERSION
 116 #define PFX DRV_NAME ": "
 117
 118 /* Default Message level */
 119 #define RTL8139_DEF_MSG_ENABLE   (NETIF_MSG_DRV   | \
 120                                  NETIF_MSG_PROBE  | \
 121                                  NETIF_MSG_LINK)
 122
 123
 124 /* enable PIO instead of MMIO, if CONFIG_8139TOO_PIO is selected */
 125 #ifdef CONFIG_8139TOO_PIO
 126 #define USE_IO_OPS 1
 127 #endif
 128
 129 /* define to 1, 2 or 3 to enable copious debugging info */
 130 #define RTL8139_DEBUG 0
 131
 132 /* define to 1 to disable lightweight runtime debugging checks */
 133 #undef RTL8139_NDEBUG
 134
 135
 136 #if RTL8139_DEBUG
 137 /* note: prints function name for you */
 138 #  define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
 139 #else
 140 #  define DPRINTK(fmt, args...)
 141 #endif
 142
 143 #ifdef RTL8139_NDEBUG
 144 #  define assert(expr) do {} while (0)
 145 #else
 146 #  define assert(expr) \
 147         if(unlikely(!(expr))) {                                 \
 148         printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
 149         #expr,__FILE__,__FUNCTION__,__LINE__);                  \
 150         }
 151 #endif
 152
 153
 154 /* A few user-configurable values. */
 155 /* media options */
 156 #define MAX_UNITS 8
 157 static int media[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
 158 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
 159
 160 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
 161    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
 162 static int multicast_filter_limit = 32;
 163
 164 /* bitmapped message enable number */
 165 static int debug = -1;
 166
 167 /*
 168  * Receive ring size
 169  * Warning: 64K ring has hardware issues and may lock up.
 170  */
 171 #if defined(CONFIG_SH_DREAMCAST)
 172 #define RX_BUF_IDX      1       /* 16K ring */
 173 #else
 174 #define RX_BUF_IDX      2       /* 32K ring */
 175 #endif
 176 #define RX_BUF_LEN      (8192 << RX_BUF_IDX)
 177 #define RX_BUF_PAD      16
 178 #define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
 179
 180 #if RX_BUF_LEN == 65536
 181 #define RX_BUF_TOT_LEN  RX_BUF_LEN
 182 #else
 183 #define RX_BUF_TOT_LEN  (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
 184 #endif
 185
 186 /* Number of Tx descriptor registers. */
 187 #define NUM_TX_DESC     4
 188
 189 /* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
 190 #define MAX_ETH_FRAME_SIZE      1536
 191
 192 /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
 193 #define TX_BUF_SIZE     MAX_ETH_FRAME_SIZE
 194 #define TX_BUF_TOT_LEN  (TX_BUF_SIZE * NUM_TX_DESC)
 195
 196 /* PCI Tuning Parameters
 197    Threshold is bytes transferred to chip before transmission starts. */
 198 #define TX_FIFO_THRESH 256      /* In bytes, rounded down to 32 byte units. */
 199
 200 /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024, 7==end of packet. */
 201 #define RX_FIFO_THRESH  7       /* Rx buffer level before first PCI xfer.  */
 202 #define RX_DMA_BURST    7       /* Maximum PCI burst, '6' is 1024 */
 203 #define TX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
 204 #define TX_RETRY        8       /* 0-15.  retries = 16 + (TX_RETRY * 16) */
 205
 206 /* Operational parameters that usually are not changed. */
 207 /* Time in jiffies before concluding the transmitter is hung. */
 208 #define TX_TIMEOUT  (6*HZ)
 209
 210
 211 enum {
 212         HAS_MII_XCVR = 0x010000,
 213         HAS_CHIP_XCVR = 0x020000,
 214         HAS_LNK_CHNG = 0x040000,
 215 };
 216
 217 #define RTL_NUM_STATS 4         /* number of ETHTOOL_GSTATS u64's */
 218 #define RTL_REGS_VER 1          /* version of reg. data in ETHTOOL_GREGS */
 219 #define RTL_MIN_IO_SIZE 0x80
 220 #define RTL8139B_IO_SIZE 256
 221
 222 #define RTL8129_CAPS    HAS_MII_XCVR
 223 #define RTL8139_CAPS    HAS_CHIP_XCVR|HAS_LNK_CHNG
 224
 225 typedef enum {
 226         RTL8139 = 0,
 227         RTL8129,
 228 } board_t;
 229
 230
 231 /* indexed by board_t, above */
 232 static struct {
 233         const char *name;
 234         u32 hw_flags;
 235 } board_info[] __devinitdata = {
 236         { "RealTek RTL8139", RTL8139_CAPS },
 237         { "RealTek RTL8129", RTL8129_CAPS },
 238 };
 239
 240
 241 static struct pci_device_id rtl8139_pci_tbl[] = {
 242         {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 243         {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 244         {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 245         {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 246         {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 247         {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 248         {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 249         {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 250         {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 251         {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 252         {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 253         {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 254         {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 255         {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 256         {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 257         {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 258         {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 259         {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 260         {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 261
 262 #ifdef CONFIG_SH_SECUREEDGE5410
 263         /* Bogus 8139 silicon reports 8129 without external PROM :-( */
 264         {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 265 #endif
 266 #ifdef CONFIG_8139TOO_8129
 267         {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
 268 #endif
 269
 270         /* some crazy cards report invalid vendor ids like
 271          * 0x0001 here.  The other ids are valid and constant,
 272          * so we simply don't match on the main vendor id.
 273          */
 274         {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
 275         {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
 276         {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
 277
 278         {0,}
 279 };
 280 MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);
 281
 282 static struct {
 283         const char str[ETH_GSTRING_LEN];
 284 } ethtool_stats_keys[] = {
 285         { "early_rx" },
 286         { "tx_buf_mapped" },
 287         { "tx_timeouts" },
 288         { "rx_lost_in_ring" },
 289 };
 290
 291 /* The rest of these values should never change. */
 292
 293 /* Symbolic offsets to registers. */
 294 enum RTL8139_registers {
 295         MAC0 = 0,               /* Ethernet hardware address. */
 296         MAR0 = 8,               /* Multicast filter. */
 297         TxStatus0 = 0x10,       /* Transmit status (Four 32bit registers). */
 298         TxAddr0 = 0x20,         /* Tx descriptors (also four 32bit). */
 299         RxBuf = 0x30,
 300         ChipCmd = 0x37,
 301         RxBufPtr = 0x38,
 302         RxBufAddr = 0x3A,
 303         IntrMask = 0x3C,
 304         IntrStatus = 0x3E,
 305         TxConfig = 0x40,
 306         RxConfig = 0x44,
 307         Timer = 0x48,           /* A general-purpose counter. */
 308         RxMissed = 0x4C,        /* 24 bits valid, write clears. */
 309         Cfg9346 = 0x50,
 310         Config0 = 0x51,
 311         Config1 = 0x52,
 312         FlashReg = 0x54,
 313         MediaStatus = 0x58,
 314         Config3 = 0x59,
 315         Config4 = 0x5A,         /* absent on RTL-8139A */
 316         HltClk = 0x5B,
 317         MultiIntr = 0x5C,
 318         TxSummary = 0x60,
 319         BasicModeCtrl = 0x62,
 320         BasicModeStatus = 0x64,
 321         NWayAdvert = 0x66,
 322         NWayLPAR = 0x68,
 323         NWayExpansion = 0x6A,
 324         /* Undocumented registers, but required for proper operation. */
 325         FIFOTMS = 0x70,         /* FIFO Control and test. */
 326         CSCR = 0x74,            /* Chip Status and Configuration Register. */
 327         PARA78 = 0x78,
 328         PARA7c = 0x7c,          /* Magic transceiver parameter register. */
 329         Config5 = 0xD8,         /* absent on RTL-8139A */
 330 };
 331
 332 enum ClearBitMasks {
 333         MultiIntrClear = 0xF000,
 334         ChipCmdClear = 0xE2,
 335         Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
 336 };
 337
 338 enum ChipCmdBits {
 339         CmdReset = 0x10,
 340         CmdRxEnb = 0x08,
 341         CmdTxEnb = 0x04,
 342         RxBufEmpty = 0x01,
 343 };
 344
 345 /* Interrupt register bits, using my own meaningful names. */
 346 enum IntrStatusBits {
 347         PCIErr = 0x8000,
 348         PCSTimeout = 0x4000,
 349         RxFIFOOver = 0x40,
 350         RxUnderrun = 0x20,
 351         RxOverflow = 0x10,
 352         TxErr = 0x08,
 353         TxOK = 0x04,
 354         RxErr = 0x02,
 355         RxOK = 0x01,
 356
 357         RxAckBits = RxFIFOOver | RxOverflow | RxOK,
 358 };
 359
 360 enum TxStatusBits {
 361         TxHostOwns = 0x2000,
 362         TxUnderrun = 0x4000,
 363         TxStatOK = 0x8000,
 364         TxOutOfWindow = 0x20000000,
 365         TxAborted = 0x40000000,
 366         TxCarrierLost = 0x80000000,
 367 };
 368 enum RxStatusBits {
 369         RxMulticast = 0x8000,
 370         RxPhysical = 0x4000,
 371         RxBroadcast = 0x2000,
 372         RxBadSymbol = 0x0020,
 373         RxRunt = 0x0010,
 374         RxTooLong = 0x0008,
 375         RxCRCErr = 0x0004,
 376         RxBadAlign = 0x0002,
 377         RxStatusOK = 0x0001,
 378 };
 379
 380 /* Bits in RxConfig. */
 381 enum rx_mode_bits {
 382         AcceptErr = 0x20,
 383         AcceptRunt = 0x10,
 384         AcceptBroadcast = 0x08,
 385         AcceptMulticast = 0x04,
 386         AcceptMyPhys = 0x02,
 387         AcceptAllPhys = 0x01,
 388 };
 389
 390 /* Bits in TxConfig. */
 391 enum tx_config_bits {
 392
 393         /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
 394         TxIFGShift = 24,
 395         TxIFG84 = (0 << TxIFGShift),    /* 8.4us / 840ns (10 / 100Mbps) */
 396         TxIFG88 = (1 << TxIFGShift),    /* 8.8us / 880ns (10 / 100Mbps) */
 397         TxIFG92 = (2 << TxIFGShift),    /* 9.2us / 920ns (10 / 100Mbps) */
 398         TxIFG96 = (3 << TxIFGShift),    /* 9.6us / 960ns (10 / 100Mbps) */
 399
 400         TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
 401         TxCRC = (1 << 16),      /* DISABLE appending CRC to end of Tx packets */
 402         TxClearAbt = (1 << 0),  /* Clear abort (WO) */
 403         TxDMAShift = 8,         /* DMA burst value (0-7) is shifted this many bits */
 404         TxRetryShift = 4,       /* TXRR value (0-15) is shifted this many bits */
 405
 406         TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
 407 };
 408
 409 /* Bits in Config1 */
 410 enum Config1Bits {
 411         Cfg1_PM_Enable = 0x01,
 412         Cfg1_VPD_Enable = 0x02,
 413         Cfg1_PIO = 0x04,
 414         Cfg1_MMIO = 0x08,
 415         LWAKE = 0x10,           /* not on 8139, 8139A */
 416         Cfg1_Driver_Load = 0x20,
 417         Cfg1_LED0 = 0x40,
 418         Cfg1_LED1 = 0x80,
 419         SLEEP = (1 << 1),       /* only on 8139, 8139A */
 420         PWRDN = (1 << 0),       /* only on 8139, 8139A */
 421 };
 422
 423 /* Bits in Config3 */
 424 enum Config3Bits {
 425         Cfg3_FBtBEn    = (1 << 0), /* 1 = Fast Back to Back */
 426         Cfg3_FuncRegEn = (1 << 1), /* 1 = enable CardBus Function registers */
 427         Cfg3_CLKRUN_En = (1 << 2), /* 1 = enable CLKRUN */
 428         Cfg3_CardB_En  = (1 << 3), /* 1 = enable CardBus registers */
 429         Cfg3_LinkUp    = (1 << 4), /* 1 = wake up on link up */
 430         Cfg3_Magic     = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
 431         Cfg3_PARM_En   = (1 << 6), /* 0 = software can set twister parameters */
 432         Cfg3_GNTSel    = (1 << 7), /* 1 = delay 1 clock from PCI GNT signal */
 433 };
 434
 435 /* Bits in Config4 */
 436 enum Config4Bits {
 437         LWPTN = (1 << 2),       /* not on 8139, 8139A */
 438 };
 439
 440 /* Bits in Config5 */
 441 enum Config5Bits {
 442         Cfg5_PME_STS     = (1 << 0), /* 1 = PCI reset resets PME_Status */
 443         Cfg5_LANWake     = (1 << 1), /* 1 = enable LANWake signal */
 444         Cfg5_LDPS        = (1 << 2), /* 0 = save power when link is down */
 445         Cfg5_FIFOAddrPtr = (1 << 3), /* Realtek internal SRAM testing */
 446         Cfg5_UWF         = (1 << 4), /* 1 = accept unicast wakeup frame */
 447         Cfg5_MWF         = (1 << 5), /* 1 = accept multicast wakeup frame */
 448         Cfg5_BWF         = (1 << 6), /* 1 = accept broadcast wakeup frame */
 449 };
 450
 451 enum RxConfigBits {
 452         /* rx fifo threshold */
 453         RxCfgFIFOShift = 13,
 454         RxCfgFIFONone = (7 << RxCfgFIFOShift),
 455
 456         /* Max DMA burst */
 457         RxCfgDMAShift = 8,
 458         RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
 459
 460         /* rx ring buffer length */
 461         RxCfgRcv8K = 0,
 462         RxCfgRcv16K = (1 << 11),
 463         RxCfgRcv32K = (1 << 12),
 464         RxCfgRcv64K = (1 << 11) | (1 << 12),
 465
 466         /* Disable packet wrap at end of Rx buffer. (not possible with 64k) */
 467         RxNoWrap = (1 << 7),
 468 };
 469
 470 /* Twister tuning parameters from RealTek.
 471    Completely undocumented, but required to tune bad links on some boards. */
 472 enum CSCRBits {
 473         CSCR_LinkOKBit = 0x0400,
 474         CSCR_LinkChangeBit = 0x0800,
 475         CSCR_LinkStatusBits = 0x0f000,
 476         CSCR_LinkDownOffCmd = 0x003c0,
 477         CSCR_LinkDownCmd = 0x0f3c0,
 478 };
 479
 480 enum Cfg9346Bits {
 481         Cfg9346_Lock = 0x00,
 482         Cfg9346_Unlock = 0xC0,
 483 };
 484
 485 typedef enum {
 486         CH_8139 = 0,
 487         CH_8139_K,
 488         CH_8139A,
 489         CH_8139A_G,
 490         CH_8139B,
 491         CH_8130,
 492         CH_8139C,
 493         CH_8100,
 494         CH_8100B_8139D,
 495         CH_8101,
 496 } chip_t;
 497
 498 enum chip_flags {
 499         HasHltClk = (1 << 0),
 500         HasLWake = (1 << 1),
 501 };
 502
 503 #define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \
 504         (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
 505 #define HW_REVID_MASK   HW_REVID(1, 1, 1, 1, 1, 1, 1)
 506
 507 /* directly indexed by chip_t, above */
 508 const static struct {
 509         const char *name;
 510         u32 version; /* from RTL8139C/RTL8139D docs */
 511         u32 flags;
 512 } rtl_chip_info[] = {
 513         { "RTL-8139",
 514           HW_REVID(1, 0, 0, 0, 0, 0, 0),
 515           HasHltClk,
 516         },
 517
 518         { "RTL-8139 rev K",
 519           HW_REVID(1, 1, 0, 0, 0, 0, 0),
 520           HasHltClk,
 521         },
 522
 523         { "RTL-8139A",
 524           HW_REVID(1, 1, 1, 0, 0, 0, 0),
 525           HasHltClk, /* XXX undocumented? */
 526         },
 527
 528         { "RTL-8139A rev G",
 529           HW_REVID(1, 1, 1, 0, 0, 1, 0),
 530           HasHltClk, /* XXX undocumented? */
 531         },
 532
 533         { "RTL-8139B",
 534           HW_REVID(1, 1, 1, 1, 0, 0, 0),
 535           HasLWake,
 536         },
 537
 538         { "RTL-8130",
 539           HW_REVID(1, 1, 1, 1, 1, 0, 0),
 540           HasLWake,
 541         },
 542
 543         { "RTL-8139C",
 544           HW_REVID(1, 1, 1, 0, 1, 0, 0),
 545           HasLWake,
 546         },
 547
 548         { "RTL-8100",
 549           HW_REVID(1, 1, 1, 1, 0, 1, 0),
 550           HasLWake,
 551         },
 552
 553         { "RTL-8100B/8139D",
 554           HW_REVID(1, 1, 1, 0, 1, 0, 1),
 555           HasHltClk /* XXX undocumented? */
 556         | HasLWake,
 557         },
 558
 559         { "RTL-8101",
 560           HW_REVID(1, 1, 1, 0, 1, 1, 1),
 561           HasLWake,
 562         },
 563 };
 564
 565 struct rtl_extra_stats {
 566         unsigned long early_rx;
 567         unsigned long tx_buf_mapped;
 568         unsigned long tx_timeouts;
 569         unsigned long rx_lost_in_ring;
 570 };
 571
 572 struct rtl8139_private {
 573         void __iomem *mmio_addr;
 574         int drv_flags;
 575         struct pci_dev *pci_dev;
 576         u32 msg_enable;
 577         struct net_device_stats stats;
 578         unsigned char *rx_ring;
 579         unsigned int cur_rx;    /* Index into the Rx buffer of next Rx pkt. */
 580         unsigned int tx_flag;
 581         unsigned long cur_tx;
 582         unsigned long dirty_tx;
 583         unsigned char *tx_buf[NUM_TX_DESC];     /* Tx bounce buffers */
 584         unsigned char *tx_bufs; /* Tx bounce buffer region. */
 585         dma_addr_t rx_ring_dma;
 586         dma_addr_t tx_bufs_dma;
 587         signed char phys[4];            /* MII device addresses. */
 588         char twistie, twist_row, twist_col;     /* Twister tune state. */
 589         unsigned int default_port:4;    /* Last dev->if_port value. */
 590         spinlock_t lock;
 591         spinlock_t rx_lock;
 592         chip_t chipset;
 593         pid_t thr_pid;
 594         wait_queue_head_t thr_wait;
 595         struct completion thr_exited;
 596         u32 rx_config;
 597         struct rtl_extra_stats xstats;
 598         int time_to_die;
 599         struct mii_if_info mii;
 600         unsigned int regs_len;
 601         unsigned long fifo_copy_timeout;
 602 };
 603
 604 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
 605 MODULE_DESCRIPTION ("RealTek RTL-8139 Fast Ethernet driver");
 606 MODULE_LICENSE("GPL");
 607 MODULE_VERSION(DRV_VERSION);
 608
 609 module_param(multicast_filter_limit, int, 0);
 610 module_param_array(media, int, NULL, 0);
 611 module_param_array(full_duplex, int, NULL, 0);
 612 module_param(debug, int, 0);
 613 MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");
 614 MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
 615 MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
 616 MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
 617
 618 static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);
 619 static int rtl8139_open (struct net_device *dev);
 620 static int mdio_read (struct net_device *dev, int phy_id, int location);
 621 static void mdio_write (struct net_device *dev, int phy_id, int location,
 622                         int val);
 623 static void rtl8139_start_thread(struct net_device *dev);
 624 static void rtl8139_tx_timeout (struct net_device *dev);
 625 static void rtl8139_init_ring (struct net_device *dev);
 626 static int rtl8139_start_xmit (struct sk_buff *skb,
 627                                struct net_device *dev);
 628 static int rtl8139_poll(struct net_device *dev, int *budget);
 629 #ifdef CONFIG_NET_POLL_CONTROLLER
 630 static void rtl8139_poll_controller(struct net_device *dev);
 631 #endif
 632 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance,
 633                                struct pt_regs *regs);
 634 static int rtl8139_close (struct net_device *dev);
 635 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
 636 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
 637 static void rtl8139_set_rx_mode (struct net_device *dev);
 638 static void __set_rx_mode (struct net_device *dev);
 639 static void rtl8139_hw_start (struct net_device *dev);
 640 static struct ethtool_ops rtl8139_ethtool_ops;
 641
 642 /* write MMIO register, with flush */
 643 /* Flush avoids rtl8139 bug w/ posted MMIO writes */
 644 #define RTL_W8_F(reg, val8)     do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)
 645 #define RTL_W16_F(reg, val16)   do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)
 646 #define RTL_W32_F(reg, val32)   do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)
 647
 648
 649 #define MMIO_FLUSH_AUDIT_COMPLETE 1
 650 #if MMIO_FLUSH_AUDIT_COMPLETE
 651
 652 /* write MMIO register */
 653 #define RTL_W8(reg, val8)       iowrite8 ((val8), ioaddr + (reg))
 654 #define RTL_W16(reg, val16)     iowrite16 ((val16), ioaddr + (reg))
 655 #define RTL_W32(reg, val32)     iowrite32 ((val32), ioaddr + (reg))
 656
 657 #else
 658
 659 /* write MMIO register, then flush */
 660 #define RTL_W8          RTL_W8_F
 661 #define RTL_W16         RTL_W16_F
 662 #define RTL_W32         RTL_W32_F
 663
 664 #endif /* MMIO_FLUSH_AUDIT_COMPLETE */
 665
 666 /* read MMIO register */
 667 #define RTL_R8(reg)             ioread8 (ioaddr + (reg))
 668 #define RTL_R16(reg)            ioread16 (ioaddr + (reg))
 669 #define RTL_R32(reg)            ((unsigned long) ioread32 (ioaddr + (reg)))
 670
 671
 672 static const u16 rtl8139_intr_mask =
 673         PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
 674         TxErr | TxOK | RxErr | RxOK;
 675
 676 static const u16 rtl8139_norx_intr_mask =
 677         PCIErr | PCSTimeout | RxUnderrun |
 678         TxErr | TxOK | RxErr ;
 679
 680 #if RX_BUF_IDX == 0
 681 static const unsigned int rtl8139_rx_config =
 682         RxCfgRcv8K | RxNoWrap |
 683         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 684         (RX_DMA_BURST << RxCfgDMAShift);
 685 #elif RX_BUF_IDX == 1
 686 static const unsigned int rtl8139_rx_config =
 687         RxCfgRcv16K | RxNoWrap |
 688         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 689         (RX_DMA_BURST << RxCfgDMAShift);
 690 #elif RX_BUF_IDX == 2
 691 static const unsigned int rtl8139_rx_config =
 692         RxCfgRcv32K | RxNoWrap |
 693         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 694         (RX_DMA_BURST << RxCfgDMAShift);
 695 #elif RX_BUF_IDX == 3
 696 static const unsigned int rtl8139_rx_config =
 697         RxCfgRcv64K |
 698         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 699         (RX_DMA_BURST << RxCfgDMAShift);
 700 #else
 701 #error "Invalid configuration for 8139_RXBUF_IDX"
 702 #endif
 703
 704 static const unsigned int rtl8139_tx_config =
 705         TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);
 706
 707 static void __rtl8139_cleanup_dev (struct net_device *dev)
 708 {
 709         struct rtl8139_private *tp = netdev_priv(dev);
 710         struct pci_dev *pdev;
 711
 712         assert (dev != NULL);
 713         assert (tp->pci_dev != NULL);
 714         pdev = tp->pci_dev;
 715
 716 #ifdef USE_IO_OPS
 717         if (tp->mmio_addr)
 718                 ioport_unmap (tp->mmio_addr);
 719 #else
 720         if (tp->mmio_addr)
 721                 pci_iounmap (pdev, tp->mmio_addr);
 722 #endif /* USE_IO_OPS */
 723
 724         /* it's ok to call this even if we have no regions to free */
 725         pci_release_regions (pdev);
 726
 727         free_netdev(dev);
 728         pci_set_drvdata (pdev, NULL);
 729 }
 730
 731
 732 static void rtl8139_chip_reset (void __iomem *ioaddr)
 733 {
 734         int i;
 735
 736         /* Soft reset the chip. */
 737         RTL_W8 (ChipCmd, CmdReset);
 738
 739         /* Check that the chip has finished the reset. */
 740         for (i = 1000; i > 0; i--) {
 741                 barrier();
 742                 if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
 743                         break;
 744                 udelay (10);
 745         }
 746 }
 747
 748
 749 static int __devinit rtl8139_init_board (struct pci_dev *pdev,
 750                                          struct net_device **dev_out)
 751 {
 752         void __iomem *ioaddr;
 753         struct net_device *dev;
 754         struct rtl8139_private *tp;
 755         u8 tmp8;
 756         int rc, disable_dev_on_err = 0;
 757         unsigned int i;
 758         unsigned long pio_start, pio_end, pio_flags, pio_len;
 759         unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
 760         u32 version;
 761
 762         assert (pdev != NULL);
 763
 764         *dev_out = NULL;
 765
 766         /* dev and priv zeroed in alloc_etherdev */
 767         dev = alloc_etherdev (sizeof (*tp));
 768         if (dev == NULL) {
 769                 printk (KERN_ERR PFX "%s: Unable to alloc new net device\n", pci_name(pdev));
 770                 return -ENOMEM;
 771         }
 772         SET_MODULE_OWNER(dev);
 773         SET_NETDEV_DEV(dev, &pdev->dev);
 774
 775         tp = netdev_priv(dev);
 776         tp->pci_dev = pdev;
 777
 778         /* enable device (incl. PCI PM wakeup and hotplug setup) */
 779         rc = pci_enable_device (pdev);
 780         if (rc)
 781                 goto err_out;
 782
 783         pio_start = pci_resource_start (pdev, 0);
 784         pio_end = pci_resource_end (pdev, 0);
 785         pio_flags = pci_resource_flags (pdev, 0);
 786         pio_len = pci_resource_len (pdev, 0);
 787
 788         mmio_start = pci_resource_start (pdev, 1);
 789         mmio_end = pci_resource_end (pdev, 1);
 790         mmio_flags = pci_resource_flags (pdev, 1);
 791         mmio_len = pci_resource_len (pdev, 1);
 792
 793         /* set this immediately, we need to know before
 794          * we talk to the chip directly */
 795         DPRINTK("PIO region size == 0x%02X\n", pio_len);
 796         DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
 797
 798 #ifdef USE_IO_OPS
 799         /* make sure PCI base addr 0 is PIO */
 800         if (!(pio_flags & IORESOURCE_IO)) {
 801                 printk (KERN_ERR PFX "%s: region #0 not a PIO resource, aborting\n", pci_name(pdev));
 802                 rc = -ENODEV;
 803                 goto err_out;
 804         }
 805         /* check for weird/broken PCI region reporting */
 806         if (pio_len < RTL_MIN_IO_SIZE) {
 807                 printk (KERN_ERR PFX "%s: Invalid PCI I/O region size(s), aborting\n", pci_name(pdev));
 808                 rc = -ENODEV;
 809                 goto err_out;
 810         }
 811 #else
 812         /* make sure PCI base addr 1 is MMIO */
 813         if (!(mmio_flags & IORESOURCE_MEM)) {
 814                 printk (KERN_ERR PFX "%s: region #1 not an MMIO resource, aborting\n", pci_name(pdev));
 815                 rc = -ENODEV;
 816                 goto err_out;
 817         }
 818         if (mmio_len < RTL_MIN_IO_SIZE) {
 819                 printk (KERN_ERR PFX "%s: Invalid PCI mem region size(s), aborting\n", pci_name(pdev));
 820                 rc = -ENODEV;
 821                 goto err_out;
 822         }
 823 #endif
 824
 825         rc = pci_request_regions (pdev, "8139too");
 826         if (rc)
 827                 goto err_out;
 828         disable_dev_on_err = 1;
 829
 830         /* enable PCI bus-mastering */
 831         pci_set_master (pdev);
 832
 833 #ifdef USE_IO_OPS
 834         ioaddr = ioport_map(pio_start, pio_len);
 835         if (!ioaddr) {
 836                 printk (KERN_ERR PFX "%s: cannot map PIO, aborting\n", pci_name(pdev));
 837                 rc = -EIO;
 838                 goto err_out;
 839         }
 840         dev->base_addr = pio_start;
 841         tp->mmio_addr = ioaddr;
 842         tp->regs_len = pio_len;
 843 #else
 844         /* ioremap MMIO region */
 845         ioaddr = pci_iomap(pdev, 1, 0);
 846         if (ioaddr == NULL) {
 847                 printk (KERN_ERR PFX "%s: cannot remap MMIO, aborting\n", pci_name(pdev));
 848                 rc = -EIO;
 849                 goto err_out;
 850         }
 851         dev->base_addr = (long) ioaddr;
 852         tp->mmio_addr = ioaddr;
 853         tp->regs_len = mmio_len;
 854 #endif /* USE_IO_OPS */
 855
 856         /* Bring old chips out of low-power mode. */
 857         RTL_W8 (HltClk, 'R');
 858
 859         /* check for missing/broken hardware */
 860         if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {
 861                 printk (KERN_ERR PFX "%s: Chip not responding, ignoring board\n",
 862                         pci_name(pdev));
 863                 rc = -EIO;
 864                 goto err_out;
 865         }
 866
 867         /* identify chip attached to board */
 868         version = RTL_R32 (TxConfig) & HW_REVID_MASK;
 869         for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)
 870                 if (version == rtl_chip_info[i].version) {
 871                         tp->chipset = i;
 872                         goto match;
 873                 }
 874
 875         /* if unknown chip, assume array element #0, original RTL-8139 in this case */
 876         printk (KERN_DEBUG PFX "%s: unknown chip version, assuming RTL-8139\n",
 877                 pci_name(pdev));
 878         printk (KERN_DEBUG PFX "%s: TxConfig = 0x%lx\n", pci_name(pdev), RTL_R32 (TxConfig));
 879         tp->chipset = 0;
 880
 881 match:
 882         DPRINTK ("chipset id (%d) == index %d, '%s'\n",
 883                  version, i, rtl_chip_info[i].name);
 884
 885         if (tp->chipset >= CH_8139B) {
 886                 u8 new_tmp8 = tmp8 = RTL_R8 (Config1);
 887                 DPRINTK("PCI PM wakeup\n");
 888                 if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&
 889                     (tmp8 & LWAKE))
 890                         new_tmp8 &= ~LWAKE;
 891                 new_tmp8 |= Cfg1_PM_Enable;
 892                 if (new_tmp8 != tmp8) {
 893                         RTL_W8 (Cfg9346, Cfg9346_Unlock);
 894                         RTL_W8 (Config1, tmp8);
 895                         RTL_W8 (Cfg9346, Cfg9346_Lock);
 896                 }
 897                 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
 898                         tmp8 = RTL_R8 (Config4);
 899                         if (tmp8 & LWPTN) {
 900                                 RTL_W8 (Cfg9346, Cfg9346_Unlock);
 901                                 RTL_W8 (Config4, tmp8 & ~LWPTN);
 902                                 RTL_W8 (Cfg9346, Cfg9346_Lock);
 903                         }
 904                 }
 905         } else {
 906                 DPRINTK("Old chip wakeup\n");
 907                 tmp8 = RTL_R8 (Config1);
 908                 tmp8 &= ~(SLEEP | PWRDN);
 909                 RTL_W8 (Config1, tmp8);
 910         }
 911
 912         rtl8139_chip_reset (ioaddr);
 913
 914         *dev_out = dev;
 915         return 0;
 916
 917 err_out:
 918         __rtl8139_cleanup_dev (dev);
 919         if (disable_dev_on_err)
 920                 pci_disable_device (pdev);
 921         return rc;
 922 }
 923
 924
 925 static int __devinit rtl8139_init_one (struct pci_dev *pdev,
 926                                        const struct pci_device_id *ent)
 927 {
 928         struct net_device *dev = NULL;
 929         struct rtl8139_private *tp;
 930         int i, addr_len, option;
 931         void __iomem *ioaddr;
 932         static int board_idx = -1;
 933         u8 pci_rev;
 934
 935         assert (pdev != NULL);
 936         assert (ent != NULL);
 937
 938         board_idx++;
 939
 940         /* when we're built into the kernel, the driver version message
 941          * is only printed if at least one 8139 board has been found
 942          */
 943 #ifndef MODULE
 944         {
 945                 static int printed_version;
 946                 if (!printed_version++)
 947                         printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
 948         }
 949 #endif
 950
 951         pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);
 952
 953         if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
 954             pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev >= 0x20) {
 955                 printk(KERN_INFO PFX "pci dev %s (id %04x:%04x rev %02x) is an enhanced 8139C+ chip\n",
 956                        pci_name(pdev), pdev->vendor, pdev->device, pci_rev);
 957                 printk(KERN_INFO PFX "Use the \"8139cp\" driver for improved performance and stability.\n");
 958         }
 959
 960         i = rtl8139_init_board (pdev, &dev);
 961         if (i < 0)
 962                 return i;
 963
 964         assert (dev != NULL);
 965         tp = netdev_priv(dev);
 966
 967         ioaddr = tp->mmio_addr;
 968         assert (ioaddr != NULL);
 969
 970         addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
 971         for (i = 0; i < 3; i++)
 972                 ((u16 *) (dev->dev_addr))[i] =
 973                     le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
 974         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 975
 976         /* The Rtl8139-specific entries in the device structure. */
 977         dev->open = rtl8139_open;
 978         dev->hard_start_xmit = rtl8139_start_xmit;
 979         dev->poll = rtl8139_poll;
 980         dev->weight = 64;
 981         dev->stop = rtl8139_close;
 982         dev->get_stats = rtl8139_get_stats;
 983         dev->set_multicast_list = rtl8139_set_rx_mode;
 984         dev->do_ioctl = netdev_ioctl;
 985         dev->ethtool_ops = &rtl8139_ethtool_ops;
 986         dev->tx_timeout = rtl8139_tx_timeout;
 987         dev->watchdog_timeo = TX_TIMEOUT;
 988 #ifdef CONFIG_NET_POLL_CONTROLLER
 989         dev->poll_controller = rtl8139_poll_controller;
 990 #endif
 991
 992         /* note: the hardware is not capable of sg/csum/highdma, however
 993          * through the use of skb_copy_and_csum_dev we enable these
 994          * features
 995          */
 996         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
 997
 998         dev->irq = pdev->irq;
 999
1000         /* tp zeroed and aligned in alloc_etherdev */
1001         tp = netdev_priv(dev);
1002
1003         /* note: tp->chipset set in rtl8139_init_board */
1004         tp->drv_flags = board_info[ent->driver_data].hw_flags;
1005         tp->mmio_addr = ioaddr;
1006         tp->msg_enable =
1007                 (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));
1008         spin_lock_init (&tp->lock);
1009         spin_lock_init (&tp->rx_lock);
1010         init_waitqueue_head (&tp->thr_wait);
1011         init_completion (&tp->thr_exited);
1012         tp->mii.dev = dev;
1013         tp->mii.mdio_read = mdio_read;
1014         tp->mii.mdio_write = mdio_write;
1015         tp->mii.phy_id_mask = 0x3f;
1016         tp->mii.reg_num_mask = 0x1f;
1017
1018         /* dev is fully set up and ready to use now */
1019         DPRINTK("about to register device named %s (%p)...\n", dev->name, dev);
1020         i = register_netdev (dev);
1021         if (i) goto err_out;
1022
1023         pci_set_drvdata (pdev, dev);
1024
1025         printk (KERN_INFO "%s: %s at 0x%lx, "
1026                 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
1027                 "IRQ %d\n",
1028                 dev->name,
1029                 board_info[ent->driver_data].name,
1030                 dev->base_addr,
1031                 dev->dev_addr[0], dev->dev_addr[1],
1032                 dev->dev_addr[2], dev->dev_addr[3],
1033                 dev->dev_addr[4], dev->dev_addr[5],
1034                 dev->irq);
1035
1036         printk (KERN_DEBUG "%s:  Identified 8139 chip type '%s'\n",
1037                 dev->name, rtl_chip_info[tp->chipset].name);
1038
1039         /* Find the connected MII xcvrs.
1040            Doing this in open() would allow detecting external xcvrs later, but
1041            takes too much time. */
1042 #ifdef CONFIG_8139TOO_8129
1043         if (tp->drv_flags & HAS_MII_XCVR) {
1044                 int phy, phy_idx = 0;
1045                 for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {
1046                         int mii_status = mdio_read(dev, phy, 1);
1047                         if (mii_status != 0xffff  &&  mii_status != 0x0000) {
1048                                 u16 advertising = mdio_read(dev, phy, 4);
1049                                 tp->phys[phy_idx++] = phy;
1050                                 printk(KERN_INFO "%s: MII transceiver %d status 0x%4.4x "
1051                                            "advertising %4.4x.\n",
1052                                            dev->name, phy, mii_status, advertising);
1053                         }
1054                 }
1055                 if (phy_idx == 0) {
1056                         printk(KERN_INFO "%s: No MII transceivers found!  Assuming SYM "
1057                                    "transceiver.\n",
1058                                    dev->name);
1059                         tp->phys[0] = 32;
1060                 }
1061         } else
1062 #endif
1063                 tp->phys[0] = 32;
1064         tp->mii.phy_id = tp->phys[0];
1065
1066         /* The lower four bits are the media type. */
1067         option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
1068         if (option > 0) {
1069                 tp->mii.full_duplex = (option & 0x210) ? 1 : 0;
1070                 tp->default_port = option & 0xFF;
1071                 if (tp->default_port)
1072                         tp->mii.force_media = 1;
1073         }
1074         if (board_idx < MAX_UNITS  &&  full_duplex[board_idx] > 0)
1075                 tp->mii.full_duplex = full_duplex[board_idx];
1076         if (tp->mii.full_duplex) {
1077                 printk(KERN_INFO "%s: Media type forced to Full Duplex.\n", dev->name);
1078                 /* Changing the MII-advertised media because might prevent
1079                    re-connection. */
1080                 tp->mii.force_media = 1;
1081         }
1082         if (tp->default_port) {
1083                 printk(KERN_INFO "  Forcing %dMbps %s-duplex operation.\n",
1084                            (option & 0x20 ? 100 : 10),
1085                            (option & 0x10 ? "full" : "half"));
1086                 mdio_write(dev, tp->phys[0], 0,
1087                                    ((option & 0x20) ? 0x2000 : 0) |     /* 100Mbps? */
1088                                    ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
1089         }
1090
1091         /* Put the chip into low-power mode. */
1092         if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1093                 RTL_W8 (HltClk, 'H');   /* 'R' would leave the clock running. */
1094
1095         return 0;
1096
1097 err_out:
1098         __rtl8139_cleanup_dev (dev);
1099         pci_disable_device (pdev);
1100         return i;
1101 }
1102
1103
1104 static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
1105 {
1106         struct net_device *dev = pci_get_drvdata (pdev);
1107
1108         assert (dev != NULL);
1109
1110         unregister_netdev (dev);
1111
1112         __rtl8139_cleanup_dev (dev);
1113         pci_disable_device (pdev);
1114 }
1115
1116
1117 /* Serial EEPROM section. */
1118
1119 /*  EEPROM_Ctrl bits. */
1120 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
1121 #define EE_CS                   0x08    /* EEPROM chip select. */
1122 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
1123 #define EE_WRITE_0              0x00
1124 #define EE_WRITE_1              0x02
1125 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
1126 #define EE_ENB                  (0x80 | EE_CS)
1127
1128 /* Delay between EEPROM clock transitions.
1129    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1130  */
1131
1132 #define eeprom_delay()  RTL_R32(Cfg9346)
1133
1134 /* The EEPROM commands include the alway-set leading bit. */
1135 #define EE_WRITE_CMD    (5)
1136 #define EE_READ_CMD             (6)
1137 #define EE_ERASE_CMD    (7)
1138
1139 static int __devinit read_eeprom (void __iomem *ioaddr, int location, int addr_len)
1140 {
1141         int i;
1142         unsigned retval = 0;
1143         int read_cmd = location | (EE_READ_CMD << addr_len);
1144
1145         RTL_W8 (Cfg9346, EE_ENB & ~EE_CS);
1146         RTL_W8 (Cfg9346, EE_ENB);
1147         eeprom_delay ();
1148
1149         /* Shift the read command bits out. */
1150         for (i = 4 + addr_len; i >= 0; i--) {
1151                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1152                 RTL_W8 (Cfg9346, EE_ENB | dataval);
1153                 eeprom_delay ();
1154                 RTL_W8 (Cfg9346, EE_ENB | dataval | EE_SHIFT_CLK);
1155                 eeprom_delay ();
1156         }
1157         RTL_W8 (Cfg9346, EE_ENB);
1158         eeprom_delay ();
1159
1160         for (i = 16; i > 0; i--) {
1161                 RTL_W8 (Cfg9346, EE_ENB | EE_SHIFT_CLK);
1162                 eeprom_delay ();
1163                 retval =
1164                     (retval << 1) | ((RTL_R8 (Cfg9346) & EE_DATA_READ) ? 1 :
1165                                      0);
1166                 RTL_W8 (Cfg9346, EE_ENB);
1167                 eeprom_delay ();
1168         }
1169
1170         /* Terminate the EEPROM access. */
1171         RTL_W8 (Cfg9346, ~EE_CS);
1172         eeprom_delay ();
1173
1174         return retval;
1175 }
1176
1177 /* MII serial management: mostly bogus for now. */
1178 /* Read and write the MII management registers using software-generated
1179    serial MDIO protocol.
1180    The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
1181    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1182    "overclocking" issues. */
1183 #define MDIO_DIR                0x80
1184 #define MDIO_DATA_OUT   0x04
1185 #define MDIO_DATA_IN    0x02
1186 #define MDIO_CLK                0x01
1187 #define MDIO_WRITE0 (MDIO_DIR)
1188 #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
1189
1190 #define mdio_delay()    RTL_R8(Config4)
1191
1192
1193 static char mii_2_8139_map[8] = {
1194         BasicModeCtrl,
1195         BasicModeStatus,
1196         0,
1197         0,
1198         NWayAdvert,
1199         NWayLPAR,
1200         NWayExpansion,
1201         0
1202 };
1203
1204
1205 #ifdef CONFIG_8139TOO_8129
1206 /* Syncronize the MII management interface by shifting 32 one bits out. */
1207 static void mdio_sync (void __iomem *ioaddr)
1208 {
1209         int i;
1210
1211         for (i = 32; i >= 0; i--) {
1212                 RTL_W8 (Config4, MDIO_WRITE1);
1213                 mdio_delay ();
1214                 RTL_W8 (Config4, MDIO_WRITE1 | MDIO_CLK);
1215                 mdio_delay ();
1216         }
1217 }
1218 #endif
1219
1220 static int mdio_read (struct net_device *dev, int phy_id, int location)
1221 {
1222         struct rtl8139_private *tp = netdev_priv(dev);
1223         int retval = 0;
1224 #ifdef CONFIG_8139TOO_8129
1225         void __iomem *ioaddr = tp->mmio_addr;
1226         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1227         int i;
1228 #endif
1229
1230         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
1231                 void __iomem *ioaddr = tp->mmio_addr;
1232                 return location < 8 && mii_2_8139_map[location] ?
1233                     RTL_R16 (mii_2_8139_map[location]) : 0;
1234         }
1235
1236 #ifdef CONFIG_8139TOO_8129
1237         mdio_sync (ioaddr);
1238         /* Shift the read command bits out. */
1239         for (i = 15; i >= 0; i--) {
1240                 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1241
1242                 RTL_W8 (Config4, MDIO_DIR | dataval);
1243                 mdio_delay ();
1244                 RTL_W8 (Config4, MDIO_DIR | dataval | MDIO_CLK);
1245                 mdio_delay ();
1246         }
1247
1248         /* Read the two transition, 16 data, and wire-idle bits. */
1249         for (i = 19; i > 0; i--) {
1250                 RTL_W8 (Config4, 0);
1251                 mdio_delay ();
1252                 retval = (retval << 1) | ((RTL_R8 (Config4) & MDIO_DATA_IN) ? 1 : 0);
1253                 RTL_W8 (Config4, MDIO_CLK);
1254                 mdio_delay ();
1255         }
1256 #endif
1257
1258         return (retval >> 1) & 0xffff;
1259 }
1260
1261
1262 static void mdio_write (struct net_device *dev, int phy_id, int location,
1263                         int value)
1264 {
1265         struct rtl8139_private *tp = netdev_priv(dev);
1266 #ifdef CONFIG_8139TOO_8129
1267         void __iomem *ioaddr = tp->mmio_addr;
1268         int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1269         int i;
1270 #endif
1271
1272         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
1273                 void __iomem *ioaddr = tp->mmio_addr;
1274                 if (location == 0) {
1275                         RTL_W8 (Cfg9346, Cfg9346_Unlock);
1276                         RTL_W16 (BasicModeCtrl, value);
1277                         RTL_W8 (Cfg9346, Cfg9346_Lock);
1278                 } else if (location < 8 && mii_2_8139_map[location])
1279                         RTL_W16 (mii_2_8139_map[location], value);
1280                 return;
1281         }
1282
1283 #ifdef CONFIG_8139TOO_8129
1284         mdio_sync (ioaddr);
1285
1286         /* Shift the command bits out. */
1287         for (i = 31; i >= 0; i--) {
1288                 int dataval =
1289                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1290                 RTL_W8 (Config4, dataval);
1291                 mdio_delay ();
1292                 RTL_W8 (Config4, dataval | MDIO_CLK);
1293                 mdio_delay ();
1294         }
1295         /* Clear out extra bits. */
1296         for (i = 2; i > 0; i--) {
1297                 RTL_W8 (Config4, 0);
1298                 mdio_delay ();
1299                 RTL_W8 (Config4, MDIO_CLK);
1300                 mdio_delay ();
1301         }
1302 #endif
1303 }
1304
1305
1306 static int rtl8139_open (struct net_device *dev)
1307 {
1308         struct rtl8139_private *tp = netdev_priv(dev);
1309         int retval;
1310         void __iomem *ioaddr = tp->mmio_addr;
1311
1312         retval = request_irq (dev->irq, rtl8139_interrupt, SA_SHIRQ, dev->name, dev);
1313         if (retval)
1314                 return retval;
1315
1316         tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1317                                            &tp->tx_bufs_dma);
1318         tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1319                                            &tp->rx_ring_dma);
1320         if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1321                 free_irq(dev->irq, dev);
1322
1323                 if (tp->tx_bufs)
1324                         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1325                                             tp->tx_bufs, tp->tx_bufs_dma);
1326                 if (tp->rx_ring)
1327                         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1328                                             tp->rx_ring, tp->rx_ring_dma);
1329
1330                 return -ENOMEM;
1331
1332         }
1333
1334         tp->mii.full_duplex = tp->mii.force_media;
1335         tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1336
1337         rtl8139_init_ring (dev);
1338         rtl8139_hw_start (dev);
1339         netif_start_queue (dev);
1340
1341         if (netif_msg_ifup(tp))
1342                 printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#lx IRQ %d"
1343                         " GP Pins %2.2x %s-duplex.\n",
1344                         dev->name, pci_resource_start (tp->pci_dev, 1),
1345                         dev->irq, RTL_R8 (MediaStatus),
1346                         tp->mii.full_duplex ? "full" : "half");
1347
1348         rtl8139_start_thread(dev);
1349
1350         return 0;
1351 }
1352
1353
1354 static void rtl_check_media (struct net_device *dev, unsigned int init_media)
1355 {
1356         struct rtl8139_private *tp = netdev_priv(dev);
1357
1358         if (tp->phys[0] >= 0) {
1359                 mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
1360         }
1361 }
1362
1363 /* Start the hardware at open or resume. */
1364 static void rtl8139_hw_start (struct net_device *dev)
1365 {
1366         struct rtl8139_private *tp = netdev_priv(dev);
1367         void __iomem *ioaddr = tp->mmio_addr;
1368         u32 i;
1369         u8 tmp;
1370
1371         /* Bring old chips out of low-power mode. */
1372         if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1373                 RTL_W8 (HltClk, 'R');
1374
1375         rtl8139_chip_reset (ioaddr);
1376
1377         /* unlock Config[01234] and BMCR register writes */
1378         RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1379         /* Restore our idea of the MAC address. */
1380         RTL_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
1381         RTL_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
1382
1383         /* Must enable Tx/Rx before setting transfer thresholds! */
1384         RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1385
1386         tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1387         RTL_W32 (RxConfig, tp->rx_config);
1388         RTL_W32 (TxConfig, rtl8139_tx_config);
1389
1390         tp->cur_rx = 0;
1391
1392         rtl_check_media (dev, 1);
1393
1394         if (tp->chipset >= CH_8139B) {
1395                 /* Disable magic packet scanning, which is enabled
1396                  * when PM is enabled in Config1.  It can be reenabled
1397                  * via ETHTOOL_SWOL if desired.  */
1398                 RTL_W8 (Config3, RTL_R8 (Config3) & ~Cfg3_Magic);
1399         }
1400
1401         DPRINTK("init buffer addresses\n");
1402
1403         /* Lock Config[01234] and BMCR register writes */
1404         RTL_W8 (Cfg9346, Cfg9346_Lock);
1405
1406         /* init Rx ring buffer DMA address */
1407         RTL_W32_F (RxBuf, tp->rx_ring_dma);
1408
1409         /* init Tx buffer DMA addresses */
1410         for (i = 0; i < NUM_TX_DESC; i++)
1411                 RTL_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1412
1413         RTL_W32 (RxMissed, 0);
1414
1415         rtl8139_set_rx_mode (dev);
1416
1417         /* no early-rx interrupts */
1418         RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
1419
1420         /* make sure RxTx has started */
1421         tmp = RTL_R8 (ChipCmd);
1422         if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
1423                 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1424
1425         /* Enable all known interrupts by setting the interrupt mask. */
1426         RTL_W16 (IntrMask, rtl8139_intr_mask);
1427 }
1428
1429
1430 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1431 static void rtl8139_init_ring (struct net_device *dev)
1432 {
1433         struct rtl8139_private *tp = netdev_priv(dev);
1434         int i;
1435
1436         tp->cur_rx = 0;
1437         tp->cur_tx = 0;
1438         tp->dirty_tx = 0;
1439
1440         for (i = 0; i < NUM_TX_DESC; i++)
1441                 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1442 }
1443
1444
1445 /* This must be global for CONFIG_8139TOO_TUNE_TWISTER case */
1446 static int next_tick = 3 * HZ;
1447
1448 #ifndef CONFIG_8139TOO_TUNE_TWISTER
1449 static inline void rtl8139_tune_twister (struct net_device *dev,
1450                                   struct rtl8139_private *tp) {}
1451 #else
1452 enum TwisterParamVals {
1453         PARA78_default  = 0x78fa8388,
1454         PARA7c_default  = 0xcb38de43,   /* param[0][3] */
1455         PARA7c_xxx      = 0xcb38de43,
1456 };
1457
1458 static const unsigned long param[4][4] = {
1459         {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
1460         {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1461         {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1462         {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
1463 };
1464
1465 static void rtl8139_tune_twister (struct net_device *dev,
1466                                   struct rtl8139_private *tp)
1467 {
1468         int linkcase;
1469         void __iomem *ioaddr = tp->mmio_addr;
1470
1471         /* This is a complicated state machine to configure the "twister" for
1472            impedance/echos based on the cable length.
1473            All of this is magic and undocumented.
1474          */
1475         switch (tp->twistie) {
1476         case 1:
1477                 if (RTL_R16 (CSCR) & CSCR_LinkOKBit) {
1478                         /* We have link beat, let us tune the twister. */
1479                         RTL_W16 (CSCR, CSCR_LinkDownOffCmd);
1480                         tp->twistie = 2;        /* Change to state 2. */
1481                         next_tick = HZ / 10;
1482                 } else {
1483                         /* Just put in some reasonable defaults for when beat returns. */
1484                         RTL_W16 (CSCR, CSCR_LinkDownCmd);
1485                         RTL_W32 (FIFOTMS, 0x20);        /* Turn on cable test mode. */
1486                         RTL_W32 (PARA78, PARA78_default);
1487                         RTL_W32 (PARA7c, PARA7c_default);
1488                         tp->twistie = 0;        /* Bail from future actions. */
1489                 }
1490                 break;
1491         case 2:
1492                 /* Read how long it took to hear the echo. */
1493                 linkcase = RTL_R16 (CSCR) & CSCR_LinkStatusBits;
1494                 if (linkcase == 0x7000)
1495                         tp->twist_row = 3;
1496                 else if (linkcase == 0x3000)
1497                         tp->twist_row = 2;
1498                 else if (linkcase == 0x1000)
1499                         tp->twist_row = 1;
1500                 else
1501                         tp->twist_row = 0;
1502                 tp->twist_col = 0;
1503                 tp->twistie = 3;        /* Change to state 2. */
1504                 next_tick = HZ / 10;
1505                 break;
1506         case 3:
1507                 /* Put out four tuning parameters, one per 100msec. */
1508                 if (tp->twist_col == 0)
1509                         RTL_W16 (FIFOTMS, 0);
1510                 RTL_W32 (PARA7c, param[(int) tp->twist_row]
1511                          [(int) tp->twist_col]);
1512                 next_tick = HZ / 10;
1513                 if (++tp->twist_col >= 4) {
1514                         /* For short cables we are done.
1515                            For long cables (row == 3) check for mistune. */
1516                         tp->twistie =
1517                             (tp->twist_row == 3) ? 4 : 0;
1518                 }
1519                 break;
1520         case 4:
1521                 /* Special case for long cables: check for mistune. */
1522                 if ((RTL_R16 (CSCR) &
1523                      CSCR_LinkStatusBits) == 0x7000) {
1524                         tp->twistie = 0;
1525                         break;
1526                 } else {
1527                         RTL_W32 (PARA7c, 0xfb38de03);
1528                         tp->twistie = 5;
1529                         next_tick = HZ / 10;
1530                 }
1531                 break;
1532         case 5:
1533                 /* Retune for shorter cable (column 2). */
1534                 RTL_W32 (FIFOTMS, 0x20);
1535                 RTL_W32 (PARA78, PARA78_default);
1536                 RTL_W32 (PARA7c, PARA7c_default);
1537                 RTL_W32 (FIFOTMS, 0x00);
1538                 tp->twist_row = 2;
1539                 tp->twist_col = 0;
1540                 tp->twistie = 3;
1541                 next_tick = HZ / 10;
1542                 break;
1543
1544         default:
1545                 /* do nothing */
1546                 break;
1547         }
1548 }
1549 #endif /* CONFIG_8139TOO_TUNE_TWISTER */
1550
1551 static inline void rtl8139_thread_iter (struct net_device *dev,
1552                                  struct rtl8139_private *tp,
1553                                  void __iomem *ioaddr)
1554 {
1555         int mii_lpa;
1556
1557         mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1558
1559         if (!tp->mii.force_media && mii_lpa != 0xffff) {
1560                 int duplex = (mii_lpa & LPA_100FULL)
1561                     || (mii_lpa & 0x01C0) == 0x0040;
1562                 if (tp->mii.full_duplex != duplex) {
1563                         tp->mii.full_duplex = duplex;
1564
1565                         if (mii_lpa) {
1566                                 printk (KERN_INFO
1567                                         "%s: Setting %s-duplex based on MII #%d link"
1568                                         " partner ability of %4.4x.\n",
1569                                         dev->name,
1570                                         tp->mii.full_duplex ? "full" : "half",
1571                                         tp->phys[0], mii_lpa);
1572                         } else {
1573                                 printk(KERN_INFO"%s: media is unconnected, link down, or incompatible connection\n",
1574                                        dev->name);
1575                         }
1576 #if 0
1577                         RTL_W8 (Cfg9346, Cfg9346_Unlock);
1578                         RTL_W8 (Config1, tp->mii.full_duplex ? 0x60 : 0x20);
1579                         RTL_W8 (Cfg9346, Cfg9346_Lock);
1580 #endif
1581                 }
1582         }
1583
1584         next_tick = HZ * 60;
1585
1586         rtl8139_tune_twister (dev, tp);
1587
1588         DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1589                  dev->name, RTL_R16 (NWayLPAR));
1590         DPRINTK ("%s:  Other registers are IntMask %4.4x IntStatus %4.4x\n",
1591                  dev->name, RTL_R16 (IntrMask), RTL_R16 (IntrStatus));
1592         DPRINTK ("%s:  Chip config %2.2x %2.2x.\n",
1593                  dev->name, RTL_R8 (Config0),
1594                  RTL_R8 (Config1));
1595 }
1596
1597 static int rtl8139_thread (void *data)
1598 {
1599         struct net_device *dev = data;
1600         struct rtl8139_private *tp = netdev_priv(dev);
1601         unsigned long timeout;
1602
1603         daemonize("%s", dev->name);
1604         allow_signal(SIGTERM);
1605
1606         while (1) {
1607                 timeout = next_tick;
1608                 do {
1609                         timeout = interruptible_sleep_on_timeout (&tp->thr_wait, timeout);
1610                         /* make swsusp happy with our thread */
1611                         try_to_freeze();
1612                 } while (!signal_pending (current) && (timeout > 0));
1613
1614                 if (signal_pending (current)) {
1615                         flush_signals(current);
1616                 }
1617
1618                 if (tp->time_to_die)
1619                         break;
1620
1621                 if (rtnl_lock_interruptible ())
1622                         break;
1623                 rtl8139_thread_iter (dev, tp, tp->mmio_addr);
1624                 rtnl_unlock ();
1625         }
1626
1627         complete_and_exit (&tp->thr_exited, 0);
1628 }
1629
1630 static void rtl8139_start_thread(struct net_device *dev)
1631 {
1632         struct rtl8139_private *tp = netdev_priv(dev);
1633
1634         tp->thr_pid = -1;
1635         tp->twistie = 0;
1636         tp->time_to_die = 0;
1637         if (tp->chipset == CH_8139_K)
1638                 tp->twistie = 1;
1639         else if (tp->drv_flags & HAS_LNK_CHNG)
1640                 return;
1641
1642         tp->thr_pid = kernel_thread(rtl8139_thread, dev, CLONE_FS|CLONE_FILES);
1643         if (tp->thr_pid < 0) {
1644                 printk (KERN_WARNING "%s: unable to start kernel thread\n",
1645                         dev->name);
1646         }
1647 }
1648
1649 static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
1650 {
1651         tp->cur_tx = 0;
1652         tp->dirty_tx = 0;
1653
1654         /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
1655 }
1656
1657
1658 static void rtl8139_tx_timeout (struct net_device *dev)
1659 {
1660         struct rtl8139_private *tp = netdev_priv(dev);
1661         void __iomem *ioaddr = tp->mmio_addr;
1662         int i;
1663         u8 tmp8;
1664         unsigned long flags;
1665
1666         printk (KERN_DEBUG "%s: Transmit timeout, status %2.2x %4.4x %4.4x "
1667                 "media %2.2x.\n", dev->name, RTL_R8 (ChipCmd),
1668                 RTL_R16(IntrStatus), RTL_R16(IntrMask), RTL_R8(MediaStatus));
1669         /* Emit info to figure out what went wrong. */
1670         printk (KERN_DEBUG "%s: Tx queue start entry %ld  dirty entry %ld.\n",
1671                 dev->name, tp->cur_tx, tp->dirty_tx);
1672         for (i = 0; i < NUM_TX_DESC; i++)
1673                 printk (KERN_DEBUG "%s:  Tx descriptor %d is %8.8lx.%s\n",
1674                         dev->name, i, RTL_R32 (TxStatus0 + (i * 4)),
1675                         i == tp->dirty_tx % NUM_TX_DESC ?
1676                                 " (queue head)" : "");
1677
1678         tp->xstats.tx_timeouts++;
1679
1680         /* disable Tx ASAP, if not already */
1681         tmp8 = RTL_R8 (ChipCmd);
1682         if (tmp8 & CmdTxEnb)
1683                 RTL_W8 (ChipCmd, CmdRxEnb);
1684
1685         spin_lock(&tp->rx_lock);
1686         /* Disable interrupts by clearing the interrupt mask. */
1687         RTL_W16 (IntrMask, 0x0000);
1688
1689         /* Stop a shared interrupt from scavenging while we are. */
1690         spin_lock_irqsave (&tp->lock, flags);
1691         rtl8139_tx_clear (tp);
1692         spin_unlock_irqrestore (&tp->lock, flags);
1693
1694         /* ...and finally, reset everything */
1695         if (netif_running(dev)) {
1696                 rtl8139_hw_start (dev);
1697                 netif_wake_queue (dev);
1698         }
1699         spin_unlock(&tp->rx_lock);
1700 }
1701
1702
1703 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
1704 {
1705         struct rtl8139_private *tp = netdev_priv(dev);
1706         void __iomem *ioaddr = tp->mmio_addr;
1707         unsigned int entry;
1708         unsigned int len = skb->len;
1709
1710         /* Calculate the next Tx descriptor entry. */
1711         entry = tp->cur_tx % NUM_TX_DESC;
1712
1713         /* Note: the chip doesn't have auto-pad! */
1714         if (likely(len < TX_BUF_SIZE)) {
1715                 if (len < ETH_ZLEN)
1716                         memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1717                 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1718                 dev_kfree_skb(skb);
1719         } else {
1720                 dev_kfree_skb(skb);
1721                 tp->stats.tx_dropped++;
1722                 return 0;
1723         }
1724
1725         spin_lock_irq(&tp->lock);
1726         RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1727                    tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1728
1729         dev->trans_start = jiffies;
1730
1731         tp->cur_tx++;
1732         wmb();
1733
1734         if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1735                 netif_stop_queue (dev);
1736         spin_unlock_irq(&tp->lock);
1737
1738         if (netif_msg_tx_queued(tp))
1739                 printk (KERN_DEBUG "%s: Queued Tx packet size %u to slot %d.\n",
1740                         dev->name, len, entry);
1741
1742         return 0;
1743 }
1744
1745
1746 static void rtl8139_tx_interrupt (struct net_device *dev,
1747                                   struct rtl8139_private *tp,
1748                                   void __iomem *ioaddr)
1749 {
1750         unsigned long dirty_tx, tx_left;
1751
1752         assert (dev != NULL);
1753         assert (ioaddr != NULL);
1754
1755         dirty_tx = tp->dirty_tx;
1756         tx_left = tp->cur_tx - dirty_tx;
1757         while (tx_left > 0) {
1758                 int entry = dirty_tx % NUM_TX_DESC;
1759                 int txstatus;
1760
1761                 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1762
1763                 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1764                         break;  /* It still hasn't been Txed */
1765
1766                 /* Note: TxCarrierLost is always asserted at 100mbps. */
1767                 if (txstatus & (TxOutOfWindow | TxAborted)) {
1768                         /* There was an major error, log it. */
1769                         if (netif_msg_tx_err(tp))
1770                                 printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
1771                                         dev->name, txstatus);
1772                         tp->stats.tx_errors++;
1773                         if (txstatus & TxAborted) {
1774                                 tp->stats.tx_aborted_errors++;
1775                                 RTL_W32 (TxConfig, TxClearAbt);
1776                                 RTL_W16 (IntrStatus, TxErr);
1777                                 wmb();
1778                         }
1779                         if (txstatus & TxCarrierLost)
1780                                 tp->stats.tx_carrier_errors++;
1781                         if (txstatus & TxOutOfWindow)
1782                                 tp->stats.tx_window_errors++;
1783                 } else {
1784                         if (txstatus & TxUnderrun) {
1785                                 /* Add 64 to the Tx FIFO threshold. */
1786                                 if (tp->tx_flag < 0x00300000)
1787                                         tp->tx_flag += 0x00020000;
1788                                 tp->stats.tx_fifo_errors++;
1789                         }
1790                         tp->stats.collisions += (txstatus >> 24) & 15;
1791                         tp->stats.tx_bytes += txstatus & 0x7ff;
1792                         tp->stats.tx_packets++;
1793                 }
1794
1795                 dirty_tx++;
1796                 tx_left--;
1797         }
1798
1799 #ifndef RTL8139_NDEBUG
1800         if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
1801                 printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
1802                         dev->name, dirty_tx, tp->cur_tx);
1803                 dirty_tx += NUM_TX_DESC;
1804         }
1805 #endif /* RTL8139_NDEBUG */
1806
1807         /* only wake the queue if we did work, and the queue is stopped */
1808         if (tp->dirty_tx != dirty_tx) {
1809                 tp->dirty_tx = dirty_tx;
1810                 mb();
1811                 netif_wake_queue (dev);
1812         }
1813 }
1814
1815
1816 /* TODO: clean this up!  Rx reset need not be this intensive */
1817 static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
1818                             struct rtl8139_private *tp, void __iomem *ioaddr)
1819 {
1820         u8 tmp8;
1821 #ifdef CONFIG_8139_OLD_RX_RESET
1822         int tmp_work;
1823 #endif
1824
1825         if (netif_msg_rx_err (tp))
1826                 printk(KERN_DEBUG "%s: Ethernet frame had errors, status %8.8x.\n",
1827                         dev->name, rx_status);
1828         tp->stats.rx_errors++;
1829         if (!(rx_status & RxStatusOK)) {
1830                 if (rx_status & RxTooLong) {
1831                         DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1832                                 dev->name, rx_status);
1833                         /* A.C.: The chip hangs here. */
1834                 }
1835                 if (rx_status & (RxBadSymbol | RxBadAlign))
1836                         tp->stats.rx_frame_errors++;
1837                 if (rx_status & (RxRunt | RxTooLong))
1838                         tp->stats.rx_length_errors++;
1839                 if (rx_status & RxCRCErr)
1840                         tp->stats.rx_crc_errors++;
1841         } else {
1842                 tp->xstats.rx_lost_in_ring++;
1843         }
1844
1845 #ifndef CONFIG_8139_OLD_RX_RESET
1846         tmp8 = RTL_R8 (ChipCmd);
1847         RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1848         RTL_W8 (ChipCmd, tmp8);
1849         RTL_W32 (RxConfig, tp->rx_config);
1850         tp->cur_rx = 0;
1851 #else
1852         /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1853
1854         /* disable receive */
1855         RTL_W8_F (ChipCmd, CmdTxEnb);
1856         tmp_work = 200;
1857         while (--tmp_work > 0) {
1858                 udelay(1);
1859                 tmp8 = RTL_R8 (ChipCmd);
1860                 if (!(tmp8 & CmdRxEnb))
1861                         break;
1862         }
1863         if (tmp_work <= 0)
1864                 printk (KERN_WARNING PFX "rx stop wait too long\n");
1865         /* restart receive */
1866         tmp_work = 200;
1867         while (--tmp_work > 0) {
1868                 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1869                 udelay(1);
1870                 tmp8 = RTL_R8 (ChipCmd);
1871                 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1872                         break;
1873         }
1874         if (tmp_work <= 0)
1875                 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1876
1877         /* and reinitialize all rx related registers */
1878         RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1879         /* Must enable Tx/Rx before setting transfer thresholds! */
1880         RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1881
1882         tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1883         RTL_W32 (RxConfig, tp->rx_config);
1884         tp->cur_rx = 0;
1885
1886         DPRINTK("init buffer addresses\n");
1887
1888         /* Lock Config[01234] and BMCR register writes */
1889         RTL_W8 (Cfg9346, Cfg9346_Lock);
1890
1891         /* init Rx ring buffer DMA address */
1892         RTL_W32_F (RxBuf, tp->rx_ring_dma);
1893
1894         /* A.C.: Reset the multicast list. */
1895         __set_rx_mode (dev);
1896 #endif
1897 }
1898
1899 #if RX_BUF_IDX == 3
1900 static __inline__ void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
1901                                  u32 offset, unsigned int size)
1902 {
1903         u32 left = RX_BUF_LEN - offset;
1904
1905         if (size > left) {
1906                 memcpy(skb->data, ring + offset, left);
1907                 memcpy(skb->data+left, ring, size - left);
1908         } else
1909                 memcpy(skb->data, ring + offset, size);
1910 }
1911 #endif
1912
1913 static void rtl8139_isr_ack(struct rtl8139_private *tp)
1914 {
1915         void __iomem *ioaddr = tp->mmio_addr;
1916         u16 status;
1917
1918         status = RTL_R16 (IntrStatus) & RxAckBits;
1919
1920         /* Clear out errors and receive interrupts */
1921         if (likely(status != 0)) {
1922                 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
1923                         tp->stats.rx_errors++;
1924                         if (status & RxFIFOOver)
1925                                 tp->stats.rx_fifo_errors++;
1926                 }
1927                 RTL_W16_F (IntrStatus, RxAckBits);
1928         }
1929 }
1930
1931 static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1932                       int budget)
1933 {
1934         void __iomem *ioaddr = tp->mmio_addr;
1935         int received = 0;
1936         unsigned char *rx_ring = tp->rx_ring;
1937         unsigned int cur_rx = tp->cur_rx;
1938         unsigned int rx_size = 0;
1939
1940         DPRINTK ("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x,"
1941                  " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx,
1942                  RTL_R16 (RxBufAddr),
1943                  RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
1944
1945         while (netif_running(dev) && received < budget
1946                && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
1947                 u32 ring_offset = cur_rx % RX_BUF_LEN;
1948                 u32 rx_status;
1949                 unsigned int pkt_size;
1950                 struct sk_buff *skb;
1951
1952                 rmb();
1953
1954                 /* read size+status of next frame from DMA ring buffer */
1955                 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
1956                 rx_size = rx_status >> 16;
1957                 pkt_size = rx_size - 4;
1958
1959                 if (netif_msg_rx_status(tp))
1960                         printk(KERN_DEBUG "%s:  rtl8139_rx() status %4.4x, size %4.4x,"
1961                                 " cur %4.4x.\n", dev->name, rx_status,
1962                          rx_size, cur_rx);
1963 #if RTL8139_DEBUG > 2
1964                 {
1965                         int i;
1966                         DPRINTK ("%s: Frame contents ", dev->name);
1967                         for (i = 0; i < 70; i++)
1968                                 printk (" %2.2x",
1969                                         rx_ring[ring_offset + i]);
1970                         printk (".\n");
1971                 }
1972 #endif
1973
1974                 /* Packet copy from FIFO still in progress.
1975                  * Theoretically, this should never happen
1976                  * since EarlyRx is disabled.
1977                  */
1978                 if (unlikely(rx_size == 0xfff0)) {
1979                         if (!tp->fifo_copy_timeout)
1980                                 tp->fifo_copy_timeout = jiffies + 2;
1981                         else if (time_after(jiffies, tp->fifo_copy_timeout)) {
1982                                 DPRINTK ("%s: hung FIFO. Reset.", dev->name);
1983                                 rx_size = 0;
1984                                 goto no_early_rx;
1985                         }
1986                         if (netif_msg_intr(tp)) {
1987                                 printk(KERN_DEBUG "%s: fifo copy in progress.",
1988                                        dev->name);
1989                         }
1990                         tp->xstats.early_rx++;
1991                         break;
1992                 }
1993
1994 no_early_rx:
1995                 tp->fifo_copy_timeout = 0;
1996
1997                 /* If Rx err or invalid rx_size/rx_status received
1998                  * (which happens if we get lost in the ring),
1999                  * Rx process gets reset, so we abort any further
2000                  * Rx processing.
2001                  */
2002                 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
2003                              (rx_size < 8) ||
2004                              (!(rx_status & RxStatusOK)))) {
2005                         rtl8139_rx_err (rx_status, dev, tp, ioaddr);
2006                         received = -1;
2007                         goto out;
2008                 }
2009
2010                 /* Malloc up new buffer, compatible with net-2e. */
2011                 /* Omit the four octet CRC from the length. */
2012
2013                 skb = dev_alloc_skb (pkt_size + 2);
2014                 if (likely(skb)) {
2015                         skb->dev = dev;
2016                         skb_reserve (skb, 2);   /* 16 byte align the IP fields. */
2017 #if RX_BUF_IDX == 3
2018                         wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
2019 #else
2020                         eth_copy_and_sum (skb, &rx_ring[ring_offset + 4], pkt_size, 0);
2021 #endif
2022                         skb_put (skb, pkt_size);
2023
2024                         skb->protocol = eth_type_trans (skb, dev);
2025
2026                         dev->last_rx = jiffies;
2027                         tp->stats.rx_bytes += pkt_size;
2028                         tp->stats.rx_packets++;
2029
2030                         netif_receive_skb (skb);
2031                 } else {
2032                         if (net_ratelimit())
2033                                 printk (KERN_WARNING
2034                                         "%s: Memory squeeze, dropping packet.\n",
2035                                         dev->name);
2036                         tp->stats.rx_dropped++;
2037                 }
2038                 received++;
2039
2040                 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2041                 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2042
2043                 rtl8139_isr_ack(tp);
2044         }
2045
2046         if (unlikely(!received || rx_size == 0xfff0))
2047                 rtl8139_isr_ack(tp);
2048
2049 #if RTL8139_DEBUG > 1
2050         DPRINTK ("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x,"
2051                  " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
2052                  RTL_R16 (RxBufAddr),
2053                  RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
2054 #endif
2055
2056         tp->cur_rx = cur_rx;
2057
2058         /*
2059          * The receive buffer should be mostly empty.
2060          * Tell NAPI to reenable the Rx irq.
2061          */
2062         if (tp->fifo_copy_timeout)
2063                 received = budget;
2064
2065 out:
2066         return received;
2067 }
2068
2069
2070 static void rtl8139_weird_interrupt (struct net_device *dev,
2071                                      struct rtl8139_private *tp,
2072                                      void __iomem *ioaddr,
2073                                      int status, int link_changed)
2074 {
2075         DPRINTK ("%s: Abnormal interrupt, status %8.8x.\n",
2076                  dev->name, status);
2077
2078         assert (dev != NULL);
2079         assert (tp != NULL);
2080         assert (ioaddr != NULL);
2081
2082         /* Update the error count. */
2083         tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2084         RTL_W32 (RxMissed, 0);
2085
2086         if ((status & RxUnderrun) && link_changed &&
2087             (tp->drv_flags & HAS_LNK_CHNG)) {
2088                 rtl_check_media(dev, 0);
2089                 status &= ~RxUnderrun;
2090         }
2091
2092         if (status & (RxUnderrun | RxErr))
2093                 tp->stats.rx_errors++;
2094
2095         if (status & PCSTimeout)
2096                 tp->stats.rx_length_errors++;
2097         if (status & RxUnderrun)
2098                 tp->stats.rx_fifo_errors++;
2099         if (status & PCIErr) {
2100                 u16 pci_cmd_status;
2101                 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2102                 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2103
2104                 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
2105                         dev->name, pci_cmd_status);
2106         }
2107 }
2108
2109 static int rtl8139_poll(struct net_device *dev, int *budget)
2110 {
2111         struct rtl8139_private *tp = netdev_priv(dev);
2112         void __iomem *ioaddr = tp->mmio_addr;
2113         int orig_budget = min(*budget, dev->quota);
2114         int done = 1;
2115
2116         spin_lock(&tp->rx_lock);
2117         if (likely(RTL_R16(IntrStatus) & RxAckBits)) {
2118                 int work_done;
2119
2120                 work_done = rtl8139_rx(dev, tp, orig_budget);
2121                 if (likely(work_done > 0)) {
2122                         *budget -= work_done;
2123                         dev->quota -= work_done;
2124                         done = (work_done < orig_budget);
2125                 }
2126         }
2127
2128         if (done) {
2129                 /*
2130                  * Order is important since data can get interrupted
2131                  * again when we think we are done.
2132                  */
2133                 local_irq_disable();
2134                 RTL_W16_F(IntrMask, rtl8139_intr_mask);
2135                 __netif_rx_complete(dev);
2136                 local_irq_enable();
2137         }
2138         spin_unlock(&tp->rx_lock);
2139
2140         return !done;
2141 }
2142
2143 /* The interrupt handler does all of the Rx thread work and cleans up
2144    after the Tx thread. */
2145 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance,
2146                                struct pt_regs *regs)
2147 {
2148         struct net_device *dev = (struct net_device *) dev_instance;
2149         struct rtl8139_private *tp = netdev_priv(dev);
2150         void __iomem *ioaddr = tp->mmio_addr;
2151         u16 status, ackstat;
2152         int link_changed = 0; /* avoid bogus "uninit" warning */
2153         int handled = 0;
2154
2155         spin_lock (&tp->lock);
2156         status = RTL_R16 (IntrStatus);
2157
2158         /* shared irq? */
2159         if (unlikely((status & rtl8139_intr_mask) == 0))
2160                 goto out;
2161
2162         handled = 1;
2163
2164         /* h/w no longer present (hotplug?) or major error, bail */
2165         if (unlikely(status == 0xFFFF))
2166                 goto out;
2167
2168         /* close possible race's with dev_close */
2169         if (unlikely(!netif_running(dev))) {
2170                 RTL_W16 (IntrMask, 0);
2171                 goto out;
2172         }
2173
2174         /* Acknowledge all of the current interrupt sources ASAP, but
2175            an first get an additional status bit from CSCR. */
2176         if (unlikely(status & RxUnderrun))
2177                 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2178
2179         ackstat = status & ~(RxAckBits | TxErr);
2180         if (ackstat)
2181                 RTL_W16 (IntrStatus, ackstat);
2182
2183         /* Receive packets are processed by poll routine.
2184            If not running start it now. */
2185         if (status & RxAckBits){
2186                 if (netif_rx_schedule_prep(dev)) {
2187                         RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
2188                         __netif_rx_schedule (dev);
2189                 }
2190         }
2191
2192         /* Check uncommon events with one test. */
2193         if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2194                 rtl8139_weird_interrupt (dev, tp, ioaddr,
2195                                          status, link_changed);
2196
2197         if (status & (TxOK | TxErr)) {
2198                 rtl8139_tx_interrupt (dev, tp, ioaddr);
2199                 if (status & TxErr)
2200                         RTL_W16 (IntrStatus, TxErr);
2201         }
2202  out:
2203         spin_unlock (&tp->lock);
2204
2205         DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
2206                  dev->name, RTL_R16 (IntrStatus));
2207         return IRQ_RETVAL(handled);
2208 }
2209
2210 #ifdef CONFIG_NET_POLL_CONTROLLER
2211 /*
2212  * Polling receive - used by netconsole and other diagnostic tools
2213  * to allow network i/o with interrupts disabled.
2214  */
2215 static void rtl8139_poll_controller(struct net_device *dev)
2216 {
2217         disable_irq(dev->irq);
2218         rtl8139_interrupt(dev->irq, dev, NULL);
2219         enable_irq(dev->irq);
2220 }
2221 #endif
2222
2223 static int rtl8139_close (struct net_device *dev)
2224 {
2225         struct rtl8139_private *tp = netdev_priv(dev);
2226         void __iomem *ioaddr = tp->mmio_addr;
2227         int ret = 0;
2228         unsigned long flags;
2229
2230         netif_stop_queue (dev);
2231
2232         if (tp->thr_pid >= 0) {
2233                 tp->time_to_die = 1;
2234                 wmb();
2235                 ret = kill_proc (tp->thr_pid, SIGTERM, 1);
2236                 if (ret) {
2237                         printk (KERN_ERR "%s: unable to signal thread\n", dev->name);
2238                         return ret;
2239                 }
2240                 wait_for_completion (&tp->thr_exited);
2241         }
2242
2243         if (netif_msg_ifdown(tp))
2244                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n",
2245                         dev->name, RTL_R16 (IntrStatus));
2246
2247         spin_lock_irqsave (&tp->lock, flags);
2248
2249         /* Stop the chip's Tx and Rx DMA processes. */
2250         RTL_W8 (ChipCmd, 0);
2251
2252         /* Disable interrupts by clearing the interrupt mask. */
2253         RTL_W16 (IntrMask, 0);
2254
2255         /* Update the error counts. */
2256         tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2257         RTL_W32 (RxMissed, 0);
2258
2259         spin_unlock_irqrestore (&tp->lock, flags);
2260
2261         synchronize_irq (dev->irq);     /* racy, but that's ok here */
2262         free_irq (dev->irq, dev);
2263
2264         rtl8139_tx_clear (tp);
2265
2266         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
2267                             tp->rx_ring, tp->rx_ring_dma);
2268         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
2269                             tp->tx_bufs, tp->tx_bufs_dma);
2270         tp->rx_ring = NULL;
2271         tp->tx_bufs = NULL;
2272
2273         /* Green! Put the chip in low-power mode. */
2274         RTL_W8 (Cfg9346, Cfg9346_Unlock);
2275
2276         if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2277                 RTL_W8 (HltClk, 'H');   /* 'R' would leave the clock running. */
2278
2279         return 0;
2280 }
2281
2282
2283 /* Get the ethtool Wake-on-LAN settings.  Assumes that wol points to
2284    kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2285    other threads or interrupts aren't messing with the 8139.  */
2286 static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2287 {
2288         struct rtl8139_private *np = netdev_priv(dev);
2289         void __iomem *ioaddr = np->mmio_addr;
2290
2291         spin_lock_irq(&np->lock);
2292         if (rtl_chip_info[np->chipset].flags & HasLWake) {
2293                 u8 cfg3 = RTL_R8 (Config3);
2294                 u8 cfg5 = RTL_R8 (Config5);
2295
2296                 wol->supported = WAKE_PHY | WAKE_MAGIC
2297                         | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2298
2299                 wol->wolopts = 0;
2300                 if (cfg3 & Cfg3_LinkUp)
2301                         wol->wolopts |= WAKE_PHY;
2302                 if (cfg3 & Cfg3_Magic)
2303                         wol->wolopts |= WAKE_MAGIC;
2304                 /* (KON)FIXME: See how netdev_set_wol() handles the
2305                    following constants.  */
2306                 if (cfg5 & Cfg5_UWF)
2307                         wol->wolopts |= WAKE_UCAST;
2308                 if (cfg5 & Cfg5_MWF)
2309                         wol->wolopts |= WAKE_MCAST;
2310                 if (cfg5 & Cfg5_BWF)
2311                         wol->wolopts |= WAKE_BCAST;
2312         }
2313         spin_unlock_irq(&np->lock);
2314 }
2315
2316
2317 /* Set the ethtool Wake-on-LAN settings.  Return 0 or -errno.  Assumes
2318    that wol points to kernel memory and other threads or interrupts
2319    aren't messing with the 8139.  */
2320 static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2321 {
2322         struct rtl8139_private *np = netdev_priv(dev);
2323         void __iomem *ioaddr = np->mmio_addr;
2324         u32 support;
2325         u8 cfg3, cfg5;
2326
2327         support = ((rtl_chip_info[np->chipset].flags & HasLWake)
2328                    ? (WAKE_PHY | WAKE_MAGIC
2329                       | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2330                    : 0);
2331         if (wol->wolopts & ~support)
2332                 return -EINVAL;
2333
2334         spin_lock_irq(&np->lock);
2335         cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2336         if (wol->wolopts & WAKE_PHY)
2337                 cfg3 |= Cfg3_LinkUp;
2338         if (wol->wolopts & WAKE_MAGIC)
2339                 cfg3 |= Cfg3_Magic;
2340         RTL_W8 (Cfg9346, Cfg9346_Unlock);
2341         RTL_W8 (Config3, cfg3);
2342         RTL_W8 (Cfg9346, Cfg9346_Lock);
2343
2344         cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2345         /* (KON)FIXME: These are untested.  We may have to set the
2346            CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2347            documentation.  */
2348         if (wol->wolopts & WAKE_UCAST)
2349                 cfg5 |= Cfg5_UWF;
2350         if (wol->wolopts & WAKE_MCAST)
2351                 cfg5 |= Cfg5_MWF;
2352         if (wol->wolopts & WAKE_BCAST)
2353                 cfg5 |= Cfg5_BWF;
2354         RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
2355         spin_unlock_irq(&np->lock);
2356
2357         return 0;
2358 }
2359
2360 static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2361 {
2362         struct rtl8139_private *np = netdev_priv(dev);
2363         strcpy(info->driver, DRV_NAME);
2364         strcpy(info->version, DRV_VERSION);
2365         strcpy(info->bus_info, pci_name(np->pci_dev));
2366         info->regdump_len = np->regs_len;
2367 }
2368
2369 static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2370 {
2371         struct rtl8139_private *np = netdev_priv(dev);
2372         spin_lock_irq(&np->lock);
2373         mii_ethtool_gset(&np->mii, cmd);
2374         spin_unlock_irq(&np->lock);
2375         return 0;
2376 }
2377
2378 static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2379 {
2380         struct rtl8139_private *np = netdev_priv(dev);
2381         int rc;
2382         spin_lock_irq(&np->lock);
2383         rc = mii_ethtool_sset(&np->mii, cmd);
2384         spin_unlock_irq(&np->lock);
2385         return rc;
2386 }
2387
2388 static int rtl8139_nway_reset(struct net_device *dev)
2389 {
2390         struct rtl8139_private *np = netdev_priv(dev);
2391         return mii_nway_restart(&np->mii);
2392 }
2393
2394 static u32 rtl8139_get_link(struct net_device *dev)
2395 {
2396         struct rtl8139_private *np = netdev_priv(dev);
2397         return mii_link_ok(&np->mii);
2398 }
2399
2400 static u32 rtl8139_get_msglevel(struct net_device *dev)
2401 {
2402         struct rtl8139_private *np = netdev_priv(dev);
2403         return np->msg_enable;
2404 }
2405
2406 static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2407 {
2408         struct rtl8139_private *np = netdev_priv(dev);
2409         np->msg_enable = datum;
2410 }
2411
2412 /* TODO: we are too slack to do reg dumping for pio, for now */
2413 #ifdef CONFIG_8139TOO_PIO
2414 #define rtl8139_get_regs_len    NULL
2415 #define rtl8139_get_regs        NULL
2416 #else
2417 static int rtl8139_get_regs_len(struct net_device *dev)
2418 {
2419         struct rtl8139_private *np = netdev_priv(dev);
2420         return np->regs_len;
2421 }
2422
2423 static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2424 {
2425         struct rtl8139_private *np = netdev_priv(dev);
2426
2427         regs->version = RTL_REGS_VER;
2428
2429         spin_lock_irq(&np->lock);
2430         memcpy_fromio(regbuf, np->mmio_addr, regs->len);
2431         spin_unlock_irq(&np->lock);
2432 }
2433 #endif /* CONFIG_8139TOO_MMIO */
2434
2435 static int rtl8139_get_stats_count(struct net_device *dev)
2436 {
2437         return RTL_NUM_STATS;
2438 }
2439
2440 static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2441 {
2442         struct rtl8139_private *np = netdev_priv(dev);
2443
2444         data[0] = np->xstats.early_rx;
2445         data[1] = np->xstats.tx_buf_mapped;
2446         data[2] = np->xstats.tx_timeouts;
2447         data[3] = np->xstats.rx_lost_in_ring;
2448 }
2449
2450 static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2451 {
2452         memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2453 }
2454
2455 static struct ethtool_ops rtl8139_ethtool_ops = {
2456         .get_drvinfo            = rtl8139_get_drvinfo,
2457         .get_settings           = rtl8139_get_settings,
2458         .set_settings           = rtl8139_set_settings,
2459         .get_regs_len           = rtl8139_get_regs_len,
2460         .get_regs               = rtl8139_get_regs,
2461         .nway_reset             = rtl8139_nway_reset,
2462         .get_link               = rtl8139_get_link,
2463         .get_msglevel           = rtl8139_get_msglevel,
2464         .set_msglevel           = rtl8139_set_msglevel,
2465         .get_wol                = rtl8139_get_wol,
2466         .set_wol                = rtl8139_set_wol,
2467         .get_strings            = rtl8139_get_strings,
2468         .get_stats_count        = rtl8139_get_stats_count,
2469         .get_ethtool_stats      = rtl8139_get_ethtool_stats,
2470         .get_perm_addr          = ethtool_op_get_perm_addr,
2471 };
2472
2473 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2474 {
2475         struct rtl8139_private *np = netdev_priv(dev);
2476         int rc;
2477
2478         if (!netif_running(dev))
2479                 return -EINVAL;
2480
2481         spin_lock_irq(&np->lock);
2482         rc = generic_mii_ioctl(&np->mii, if_mii(rq), cmd, NULL);
2483         spin_unlock_irq(&np->lock);
2484
2485         return rc;
2486 }
2487
2488
2489 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2490 {
2491         struct rtl8139_private *tp = netdev_priv(dev);
2492         void __iomem *ioaddr = tp->mmio_addr;
2493         unsigned long flags;
2494
2495         if (netif_running(dev)) {
2496                 spin_lock_irqsave (&tp->lock, flags);
2497                 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2498                 RTL_W32 (RxMissed, 0);
2499                 spin_unlock_irqrestore (&tp->lock, flags);
2500         }
2501
2502         return &tp->stats;
2503 }
2504
2505 /* Set or clear the multicast filter for this adaptor.
2506    This routine is not state sensitive and need not be SMP locked. */
2507
2508 static void __set_rx_mode (struct net_device *dev)
2509 {
2510         struct rtl8139_private *tp = netdev_priv(dev);
2511         void __iomem *ioaddr = tp->mmio_addr;
2512         u32 mc_filter[2];       /* Multicast hash filter */
2513         int i, rx_mode;
2514         u32 tmp;
2515
2516         DPRINTK ("%s:   rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
2517                         dev->name, dev->flags, RTL_R32 (RxConfig));
2518
2519         /* Note: do not reorder, GCC is clever about common statements. */
2520         if (dev->flags & IFF_PROMISC) {
2521                 /* Unconditionally log net taps. */
2522                 printk (KERN_NOTICE "%s: Promiscuous mode enabled.\n",
2523                         dev->name);
2524                 rx_mode =
2525                     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2526                     AcceptAllPhys;
2527                 mc_filter[1] = mc_filter[0] = 0xffffffff;
2528         } else if ((dev->mc_count > multicast_filter_limit)
2529                    || (dev->flags & IFF_ALLMULTI)) {
2530                 /* Too many to filter perfectly -- accept all multicasts. */
2531                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2532                 mc_filter[1] = mc_filter[0] = 0xffffffff;
2533         } else {
2534                 struct dev_mc_list *mclist;
2535                 rx_mode = AcceptBroadcast | AcceptMyPhys;
2536                 mc_filter[1] = mc_filter[0] = 0;
2537                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2538                      i++, mclist = mclist->next) {
2539                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
2540
2541                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2542                         rx_mode |= AcceptMulticast;
2543                 }
2544         }
2545
2546         /* We can safely update without stopping the chip. */
2547         tmp = rtl8139_rx_config | rx_mode;
2548         if (tp->rx_config != tmp) {
2549                 RTL_W32_F (RxConfig, tmp);
2550                 tp->rx_config = tmp;
2551         }
2552         RTL_W32_F (MAR0 + 0, mc_filter[0]);
2553         RTL_W32_F (MAR0 + 4, mc_filter[1]);
2554 }
2555
2556 static void rtl8139_set_rx_mode (struct net_device *dev)
2557 {
2558         unsigned long flags;
2559         struct rtl8139_private *tp = netdev_priv(dev);
2560
2561         spin_lock_irqsave (&tp->lock, flags);
2562         __set_rx_mode(dev);
2563         spin_unlock_irqrestore (&tp->lock, flags);
2564 }
2565
2566 #ifdef CONFIG_PM
2567
2568 static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2569 {
2570         struct net_device *dev = pci_get_drvdata (pdev);
2571         struct rtl8139_private *tp = netdev_priv(dev);
2572         void __iomem *ioaddr = tp->mmio_addr;
2573         unsigned long flags;
2574
2575         pci_save_state (pdev);
2576
2577         if (!netif_running (dev))
2578                 return 0;
2579
2580         netif_device_detach (dev);
2581
2582         spin_lock_irqsave (&tp->lock, flags);
2583
2584         /* Disable interrupts, stop Tx and Rx. */
2585         RTL_W16 (IntrMask, 0);
2586         RTL_W8 (ChipCmd, 0);
2587
2588         /* Update the error counts. */
2589         tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2590         RTL_W32 (RxMissed, 0);
2591
2592         spin_unlock_irqrestore (&tp->lock, flags);
2593
2594         pci_set_power_state (pdev, PCI_D3hot);
2595
2596         return 0;
2597 }
2598
2599
2600 static int rtl8139_resume (struct pci_dev *pdev)
2601 {
2602         struct net_device *dev = pci_get_drvdata (pdev);
2603
2604         pci_restore_state (pdev);
2605         if (!netif_running (dev))
2606                 return 0;
2607         pci_set_power_state (pdev, PCI_D0);
2608         rtl8139_init_ring (dev);
2609         rtl8139_hw_start (dev);
2610         netif_device_attach (dev);
2611         return 0;
2612 }
2613
2614 #endif /* CONFIG_PM */
2615
2616
2617 static struct pci_driver rtl8139_pci_driver = {
2618         .name           = DRV_NAME,
2619         .id_table       = rtl8139_pci_tbl,
2620         .probe          = rtl8139_init_one,
2621         .remove         = __devexit_p(rtl8139_remove_one),
2622 #ifdef CONFIG_PM
2623         .suspend        = rtl8139_suspend,
2624         .resume         = rtl8139_resume,
2625 #endif /* CONFIG_PM */
2626 };
2627
2628
2629 static int __init rtl8139_init_module (void)
2630 {
2631         /* when we're a module, we always print a version message,
2632          * even if no 8139 board is found.
2633          */
2634 #ifdef MODULE
2635         printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
2636 #endif
2637
2638         return pci_module_init (&rtl8139_pci_driver);
2639 }
2640
2641
2642 static void __exit rtl8139_cleanup_module (void)
2643 {
2644         pci_unregister_driver (&rtl8139_pci_driver);
2645 }
2646
2647
2648 module_init(rtl8139_init_module);
2649 module_exit(rtl8139_cleanup_module);