git.oblomov.eu Git - linux-2.6/blob - drivers/net/8139too.c

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