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