drivers/net/8139too.c

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