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