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