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