git.oblomov.eu Git - linux-2.6/blob - 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           HasLWake,
 556         },
 557
 558         { "RTL-8101",
 559           HW_REVID(1, 1, 1, 0, 1, 1, 1),
 560           HasLWake,
 561         },
 562 };
 563
 564 struct rtl_extra_stats {
 565         unsigned long early_rx;
 566         unsigned long tx_buf_mapped;
 567         unsigned long tx_timeouts;
 568         unsigned long rx_lost_in_ring;
 569 };
 570
 571 struct rtl8139_private {
 572         void __iomem *mmio_addr;
 573         int drv_flags;
 574         struct pci_dev *pci_dev;
 575         u32 msg_enable;
 576         struct net_device_stats stats;
 577         unsigned char *rx_ring;
 578         unsigned int cur_rx;    /* Index into the Rx buffer of next Rx pkt. */
 579         unsigned int tx_flag;
 580         unsigned long cur_tx;
 581         unsigned long dirty_tx;
 582         unsigned char *tx_buf[NUM_TX_DESC];     /* Tx bounce buffers */
 583         unsigned char *tx_bufs; /* Tx bounce buffer region. */
 584         dma_addr_t rx_ring_dma;
 585         dma_addr_t tx_bufs_dma;
 586         signed char phys[4];            /* MII device addresses. */
 587         char twistie, twist_row, twist_col;     /* Twister tune state. */
 588         unsigned int default_port:4;    /* Last dev->if_port value. */
 589         spinlock_t lock;
 590         spinlock_t rx_lock;
 591         chip_t chipset;
 592         pid_t thr_pid;
 593         wait_queue_head_t thr_wait;
 594         struct completion thr_exited;
 595         u32 rx_config;
 596         struct rtl_extra_stats xstats;
 597         int time_to_die;
 598         struct mii_if_info mii;
 599         unsigned int regs_len;
 600         unsigned long fifo_copy_timeout;
 601 };
 602
 603 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
 604 MODULE_DESCRIPTION ("RealTek RTL-8139 Fast Ethernet driver");
 605 MODULE_LICENSE("GPL");
 606 MODULE_VERSION(DRV_VERSION);
 607
 608 module_param(multicast_filter_limit, int, 0);
 609 module_param_array(media, int, NULL, 0);
 610 module_param_array(full_duplex, int, NULL, 0);
 611 module_param(debug, int, 0);
 612 MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");
 613 MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
 614 MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
 615 MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
 616
 617 static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);
 618 static int rtl8139_open (struct net_device *dev);
 619 static int mdio_read (struct net_device *dev, int phy_id, int location);
 620 static void mdio_write (struct net_device *dev, int phy_id, int location,
 621                         int val);
 622 static void rtl8139_start_thread(struct net_device *dev);
 623 static void rtl8139_tx_timeout (struct net_device *dev);
 624 static void rtl8139_init_ring (struct net_device *dev);
 625 static int rtl8139_start_xmit (struct sk_buff *skb,
 626                                struct net_device *dev);
 627 static int rtl8139_poll(struct net_device *dev, int *budget);
 628 #ifdef CONFIG_NET_POLL_CONTROLLER
 629 static void rtl8139_poll_controller(struct net_device *dev);
 630 #endif
 631 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance,
 632                                struct pt_regs *regs);
 633 static int rtl8139_close (struct net_device *dev);
 634 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
 635 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
 636 static void rtl8139_set_rx_mode (struct net_device *dev);
 637 static void __set_rx_mode (struct net_device *dev);
 638 static void rtl8139_hw_start (struct net_device *dev);
 639 static struct ethtool_ops rtl8139_ethtool_ops;
 640
 641 /* write MMIO register, with flush */
 642 /* Flush avoids rtl8139 bug w/ posted MMIO writes */
 643 #define RTL_W8_F(reg, val8)     do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)
 644 #define RTL_W16_F(reg, val16)   do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)
 645 #define RTL_W32_F(reg, val32)   do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)
 646
 647
 648 #define MMIO_FLUSH_AUDIT_COMPLETE 1
 649 #if MMIO_FLUSH_AUDIT_COMPLETE
 650
 651 /* write MMIO register */
 652 #define RTL_W8(reg, val8)       iowrite8 ((val8), ioaddr + (reg))
 653 #define RTL_W16(reg, val16)     iowrite16 ((val16), ioaddr + (reg))
 654 #define RTL_W32(reg, val32)     iowrite32 ((val32), ioaddr + (reg))
 655
 656 #else
 657
 658 /* write MMIO register, then flush */
 659 #define RTL_W8          RTL_W8_F
 660 #define RTL_W16         RTL_W16_F
 661 #define RTL_W32         RTL_W32_F
 662
 663 #endif /* MMIO_FLUSH_AUDIT_COMPLETE */
 664
 665 /* read MMIO register */
 666 #define RTL_R8(reg)             ioread8 (ioaddr + (reg))
 667 #define RTL_R16(reg)            ioread16 (ioaddr + (reg))
 668 #define RTL_R32(reg)            ((unsigned long) ioread32 (ioaddr + (reg)))
 669
 670
 671 static const u16 rtl8139_intr_mask =
 672         PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
 673         TxErr | TxOK | RxErr | RxOK;
 674
 675 static const u16 rtl8139_norx_intr_mask =
 676         PCIErr | PCSTimeout | RxUnderrun |
 677         TxErr | TxOK | RxErr ;
 678
 679 #if RX_BUF_IDX == 0
 680 static const unsigned int rtl8139_rx_config =
 681         RxCfgRcv8K | RxNoWrap |
 682         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 683         (RX_DMA_BURST << RxCfgDMAShift);
 684 #elif RX_BUF_IDX == 1
 685 static const unsigned int rtl8139_rx_config =
 686         RxCfgRcv16K | RxNoWrap |
 687         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 688         (RX_DMA_BURST << RxCfgDMAShift);
 689 #elif RX_BUF_IDX == 2
 690 static const unsigned int rtl8139_rx_config =
 691         RxCfgRcv32K | RxNoWrap |
 692         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 693         (RX_DMA_BURST << RxCfgDMAShift);
 694 #elif RX_BUF_IDX == 3
 695 static const unsigned int rtl8139_rx_config =
 696         RxCfgRcv64K |
 697         (RX_FIFO_THRESH << RxCfgFIFOShift) |
 698         (RX_DMA_BURST << RxCfgDMAShift);
 699 #else
 700 #error "Invalid configuration for 8139_RXBUF_IDX"
 701 #endif
 702
 703 static const unsigned int rtl8139_tx_config =
 704         TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);
 705
 706 static void __rtl8139_cleanup_dev (struct net_device *dev)
 707 {
 708         struct rtl8139_private *tp = netdev_priv(dev);
 709         struct pci_dev *pdev;
 710
 711         assert (dev != NULL);
 712         assert (tp->pci_dev != NULL);
 713         pdev = tp->pci_dev;
 714
 715 #ifdef USE_IO_OPS
 716         if (tp->mmio_addr)
 717                 ioport_unmap (tp->mmio_addr);
 718 #else
 719         if (tp->mmio_addr)
 720                 pci_iounmap (pdev, tp->mmio_addr);
 721 #endif /* USE_IO_OPS */
 722
 723         /* it's ok to call this even if we have no regions to free */
 724         pci_release_regions (pdev);
 725
 726         free_netdev(dev);
 727         pci_set_drvdata (pdev, NULL);
 728 }
 729
 730
 731 static void rtl8139_chip_reset (void __iomem *ioaddr)
 732 {
 733         int i;
 734
 735         /* Soft reset the chip. */
 736         RTL_W8 (ChipCmd, CmdReset);
 737
 738         /* Check that the chip has finished the reset. */
 739         for (i = 1000; i > 0; i--) {
 740                 barrier();
 741                 if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
 742                         break;
 743                 udelay (10);
 744         }
 745 }
 746
 747
 748 static int __devinit rtl8139_init_board (struct pci_dev *pdev,
 749                                          struct net_device **dev_out)
 750 {
 751         void __iomem *ioaddr;
 752         struct net_device *dev;
 753         struct rtl8139_private *tp;
 754         u8 tmp8;
 755         int rc, disable_dev_on_err = 0;
 756         unsigned int i;
 757         unsigned long pio_start, pio_end, pio_flags, pio_len;
 758         unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
 759         u32 version;
 760
 761         assert (pdev != NULL);
 762
 763         *dev_out = NULL;
 764
 765         /* dev and priv zeroed in alloc_etherdev */
 766         dev = alloc_etherdev (sizeof (*tp));
 767         if (dev == NULL) {
 768                 printk (KERN_ERR PFX "%s: Unable to alloc new net device\n", pci_name(pdev));
 769                 return -ENOMEM;
 770         }
 771         SET_MODULE_OWNER(dev);
 772         SET_NETDEV_DEV(dev, &pdev->dev);
 773
 774         tp = netdev_priv(dev);
 775         tp->pci_dev = pdev;
 776
 777         /* enable device (incl. PCI PM wakeup and hotplug setup) */
 778         rc = pci_enable_device (pdev);
 779         if (rc)
 780                 goto err_out;
 781
 782         pio_start = pci_resource_start (pdev, 0);
 783         pio_end = pci_resource_end (pdev, 0);
 784         pio_flags = pci_resource_flags (pdev, 0);
 785         pio_len = pci_resource_len (pdev, 0);
 786
 787         mmio_start = pci_resource_start (pdev, 1);
 788         mmio_end = pci_resource_end (pdev, 1);
 789         mmio_flags = pci_resource_flags (pdev, 1);
 790         mmio_len = pci_resource_len (pdev, 1);
 791
 792         /* set this immediately, we need to know before
 793          * we talk to the chip directly */
 794         DPRINTK("PIO region size == 0x%02X\n", pio_len);
 795         DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
 796
 797 #ifdef USE_IO_OPS
 798         /* make sure PCI base addr 0 is PIO */
 799         if (!(pio_flags & IORESOURCE_IO)) {
 800                 printk (KERN_ERR PFX "%s: region #0 not a PIO resource, aborting\n", pci_name(pdev));
 801                 rc = -ENODEV;
 802                 goto err_out;
 803         }
 804         /* check for weird/broken PCI region reporting */
 805         if (pio_len < RTL_MIN_IO_SIZE) {
 806                 printk (KERN_ERR PFX "%s: Invalid PCI I/O region size(s), aborting\n", pci_name(pdev));
 807                 rc = -ENODEV;
 808                 goto err_out;
 809         }
 810 #else
 811         /* make sure PCI base addr 1 is MMIO */
 812         if (!(mmio_flags & IORESOURCE_MEM)) {
 813                 printk (KERN_ERR PFX "%s: region #1 not an MMIO resource, aborting\n", pci_name(pdev));
 814                 rc = -ENODEV;
 815                 goto err_out;
 816         }
 817         if (mmio_len < RTL_MIN_IO_SIZE) {
 818                 printk (KERN_ERR PFX "%s: Invalid PCI mem region size(s), aborting\n", pci_name(pdev));
 819                 rc = -ENODEV;
 820                 goto err_out;
 821         }
 822 #endif
 823
 824         rc = pci_request_regions (pdev, "8139too");
 825         if (rc)
 826                 goto err_out;
 827         disable_dev_on_err = 1;
 828
 829         /* enable PCI bus-mastering */
 830         pci_set_master (pdev);
 831
 832 #ifdef USE_IO_OPS
 833         ioaddr = ioport_map(pio_start, pio_len);
 834         if (!ioaddr) {
 835                 printk (KERN_ERR PFX "%s: cannot map PIO, aborting\n", pci_name(pdev));
 836                 rc = -EIO;
 837                 goto err_out;
 838         }
 839         dev->base_addr = pio_start;
 840         tp->mmio_addr = ioaddr;
 841         tp->regs_len = pio_len;
 842 #else
 843         /* ioremap MMIO region */
 844         ioaddr = pci_iomap(pdev, 1, 0);
 845         if (ioaddr == NULL) {
 846                 printk (KERN_ERR PFX "%s: cannot remap MMIO, aborting\n", pci_name(pdev));
 847                 rc = -EIO;
 848                 goto err_out;
 849         }
 850         dev->base_addr = (long) ioaddr;
 851         tp->mmio_addr = ioaddr;
 852         tp->regs_len = mmio_len;
 853 #endif /* USE_IO_OPS */
 854
 855         /* Bring old chips out of low-power mode. */
 856         RTL_W8 (HltClk, 'R');
 857
 858         /* check for missing/broken hardware */
 859         if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {
 860                 printk (KERN_ERR PFX "%s: Chip not responding, ignoring board\n",
 861                         pci_name(pdev));
 862                 rc = -EIO;
 863                 goto err_out;
 864         }
 865
 866         /* identify chip attached to board */
 867         version = RTL_R32 (TxConfig) & HW_REVID_MASK;
 868         for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)
 869                 if (version == rtl_chip_info[i].version) {
 870                         tp->chipset = i;
 871                         goto match;
 872                 }
 873
 874         /* if unknown chip, assume array element #0, original RTL-8139 in this case */
 875         printk (KERN_DEBUG PFX "%s: unknown chip version, assuming RTL-8139\n",
 876                 pci_name(pdev));
 877         printk (KERN_DEBUG PFX "%s: TxConfig = 0x%lx\n", pci_name(pdev), RTL_R32 (TxConfig));
 878         tp->chipset = 0;
 879
 880 match:
 881         DPRINTK ("chipset id (%d) == index %d, '%s'\n",
 882                  version, i, rtl_chip_info[i].name);
 883
 884         if (tp->chipset >= CH_8139B) {
 885                 u8 new_tmp8 = tmp8 = RTL_R8 (Config1);
 886                 DPRINTK("PCI PM wakeup\n");
 887                 if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&
 888                     (tmp8 & LWAKE))
 889                         new_tmp8 &= ~LWAKE;
 890                 new_tmp8 |= Cfg1_PM_Enable;
 891                 if (new_tmp8 != tmp8) {
 892                         RTL_W8 (Cfg9346, Cfg9346_Unlock);
 893                         RTL_W8 (Config1, tmp8);
 894                         RTL_W8 (Cfg9346, Cfg9346_Lock);
 895                 }
 896                 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
 897                         tmp8 = RTL_R8 (Config4);
 898                         if (tmp8 & LWPTN) {
 899                                 RTL_W8 (Cfg9346, Cfg9346_Unlock);
 900                                 RTL_W8 (Config4, tmp8 & ~LWPTN);
 901                                 RTL_W8 (Cfg9346, Cfg9346_Lock);
 902                         }
 903                 }
 904         } else {
 905                 DPRINTK("Old chip wakeup\n");
 906                 tmp8 = RTL_R8 (Config1);
 907                 tmp8 &= ~(SLEEP | PWRDN);
 908                 RTL_W8 (Config1, tmp8);
 909         }
 910
 911         rtl8139_chip_reset (ioaddr);
 912
 913         *dev_out = dev;
 914         return 0;
 915
 916 err_out:
 917         __rtl8139_cleanup_dev (dev);
 918         if (disable_dev_on_err)
 919                 pci_disable_device (pdev);
 920         return rc;
 921 }
 922
 923
 924 static int __devinit rtl8139_init_one (struct pci_dev *pdev,
 925                                        const struct pci_device_id *ent)
 926 {
 927         struct net_device *dev = NULL;
 928         struct rtl8139_private *tp;
 929         int i, addr_len, option;
 930         void __iomem *ioaddr;
 931         static int board_idx = -1;
 932         u8 pci_rev;
 933
 934         assert (pdev != NULL);
 935         assert (ent != NULL);
 936
 937         board_idx++;
 938
 939         /* when we're built into the kernel, the driver version message
 940          * is only printed if at least one 8139 board has been found
 941          */
 942 #ifndef MODULE
 943         {
 944                 static int printed_version;
 945                 if (!printed_version++)
 946                         printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
 947         }
 948 #endif
 949
 950         pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);
 951
 952         if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
 953             pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev >= 0x20) {
 954                 printk(KERN_INFO PFX "pci dev %s (id %04x:%04x rev %02x) is an enhanced 8139C+ chip\n",
 955                        pci_name(pdev), pdev->vendor, pdev->device, pci_rev);
 956                 printk(KERN_INFO PFX "Use the \"8139cp\" driver for improved performance and stability.\n");
 957         }
 958
 959         i = rtl8139_init_board (pdev, &dev);
 960         if (i < 0)
 961                 return i;
 962
 963         assert (dev != NULL);
 964         tp = netdev_priv(dev);
 965
 966         ioaddr = tp->mmio_addr;
 967         assert (ioaddr != NULL);
 968
 969         addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
 970         for (i = 0; i < 3; i++)
 971                 ((u16 *) (dev->dev_addr))[i] =
 972                     le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
 973         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 974
 975         /* The Rtl8139-specific entries in the device structure. */
 976         dev->open = rtl8139_open;
 977         dev->hard_start_xmit = rtl8139_start_xmit;
 978         dev->poll = rtl8139_poll;
 979         dev->weight = 64;
 980         dev->stop = rtl8139_close;
 981         dev->get_stats = rtl8139_get_stats;
 982         dev->set_multicast_list = rtl8139_set_rx_mode;
 983         dev->do_ioctl = netdev_ioctl;
 984         dev->ethtool_ops = &rtl8139_ethtool_ops;
 985         dev->tx_timeout = rtl8139_tx_timeout;
 986         dev->watchdog_timeo = TX_TIMEOUT;
 987 #ifdef CONFIG_NET_POLL_CONTROLLER
 988         dev->poll_controller = rtl8139_poll_controller;
 989 #endif
 990
 991         /* note: the hardware is not capable of sg/csum/highdma, however
 992          * through the use of skb_copy_and_csum_dev we enable these
 993          * features
 994          */
 995         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
 996
 997         dev->irq = pdev->irq;
 998
 999         /* tp zeroed and aligned in alloc_etherdev */
1000         tp = netdev_priv(dev);
1001
1002         /* note: tp->chipset set in rtl8139_init_board */
1003         tp->drv_flags = board_info[ent->driver_data].hw_flags;
1004         tp->mmio_addr = ioaddr;
1005         tp->msg_enable =
1006                 (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));
1007         spin_lock_init (&tp->lock);
1008         spin_lock_init (&tp->rx_lock);
1009         init_waitqueue_head (&tp->thr_wait);
1010         init_completion (&tp->thr_exited);
1011         tp->mii.dev = dev;
1012         tp->mii.mdio_read = mdio_read;
1013         tp->mii.mdio_write = mdio_write;
1014         tp->mii.phy_id_mask = 0x3f;
1015         tp->mii.reg_num_mask = 0x1f;
1016
1017         /* dev is fully set up and ready to use now */
1018         DPRINTK("about to register device named %s (%p)...\n", dev->name, dev);
1019         i = register_netdev (dev);
1020         if (i) goto err_out;
1021
1022         pci_set_drvdata (pdev, dev);
1023
1024         printk (KERN_INFO "%s: %s at 0x%lx, "
1025                 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
1026                 "IRQ %d\n",
1027                 dev->name,
1028                 board_info[ent->driver_data].name,
1029                 dev->base_addr,
1030                 dev->dev_addr[0], dev->dev_addr[1],
1031                 dev->dev_addr[2], dev->dev_addr[3],
1032                 dev->dev_addr[4], dev->dev_addr[5],
1033                 dev->irq);
1034
1035         printk (KERN_DEBUG "%s:  Identified 8139 chip type '%s'\n",
1036                 dev->name, rtl_chip_info[tp->chipset].name);
1037
1038         /* Find the connected MII xcvrs.
1039            Doing this in open() would allow detecting external xcvrs later, but
1040            takes too much time. */
1041 #ifdef CONFIG_8139TOO_8129
1042         if (tp->drv_flags & HAS_MII_XCVR) {
1043                 int phy, phy_idx = 0;
1044                 for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {
1045                         int mii_status = mdio_read(dev, phy, 1);
1046                         if (mii_status != 0xffff  &&  mii_status != 0x0000) {
1047                                 u16 advertising = mdio_read(dev, phy, 4);
1048                                 tp->phys[phy_idx++] = phy;
1049                                 printk(KERN_INFO "%s: MII transceiver %d status 0x%4.4x "
1050                                            "advertising %4.4x.\n",
1051                                            dev->name, phy, mii_status, advertising);
1052                         }
1053                 }
1054                 if (phy_idx == 0) {
1055                         printk(KERN_INFO "%s: No MII transceivers found!  Assuming SYM "
1056                                    "transceiver.\n",
1057                                    dev->name);
1058                         tp->phys[0] = 32;
1059                 }
1060         } else
1061 #endif
1062                 tp->phys[0] = 32;
1063         tp->mii.phy_id = tp->phys[0];
1064
1065         /* The lower four bits are the media type. */
1066         option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
1067         if (option > 0) {
1068                 tp->mii.full_duplex = (option & 0x210) ? 1 : 0;
1069                 tp->default_port = option & 0xFF;
1070                 if (tp->default_port)
1071                         tp->mii.force_media = 1;
1072         }
1073         if (board_idx < MAX_UNITS  &&  full_duplex[board_idx] > 0)
1074                 tp->mii.full_duplex = full_duplex[board_idx];
1075         if (tp->mii.full_duplex) {
1076                 printk(KERN_INFO "%s: Media type forced to Full Duplex.\n", dev->name);
1077                 /* Changing the MII-advertised media because might prevent
1078                    re-connection. */
1079                 tp->mii.force_media = 1;
1080         }
1081         if (tp->default_port) {
1082                 printk(KERN_INFO "  Forcing %dMbps %s-duplex operation.\n",
1083                            (option & 0x20 ? 100 : 10),
1084                            (option & 0x10 ? "full" : "half"));
1085                 mdio_write(dev, tp->phys[0], 0,
1086                                    ((option & 0x20) ? 0x2000 : 0) |     /* 100Mbps? */
1087                                    ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
1088         }
1089
1090         /* Put the chip into low-power mode. */
1091         if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1092                 RTL_W8 (HltClk, 'H');   /* 'R' would leave the clock running. */
1093
1094         return 0;
1095
1096 err_out:
1097         __rtl8139_cleanup_dev (dev);
1098         pci_disable_device (pdev);
1099         return i;
1100 }
1101
1102
1103 static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
1104 {
1105         struct net_device *dev = pci_get_drvdata (pdev);
1106
1107         assert (dev != NULL);
1108
1109         unregister_netdev (dev);
1110
1111         __rtl8139_cleanup_dev (dev);
1112         pci_disable_device (pdev);
1113 }
1114
1115
1116 /* Serial EEPROM section. */
1117
1118 /*  EEPROM_Ctrl bits. */
1119 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
1120 #define EE_CS                   0x08    /* EEPROM chip select. */
1121 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
1122 #define EE_WRITE_0              0x00
1123 #define EE_WRITE_1              0x02
1124 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
1125 #define EE_ENB                  (0x80 | EE_CS)
1126
1127 /* Delay between EEPROM clock transitions.
1128    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1129  */
1130
1131 #define eeprom_delay()  RTL_R32(Cfg9346)
1132
1133 /* The EEPROM commands include the alway-set leading bit. */
1134 #define EE_WRITE_CMD    (5)
1135 #define EE_READ_CMD             (6)
1136 #define EE_ERASE_CMD    (7)
1137
1138 static int __devinit read_eeprom (void __iomem *ioaddr, int location, int addr_len)
1139 {
1140         int i;
1141         unsigned retval = 0;
1142         int read_cmd = location | (EE_READ_CMD << addr_len);
1143
1144         RTL_W8 (Cfg9346, EE_ENB & ~EE_CS);
1145         RTL_W8 (Cfg9346, EE_ENB);
1146         eeprom_delay ();
1147
1148         /* Shift the read command bits out. */
1149         for (i = 4 + addr_len; i >= 0; i--) {
1150                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1151                 RTL_W8 (Cfg9346, EE_ENB | dataval);
1152                 eeprom_delay ();
1153                 RTL_W8 (Cfg9346, EE_ENB | dataval | EE_SHIFT_CLK);
1154                 eeprom_delay ();
1155         }
1156         RTL_W8 (Cfg9346, EE_ENB);
1157         eeprom_delay ();
1158
1159         for (i = 16; i > 0; i--) {
1160                 RTL_W8 (Cfg9346, EE_ENB | EE_SHIFT_CLK);
1161                 eeprom_delay ();
1162                 retval =
1163                     (retval << 1) | ((RTL_R8 (Cfg9346) & EE_DATA_READ) ? 1 :
1164                                      0);
1165                 RTL_W8 (Cfg9346, EE_ENB);
1166                 eeprom_delay ();
1167         }
1168
1169         /* Terminate the EEPROM access. */
1170         RTL_W8 (Cfg9346, ~EE_CS);
1171         eeprom_delay ();
1172
1173         return retval;
1174 }
1175
1176 /* MII serial management: mostly bogus for now. */
1177 /* Read and write the MII management registers using software-generated
1178    serial MDIO protocol.
1179    The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
1180    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1181    "overclocking" issues. */
1182 #define MDIO_DIR                0x80
1183 #define MDIO_DATA_OUT   0x04
1184 #define MDIO_DATA_IN    0x02
1185 #define MDIO_CLK                0x01
1186 #define MDIO_WRITE0 (MDIO_DIR)
1187 #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
1188
1189 #define mdio_delay()    RTL_R8(Config4)
1190
1191
1192 static char mii_2_8139_map[8] = {
1193         BasicModeCtrl,
1194         BasicModeStatus,
1195         0,
1196         0,
1197         NWayAdvert,
1198         NWayLPAR,
1199         NWayExpansion,
1200         0
1201 };
1202
1203
1204 #ifdef CONFIG_8139TOO_8129
1205 /* Syncronize the MII management interface by shifting 32 one bits out. */
1206 static void mdio_sync (void __iomem *ioaddr)
1207 {
1208         int i;
1209
1210         for (i = 32; i >= 0; i--) {
1211                 RTL_W8 (Config4, MDIO_WRITE1);
1212                 mdio_delay ();
1213                 RTL_W8 (Config4, MDIO_WRITE1 | MDIO_CLK);
1214                 mdio_delay ();
1215         }
1216 }
1217 #endif
1218
1219 static int mdio_read (struct net_device *dev, int phy_id, int location)
1220 {
1221         struct rtl8139_private *tp = netdev_priv(dev);
1222         int retval = 0;
1223 #ifdef CONFIG_8139TOO_8129
1224         void __iomem *ioaddr = tp->mmio_addr;
1225         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1226         int i;
1227 #endif
1228
1229         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
1230                 void __iomem *ioaddr = tp->mmio_addr;
1231                 return location < 8 && mii_2_8139_map[location] ?
1232                     RTL_R16 (mii_2_8139_map[location]) : 0;
1233         }
1234
1235 #ifdef CONFIG_8139TOO_8129
1236         mdio_sync (ioaddr);
1237         /* Shift the read command bits out. */
1238         for (i = 15; i >= 0; i--) {
1239                 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1240
1241                 RTL_W8 (Config4, MDIO_DIR | dataval);
1242                 mdio_delay ();
1243                 RTL_W8 (Config4, MDIO_DIR | dataval | MDIO_CLK);
1244                 mdio_delay ();
1245         }
1246
1247         /* Read the two transition, 16 data, and wire-idle bits. */
1248         for (i = 19; i > 0; i--) {
1249                 RTL_W8 (Config4, 0);
1250                 mdio_delay ();
1251                 retval = (retval << 1) | ((RTL_R8 (Config4) & MDIO_DATA_IN) ? 1 : 0);
1252                 RTL_W8 (Config4, MDIO_CLK);
1253                 mdio_delay ();
1254         }
1255 #endif
1256
1257         return (retval >> 1) & 0xffff;
1258 }
1259
1260
1261 static void mdio_write (struct net_device *dev, int phy_id, int location,
1262                         int value)
1263 {
1264         struct rtl8139_private *tp = netdev_priv(dev);
1265 #ifdef CONFIG_8139TOO_8129
1266         void __iomem *ioaddr = tp->mmio_addr;
1267         int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1268         int i;
1269 #endif
1270
1271         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
1272                 void __iomem *ioaddr = tp->mmio_addr;
1273                 if (location == 0) {
1274                         RTL_W8 (Cfg9346, Cfg9346_Unlock);
1275                         RTL_W16 (BasicModeCtrl, value);
1276                         RTL_W8 (Cfg9346, Cfg9346_Lock);
1277                 } else if (location < 8 && mii_2_8139_map[location])
1278                         RTL_W16 (mii_2_8139_map[location], value);
1279                 return;
1280         }
1281
1282 #ifdef CONFIG_8139TOO_8129
1283         mdio_sync (ioaddr);
1284
1285         /* Shift the command bits out. */
1286         for (i = 31; i >= 0; i--) {
1287                 int dataval =
1288                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1289                 RTL_W8 (Config4, dataval);
1290                 mdio_delay ();
1291                 RTL_W8 (Config4, dataval | MDIO_CLK);
1292                 mdio_delay ();
1293         }
1294         /* Clear out extra bits. */
1295         for (i = 2; i > 0; i--) {
1296                 RTL_W8 (Config4, 0);
1297                 mdio_delay ();
1298                 RTL_W8 (Config4, MDIO_CLK);
1299                 mdio_delay ();
1300         }
1301 #endif
1302 }
1303
1304
1305 static int rtl8139_open (struct net_device *dev)
1306 {
1307         struct rtl8139_private *tp = netdev_priv(dev);
1308         int retval;
1309         void __iomem *ioaddr = tp->mmio_addr;
1310
1311         retval = request_irq (dev->irq, rtl8139_interrupt, SA_SHIRQ, dev->name, dev);
1312         if (retval)
1313                 return retval;
1314
1315         tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1316                                            &tp->tx_bufs_dma);
1317         tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1318                                            &tp->rx_ring_dma);
1319         if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1320                 free_irq(dev->irq, dev);
1321
1322                 if (tp->tx_bufs)
1323                         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1324                                             tp->tx_bufs, tp->tx_bufs_dma);
1325                 if (tp->rx_ring)
1326                         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1327                                             tp->rx_ring, tp->rx_ring_dma);
1328
1329                 return -ENOMEM;
1330
1331         }
1332
1333         tp->mii.full_duplex = tp->mii.force_media;
1334         tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1335
1336         rtl8139_init_ring (dev);
1337         rtl8139_hw_start (dev);
1338         netif_start_queue (dev);
1339
1340         if (netif_msg_ifup(tp))
1341                 printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#lx IRQ %d"
1342                         " GP Pins %2.2x %s-duplex.\n",
1343                         dev->name, pci_resource_start (tp->pci_dev, 1),
1344                         dev->irq, RTL_R8 (MediaStatus),
1345                         tp->mii.full_duplex ? "full" : "half");
1346
1347         rtl8139_start_thread(dev);
1348
1349         return 0;
1350 }
1351
1352
1353 static void rtl_check_media (struct net_device *dev, unsigned int init_media)
1354 {
1355         struct rtl8139_private *tp = netdev_priv(dev);
1356
1357         if (tp->phys[0] >= 0) {
1358                 mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
1359         }
1360 }
1361
1362 /* Start the hardware at open or resume. */
1363 static void rtl8139_hw_start (struct net_device *dev)
1364 {
1365         struct rtl8139_private *tp = netdev_priv(dev);
1366         void __iomem *ioaddr = tp->mmio_addr;
1367         u32 i;
1368         u8 tmp;
1369
1370         /* Bring old chips out of low-power mode. */
1371         if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1372                 RTL_W8 (HltClk, 'R');
1373
1374         rtl8139_chip_reset (ioaddr);
1375
1376         /* unlock Config[01234] and BMCR register writes */
1377         RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1378         /* Restore our idea of the MAC address. */
1379         RTL_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
1380         RTL_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
1381
1382         /* Must enable Tx/Rx before setting transfer thresholds! */
1383         RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1384
1385         tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1386         RTL_W32 (RxConfig, tp->rx_config);
1387         RTL_W32 (TxConfig, rtl8139_tx_config);
1388
1389         tp->cur_rx = 0;
1390
1391         rtl_check_media (dev, 1);
1392
1393         if (tp->chipset >= CH_8139B) {
1394                 /* Disable magic packet scanning, which is enabled
1395                  * when PM is enabled in Config1.  It can be reenabled
1396                  * via ETHTOOL_SWOL if desired.  */
1397                 RTL_W8 (Config3, RTL_R8 (Config3) & ~Cfg3_Magic);
1398         }
1399
1400         DPRINTK("init buffer addresses\n");
1401
1402         /* Lock Config[01234] and BMCR register writes */
1403         RTL_W8 (Cfg9346, Cfg9346_Lock);
1404
1405         /* init Rx ring buffer DMA address */
1406         RTL_W32_F (RxBuf, tp->rx_ring_dma);
1407
1408         /* init Tx buffer DMA addresses */
1409         for (i = 0; i < NUM_TX_DESC; i++)
1410                 RTL_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1411
1412         RTL_W32 (RxMissed, 0);
1413
1414         rtl8139_set_rx_mode (dev);
1415
1416         /* no early-rx interrupts */
1417         RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
1418
1419         /* make sure RxTx has started */
1420         tmp = RTL_R8 (ChipCmd);
1421         if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
1422                 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1423
1424         /* Enable all known interrupts by setting the interrupt mask. */
1425         RTL_W16 (IntrMask, rtl8139_intr_mask);
1426 }
1427
1428
1429 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1430 static void rtl8139_init_ring (struct net_device *dev)
1431 {
1432         struct rtl8139_private *tp = netdev_priv(dev);
1433         int i;
1434
1435         tp->cur_rx = 0;
1436         tp->cur_tx = 0;
1437         tp->dirty_tx = 0;
1438
1439         for (i = 0; i < NUM_TX_DESC; i++)
1440                 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1441 }
1442
1443
1444 /* This must be global for CONFIG_8139TOO_TUNE_TWISTER case */
1445 static int next_tick = 3 * HZ;
1446
1447 #ifndef CONFIG_8139TOO_TUNE_TWISTER
1448 static inline void rtl8139_tune_twister (struct net_device *dev,
1449                                   struct rtl8139_private *tp) {}
1450 #else
1451 enum TwisterParamVals {
1452         PARA78_default  = 0x78fa8388,
1453         PARA7c_default  = 0xcb38de43,   /* param[0][3] */
1454         PARA7c_xxx      = 0xcb38de43,
1455 };
1456
1457 static const unsigned long param[4][4] = {
1458         {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
1459         {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1460         {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1461         {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
1462 };
1463
1464 static void rtl8139_tune_twister (struct net_device *dev,
1465                                   struct rtl8139_private *tp)
1466 {
1467         int linkcase;
1468         void __iomem *ioaddr = tp->mmio_addr;
1469
1470         /* This is a complicated state machine to configure the "twister" for
1471            impedance/echos based on the cable length.
1472            All of this is magic and undocumented.
1473          */
1474         switch (tp->twistie) {
1475         case 1:
1476                 if (RTL_R16 (CSCR) & CSCR_LinkOKBit) {
1477                         /* We have link beat, let us tune the twister. */
1478                         RTL_W16 (CSCR, CSCR_LinkDownOffCmd);
1479                         tp->twistie = 2;        /* Change to state 2. */
1480                         next_tick = HZ / 10;
1481                 } else {
1482                         /* Just put in some reasonable defaults for when beat returns. */
1483                         RTL_W16 (CSCR, CSCR_LinkDownCmd);
1484                         RTL_W32 (FIFOTMS, 0x20);        /* Turn on cable test mode. */
1485                         RTL_W32 (PARA78, PARA78_default);
1486                         RTL_W32 (PARA7c, PARA7c_default);
1487                         tp->twistie = 0;        /* Bail from future actions. */
1488                 }
1489                 break;
1490         case 2:
1491                 /* Read how long it took to hear the echo. */
1492                 linkcase = RTL_R16 (CSCR) & CSCR_LinkStatusBits;
1493                 if (linkcase == 0x7000)
1494                         tp->twist_row = 3;
1495                 else if (linkcase == 0x3000)
1496                         tp->twist_row = 2;
1497                 else if (linkcase == 0x1000)
1498                         tp->twist_row = 1;
1499                 else
1500                         tp->twist_row = 0;
1501                 tp->twist_col = 0;
1502                 tp->twistie = 3;        /* Change to state 2. */
1503                 next_tick = HZ / 10;
1504                 break;
1505         case 3:
1506                 /* Put out four tuning parameters, one per 100msec. */
1507                 if (tp->twist_col == 0)
1508                         RTL_W16 (FIFOTMS, 0);
1509                 RTL_W32 (PARA7c, param[(int) tp->twist_row]
1510                          [(int) tp->twist_col]);
1511                 next_tick = HZ / 10;
1512                 if (++tp->twist_col >= 4) {
1513                         /* For short cables we are done.
1514                            For long cables (row == 3) check for mistune. */
1515                         tp->twistie =
1516                             (tp->twist_row == 3) ? 4 : 0;
1517                 }
1518                 break;
1519         case 4:
1520                 /* Special case for long cables: check for mistune. */
1521                 if ((RTL_R16 (CSCR) &
1522                      CSCR_LinkStatusBits) == 0x7000) {
1523                         tp->twistie = 0;
1524                         break;
1525                 } else {
1526                         RTL_W32 (PARA7c, 0xfb38de03);
1527                         tp->twistie = 5;
1528                         next_tick = HZ / 10;
1529                 }
1530                 break;
1531         case 5:
1532                 /* Retune for shorter cable (column 2). */
1533                 RTL_W32 (FIFOTMS, 0x20);
1534                 RTL_W32 (PARA78, PARA78_default);
1535                 RTL_W32 (PARA7c, PARA7c_default);
1536                 RTL_W32 (FIFOTMS, 0x00);
1537                 tp->twist_row = 2;
1538                 tp->twist_col = 0;
1539                 tp->twistie = 3;
1540                 next_tick = HZ / 10;
1541                 break;
1542
1543         default:
1544                 /* do nothing */
1545                 break;
1546         }
1547 }
1548 #endif /* CONFIG_8139TOO_TUNE_TWISTER */
1549
1550 static inline void rtl8139_thread_iter (struct net_device *dev,
1551                                  struct rtl8139_private *tp,
1552                                  void __iomem *ioaddr)
1553 {
1554         int mii_lpa;
1555
1556         mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1557
1558         if (!tp->mii.force_media && mii_lpa != 0xffff) {
1559                 int duplex = (mii_lpa & LPA_100FULL)
1560                     || (mii_lpa & 0x01C0) == 0x0040;
1561                 if (tp->mii.full_duplex != duplex) {
1562                         tp->mii.full_duplex = duplex;
1563
1564                         if (mii_lpa) {
1565                                 printk (KERN_INFO
1566                                         "%s: Setting %s-duplex based on MII #%d link"
1567                                         " partner ability of %4.4x.\n",
1568                                         dev->name,
1569                                         tp->mii.full_duplex ? "full" : "half",
1570                                         tp->phys[0], mii_lpa);
1571                         } else {
1572                                 printk(KERN_INFO"%s: media is unconnected, link down, or incompatible connection\n",
1573                                        dev->name);
1574                         }
1575 #if 0
1576                         RTL_W8 (Cfg9346, Cfg9346_Unlock);
1577                         RTL_W8 (Config1, tp->mii.full_duplex ? 0x60 : 0x20);
1578                         RTL_W8 (Cfg9346, Cfg9346_Lock);
1579 #endif
1580                 }
1581         }
1582
1583         next_tick = HZ * 60;
1584
1585         rtl8139_tune_twister (dev, tp);
1586
1587         DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1588                  dev->name, RTL_R16 (NWayLPAR));
1589         DPRINTK ("%s:  Other registers are IntMask %4.4x IntStatus %4.4x\n",
1590                  dev->name, RTL_R16 (IntrMask), RTL_R16 (IntrStatus));
1591         DPRINTK ("%s:  Chip config %2.2x %2.2x.\n",
1592                  dev->name, RTL_R8 (Config0),
1593                  RTL_R8 (Config1));
1594 }
1595
1596 static int rtl8139_thread (void *data)
1597 {
1598         struct net_device *dev = data;
1599         struct rtl8139_private *tp = netdev_priv(dev);
1600         unsigned long timeout;
1601
1602         daemonize("%s", dev->name);
1603         allow_signal(SIGTERM);
1604
1605         while (1) {
1606                 timeout = next_tick;
1607                 do {
1608                         timeout = interruptible_sleep_on_timeout (&tp->thr_wait, timeout);
1609                         /* make swsusp happy with our thread */
1610                         try_to_freeze();
1611                 } while (!signal_pending (current) && (timeout > 0));
1612
1613                 if (signal_pending (current)) {
1614                         flush_signals(current);
1615                 }
1616
1617                 if (tp->time_to_die)
1618                         break;
1619
1620                 if (rtnl_lock_interruptible ())
1621                         break;
1622                 rtl8139_thread_iter (dev, tp, tp->mmio_addr);
1623                 rtnl_unlock ();
1624         }
1625
1626         complete_and_exit (&tp->thr_exited, 0);
1627 }
1628
1629 static void rtl8139_start_thread(struct net_device *dev)
1630 {
1631         struct rtl8139_private *tp = netdev_priv(dev);
1632
1633         tp->thr_pid = -1;
1634         tp->twistie = 0;
1635         tp->time_to_die = 0;
1636         if (tp->chipset == CH_8139_K)
1637                 tp->twistie = 1;
1638         else if (tp->drv_flags & HAS_LNK_CHNG)
1639                 return;
1640
1641         tp->thr_pid = kernel_thread(rtl8139_thread, dev, CLONE_FS|CLONE_FILES);
1642         if (tp->thr_pid < 0) {
1643                 printk (KERN_WARNING "%s: unable to start kernel thread\n",
1644                         dev->name);
1645         }
1646 }
1647
1648 static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
1649 {
1650         tp->cur_tx = 0;
1651         tp->dirty_tx = 0;
1652
1653         /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
1654 }
1655
1656
1657 static void rtl8139_tx_timeout (struct net_device *dev)
1658 {
1659         struct rtl8139_private *tp = netdev_priv(dev);
1660         void __iomem *ioaddr = tp->mmio_addr;
1661         int i;
1662         u8 tmp8;
1663         unsigned long flags;
1664
1665         printk (KERN_DEBUG "%s: Transmit timeout, status %2.2x %4.4x %4.4x "
1666                 "media %2.2x.\n", dev->name, RTL_R8 (ChipCmd),
1667                 RTL_R16(IntrStatus), RTL_R16(IntrMask), RTL_R8(MediaStatus));
1668         /* Emit info to figure out what went wrong. */
1669         printk (KERN_DEBUG "%s: Tx queue start entry %ld  dirty entry %ld.\n",
1670                 dev->name, tp->cur_tx, tp->dirty_tx);
1671         for (i = 0; i < NUM_TX_DESC; i++)
1672                 printk (KERN_DEBUG "%s:  Tx descriptor %d is %8.8lx.%s\n",
1673                         dev->name, i, RTL_R32 (TxStatus0 + (i * 4)),
1674                         i == tp->dirty_tx % NUM_TX_DESC ?
1675                                 " (queue head)" : "");
1676
1677         tp->xstats.tx_timeouts++;
1678
1679         /* disable Tx ASAP, if not already */
1680         tmp8 = RTL_R8 (ChipCmd);
1681         if (tmp8 & CmdTxEnb)
1682                 RTL_W8 (ChipCmd, CmdRxEnb);
1683
1684         spin_lock(&tp->rx_lock);
1685         /* Disable interrupts by clearing the interrupt mask. */
1686         RTL_W16 (IntrMask, 0x0000);
1687
1688         /* Stop a shared interrupt from scavenging while we are. */
1689         spin_lock_irqsave (&tp->lock, flags);
1690         rtl8139_tx_clear (tp);
1691         spin_unlock_irqrestore (&tp->lock, flags);
1692
1693         /* ...and finally, reset everything */
1694         if (netif_running(dev)) {
1695                 rtl8139_hw_start (dev);
1696                 netif_wake_queue (dev);
1697         }
1698         spin_unlock(&tp->rx_lock);
1699 }
1700
1701
1702 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
1703 {
1704         struct rtl8139_private *tp = netdev_priv(dev);
1705         void __iomem *ioaddr = tp->mmio_addr;
1706         unsigned int entry;
1707         unsigned int len = skb->len;
1708
1709         /* Calculate the next Tx descriptor entry. */
1710         entry = tp->cur_tx % NUM_TX_DESC;
1711
1712         /* Note: the chip doesn't have auto-pad! */
1713         if (likely(len < TX_BUF_SIZE)) {
1714                 if (len < ETH_ZLEN)
1715                         memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1716                 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1717                 dev_kfree_skb(skb);
1718         } else {
1719                 dev_kfree_skb(skb);
1720                 tp->stats.tx_dropped++;
1721                 return 0;
1722         }
1723
1724         spin_lock_irq(&tp->lock);
1725         RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1726                    tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1727
1728         dev->trans_start = jiffies;
1729
1730         tp->cur_tx++;
1731         wmb();
1732
1733         if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1734                 netif_stop_queue (dev);
1735         spin_unlock_irq(&tp->lock);
1736
1737         if (netif_msg_tx_queued(tp))
1738                 printk (KERN_DEBUG "%s: Queued Tx packet size %u to slot %d.\n",
1739                         dev->name, len, entry);
1740
1741         return 0;
1742 }
1743
1744
1745 static void rtl8139_tx_interrupt (struct net_device *dev,
1746                                   struct rtl8139_private *tp,
1747                                   void __iomem *ioaddr)
1748 {
1749         unsigned long dirty_tx, tx_left;
1750
1751         assert (dev != NULL);
1752         assert (ioaddr != NULL);
1753
1754         dirty_tx = tp->dirty_tx;
1755         tx_left = tp->cur_tx - dirty_tx;
1756         while (tx_left > 0) {
1757                 int entry = dirty_tx % NUM_TX_DESC;
1758                 int txstatus;
1759
1760                 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1761
1762                 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1763                         break;  /* It still hasn't been Txed */
1764
1765                 /* Note: TxCarrierLost is always asserted at 100mbps. */
1766                 if (txstatus & (TxOutOfWindow | TxAborted)) {
1767                         /* There was an major error, log it. */
1768                         if (netif_msg_tx_err(tp))
1769                                 printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
1770                                         dev->name, txstatus);
1771                         tp->stats.tx_errors++;
1772                         if (txstatus & TxAborted) {
1773                                 tp->stats.tx_aborted_errors++;
1774                                 RTL_W32 (TxConfig, TxClearAbt);
1775                                 RTL_W16 (IntrStatus, TxErr);
1776                                 wmb();
1777                         }
1778                         if (txstatus & TxCarrierLost)
1779                                 tp->stats.tx_carrier_errors++;
1780                         if (txstatus & TxOutOfWindow)
1781                                 tp->stats.tx_window_errors++;
1782                 } else {
1783                         if (txstatus & TxUnderrun) {
1784                                 /* Add 64 to the Tx FIFO threshold. */
1785                                 if (tp->tx_flag < 0x00300000)
1786                                         tp->tx_flag += 0x00020000;
1787                                 tp->stats.tx_fifo_errors++;
1788                         }
1789                         tp->stats.collisions += (txstatus >> 24) & 15;
1790                         tp->stats.tx_bytes += txstatus & 0x7ff;
1791                         tp->stats.tx_packets++;
1792                 }
1793
1794                 dirty_tx++;
1795                 tx_left--;
1796         }
1797
1798 #ifndef RTL8139_NDEBUG
1799         if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
1800                 printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
1801                         dev->name, dirty_tx, tp->cur_tx);
1802                 dirty_tx += NUM_TX_DESC;
1803         }
1804 #endif /* RTL8139_NDEBUG */
1805
1806         /* only wake the queue if we did work, and the queue is stopped */
1807         if (tp->dirty_tx != dirty_tx) {
1808                 tp->dirty_tx = dirty_tx;
1809                 mb();
1810                 netif_wake_queue (dev);
1811         }
1812 }
1813
1814
1815 /* TODO: clean this up!  Rx reset need not be this intensive */
1816 static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
1817                             struct rtl8139_private *tp, void __iomem *ioaddr)
1818 {
1819         u8 tmp8;
1820 #ifdef CONFIG_8139_OLD_RX_RESET
1821         int tmp_work;
1822 #endif
1823
1824         if (netif_msg_rx_err (tp))
1825                 printk(KERN_DEBUG "%s: Ethernet frame had errors, status %8.8x.\n",
1826                         dev->name, rx_status);
1827         tp->stats.rx_errors++;
1828         if (!(rx_status & RxStatusOK)) {
1829                 if (rx_status & RxTooLong) {
1830                         DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1831                                 dev->name, rx_status);
1832                         /* A.C.: The chip hangs here. */
1833                 }
1834                 if (rx_status & (RxBadSymbol | RxBadAlign))
1835                         tp->stats.rx_frame_errors++;
1836                 if (rx_status & (RxRunt | RxTooLong))
1837                         tp->stats.rx_length_errors++;
1838                 if (rx_status & RxCRCErr)
1839                         tp->stats.rx_crc_errors++;
1840         } else {
1841                 tp->xstats.rx_lost_in_ring++;
1842         }
1843
1844 #ifndef CONFIG_8139_OLD_RX_RESET
1845         tmp8 = RTL_R8 (ChipCmd);
1846         RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1847         RTL_W8 (ChipCmd, tmp8);
1848         RTL_W32 (RxConfig, tp->rx_config);
1849         tp->cur_rx = 0;
1850 #else
1851         /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1852
1853         /* disable receive */
1854         RTL_W8_F (ChipCmd, CmdTxEnb);
1855         tmp_work = 200;
1856         while (--tmp_work > 0) {
1857                 udelay(1);
1858                 tmp8 = RTL_R8 (ChipCmd);
1859                 if (!(tmp8 & CmdRxEnb))
1860                         break;
1861         }
1862         if (tmp_work <= 0)
1863                 printk (KERN_WARNING PFX "rx stop wait too long\n");
1864         /* restart receive */
1865         tmp_work = 200;
1866         while (--tmp_work > 0) {
1867                 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1868                 udelay(1);
1869                 tmp8 = RTL_R8 (ChipCmd);
1870                 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1871                         break;
1872         }
1873         if (tmp_work <= 0)
1874                 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1875
1876         /* and reinitialize all rx related registers */
1877         RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1878         /* Must enable Tx/Rx before setting transfer thresholds! */
1879         RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1880
1881         tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1882         RTL_W32 (RxConfig, tp->rx_config);
1883         tp->cur_rx = 0;
1884
1885         DPRINTK("init buffer addresses\n");
1886
1887         /* Lock Config[01234] and BMCR register writes */
1888         RTL_W8 (Cfg9346, Cfg9346_Lock);
1889
1890         /* init Rx ring buffer DMA address */
1891         RTL_W32_F (RxBuf, tp->rx_ring_dma);
1892
1893         /* A.C.: Reset the multicast list. */
1894         __set_rx_mode (dev);
1895 #endif
1896 }
1897
1898 #if RX_BUF_IDX == 3
1899 static __inline__ void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
1900                                  u32 offset, unsigned int size)
1901 {
1902         u32 left = RX_BUF_LEN - offset;
1903
1904         if (size > left) {
1905                 memcpy(skb->data, ring + offset, left);
1906                 memcpy(skb->data+left, ring, size - left);
1907         } else
1908                 memcpy(skb->data, ring + offset, size);
1909 }
1910 #endif
1911
1912 static void rtl8139_isr_ack(struct rtl8139_private *tp)
1913 {
1914         void __iomem *ioaddr = tp->mmio_addr;
1915         u16 status;
1916
1917         status = RTL_R16 (IntrStatus) & RxAckBits;
1918
1919         /* Clear out errors and receive interrupts */
1920         if (likely(status != 0)) {
1921                 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
1922                         tp->stats.rx_errors++;
1923                         if (status & RxFIFOOver)
1924                                 tp->stats.rx_fifo_errors++;
1925                 }
1926                 RTL_W16_F (IntrStatus, RxAckBits);
1927         }
1928 }
1929
1930 static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1931                       int budget)
1932 {
1933         void __iomem *ioaddr = tp->mmio_addr;
1934         int received = 0;
1935         unsigned char *rx_ring = tp->rx_ring;
1936         unsigned int cur_rx = tp->cur_rx;
1937         unsigned int rx_size = 0;
1938
1939         DPRINTK ("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x,"
1940                  " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx,
1941                  RTL_R16 (RxBufAddr),
1942                  RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
1943
1944         while (netif_running(dev) && received < budget
1945                && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
1946                 u32 ring_offset = cur_rx % RX_BUF_LEN;
1947                 u32 rx_status;
1948                 unsigned int pkt_size;
1949                 struct sk_buff *skb;
1950
1951                 rmb();
1952
1953                 /* read size+status of next frame from DMA ring buffer */
1954                 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
1955                 rx_size = rx_status >> 16;
1956                 pkt_size = rx_size - 4;
1957
1958                 if (netif_msg_rx_status(tp))
1959                         printk(KERN_DEBUG "%s:  rtl8139_rx() status %4.4x, size %4.4x,"
1960                                 " cur %4.4x.\n", dev->name, rx_status,
1961                          rx_size, cur_rx);
1962 #if RTL8139_DEBUG > 2
1963                 {
1964                         int i;
1965                         DPRINTK ("%s: Frame contents ", dev->name);
1966                         for (i = 0; i < 70; i++)
1967                                 printk (" %2.2x",
1968                                         rx_ring[ring_offset + i]);
1969                         printk (".\n");
1970                 }
1971 #endif
1972
1973                 /* Packet copy from FIFO still in progress.
1974                  * Theoretically, this should never happen
1975                  * since EarlyRx is disabled.
1976                  */
1977                 if (unlikely(rx_size == 0xfff0)) {
1978                         if (!tp->fifo_copy_timeout)
1979                                 tp->fifo_copy_timeout = jiffies + 2;
1980                         else if (time_after(jiffies, tp->fifo_copy_timeout)) {
1981                                 DPRINTK ("%s: hung FIFO. Reset.", dev->name);
1982                                 rx_size = 0;
1983                                 goto no_early_rx;
1984                         }
1985                         if (netif_msg_intr(tp)) {
1986                                 printk(KERN_DEBUG "%s: fifo copy in progress.",
1987                                        dev->name);
1988                         }
1989                         tp->xstats.early_rx++;
1990                         break;
1991                 }
1992
1993 no_early_rx:
1994                 tp->fifo_copy_timeout = 0;
1995
1996                 /* If Rx err or invalid rx_size/rx_status received
1997                  * (which happens if we get lost in the ring),
1998                  * Rx process gets reset, so we abort any further
1999                  * Rx processing.
2000                  */
2001                 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
2002                              (rx_size < 8) ||
2003                              (!(rx_status & RxStatusOK)))) {
2004                         rtl8139_rx_err (rx_status, dev, tp, ioaddr);
2005                         received = -1;
2006                         goto out;
2007                 }
2008
2009                 /* Malloc up new buffer, compatible with net-2e. */
2010                 /* Omit the four octet CRC from the length. */
2011
2012                 skb = dev_alloc_skb (pkt_size + 2);
2013                 if (likely(skb)) {
2014                         skb->dev = dev;
2015                         skb_reserve (skb, 2);   /* 16 byte align the IP fields. */
2016 #if RX_BUF_IDX == 3
2017                         wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
2018 #else
2019                         eth_copy_and_sum (skb, &rx_ring[ring_offset + 4], pkt_size, 0);
2020 #endif
2021                         skb_put (skb, pkt_size);
2022
2023                         skb->protocol = eth_type_trans (skb, dev);
2024
2025                         dev->last_rx = jiffies;
2026                         tp->stats.rx_bytes += pkt_size;
2027                         tp->stats.rx_packets++;
2028
2029                         netif_receive_skb (skb);
2030                 } else {
2031                         if (net_ratelimit())
2032                                 printk (KERN_WARNING
2033                                         "%s: Memory squeeze, dropping packet.\n",
2034                                         dev->name);
2035                         tp->stats.rx_dropped++;
2036                 }
2037                 received++;
2038
2039                 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2040                 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2041
2042                 rtl8139_isr_ack(tp);
2043         }
2044
2045         if (unlikely(!received || rx_size == 0xfff0))
2046                 rtl8139_isr_ack(tp);
2047
2048 #if RTL8139_DEBUG > 1
2049         DPRINTK ("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x,"
2050                  " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
2051                  RTL_R16 (RxBufAddr),
2052                  RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
2053 #endif
2054
2055         tp->cur_rx = cur_rx;
2056
2057         /*
2058          * The receive buffer should be mostly empty.
2059          * Tell NAPI to reenable the Rx irq.
2060          */
2061         if (tp->fifo_copy_timeout)
2062                 received = budget;
2063
2064 out:
2065         return received;
2066 }
2067
2068
2069 static void rtl8139_weird_interrupt (struct net_device *dev,
2070                                      struct rtl8139_private *tp,
2071                                      void __iomem *ioaddr,
2072                                      int status, int link_changed)
2073 {
2074         DPRINTK ("%s: Abnormal interrupt, status %8.8x.\n",
2075                  dev->name, status);
2076
2077         assert (dev != NULL);
2078         assert (tp != NULL);
2079         assert (ioaddr != NULL);
2080
2081         /* Update the error count. */
2082         tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2083         RTL_W32 (RxMissed, 0);
2084
2085         if ((status & RxUnderrun) && link_changed &&
2086             (tp->drv_flags & HAS_LNK_CHNG)) {
2087                 rtl_check_media(dev, 0);
2088                 status &= ~RxUnderrun;
2089         }
2090
2091         if (status & (RxUnderrun | RxErr))
2092                 tp->stats.rx_errors++;
2093
2094         if (status & PCSTimeout)
2095                 tp->stats.rx_length_errors++;
2096         if (status & RxUnderrun)
2097                 tp->stats.rx_fifo_errors++;
2098         if (status & PCIErr) {
2099                 u16 pci_cmd_status;
2100                 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2101                 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2102
2103                 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
2104                         dev->name, pci_cmd_status);
2105         }
2106 }
2107
2108 static int rtl8139_poll(struct net_device *dev, int *budget)
2109 {
2110         struct rtl8139_private *tp = netdev_priv(dev);
2111         void __iomem *ioaddr = tp->mmio_addr;
2112         int orig_budget = min(*budget, dev->quota);
2113         int done = 1;
2114
2115         spin_lock(&tp->rx_lock);
2116         if (likely(RTL_R16(IntrStatus) & RxAckBits)) {
2117                 int work_done;
2118
2119                 work_done = rtl8139_rx(dev, tp, orig_budget);
2120                 if (likely(work_done > 0)) {
2121                         *budget -= work_done;
2122                         dev->quota -= work_done;
2123                         done = (work_done < orig_budget);
2124                 }
2125         }
2126
2127         if (done) {
2128                 /*
2129                  * Order is important since data can get interrupted
2130                  * again when we think we are done.
2131                  */
2132                 local_irq_disable();
2133                 RTL_W16_F(IntrMask, rtl8139_intr_mask);
2134                 __netif_rx_complete(dev);
2135                 local_irq_enable();
2136         }
2137         spin_unlock(&tp->rx_lock);
2138
2139         return !done;
2140 }
2141
2142 /* The interrupt handler does all of the Rx thread work and cleans up
2143    after the Tx thread. */
2144 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance,
2145                                struct pt_regs *regs)
2146 {
2147         struct net_device *dev = (struct net_device *) dev_instance;
2148         struct rtl8139_private *tp = netdev_priv(dev);
2149         void __iomem *ioaddr = tp->mmio_addr;
2150         u16 status, ackstat;
2151         int link_changed = 0; /* avoid bogus "uninit" warning */
2152         int handled = 0;
2153
2154         spin_lock (&tp->lock);
2155         status = RTL_R16 (IntrStatus);
2156
2157         /* shared irq? */
2158         if (unlikely((status & rtl8139_intr_mask) == 0))
2159                 goto out;
2160
2161         handled = 1;
2162
2163         /* h/w no longer present (hotplug?) or major error, bail */
2164         if (unlikely(status == 0xFFFF))
2165                 goto out;
2166
2167         /* close possible race's with dev_close */
2168         if (unlikely(!netif_running(dev))) {
2169                 RTL_W16 (IntrMask, 0);
2170                 goto out;
2171         }
2172
2173         /* Acknowledge all of the current interrupt sources ASAP, but
2174            an first get an additional status bit from CSCR. */
2175         if (unlikely(status & RxUnderrun))
2176                 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2177
2178         ackstat = status & ~(RxAckBits | TxErr);
2179         if (ackstat)
2180                 RTL_W16 (IntrStatus, ackstat);
2181
2182         /* Receive packets are processed by poll routine.
2183            If not running start it now. */
2184         if (status & RxAckBits){
2185                 if (netif_rx_schedule_prep(dev)) {
2186                         RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
2187                         __netif_rx_schedule (dev);
2188                 }
2189         }
2190
2191         /* Check uncommon events with one test. */
2192         if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2193                 rtl8139_weird_interrupt (dev, tp, ioaddr,
2194                                          status, link_changed);
2195
2196         if (status & (TxOK | TxErr)) {
2197                 rtl8139_tx_interrupt (dev, tp, ioaddr);
2198                 if (status & TxErr)
2199                         RTL_W16 (IntrStatus, TxErr);
2200         }
2201  out:
2202         spin_unlock (&tp->lock);
2203
2204         DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
2205                  dev->name, RTL_R16 (IntrStatus));
2206         return IRQ_RETVAL(handled);
2207 }
2208
2209 #ifdef CONFIG_NET_POLL_CONTROLLER
2210 /*
2211  * Polling receive - used by netconsole and other diagnostic tools
2212  * to allow network i/o with interrupts disabled.
2213  */
2214 static void rtl8139_poll_controller(struct net_device *dev)
2215 {
2216         disable_irq(dev->irq);
2217         rtl8139_interrupt(dev->irq, dev, NULL);
2218         enable_irq(dev->irq);
2219 }
2220 #endif
2221
2222 static int rtl8139_close (struct net_device *dev)
2223 {
2224         struct rtl8139_private *tp = netdev_priv(dev);
2225         void __iomem *ioaddr = tp->mmio_addr;
2226         int ret = 0;
2227         unsigned long flags;
2228
2229         netif_stop_queue (dev);
2230
2231         if (tp->thr_pid >= 0) {
2232                 tp->time_to_die = 1;
2233                 wmb();
2234                 ret = kill_proc (tp->thr_pid, SIGTERM, 1);
2235                 if (ret) {
2236                         printk (KERN_ERR "%s: unable to signal thread\n", dev->name);
2237                         return ret;
2238                 }
2239                 wait_for_completion (&tp->thr_exited);
2240         }
2241
2242         if (netif_msg_ifdown(tp))
2243                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n",
2244                         dev->name, RTL_R16 (IntrStatus));
2245
2246         spin_lock_irqsave (&tp->lock, flags);
2247
2248         /* Stop the chip's Tx and Rx DMA processes. */
2249         RTL_W8 (ChipCmd, 0);
2250
2251         /* Disable interrupts by clearing the interrupt mask. */
2252         RTL_W16 (IntrMask, 0);
2253
2254         /* Update the error counts. */
2255         tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2256         RTL_W32 (RxMissed, 0);
2257
2258         spin_unlock_irqrestore (&tp->lock, flags);
2259
2260         synchronize_irq (dev->irq);     /* racy, but that's ok here */
2261         free_irq (dev->irq, dev);
2262
2263         rtl8139_tx_clear (tp);
2264
2265         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
2266                             tp->rx_ring, tp->rx_ring_dma);
2267         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
2268                             tp->tx_bufs, tp->tx_bufs_dma);
2269         tp->rx_ring = NULL;
2270         tp->tx_bufs = NULL;
2271
2272         /* Green! Put the chip in low-power mode. */
2273         RTL_W8 (Cfg9346, Cfg9346_Unlock);
2274
2275         if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2276                 RTL_W8 (HltClk, 'H');   /* 'R' would leave the clock running. */
2277
2278         return 0;
2279 }
2280
2281
2282 /* Get the ethtool Wake-on-LAN settings.  Assumes that wol points to
2283    kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2284    other threads or interrupts aren't messing with the 8139.  */
2285 static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2286 {
2287         struct rtl8139_private *np = netdev_priv(dev);
2288         void __iomem *ioaddr = np->mmio_addr;
2289
2290         spin_lock_irq(&np->lock);
2291         if (rtl_chip_info[np->chipset].flags & HasLWake) {
2292                 u8 cfg3 = RTL_R8 (Config3);
2293                 u8 cfg5 = RTL_R8 (Config5);
2294
2295                 wol->supported = WAKE_PHY | WAKE_MAGIC
2296                         | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2297
2298                 wol->wolopts = 0;
2299                 if (cfg3 & Cfg3_LinkUp)
2300                         wol->wolopts |= WAKE_PHY;
2301                 if (cfg3 & Cfg3_Magic)
2302                         wol->wolopts |= WAKE_MAGIC;
2303                 /* (KON)FIXME: See how netdev_set_wol() handles the
2304                    following constants.  */
2305                 if (cfg5 & Cfg5_UWF)
2306                         wol->wolopts |= WAKE_UCAST;
2307                 if (cfg5 & Cfg5_MWF)
2308                         wol->wolopts |= WAKE_MCAST;
2309                 if (cfg5 & Cfg5_BWF)
2310                         wol->wolopts |= WAKE_BCAST;
2311         }
2312         spin_unlock_irq(&np->lock);
2313 }
2314
2315
2316 /* Set the ethtool Wake-on-LAN settings.  Return 0 or -errno.  Assumes
2317    that wol points to kernel memory and other threads or interrupts
2318    aren't messing with the 8139.  */
2319 static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2320 {
2321         struct rtl8139_private *np = netdev_priv(dev);
2322         void __iomem *ioaddr = np->mmio_addr;
2323         u32 support;
2324         u8 cfg3, cfg5;
2325
2326         support = ((rtl_chip_info[np->chipset].flags & HasLWake)
2327                    ? (WAKE_PHY | WAKE_MAGIC
2328                       | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2329                    : 0);
2330         if (wol->wolopts & ~support)
2331                 return -EINVAL;
2332
2333         spin_lock_irq(&np->lock);
2334         cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2335         if (wol->wolopts & WAKE_PHY)
2336                 cfg3 |= Cfg3_LinkUp;
2337         if (wol->wolopts & WAKE_MAGIC)
2338                 cfg3 |= Cfg3_Magic;
2339         RTL_W8 (Cfg9346, Cfg9346_Unlock);
2340         RTL_W8 (Config3, cfg3);
2341         RTL_W8 (Cfg9346, Cfg9346_Lock);
2342
2343         cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2344         /* (KON)FIXME: These are untested.  We may have to set the
2345            CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2346            documentation.  */
2347         if (wol->wolopts & WAKE_UCAST)
2348                 cfg5 |= Cfg5_UWF;
2349         if (wol->wolopts & WAKE_MCAST)
2350                 cfg5 |= Cfg5_MWF;
2351         if (wol->wolopts & WAKE_BCAST)
2352                 cfg5 |= Cfg5_BWF;
2353         RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
2354         spin_unlock_irq(&np->lock);
2355
2356         return 0;
2357 }
2358
2359 static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2360 {
2361         struct rtl8139_private *np = netdev_priv(dev);
2362         strcpy(info->driver, DRV_NAME);
2363         strcpy(info->version, DRV_VERSION);
2364         strcpy(info->bus_info, pci_name(np->pci_dev));
2365         info->regdump_len = np->regs_len;
2366 }
2367
2368 static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2369 {
2370         struct rtl8139_private *np = netdev_priv(dev);
2371         spin_lock_irq(&np->lock);
2372         mii_ethtool_gset(&np->mii, cmd);
2373         spin_unlock_irq(&np->lock);
2374         return 0;
2375 }
2376
2377 static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2378 {
2379         struct rtl8139_private *np = netdev_priv(dev);
2380         int rc;
2381         spin_lock_irq(&np->lock);
2382         rc = mii_ethtool_sset(&np->mii, cmd);
2383         spin_unlock_irq(&np->lock);
2384         return rc;
2385 }
2386
2387 static int rtl8139_nway_reset(struct net_device *dev)
2388 {
2389         struct rtl8139_private *np = netdev_priv(dev);
2390         return mii_nway_restart(&np->mii);
2391 }
2392
2393 static u32 rtl8139_get_link(struct net_device *dev)
2394 {
2395         struct rtl8139_private *np = netdev_priv(dev);
2396         return mii_link_ok(&np->mii);
2397 }
2398
2399 static u32 rtl8139_get_msglevel(struct net_device *dev)
2400 {
2401         struct rtl8139_private *np = netdev_priv(dev);
2402         return np->msg_enable;
2403 }
2404
2405 static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2406 {
2407         struct rtl8139_private *np = netdev_priv(dev);
2408         np->msg_enable = datum;
2409 }
2410
2411 /* TODO: we are too slack to do reg dumping for pio, for now */
2412 #ifdef CONFIG_8139TOO_PIO
2413 #define rtl8139_get_regs_len    NULL
2414 #define rtl8139_get_regs        NULL
2415 #else
2416 static int rtl8139_get_regs_len(struct net_device *dev)
2417 {
2418         struct rtl8139_private *np = netdev_priv(dev);
2419         return np->regs_len;
2420 }
2421
2422 static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2423 {
2424         struct rtl8139_private *np = netdev_priv(dev);
2425
2426         regs->version = RTL_REGS_VER;
2427
2428         spin_lock_irq(&np->lock);
2429         memcpy_fromio(regbuf, np->mmio_addr, regs->len);
2430         spin_unlock_irq(&np->lock);
2431 }
2432 #endif /* CONFIG_8139TOO_MMIO */
2433
2434 static int rtl8139_get_stats_count(struct net_device *dev)
2435 {
2436         return RTL_NUM_STATS;
2437 }
2438
2439 static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2440 {
2441         struct rtl8139_private *np = netdev_priv(dev);
2442
2443         data[0] = np->xstats.early_rx;
2444         data[1] = np->xstats.tx_buf_mapped;
2445         data[2] = np->xstats.tx_timeouts;
2446         data[3] = np->xstats.rx_lost_in_ring;
2447 }
2448
2449 static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2450 {
2451         memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2452 }
2453
2454 static struct ethtool_ops rtl8139_ethtool_ops = {
2455         .get_drvinfo            = rtl8139_get_drvinfo,
2456         .get_settings           = rtl8139_get_settings,
2457         .set_settings           = rtl8139_set_settings,
2458         .get_regs_len           = rtl8139_get_regs_len,
2459         .get_regs               = rtl8139_get_regs,
2460         .nway_reset             = rtl8139_nway_reset,
2461         .get_link               = rtl8139_get_link,
2462         .get_msglevel           = rtl8139_get_msglevel,
2463         .set_msglevel           = rtl8139_set_msglevel,
2464         .get_wol                = rtl8139_get_wol,
2465         .set_wol                = rtl8139_set_wol,
2466         .get_strings            = rtl8139_get_strings,
2467         .get_stats_count        = rtl8139_get_stats_count,
2468         .get_ethtool_stats      = rtl8139_get_ethtool_stats,
2469         .get_perm_addr          = ethtool_op_get_perm_addr,
2470 };
2471
2472 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2473 {
2474         struct rtl8139_private *np = netdev_priv(dev);
2475         int rc;
2476
2477         if (!netif_running(dev))
2478                 return -EINVAL;
2479
2480         spin_lock_irq(&np->lock);
2481         rc = generic_mii_ioctl(&np->mii, if_mii(rq), cmd, NULL);
2482         spin_unlock_irq(&np->lock);
2483
2484         return rc;
2485 }
2486
2487
2488 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2489 {
2490         struct rtl8139_private *tp = netdev_priv(dev);
2491         void __iomem *ioaddr = tp->mmio_addr;
2492         unsigned long flags;
2493
2494         if (netif_running(dev)) {
2495                 spin_lock_irqsave (&tp->lock, flags);
2496                 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2497                 RTL_W32 (RxMissed, 0);
2498                 spin_unlock_irqrestore (&tp->lock, flags);
2499         }
2500
2501         return &tp->stats;
2502 }
2503
2504 /* Set or clear the multicast filter for this adaptor.
2505    This routine is not state sensitive and need not be SMP locked. */
2506
2507 static void __set_rx_mode (struct net_device *dev)
2508 {
2509         struct rtl8139_private *tp = netdev_priv(dev);
2510         void __iomem *ioaddr = tp->mmio_addr;
2511         u32 mc_filter[2];       /* Multicast hash filter */
2512         int i, rx_mode;
2513         u32 tmp;
2514
2515         DPRINTK ("%s:   rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
2516                         dev->name, dev->flags, RTL_R32 (RxConfig));
2517
2518         /* Note: do not reorder, GCC is clever about common statements. */
2519         if (dev->flags & IFF_PROMISC) {
2520                 /* Unconditionally log net taps. */
2521                 printk (KERN_NOTICE "%s: Promiscuous mode enabled.\n",
2522                         dev->name);
2523                 rx_mode =
2524                     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2525                     AcceptAllPhys;
2526                 mc_filter[1] = mc_filter[0] = 0xffffffff;
2527         } else if ((dev->mc_count > multicast_filter_limit)
2528                    || (dev->flags & IFF_ALLMULTI)) {
2529                 /* Too many to filter perfectly -- accept all multicasts. */
2530                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2531                 mc_filter[1] = mc_filter[0] = 0xffffffff;
2532         } else {
2533                 struct dev_mc_list *mclist;
2534                 rx_mode = AcceptBroadcast | AcceptMyPhys;
2535                 mc_filter[1] = mc_filter[0] = 0;
2536                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2537                      i++, mclist = mclist->next) {
2538                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
2539
2540                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2541                         rx_mode |= AcceptMulticast;
2542                 }
2543         }
2544
2545         /* We can safely update without stopping the chip. */
2546         tmp = rtl8139_rx_config | rx_mode;
2547         if (tp->rx_config != tmp) {
2548                 RTL_W32_F (RxConfig, tmp);
2549                 tp->rx_config = tmp;
2550         }
2551         RTL_W32_F (MAR0 + 0, mc_filter[0]);
2552         RTL_W32_F (MAR0 + 4, mc_filter[1]);
2553 }
2554
2555 static void rtl8139_set_rx_mode (struct net_device *dev)
2556 {
2557         unsigned long flags;
2558         struct rtl8139_private *tp = netdev_priv(dev);
2559
2560         spin_lock_irqsave (&tp->lock, flags);
2561         __set_rx_mode(dev);
2562         spin_unlock_irqrestore (&tp->lock, flags);
2563 }
2564
2565 #ifdef CONFIG_PM
2566
2567 static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2568 {
2569         struct net_device *dev = pci_get_drvdata (pdev);
2570         struct rtl8139_private *tp = netdev_priv(dev);
2571         void __iomem *ioaddr = tp->mmio_addr;
2572         unsigned long flags;
2573
2574         pci_save_state (pdev);
2575
2576         if (!netif_running (dev))
2577                 return 0;
2578
2579         netif_device_detach (dev);
2580
2581         spin_lock_irqsave (&tp->lock, flags);
2582
2583         /* Disable interrupts, stop Tx and Rx. */
2584         RTL_W16 (IntrMask, 0);
2585         RTL_W8 (ChipCmd, 0);
2586
2587         /* Update the error counts. */
2588         tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2589         RTL_W32 (RxMissed, 0);
2590
2591         spin_unlock_irqrestore (&tp->lock, flags);
2592
2593         pci_set_power_state (pdev, PCI_D3hot);
2594
2595         return 0;
2596 }
2597
2598
2599 static int rtl8139_resume (struct pci_dev *pdev)
2600 {
2601         struct net_device *dev = pci_get_drvdata (pdev);
2602
2603         pci_restore_state (pdev);
2604         if (!netif_running (dev))
2605                 return 0;
2606         pci_set_power_state (pdev, PCI_D0);
2607         rtl8139_init_ring (dev);
2608         rtl8139_hw_start (dev);
2609         netif_device_attach (dev);
2610         return 0;
2611 }
2612
2613 #endif /* CONFIG_PM */
2614
2615
2616 static struct pci_driver rtl8139_pci_driver = {
2617         .name           = DRV_NAME,
2618         .id_table       = rtl8139_pci_tbl,
2619         .probe          = rtl8139_init_one,
2620         .remove         = __devexit_p(rtl8139_remove_one),
2621 #ifdef CONFIG_PM
2622         .suspend        = rtl8139_suspend,
2623         .resume         = rtl8139_resume,
2624 #endif /* CONFIG_PM */
2625 };
2626
2627
2628 static int __init rtl8139_init_module (void)
2629 {
2630         /* when we're a module, we always print a version message,
2631          * even if no 8139 board is found.
2632          */
2633 #ifdef MODULE
2634         printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
2635 #endif
2636
2637         return pci_module_init (&rtl8139_pci_driver);
2638 }
2639
2640
2641 static void __exit rtl8139_cleanup_module (void)
2642 {
2643         pci_unregister_driver (&rtl8139_pci_driver);
2644 }
2645
2646
2647 module_init(rtl8139_init_module);
2648 module_exit(rtl8139_cleanup_module);