blob: 0daf8c15e38118a0155abc2d3ee615e8c1369143 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Jan Engelhardt96de0e22007-10-19 23:21:04 +020076 Tobias Ringström - Rx interrupt status checking suggestion
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78 Andrew Morton - Clear blocked signals, avoid
79 buffer overrun setting current->comm.
80
81 Kalle Olavi Niemitalo - Wake-on-LAN ioctls
82
83 Robert Kuebel - Save kernel thread from dying on any signal.
84
85 Submitting bug reports:
86
87 "rtl8139-diag -mmmaaavvveefN" output
88 enable RTL8139_DEBUG below, and look at 'dmesg' or kernel log
89
90*/
91
92#define DRV_NAME "8139too"
Andy Gospodarekd5b20692006-09-11 17:39:18 -040093#define DRV_VERSION "0.9.28"
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#include <linux/module.h>
97#include <linux/kernel.h>
98#include <linux/compiler.h>
99#include <linux/pci.h>
100#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#include <linux/netdevice.h>
102#include <linux/etherdevice.h>
103#include <linux/rtnetlink.h>
104#include <linux/delay.h>
105#include <linux/ethtool.h>
106#include <linux/mii.h>
107#include <linux/completion.h>
108#include <linux/crc32.h>
Márton Németha9879c42008-06-15 09:52:30 +0200109#include <linux/io.h>
110#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#include <asm/irq.h>
112
113#define RTL8139_DRIVER_NAME DRV_NAME " Fast Ethernet driver " DRV_VERSION
114#define PFX DRV_NAME ": "
115
116/* Default Message level */
117#define RTL8139_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
118 NETIF_MSG_PROBE | \
119 NETIF_MSG_LINK)
120
121
Olaf Hering44456d32005-07-27 11:45:17 -0700122/* define to 1, 2 or 3 to enable copious debugging info */
123#define RTL8139_DEBUG 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125/* define to 1 to disable lightweight runtime debugging checks */
126#undef RTL8139_NDEBUG
127
128
Olaf Hering44456d32005-07-27 11:45:17 -0700129#if RTL8139_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130/* note: prints function name for you */
Márton Németha9879c42008-06-15 09:52:30 +0200131# define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __func__ , ## args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132#else
133# define DPRINTK(fmt, args...)
134#endif
135
136#ifdef RTL8139_NDEBUG
137# define assert(expr) do {} while (0)
138#else
139# define assert(expr) \
140 if(unlikely(!(expr))) { \
141 printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
Márton Németha9879c42008-06-15 09:52:30 +0200142 #expr, __FILE__, __func__, __LINE__); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 }
144#endif
145
146
147/* A few user-configurable values. */
148/* media options */
149#define MAX_UNITS 8
150static int media[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
151static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
152
Dave Joneseb581342008-07-15 19:54:53 -0400153/* Whether to use MMIO or PIO. Default to MMIO. */
154#ifdef CONFIG_8139TOO_PIO
155static int use_io = 1;
156#else
157static int use_io = 0;
158#endif
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
161 The RTL chips use a 64 element hash table based on the Ethernet CRC. */
162static int multicast_filter_limit = 32;
163
164/* bitmapped message enable number */
165static int debug = -1;
166
167/*
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400168 * Receive ring size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 * Warning: 64K ring has hardware issues and may lock up.
170 */
171#if defined(CONFIG_SH_DREAMCAST)
Adrian McMenamin2192f392008-02-08 11:21:58 +0000172#define RX_BUF_IDX 0 /* 8K ring */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173#else
174#define RX_BUF_IDX 2 /* 32K ring */
175#endif
176#define RX_BUF_LEN (8192 << RX_BUF_IDX)
177#define RX_BUF_PAD 16
178#define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
179
180#if RX_BUF_LEN == 65536
181#define RX_BUF_TOT_LEN RX_BUF_LEN
182#else
183#define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
184#endif
185
186/* Number of Tx descriptor registers. */
187#define NUM_TX_DESC 4
188
189/* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
190#define MAX_ETH_FRAME_SIZE 1536
191
192/* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
193#define TX_BUF_SIZE MAX_ETH_FRAME_SIZE
194#define TX_BUF_TOT_LEN (TX_BUF_SIZE * NUM_TX_DESC)
195
196/* PCI Tuning Parameters
197 Threshold is bytes transferred to chip before transmission starts. */
198#define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
199
200/* The following settings are log_2(bytes)-4: 0 == 16 bytes .. 6==1024, 7==end of packet. */
201#define RX_FIFO_THRESH 7 /* Rx buffer level before first PCI xfer. */
202#define RX_DMA_BURST 7 /* Maximum PCI burst, '6' is 1024 */
203#define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
204#define TX_RETRY 8 /* 0-15. retries = 16 + (TX_RETRY * 16) */
205
206/* Operational parameters that usually are not changed. */
207/* Time in jiffies before concluding the transmitter is hung. */
208#define TX_TIMEOUT (6*HZ)
209
210
211enum {
212 HAS_MII_XCVR = 0x010000,
213 HAS_CHIP_XCVR = 0x020000,
214 HAS_LNK_CHNG = 0x040000,
215};
216
217#define RTL_NUM_STATS 4 /* number of ETHTOOL_GSTATS u64's */
218#define RTL_REGS_VER 1 /* version of reg. data in ETHTOOL_GREGS */
219#define RTL_MIN_IO_SIZE 0x80
220#define RTL8139B_IO_SIZE 256
221
222#define RTL8129_CAPS HAS_MII_XCVR
Márton Németha9879c42008-06-15 09:52:30 +0200223#define RTL8139_CAPS (HAS_CHIP_XCVR|HAS_LNK_CHNG)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225typedef enum {
226 RTL8139 = 0,
227 RTL8129,
228} board_t;
229
230
231/* indexed by board_t, above */
Arjan van de Venf71e1302006-03-03 21:33:57 -0500232static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 const char *name;
234 u32 hw_flags;
235} board_info[] __devinitdata = {
236 { "RealTek RTL8139", RTL8139_CAPS },
237 { "RealTek RTL8129", RTL8129_CAPS },
238};
239
240
241static struct pci_device_id rtl8139_pci_tbl[] = {
242 {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
243 {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
244 {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
245 {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
246 {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
247 {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
248 {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
249 {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
250 {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
251 {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
252 {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
253 {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
254 {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
255 {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
256 {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
257 {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
258 {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
259 {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400260 {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
262#ifdef CONFIG_SH_SECUREEDGE5410
263 /* Bogus 8139 silicon reports 8129 without external PROM :-( */
264 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
265#endif
266#ifdef CONFIG_8139TOO_8129
267 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
268#endif
269
270 /* some crazy cards report invalid vendor ids like
271 * 0x0001 here. The other ids are valid and constant,
272 * so we simply don't match on the main vendor id.
273 */
274 {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
275 {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
276 {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
277
278 {0,}
279};
280MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);
281
282static struct {
283 const char str[ETH_GSTRING_LEN];
284} ethtool_stats_keys[] = {
285 { "early_rx" },
286 { "tx_buf_mapped" },
287 { "tx_timeouts" },
288 { "rx_lost_in_ring" },
289};
290
291/* The rest of these values should never change. */
292
293/* Symbolic offsets to registers. */
294enum RTL8139_registers {
Jeff Garzik28006c62007-09-15 12:36:46 -0700295 MAC0 = 0, /* Ethernet hardware address. */
296 MAR0 = 8, /* Multicast filter. */
297 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
298 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
299 RxBuf = 0x30,
300 ChipCmd = 0x37,
301 RxBufPtr = 0x38,
302 RxBufAddr = 0x3A,
303 IntrMask = 0x3C,
304 IntrStatus = 0x3E,
305 TxConfig = 0x40,
306 RxConfig = 0x44,
307 Timer = 0x48, /* A general-purpose counter. */
308 RxMissed = 0x4C, /* 24 bits valid, write clears. */
309 Cfg9346 = 0x50,
310 Config0 = 0x51,
311 Config1 = 0x52,
Mats Erik Anderssonda8de392008-07-17 01:05:43 +0200312 TimerInt = 0x54,
Jeff Garzik28006c62007-09-15 12:36:46 -0700313 MediaStatus = 0x58,
314 Config3 = 0x59,
315 Config4 = 0x5A, /* absent on RTL-8139A */
316 HltClk = 0x5B,
317 MultiIntr = 0x5C,
318 TxSummary = 0x60,
319 BasicModeCtrl = 0x62,
320 BasicModeStatus = 0x64,
321 NWayAdvert = 0x66,
322 NWayLPAR = 0x68,
323 NWayExpansion = 0x6A,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 /* Undocumented registers, but required for proper operation. */
Jeff Garzik28006c62007-09-15 12:36:46 -0700325 FIFOTMS = 0x70, /* FIFO Control and test. */
326 CSCR = 0x74, /* Chip Status and Configuration Register. */
327 PARA78 = 0x78,
Mats Erik Anderssonda8de392008-07-17 01:05:43 +0200328 FlashReg = 0xD4, /* Communication with Flash ROM, four bytes. */
Jeff Garzik28006c62007-09-15 12:36:46 -0700329 PARA7c = 0x7c, /* Magic transceiver parameter register. */
330 Config5 = 0xD8, /* absent on RTL-8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331};
332
333enum ClearBitMasks {
Jeff Garzik28006c62007-09-15 12:36:46 -0700334 MultiIntrClear = 0xF000,
335 ChipCmdClear = 0xE2,
336 Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337};
338
339enum ChipCmdBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700340 CmdReset = 0x10,
341 CmdRxEnb = 0x08,
342 CmdTxEnb = 0x04,
343 RxBufEmpty = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344};
345
346/* Interrupt register bits, using my own meaningful names. */
347enum IntrStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700348 PCIErr = 0x8000,
349 PCSTimeout = 0x4000,
350 RxFIFOOver = 0x40,
351 RxUnderrun = 0x20,
352 RxOverflow = 0x10,
353 TxErr = 0x08,
354 TxOK = 0x04,
355 RxErr = 0x02,
356 RxOK = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Jeff Garzik28006c62007-09-15 12:36:46 -0700358 RxAckBits = RxFIFOOver | RxOverflow | RxOK,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359};
360
361enum TxStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700362 TxHostOwns = 0x2000,
363 TxUnderrun = 0x4000,
364 TxStatOK = 0x8000,
365 TxOutOfWindow = 0x20000000,
366 TxAborted = 0x40000000,
367 TxCarrierLost = 0x80000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368};
369enum RxStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700370 RxMulticast = 0x8000,
371 RxPhysical = 0x4000,
372 RxBroadcast = 0x2000,
373 RxBadSymbol = 0x0020,
374 RxRunt = 0x0010,
375 RxTooLong = 0x0008,
376 RxCRCErr = 0x0004,
377 RxBadAlign = 0x0002,
378 RxStatusOK = 0x0001,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379};
380
381/* Bits in RxConfig. */
382enum rx_mode_bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700383 AcceptErr = 0x20,
384 AcceptRunt = 0x10,
385 AcceptBroadcast = 0x08,
386 AcceptMulticast = 0x04,
387 AcceptMyPhys = 0x02,
388 AcceptAllPhys = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389};
390
391/* Bits in TxConfig. */
392enum tx_config_bits {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
Jeff Garzik28006c62007-09-15 12:36:46 -0700394 TxIFGShift = 24,
395 TxIFG84 = (0 << TxIFGShift), /* 8.4us / 840ns (10 / 100Mbps) */
396 TxIFG88 = (1 << TxIFGShift), /* 8.8us / 880ns (10 / 100Mbps) */
397 TxIFG92 = (2 << TxIFGShift), /* 9.2us / 920ns (10 / 100Mbps) */
398 TxIFG96 = (3 << TxIFGShift), /* 9.6us / 960ns (10 / 100Mbps) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Jeff Garzik28006c62007-09-15 12:36:46 -0700400 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
401 TxCRC = (1 << 16), /* DISABLE Tx pkt CRC append */
402 TxClearAbt = (1 << 0), /* Clear abort (WO) */
403 TxDMAShift = 8, /* DMA burst value (0-7) is shifted X many bits */
404 TxRetryShift = 4, /* TXRR value (0-15) is shifted X many bits */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Jeff Garzik28006c62007-09-15 12:36:46 -0700406 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407};
408
409/* Bits in Config1 */
410enum Config1Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700411 Cfg1_PM_Enable = 0x01,
412 Cfg1_VPD_Enable = 0x02,
413 Cfg1_PIO = 0x04,
414 Cfg1_MMIO = 0x08,
415 LWAKE = 0x10, /* not on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 Cfg1_Driver_Load = 0x20,
Jeff Garzik28006c62007-09-15 12:36:46 -0700417 Cfg1_LED0 = 0x40,
418 Cfg1_LED1 = 0x80,
419 SLEEP = (1 << 1), /* only on 8139, 8139A */
420 PWRDN = (1 << 0), /* only on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421};
422
423/* Bits in Config3 */
424enum Config3Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700425 Cfg3_FBtBEn = (1 << 0), /* 1 = Fast Back to Back */
426 Cfg3_FuncRegEn = (1 << 1), /* 1 = enable CardBus Function registers */
427 Cfg3_CLKRUN_En = (1 << 2), /* 1 = enable CLKRUN */
428 Cfg3_CardB_En = (1 << 3), /* 1 = enable CardBus registers */
429 Cfg3_LinkUp = (1 << 4), /* 1 = wake up on link up */
430 Cfg3_Magic = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
431 Cfg3_PARM_En = (1 << 6), /* 0 = software can set twister parameters */
432 Cfg3_GNTSel = (1 << 7), /* 1 = delay 1 clock from PCI GNT signal */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433};
434
435/* Bits in Config4 */
436enum Config4Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700437 LWPTN = (1 << 2), /* not on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438};
439
440/* Bits in Config5 */
441enum Config5Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700442 Cfg5_PME_STS = (1 << 0), /* 1 = PCI reset resets PME_Status */
443 Cfg5_LANWake = (1 << 1), /* 1 = enable LANWake signal */
444 Cfg5_LDPS = (1 << 2), /* 0 = save power when link is down */
445 Cfg5_FIFOAddrPtr= (1 << 3), /* Realtek internal SRAM testing */
446 Cfg5_UWF = (1 << 4), /* 1 = accept unicast wakeup frame */
447 Cfg5_MWF = (1 << 5), /* 1 = accept multicast wakeup frame */
448 Cfg5_BWF = (1 << 6), /* 1 = accept broadcast wakeup frame */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449};
450
451enum RxConfigBits {
452 /* rx fifo threshold */
Jeff Garzik28006c62007-09-15 12:36:46 -0700453 RxCfgFIFOShift = 13,
454 RxCfgFIFONone = (7 << RxCfgFIFOShift),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 /* Max DMA burst */
Jeff Garzik28006c62007-09-15 12:36:46 -0700457 RxCfgDMAShift = 8,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
459
460 /* rx ring buffer length */
Jeff Garzik28006c62007-09-15 12:36:46 -0700461 RxCfgRcv8K = 0,
462 RxCfgRcv16K = (1 << 11),
463 RxCfgRcv32K = (1 << 12),
464 RxCfgRcv64K = (1 << 11) | (1 << 12),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466 /* Disable packet wrap at end of Rx buffer. (not possible with 64k) */
Jeff Garzik28006c62007-09-15 12:36:46 -0700467 RxNoWrap = (1 << 7),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468};
469
470/* Twister tuning parameters from RealTek.
471 Completely undocumented, but required to tune bad links on some boards. */
472enum CSCRBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700473 CSCR_LinkOKBit = 0x0400,
474 CSCR_LinkChangeBit = 0x0800,
475 CSCR_LinkStatusBits = 0x0f000,
476 CSCR_LinkDownOffCmd = 0x003c0,
477 CSCR_LinkDownCmd = 0x0f3c0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478};
479
480enum Cfg9346Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700481 Cfg9346_Lock = 0x00,
482 Cfg9346_Unlock = 0xC0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483};
484
485typedef enum {
Jeff Garzik28006c62007-09-15 12:36:46 -0700486 CH_8139 = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 CH_8139_K,
488 CH_8139A,
489 CH_8139A_G,
490 CH_8139B,
491 CH_8130,
492 CH_8139C,
493 CH_8100,
494 CH_8100B_8139D,
495 CH_8101,
496} chip_t;
497
498enum chip_flags {
Jeff Garzik28006c62007-09-15 12:36:46 -0700499 HasHltClk = (1 << 0),
500 HasLWake = (1 << 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501};
502
503#define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \
504 (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
505#define HW_REVID_MASK HW_REVID(1, 1, 1, 1, 1, 1, 1)
506
507/* directly indexed by chip_t, above */
Jesper Juhl3c6bee12006-01-09 20:54:01 -0800508static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 const char *name;
510 u32 version; /* from RTL8139C/RTL8139D docs */
511 u32 flags;
512} rtl_chip_info[] = {
513 { "RTL-8139",
514 HW_REVID(1, 0, 0, 0, 0, 0, 0),
515 HasHltClk,
516 },
517
518 { "RTL-8139 rev K",
519 HW_REVID(1, 1, 0, 0, 0, 0, 0),
520 HasHltClk,
521 },
522
523 { "RTL-8139A",
524 HW_REVID(1, 1, 1, 0, 0, 0, 0),
525 HasHltClk, /* XXX undocumented? */
526 },
527
528 { "RTL-8139A rev G",
529 HW_REVID(1, 1, 1, 0, 0, 1, 0),
530 HasHltClk, /* XXX undocumented? */
531 },
532
533 { "RTL-8139B",
534 HW_REVID(1, 1, 1, 1, 0, 0, 0),
535 HasLWake,
536 },
537
538 { "RTL-8130",
539 HW_REVID(1, 1, 1, 1, 1, 0, 0),
540 HasLWake,
541 },
542
543 { "RTL-8139C",
544 HW_REVID(1, 1, 1, 0, 1, 0, 0),
545 HasLWake,
546 },
547
548 { "RTL-8100",
549 HW_REVID(1, 1, 1, 1, 0, 1, 0),
550 HasLWake,
551 },
552
553 { "RTL-8100B/8139D",
554 HW_REVID(1, 1, 1, 0, 1, 0, 1),
John W. Linville7645bae2005-10-18 21:31:00 -0400555 HasHltClk /* XXX undocumented? */
556 | HasLWake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 },
558
559 { "RTL-8101",
560 HW_REVID(1, 1, 1, 0, 1, 1, 1),
561 HasLWake,
562 },
563};
564
565struct rtl_extra_stats {
566 unsigned long early_rx;
567 unsigned long tx_buf_mapped;
568 unsigned long tx_timeouts;
569 unsigned long rx_lost_in_ring;
570};
571
572struct rtl8139_private {
Jeff Garzik28006c62007-09-15 12:36:46 -0700573 void __iomem *mmio_addr;
574 int drv_flags;
575 struct pci_dev *pci_dev;
576 u32 msg_enable;
577 struct napi_struct napi;
578 struct net_device *dev;
Jeff Garzika15e0382005-10-31 07:59:37 -0500579
Jeff Garzik28006c62007-09-15 12:36:46 -0700580 unsigned char *rx_ring;
581 unsigned int cur_rx; /* RX buf index of next pkt */
582 dma_addr_t rx_ring_dma;
Jeff Garzika15e0382005-10-31 07:59:37 -0500583
Jeff Garzik28006c62007-09-15 12:36:46 -0700584 unsigned int tx_flag;
585 unsigned long cur_tx;
586 unsigned long dirty_tx;
587 unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
588 unsigned char *tx_bufs; /* Tx bounce buffer region. */
589 dma_addr_t tx_bufs_dma;
590
591 signed char phys[4]; /* MII device addresses. */
592
593 /* Twister tune state. */
594 char twistie, twist_row, twist_col;
595
596 unsigned int watchdog_fired : 1;
597 unsigned int default_port : 4; /* Last dev->if_port value. */
598 unsigned int have_thread : 1;
599
600 spinlock_t lock;
601 spinlock_t rx_lock;
602
603 chip_t chipset;
604 u32 rx_config;
605 struct rtl_extra_stats xstats;
606
607 struct delayed_work thread;
608
609 struct mii_if_info mii;
610 unsigned int regs_len;
611 unsigned long fifo_copy_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612};
613
614MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
615MODULE_DESCRIPTION ("RealTek RTL-8139 Fast Ethernet driver");
616MODULE_LICENSE("GPL");
617MODULE_VERSION(DRV_VERSION);
618
Dave Joneseb581342008-07-15 19:54:53 -0400619module_param(use_io, int, 0);
620MODULE_PARM_DESC(use_io, "Force use of I/O access mode. 0=MMIO 1=PIO");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621module_param(multicast_filter_limit, int, 0);
622module_param_array(media, int, NULL, 0);
623module_param_array(full_duplex, int, NULL, 0);
624module_param(debug, int, 0);
625MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");
626MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
627MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
628MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
629
Pekka Enberg22f714b2005-05-12 19:38:47 -0400630static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631static int rtl8139_open (struct net_device *dev);
632static int mdio_read (struct net_device *dev, int phy_id, int location);
633static void mdio_write (struct net_device *dev, int phy_id, int location,
634 int val);
Jeff Garzika15e0382005-10-31 07:59:37 -0500635static void rtl8139_start_thread(struct rtl8139_private *tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636static void rtl8139_tx_timeout (struct net_device *dev);
637static void rtl8139_init_ring (struct net_device *dev);
638static int rtl8139_start_xmit (struct sk_buff *skb,
639 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640#ifdef CONFIG_NET_POLL_CONTROLLER
641static void rtl8139_poll_controller(struct net_device *dev);
642#endif
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700643static int rtl8139_poll(struct napi_struct *napi, int budget);
David Howells7d12e782006-10-05 14:55:46 +0100644static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645static int rtl8139_close (struct net_device *dev);
646static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
647static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
648static void rtl8139_set_rx_mode (struct net_device *dev);
649static void __set_rx_mode (struct net_device *dev);
650static void rtl8139_hw_start (struct net_device *dev);
David Howellsc4028952006-11-22 14:57:56 +0000651static void rtl8139_thread (struct work_struct *work);
652static void rtl8139_tx_timeout_task(struct work_struct *work);
Jeff Garzik7282d492006-09-13 14:30:00 -0400653static const struct ethtool_ops rtl8139_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655/* write MMIO register, with flush */
656/* Flush avoids rtl8139 bug w/ posted MMIO writes */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400657#define RTL_W8_F(reg, val8) do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)
658#define RTL_W16_F(reg, val16) do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)
659#define RTL_W32_F(reg, val32) do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661/* write MMIO register */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400662#define RTL_W8(reg, val8) iowrite8 ((val8), ioaddr + (reg))
663#define RTL_W16(reg, val16) iowrite16 ((val16), ioaddr + (reg))
664#define RTL_W32(reg, val32) iowrite32 ((val32), ioaddr + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666/* read MMIO register */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400667#define RTL_R8(reg) ioread8 (ioaddr + (reg))
668#define RTL_R16(reg) ioread16 (ioaddr + (reg))
669#define RTL_R32(reg) ((unsigned long) ioread32 (ioaddr + (reg)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
671
672static const u16 rtl8139_intr_mask =
673 PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
674 TxErr | TxOK | RxErr | RxOK;
675
676static const u16 rtl8139_norx_intr_mask =
677 PCIErr | PCSTimeout | RxUnderrun |
678 TxErr | TxOK | RxErr ;
679
680#if RX_BUF_IDX == 0
681static const unsigned int rtl8139_rx_config =
682 RxCfgRcv8K | RxNoWrap |
683 (RX_FIFO_THRESH << RxCfgFIFOShift) |
684 (RX_DMA_BURST << RxCfgDMAShift);
685#elif RX_BUF_IDX == 1
686static const unsigned int rtl8139_rx_config =
687 RxCfgRcv16K | RxNoWrap |
688 (RX_FIFO_THRESH << RxCfgFIFOShift) |
689 (RX_DMA_BURST << RxCfgDMAShift);
690#elif RX_BUF_IDX == 2
691static const unsigned int rtl8139_rx_config =
692 RxCfgRcv32K | RxNoWrap |
693 (RX_FIFO_THRESH << RxCfgFIFOShift) |
694 (RX_DMA_BURST << RxCfgDMAShift);
695#elif RX_BUF_IDX == 3
696static const unsigned int rtl8139_rx_config =
697 RxCfgRcv64K |
698 (RX_FIFO_THRESH << RxCfgFIFOShift) |
699 (RX_DMA_BURST << RxCfgDMAShift);
700#else
701#error "Invalid configuration for 8139_RXBUF_IDX"
702#endif
703
704static const unsigned int rtl8139_tx_config =
705 TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);
706
707static void __rtl8139_cleanup_dev (struct net_device *dev)
708{
709 struct rtl8139_private *tp = netdev_priv(dev);
710 struct pci_dev *pdev;
711
712 assert (dev != NULL);
713 assert (tp->pci_dev != NULL);
714 pdev = tp->pci_dev;
715
Pekka Enberg22f714b2005-05-12 19:38:47 -0400716 if (tp->mmio_addr)
717 pci_iounmap (pdev, tp->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 /* it's ok to call this even if we have no regions to free */
720 pci_release_regions (pdev);
721
722 free_netdev(dev);
723 pci_set_drvdata (pdev, NULL);
724}
725
726
Pekka Enberg22f714b2005-05-12 19:38:47 -0400727static void rtl8139_chip_reset (void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728{
729 int i;
730
731 /* Soft reset the chip. */
732 RTL_W8 (ChipCmd, CmdReset);
733
734 /* Check that the chip has finished the reset. */
735 for (i = 1000; i > 0; i--) {
736 barrier();
737 if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
738 break;
739 udelay (10);
740 }
741}
742
743
744static int __devinit rtl8139_init_board (struct pci_dev *pdev,
745 struct net_device **dev_out)
746{
Pekka Enberg22f714b2005-05-12 19:38:47 -0400747 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 struct net_device *dev;
749 struct rtl8139_private *tp;
750 u8 tmp8;
751 int rc, disable_dev_on_err = 0;
752 unsigned int i;
753 unsigned long pio_start, pio_end, pio_flags, pio_len;
754 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
755 u32 version;
756
757 assert (pdev != NULL);
758
759 *dev_out = NULL;
760
761 /* dev and priv zeroed in alloc_etherdev */
762 dev = alloc_etherdev (sizeof (*tp));
763 if (dev == NULL) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400764 dev_err(&pdev->dev, "Unable to alloc new net device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 return -ENOMEM;
766 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 SET_NETDEV_DEV(dev, &pdev->dev);
768
769 tp = netdev_priv(dev);
770 tp->pci_dev = pdev;
771
772 /* enable device (incl. PCI PM wakeup and hotplug setup) */
773 rc = pci_enable_device (pdev);
774 if (rc)
775 goto err_out;
776
777 pio_start = pci_resource_start (pdev, 0);
778 pio_end = pci_resource_end (pdev, 0);
779 pio_flags = pci_resource_flags (pdev, 0);
780 pio_len = pci_resource_len (pdev, 0);
781
782 mmio_start = pci_resource_start (pdev, 1);
783 mmio_end = pci_resource_end (pdev, 1);
784 mmio_flags = pci_resource_flags (pdev, 1);
785 mmio_len = pci_resource_len (pdev, 1);
786
787 /* set this immediately, we need to know before
788 * we talk to the chip directly */
789 DPRINTK("PIO region size == 0x%02X\n", pio_len);
790 DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
791
Dave Jones1a4dc682008-07-15 19:54:52 -0400792retry:
Dave Joneseb581342008-07-15 19:54:53 -0400793 if (use_io) {
794 /* make sure PCI base addr 0 is PIO */
795 if (!(pio_flags & IORESOURCE_IO)) {
796 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
797 rc = -ENODEV;
798 goto err_out;
799 }
800 /* check for weird/broken PCI region reporting */
801 if (pio_len < RTL_MIN_IO_SIZE) {
802 dev_err(&pdev->dev, "Invalid PCI I/O region size(s), aborting\n");
803 rc = -ENODEV;
804 goto err_out;
805 }
806 } else {
807 /* make sure PCI base addr 1 is MMIO */
808 if (!(mmio_flags & IORESOURCE_MEM)) {
809 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
810 rc = -ENODEV;
811 goto err_out;
812 }
813 if (mmio_len < RTL_MIN_IO_SIZE) {
814 dev_err(&pdev->dev, "Invalid PCI mem region size(s), aborting\n");
815 rc = -ENODEV;
816 goto err_out;
817 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400820 rc = pci_request_regions (pdev, DRV_NAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (rc)
822 goto err_out;
823 disable_dev_on_err = 1;
824
825 /* enable PCI bus-mastering */
826 pci_set_master (pdev);
827
Dave Joneseb581342008-07-15 19:54:53 -0400828 if (use_io) {
829 ioaddr = pci_iomap(pdev, 0, 0);
830 if (!ioaddr) {
831 dev_err(&pdev->dev, "cannot map PIO, aborting\n");
832 rc = -EIO;
833 goto err_out;
834 }
835 dev->base_addr = pio_start;
836 tp->regs_len = pio_len;
837 } else {
838 /* ioremap MMIO region */
839 ioaddr = pci_iomap(pdev, 1, 0);
840 if (ioaddr == NULL) {
Dave Jones1a4dc682008-07-15 19:54:52 -0400841 dev_err(&pdev->dev, "cannot remap MMIO, trying PIO\n");
842 pci_release_regions(pdev);
843 use_io = 1;
844 goto retry;
Dave Joneseb581342008-07-15 19:54:53 -0400845 }
846 dev->base_addr = (long) ioaddr;
847 tp->regs_len = mmio_len;
Pekka Enberg22f714b2005-05-12 19:38:47 -0400848 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 tp->mmio_addr = ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851 /* Bring old chips out of low-power mode. */
852 RTL_W8 (HltClk, 'R');
853
854 /* check for missing/broken hardware */
855 if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400856 dev_err(&pdev->dev, "Chip not responding, ignoring board\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 rc = -EIO;
858 goto err_out;
859 }
860
861 /* identify chip attached to board */
862 version = RTL_R32 (TxConfig) & HW_REVID_MASK;
863 for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)
864 if (version == rtl_chip_info[i].version) {
865 tp->chipset = i;
866 goto match;
867 }
868
869 /* if unknown chip, assume array element #0, original RTL-8139 in this case */
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400870 dev_printk (KERN_DEBUG, &pdev->dev,
871 "unknown chip version, assuming RTL-8139\n");
872 dev_printk (KERN_DEBUG, &pdev->dev,
873 "TxConfig = 0x%lx\n", RTL_R32 (TxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 tp->chipset = 0;
875
876match:
877 DPRINTK ("chipset id (%d) == index %d, '%s'\n",
878 version, i, rtl_chip_info[i].name);
879
880 if (tp->chipset >= CH_8139B) {
881 u8 new_tmp8 = tmp8 = RTL_R8 (Config1);
882 DPRINTK("PCI PM wakeup\n");
883 if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&
884 (tmp8 & LWAKE))
885 new_tmp8 &= ~LWAKE;
886 new_tmp8 |= Cfg1_PM_Enable;
887 if (new_tmp8 != tmp8) {
888 RTL_W8 (Cfg9346, Cfg9346_Unlock);
889 RTL_W8 (Config1, tmp8);
890 RTL_W8 (Cfg9346, Cfg9346_Lock);
891 }
892 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
893 tmp8 = RTL_R8 (Config4);
894 if (tmp8 & LWPTN) {
895 RTL_W8 (Cfg9346, Cfg9346_Unlock);
896 RTL_W8 (Config4, tmp8 & ~LWPTN);
897 RTL_W8 (Cfg9346, Cfg9346_Lock);
898 }
899 }
900 } else {
901 DPRINTK("Old chip wakeup\n");
902 tmp8 = RTL_R8 (Config1);
903 tmp8 &= ~(SLEEP | PWRDN);
904 RTL_W8 (Config1, tmp8);
905 }
906
907 rtl8139_chip_reset (ioaddr);
908
909 *dev_out = dev;
910 return 0;
911
912err_out:
913 __rtl8139_cleanup_dev (dev);
914 if (disable_dev_on_err)
915 pci_disable_device (pdev);
916 return rc;
917}
918
919
920static int __devinit rtl8139_init_one (struct pci_dev *pdev,
921 const struct pci_device_id *ent)
922{
923 struct net_device *dev = NULL;
924 struct rtl8139_private *tp;
925 int i, addr_len, option;
Pekka Enberg22f714b2005-05-12 19:38:47 -0400926 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 static int board_idx = -1;
Joe Perches0795af52007-10-03 17:59:30 -0700928 DECLARE_MAC_BUF(mac);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 assert (pdev != NULL);
931 assert (ent != NULL);
932
933 board_idx++;
934
935 /* when we're built into the kernel, the driver version message
936 * is only printed if at least one 8139 board has been found
937 */
938#ifndef MODULE
939 {
940 static int printed_version;
941 if (!printed_version++)
942 printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
943 }
944#endif
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
Auke Kok44c10132007-06-08 15:46:36 -0700947 pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pdev->revision >= 0x20) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400948 dev_info(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400949 "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip\n",
Auke Kok44c10132007-06-08 15:46:36 -0700950 pdev->vendor, pdev->device, pdev->revision);
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400951 dev_info(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400952 "Use the \"8139cp\" driver for improved performance and stability.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 }
954
Dave Jones152151d2008-07-15 19:54:53 -0400955 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
956 pdev->device == PCI_DEVICE_ID_REALTEK_8139 &&
957 pdev->subsystem_vendor == PCI_VENDOR_ID_ATHEROS &&
958 pdev->subsystem_device == PCI_DEVICE_ID_REALTEK_8139) {
959 printk(KERN_INFO "8139too: OQO Model 2 detected. Forcing PIO\n");
960 use_io = 1;
961 }
962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 i = rtl8139_init_board (pdev, &dev);
964 if (i < 0)
965 return i;
966
967 assert (dev != NULL);
968 tp = netdev_priv(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700969 tp->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
971 ioaddr = tp->mmio_addr;
972 assert (ioaddr != NULL);
973
974 addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
975 for (i = 0; i < 3; i++)
Al Viroeca1ad82008-03-16 22:21:54 +0000976 ((__le16 *) (dev->dev_addr))[i] =
977 cpu_to_le16(read_eeprom (ioaddr, i + 7, addr_len));
John W. Linville62a720b2005-09-12 10:48:55 -0400978 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 /* The Rtl8139-specific entries in the device structure. */
981 dev->open = rtl8139_open;
982 dev->hard_start_xmit = rtl8139_start_xmit;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700983 netif_napi_add(dev, &tp->napi, rtl8139_poll, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 dev->stop = rtl8139_close;
985 dev->get_stats = rtl8139_get_stats;
986 dev->set_multicast_list = rtl8139_set_rx_mode;
987 dev->do_ioctl = netdev_ioctl;
988 dev->ethtool_ops = &rtl8139_ethtool_ops;
989 dev->tx_timeout = rtl8139_tx_timeout;
990 dev->watchdog_timeo = TX_TIMEOUT;
991#ifdef CONFIG_NET_POLL_CONTROLLER
992 dev->poll_controller = rtl8139_poll_controller;
993#endif
994
995 /* note: the hardware is not capable of sg/csum/highdma, however
996 * through the use of skb_copy_and_csum_dev we enable these
997 * features
998 */
999 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
1000
1001 dev->irq = pdev->irq;
1002
1003 /* tp zeroed and aligned in alloc_etherdev */
1004 tp = netdev_priv(dev);
1005
1006 /* note: tp->chipset set in rtl8139_init_board */
1007 tp->drv_flags = board_info[ent->driver_data].hw_flags;
1008 tp->mmio_addr = ioaddr;
1009 tp->msg_enable =
1010 (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));
1011 spin_lock_init (&tp->lock);
1012 spin_lock_init (&tp->rx_lock);
David Howellsc4028952006-11-22 14:57:56 +00001013 INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 tp->mii.dev = dev;
1015 tp->mii.mdio_read = mdio_read;
1016 tp->mii.mdio_write = mdio_write;
1017 tp->mii.phy_id_mask = 0x3f;
1018 tp->mii.reg_num_mask = 0x1f;
1019
1020 /* dev is fully set up and ready to use now */
1021 DPRINTK("about to register device named %s (%p)...\n", dev->name, dev);
1022 i = register_netdev (dev);
1023 if (i) goto err_out;
1024
1025 pci_set_drvdata (pdev, dev);
1026
1027 printk (KERN_INFO "%s: %s at 0x%lx, "
Joe Perches0795af52007-10-03 17:59:30 -07001028 "%s, IRQ %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 dev->name,
1030 board_info[ent->driver_data].name,
1031 dev->base_addr,
Joe Perches0795af52007-10-03 17:59:30 -07001032 print_mac(mac, dev->dev_addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 dev->irq);
1034
1035 printk (KERN_DEBUG "%s: Identified 8139 chip type '%s'\n",
1036 dev->name, rtl_chip_info[tp->chipset].name);
1037
1038 /* Find the connected MII xcvrs.
1039 Doing this in open() would allow detecting external xcvrs later, but
1040 takes too much time. */
1041#ifdef CONFIG_8139TOO_8129
1042 if (tp->drv_flags & HAS_MII_XCVR) {
1043 int phy, phy_idx = 0;
1044 for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {
1045 int mii_status = mdio_read(dev, phy, 1);
1046 if (mii_status != 0xffff && mii_status != 0x0000) {
1047 u16 advertising = mdio_read(dev, phy, 4);
1048 tp->phys[phy_idx++] = phy;
1049 printk(KERN_INFO "%s: MII transceiver %d status 0x%4.4x "
1050 "advertising %4.4x.\n",
1051 dev->name, phy, mii_status, advertising);
1052 }
1053 }
1054 if (phy_idx == 0) {
1055 printk(KERN_INFO "%s: No MII transceivers found! Assuming SYM "
1056 "transceiver.\n",
1057 dev->name);
1058 tp->phys[0] = 32;
1059 }
1060 } else
1061#endif
1062 tp->phys[0] = 32;
1063 tp->mii.phy_id = tp->phys[0];
1064
1065 /* The lower four bits are the media type. */
1066 option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
1067 if (option > 0) {
1068 tp->mii.full_duplex = (option & 0x210) ? 1 : 0;
1069 tp->default_port = option & 0xFF;
1070 if (tp->default_port)
1071 tp->mii.force_media = 1;
1072 }
1073 if (board_idx < MAX_UNITS && full_duplex[board_idx] > 0)
1074 tp->mii.full_duplex = full_duplex[board_idx];
1075 if (tp->mii.full_duplex) {
1076 printk(KERN_INFO "%s: Media type forced to Full Duplex.\n", dev->name);
1077 /* Changing the MII-advertised media because might prevent
1078 re-connection. */
1079 tp->mii.force_media = 1;
1080 }
1081 if (tp->default_port) {
1082 printk(KERN_INFO " Forcing %dMbps %s-duplex operation.\n",
1083 (option & 0x20 ? 100 : 10),
1084 (option & 0x10 ? "full" : "half"));
1085 mdio_write(dev, tp->phys[0], 0,
1086 ((option & 0x20) ? 0x2000 : 0) | /* 100Mbps? */
1087 ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
1088 }
1089
1090 /* Put the chip into low-power mode. */
1091 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1092 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
1093
1094 return 0;
1095
1096err_out:
1097 __rtl8139_cleanup_dev (dev);
1098 pci_disable_device (pdev);
1099 return i;
1100}
1101
1102
1103static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
1104{
1105 struct net_device *dev = pci_get_drvdata (pdev);
1106
1107 assert (dev != NULL);
1108
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001109 flush_scheduled_work();
1110
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 unregister_netdev (dev);
1112
1113 __rtl8139_cleanup_dev (dev);
1114 pci_disable_device (pdev);
1115}
1116
1117
1118/* Serial EEPROM section. */
1119
1120/* EEPROM_Ctrl bits. */
1121#define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
1122#define EE_CS 0x08 /* EEPROM chip select. */
1123#define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
1124#define EE_WRITE_0 0x00
1125#define EE_WRITE_1 0x02
1126#define EE_DATA_READ 0x01 /* EEPROM chip data out. */
1127#define EE_ENB (0x80 | EE_CS)
1128
1129/* Delay between EEPROM clock transitions.
1130 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1131 */
1132
Takashi Iwai10e705f2006-03-24 03:18:23 -08001133#define eeprom_delay() (void)RTL_R32(Cfg9346)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
1135/* The EEPROM commands include the alway-set leading bit. */
1136#define EE_WRITE_CMD (5)
1137#define EE_READ_CMD (6)
1138#define EE_ERASE_CMD (7)
1139
Pekka Enberg22f714b2005-05-12 19:38:47 -04001140static int __devinit read_eeprom (void __iomem *ioaddr, int location, int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141{
1142 int i;
1143 unsigned retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 int read_cmd = location | (EE_READ_CMD << addr_len);
1145
Pekka Enberg22f714b2005-05-12 19:38:47 -04001146 RTL_W8 (Cfg9346, EE_ENB & ~EE_CS);
1147 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 eeprom_delay ();
1149
1150 /* Shift the read command bits out. */
1151 for (i = 4 + addr_len; i >= 0; i--) {
1152 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001153 RTL_W8 (Cfg9346, EE_ENB | dataval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 eeprom_delay ();
Pekka Enberg22f714b2005-05-12 19:38:47 -04001155 RTL_W8 (Cfg9346, EE_ENB | dataval | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 eeprom_delay ();
1157 }
Pekka Enberg22f714b2005-05-12 19:38:47 -04001158 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 eeprom_delay ();
1160
1161 for (i = 16; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001162 RTL_W8 (Cfg9346, EE_ENB | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 eeprom_delay ();
1164 retval =
Pekka Enberg22f714b2005-05-12 19:38:47 -04001165 (retval << 1) | ((RTL_R8 (Cfg9346) & EE_DATA_READ) ? 1 :
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 0);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001167 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 eeprom_delay ();
1169 }
1170
1171 /* Terminate the EEPROM access. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001172 RTL_W8 (Cfg9346, ~EE_CS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 eeprom_delay ();
1174
1175 return retval;
1176}
1177
1178/* MII serial management: mostly bogus for now. */
1179/* Read and write the MII management registers using software-generated
1180 serial MDIO protocol.
1181 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
1182 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1183 "overclocking" issues. */
1184#define MDIO_DIR 0x80
1185#define MDIO_DATA_OUT 0x04
1186#define MDIO_DATA_IN 0x02
1187#define MDIO_CLK 0x01
1188#define MDIO_WRITE0 (MDIO_DIR)
1189#define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
1190
Pekka Enberg22f714b2005-05-12 19:38:47 -04001191#define mdio_delay() RTL_R8(Config4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193
Arjan van de Venf71e1302006-03-03 21:33:57 -05001194static const char mii_2_8139_map[8] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 BasicModeCtrl,
1196 BasicModeStatus,
1197 0,
1198 0,
1199 NWayAdvert,
1200 NWayLPAR,
1201 NWayExpansion,
1202 0
1203};
1204
1205
1206#ifdef CONFIG_8139TOO_8129
1207/* Syncronize the MII management interface by shifting 32 one bits out. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001208static void mdio_sync (void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209{
1210 int i;
1211
1212 for (i = 32; i >= 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001213 RTL_W8 (Config4, MDIO_WRITE1);
1214 mdio_delay ();
1215 RTL_W8 (Config4, MDIO_WRITE1 | MDIO_CLK);
1216 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 }
1218}
1219#endif
1220
1221static int mdio_read (struct net_device *dev, int phy_id, int location)
1222{
1223 struct rtl8139_private *tp = netdev_priv(dev);
1224 int retval = 0;
1225#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001226 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1228 int i;
1229#endif
1230
1231 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001232 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 return location < 8 && mii_2_8139_map[location] ?
Pekka Enberg22f714b2005-05-12 19:38:47 -04001234 RTL_R16 (mii_2_8139_map[location]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 }
1236
1237#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001238 mdio_sync (ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 /* Shift the read command bits out. */
1240 for (i = 15; i >= 0; i--) {
1241 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1242
Pekka Enberg22f714b2005-05-12 19:38:47 -04001243 RTL_W8 (Config4, MDIO_DIR | dataval);
1244 mdio_delay ();
1245 RTL_W8 (Config4, MDIO_DIR | dataval | MDIO_CLK);
1246 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 }
1248
1249 /* Read the two transition, 16 data, and wire-idle bits. */
1250 for (i = 19; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001251 RTL_W8 (Config4, 0);
1252 mdio_delay ();
1253 retval = (retval << 1) | ((RTL_R8 (Config4) & MDIO_DATA_IN) ? 1 : 0);
1254 RTL_W8 (Config4, MDIO_CLK);
1255 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 }
1257#endif
1258
1259 return (retval >> 1) & 0xffff;
1260}
1261
1262
1263static void mdio_write (struct net_device *dev, int phy_id, int location,
1264 int value)
1265{
1266 struct rtl8139_private *tp = netdev_priv(dev);
1267#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001268 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1270 int i;
1271#endif
1272
1273 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001274 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 if (location == 0) {
1276 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1277 RTL_W16 (BasicModeCtrl, value);
1278 RTL_W8 (Cfg9346, Cfg9346_Lock);
1279 } else if (location < 8 && mii_2_8139_map[location])
1280 RTL_W16 (mii_2_8139_map[location], value);
1281 return;
1282 }
1283
1284#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001285 mdio_sync (ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
1287 /* Shift the command bits out. */
1288 for (i = 31; i >= 0; i--) {
1289 int dataval =
1290 (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001291 RTL_W8 (Config4, dataval);
1292 mdio_delay ();
1293 RTL_W8 (Config4, dataval | MDIO_CLK);
1294 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 }
1296 /* Clear out extra bits. */
1297 for (i = 2; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001298 RTL_W8 (Config4, 0);
1299 mdio_delay ();
1300 RTL_W8 (Config4, MDIO_CLK);
1301 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
1303#endif
1304}
1305
1306
1307static int rtl8139_open (struct net_device *dev)
1308{
1309 struct rtl8139_private *tp = netdev_priv(dev);
1310 int retval;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001311 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001313 retval = request_irq (dev->irq, rtl8139_interrupt, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 if (retval)
1315 return retval;
1316
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001317 tp->tx_bufs = dma_alloc_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
1318 &tp->tx_bufs_dma, GFP_KERNEL);
1319 tp->rx_ring = dma_alloc_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
1320 &tp->rx_ring_dma, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1322 free_irq(dev->irq, dev);
1323
1324 if (tp->tx_bufs)
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001325 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 tp->tx_bufs, tp->tx_bufs_dma);
1327 if (tp->rx_ring)
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001328 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 tp->rx_ring, tp->rx_ring_dma);
1330
1331 return -ENOMEM;
1332
1333 }
1334
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001335 napi_enable(&tp->napi);
1336
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 tp->mii.full_duplex = tp->mii.force_media;
1338 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1339
1340 rtl8139_init_ring (dev);
1341 rtl8139_hw_start (dev);
1342 netif_start_queue (dev);
1343
1344 if (netif_msg_ifup(tp))
Greg Kroah-Hartman7c7459d2006-06-12 15:13:08 -07001345 printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#llx IRQ %d"
1346 " GP Pins %2.2x %s-duplex.\n", dev->name,
1347 (unsigned long long)pci_resource_start (tp->pci_dev, 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 dev->irq, RTL_R8 (MediaStatus),
1349 tp->mii.full_duplex ? "full" : "half");
1350
Jeff Garzika15e0382005-10-31 07:59:37 -05001351 rtl8139_start_thread(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352
1353 return 0;
1354}
1355
1356
1357static void rtl_check_media (struct net_device *dev, unsigned int init_media)
1358{
1359 struct rtl8139_private *tp = netdev_priv(dev);
1360
1361 if (tp->phys[0] >= 0) {
1362 mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
1363 }
1364}
1365
1366/* Start the hardware at open or resume. */
1367static void rtl8139_hw_start (struct net_device *dev)
1368{
1369 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001370 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 u32 i;
1372 u8 tmp;
1373
1374 /* Bring old chips out of low-power mode. */
1375 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1376 RTL_W8 (HltClk, 'R');
1377
1378 rtl8139_chip_reset (ioaddr);
1379
1380 /* unlock Config[01234] and BMCR register writes */
1381 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1382 /* Restore our idea of the MAC address. */
Al Viroeca1ad82008-03-16 22:21:54 +00001383 RTL_W32_F (MAC0 + 0, le32_to_cpu (*(__le32 *) (dev->dev_addr + 0)));
1384 RTL_W32_F (MAC0 + 4, le16_to_cpu (*(__le16 *) (dev->dev_addr + 4)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385
1386 /* Must enable Tx/Rx before setting transfer thresholds! */
1387 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1388
1389 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1390 RTL_W32 (RxConfig, tp->rx_config);
1391 RTL_W32 (TxConfig, rtl8139_tx_config);
1392
1393 tp->cur_rx = 0;
1394
1395 rtl_check_media (dev, 1);
1396
1397 if (tp->chipset >= CH_8139B) {
1398 /* Disable magic packet scanning, which is enabled
1399 * when PM is enabled in Config1. It can be reenabled
1400 * via ETHTOOL_SWOL if desired. */
1401 RTL_W8 (Config3, RTL_R8 (Config3) & ~Cfg3_Magic);
1402 }
1403
1404 DPRINTK("init buffer addresses\n");
1405
1406 /* Lock Config[01234] and BMCR register writes */
1407 RTL_W8 (Cfg9346, Cfg9346_Lock);
1408
1409 /* init Rx ring buffer DMA address */
1410 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1411
1412 /* init Tx buffer DMA addresses */
1413 for (i = 0; i < NUM_TX_DESC; i++)
1414 RTL_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1415
1416 RTL_W32 (RxMissed, 0);
1417
1418 rtl8139_set_rx_mode (dev);
1419
1420 /* no early-rx interrupts */
1421 RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
1422
1423 /* make sure RxTx has started */
1424 tmp = RTL_R8 (ChipCmd);
1425 if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
1426 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1427
1428 /* Enable all known interrupts by setting the interrupt mask. */
1429 RTL_W16 (IntrMask, rtl8139_intr_mask);
1430}
1431
1432
1433/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1434static void rtl8139_init_ring (struct net_device *dev)
1435{
1436 struct rtl8139_private *tp = netdev_priv(dev);
1437 int i;
1438
1439 tp->cur_rx = 0;
1440 tp->cur_tx = 0;
1441 tp->dirty_tx = 0;
1442
1443 for (i = 0; i < NUM_TX_DESC; i++)
1444 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1445}
1446
1447
1448/* This must be global for CONFIG_8139TOO_TUNE_TWISTER case */
1449static int next_tick = 3 * HZ;
1450
1451#ifndef CONFIG_8139TOO_TUNE_TWISTER
1452static inline void rtl8139_tune_twister (struct net_device *dev,
1453 struct rtl8139_private *tp) {}
1454#else
1455enum TwisterParamVals {
1456 PARA78_default = 0x78fa8388,
1457 PARA7c_default = 0xcb38de43, /* param[0][3] */
1458 PARA7c_xxx = 0xcb38de43,
1459};
1460
1461static const unsigned long param[4][4] = {
1462 {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
1463 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1464 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1465 {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
1466};
1467
1468static void rtl8139_tune_twister (struct net_device *dev,
1469 struct rtl8139_private *tp)
1470{
1471 int linkcase;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001472 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473
1474 /* This is a complicated state machine to configure the "twister" for
1475 impedance/echos based on the cable length.
1476 All of this is magic and undocumented.
1477 */
1478 switch (tp->twistie) {
1479 case 1:
1480 if (RTL_R16 (CSCR) & CSCR_LinkOKBit) {
1481 /* We have link beat, let us tune the twister. */
1482 RTL_W16 (CSCR, CSCR_LinkDownOffCmd);
1483 tp->twistie = 2; /* Change to state 2. */
1484 next_tick = HZ / 10;
1485 } else {
1486 /* Just put in some reasonable defaults for when beat returns. */
1487 RTL_W16 (CSCR, CSCR_LinkDownCmd);
1488 RTL_W32 (FIFOTMS, 0x20); /* Turn on cable test mode. */
1489 RTL_W32 (PARA78, PARA78_default);
1490 RTL_W32 (PARA7c, PARA7c_default);
1491 tp->twistie = 0; /* Bail from future actions. */
1492 }
1493 break;
1494 case 2:
1495 /* Read how long it took to hear the echo. */
1496 linkcase = RTL_R16 (CSCR) & CSCR_LinkStatusBits;
1497 if (linkcase == 0x7000)
1498 tp->twist_row = 3;
1499 else if (linkcase == 0x3000)
1500 tp->twist_row = 2;
1501 else if (linkcase == 0x1000)
1502 tp->twist_row = 1;
1503 else
1504 tp->twist_row = 0;
1505 tp->twist_col = 0;
1506 tp->twistie = 3; /* Change to state 2. */
1507 next_tick = HZ / 10;
1508 break;
1509 case 3:
1510 /* Put out four tuning parameters, one per 100msec. */
1511 if (tp->twist_col == 0)
1512 RTL_W16 (FIFOTMS, 0);
1513 RTL_W32 (PARA7c, param[(int) tp->twist_row]
1514 [(int) tp->twist_col]);
1515 next_tick = HZ / 10;
1516 if (++tp->twist_col >= 4) {
1517 /* For short cables we are done.
1518 For long cables (row == 3) check for mistune. */
1519 tp->twistie =
1520 (tp->twist_row == 3) ? 4 : 0;
1521 }
1522 break;
1523 case 4:
1524 /* Special case for long cables: check for mistune. */
1525 if ((RTL_R16 (CSCR) &
1526 CSCR_LinkStatusBits) == 0x7000) {
1527 tp->twistie = 0;
1528 break;
1529 } else {
1530 RTL_W32 (PARA7c, 0xfb38de03);
1531 tp->twistie = 5;
1532 next_tick = HZ / 10;
1533 }
1534 break;
1535 case 5:
1536 /* Retune for shorter cable (column 2). */
1537 RTL_W32 (FIFOTMS, 0x20);
1538 RTL_W32 (PARA78, PARA78_default);
1539 RTL_W32 (PARA7c, PARA7c_default);
1540 RTL_W32 (FIFOTMS, 0x00);
1541 tp->twist_row = 2;
1542 tp->twist_col = 0;
1543 tp->twistie = 3;
1544 next_tick = HZ / 10;
1545 break;
1546
1547 default:
1548 /* do nothing */
1549 break;
1550 }
1551}
1552#endif /* CONFIG_8139TOO_TUNE_TWISTER */
1553
1554static inline void rtl8139_thread_iter (struct net_device *dev,
1555 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001556 void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557{
1558 int mii_lpa;
1559
1560 mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1561
1562 if (!tp->mii.force_media && mii_lpa != 0xffff) {
1563 int duplex = (mii_lpa & LPA_100FULL)
1564 || (mii_lpa & 0x01C0) == 0x0040;
1565 if (tp->mii.full_duplex != duplex) {
1566 tp->mii.full_duplex = duplex;
1567
1568 if (mii_lpa) {
1569 printk (KERN_INFO
1570 "%s: Setting %s-duplex based on MII #%d link"
1571 " partner ability of %4.4x.\n",
1572 dev->name,
1573 tp->mii.full_duplex ? "full" : "half",
1574 tp->phys[0], mii_lpa);
1575 } else {
1576 printk(KERN_INFO"%s: media is unconnected, link down, or incompatible connection\n",
1577 dev->name);
1578 }
1579#if 0
1580 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1581 RTL_W8 (Config1, tp->mii.full_duplex ? 0x60 : 0x20);
1582 RTL_W8 (Cfg9346, Cfg9346_Lock);
1583#endif
1584 }
1585 }
1586
1587 next_tick = HZ * 60;
1588
1589 rtl8139_tune_twister (dev, tp);
1590
1591 DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1592 dev->name, RTL_R16 (NWayLPAR));
1593 DPRINTK ("%s: Other registers are IntMask %4.4x IntStatus %4.4x\n",
1594 dev->name, RTL_R16 (IntrMask), RTL_R16 (IntrStatus));
1595 DPRINTK ("%s: Chip config %2.2x %2.2x.\n",
1596 dev->name, RTL_R8 (Config0),
1597 RTL_R8 (Config1));
1598}
1599
David Howellsc4028952006-11-22 14:57:56 +00001600static void rtl8139_thread (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601{
David Howellsc4028952006-11-22 14:57:56 +00001602 struct rtl8139_private *tp =
1603 container_of(work, struct rtl8139_private, thread.work);
1604 struct net_device *dev = tp->mii.dev;
Francois Romieu371e8bc2006-01-31 01:04:33 +01001605 unsigned long thr_delay = next_tick;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001607 rtnl_lock();
1608
1609 if (!netif_running(dev))
1610 goto out_unlock;
1611
Francois Romieu371e8bc2006-01-31 01:04:33 +01001612 if (tp->watchdog_fired) {
1613 tp->watchdog_fired = 0;
David Howellsc4028952006-11-22 14:57:56 +00001614 rtl8139_tx_timeout_task(work);
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001615 } else
1616 rtl8139_thread_iter(dev, tp, tp->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001618 if (tp->have_thread)
1619 schedule_delayed_work(&tp->thread, thr_delay);
1620out_unlock:
1621 rtnl_unlock ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622}
1623
Jeff Garzika15e0382005-10-31 07:59:37 -05001624static void rtl8139_start_thread(struct rtl8139_private *tp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 tp->twistie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 if (tp->chipset == CH_8139_K)
1628 tp->twistie = 1;
1629 else if (tp->drv_flags & HAS_LNK_CHNG)
1630 return;
1631
Jeff Garzik38b492a2005-11-04 22:36:28 -05001632 tp->have_thread = 1;
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001633 tp->watchdog_fired = 0;
Jeff Garzika15e0382005-10-31 07:59:37 -05001634
1635 schedule_delayed_work(&tp->thread, next_tick);
1636}
1637
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
1639{
1640 tp->cur_tx = 0;
1641 tp->dirty_tx = 0;
1642
1643 /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
1644}
1645
David Howellsc4028952006-11-22 14:57:56 +00001646static void rtl8139_tx_timeout_task (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
David Howellsc4028952006-11-22 14:57:56 +00001648 struct rtl8139_private *tp =
1649 container_of(work, struct rtl8139_private, thread.work);
1650 struct net_device *dev = tp->mii.dev;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001651 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 int i;
1653 u8 tmp8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
1655 printk (KERN_DEBUG "%s: Transmit timeout, status %2.2x %4.4x %4.4x "
1656 "media %2.2x.\n", dev->name, RTL_R8 (ChipCmd),
1657 RTL_R16(IntrStatus), RTL_R16(IntrMask), RTL_R8(MediaStatus));
1658 /* Emit info to figure out what went wrong. */
1659 printk (KERN_DEBUG "%s: Tx queue start entry %ld dirty entry %ld.\n",
1660 dev->name, tp->cur_tx, tp->dirty_tx);
1661 for (i = 0; i < NUM_TX_DESC; i++)
1662 printk (KERN_DEBUG "%s: Tx descriptor %d is %8.8lx.%s\n",
1663 dev->name, i, RTL_R32 (TxStatus0 + (i * 4)),
1664 i == tp->dirty_tx % NUM_TX_DESC ?
1665 " (queue head)" : "");
1666
1667 tp->xstats.tx_timeouts++;
1668
1669 /* disable Tx ASAP, if not already */
1670 tmp8 = RTL_R8 (ChipCmd);
1671 if (tmp8 & CmdTxEnb)
1672 RTL_W8 (ChipCmd, CmdRxEnb);
1673
Francois Romieu371e8bc2006-01-31 01:04:33 +01001674 spin_lock_bh(&tp->rx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 /* Disable interrupts by clearing the interrupt mask. */
1676 RTL_W16 (IntrMask, 0x0000);
1677
1678 /* Stop a shared interrupt from scavenging while we are. */
Francois Romieu371e8bc2006-01-31 01:04:33 +01001679 spin_lock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 rtl8139_tx_clear (tp);
Francois Romieu371e8bc2006-01-31 01:04:33 +01001681 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
1683 /* ...and finally, reset everything */
1684 if (netif_running(dev)) {
1685 rtl8139_hw_start (dev);
1686 netif_wake_queue (dev);
1687 }
Francois Romieu371e8bc2006-01-31 01:04:33 +01001688 spin_unlock_bh(&tp->rx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689}
1690
Francois Romieu371e8bc2006-01-31 01:04:33 +01001691static void rtl8139_tx_timeout (struct net_device *dev)
1692{
1693 struct rtl8139_private *tp = netdev_priv(dev);
1694
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001695 tp->watchdog_fired = 1;
Francois Romieu371e8bc2006-01-31 01:04:33 +01001696 if (!tp->have_thread) {
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001697 INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
Francois Romieu371e8bc2006-01-31 01:04:33 +01001698 schedule_delayed_work(&tp->thread, next_tick);
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001699 }
Francois Romieu371e8bc2006-01-31 01:04:33 +01001700}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
1702static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
1703{
1704 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001705 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 unsigned int entry;
1707 unsigned int len = skb->len;
Arjan van de Venbce305f2006-07-05 15:00:40 +02001708 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
1710 /* Calculate the next Tx descriptor entry. */
1711 entry = tp->cur_tx % NUM_TX_DESC;
1712
1713 /* Note: the chip doesn't have auto-pad! */
1714 if (likely(len < TX_BUF_SIZE)) {
1715 if (len < ETH_ZLEN)
1716 memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1717 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1718 dev_kfree_skb(skb);
1719 } else {
1720 dev_kfree_skb(skb);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001721 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 return 0;
1723 }
1724
Arjan van de Venbce305f2006-07-05 15:00:40 +02001725 spin_lock_irqsave(&tp->lock, flags);
Andreas Oberritter176eaa52008-10-08 06:14:16 +00001726 /*
1727 * Writing to TxStatus triggers a DMA transfer of the data
1728 * copied to tp->tx_buf[entry] above. Use a memory barrier
1729 * to make sure that the device sees the updated data.
1730 */
1731 wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1733 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1734
1735 dev->trans_start = jiffies;
1736
1737 tp->cur_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
1739 if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1740 netif_stop_queue (dev);
Arjan van de Venbce305f2006-07-05 15:00:40 +02001741 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742
1743 if (netif_msg_tx_queued(tp))
1744 printk (KERN_DEBUG "%s: Queued Tx packet size %u to slot %d.\n",
1745 dev->name, len, entry);
1746
1747 return 0;
1748}
1749
1750
1751static void rtl8139_tx_interrupt (struct net_device *dev,
1752 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001753 void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754{
1755 unsigned long dirty_tx, tx_left;
1756
1757 assert (dev != NULL);
1758 assert (ioaddr != NULL);
1759
1760 dirty_tx = tp->dirty_tx;
1761 tx_left = tp->cur_tx - dirty_tx;
1762 while (tx_left > 0) {
1763 int entry = dirty_tx % NUM_TX_DESC;
1764 int txstatus;
1765
1766 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1767
1768 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1769 break; /* It still hasn't been Txed */
1770
1771 /* Note: TxCarrierLost is always asserted at 100mbps. */
1772 if (txstatus & (TxOutOfWindow | TxAborted)) {
1773 /* There was an major error, log it. */
1774 if (netif_msg_tx_err(tp))
1775 printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
1776 dev->name, txstatus);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001777 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 if (txstatus & TxAborted) {
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001779 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 RTL_W32 (TxConfig, TxClearAbt);
1781 RTL_W16 (IntrStatus, TxErr);
1782 wmb();
1783 }
1784 if (txstatus & TxCarrierLost)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001785 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 if (txstatus & TxOutOfWindow)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001787 dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 } else {
1789 if (txstatus & TxUnderrun) {
1790 /* Add 64 to the Tx FIFO threshold. */
1791 if (tp->tx_flag < 0x00300000)
1792 tp->tx_flag += 0x00020000;
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001793 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 }
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001795 dev->stats.collisions += (txstatus >> 24) & 15;
1796 dev->stats.tx_bytes += txstatus & 0x7ff;
1797 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 }
1799
1800 dirty_tx++;
1801 tx_left--;
1802 }
1803
1804#ifndef RTL8139_NDEBUG
1805 if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
1806 printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
1807 dev->name, dirty_tx, tp->cur_tx);
1808 dirty_tx += NUM_TX_DESC;
1809 }
1810#endif /* RTL8139_NDEBUG */
1811
1812 /* only wake the queue if we did work, and the queue is stopped */
1813 if (tp->dirty_tx != dirty_tx) {
1814 tp->dirty_tx = dirty_tx;
1815 mb();
1816 netif_wake_queue (dev);
1817 }
1818}
1819
1820
1821/* TODO: clean this up! Rx reset need not be this intensive */
1822static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001823 struct rtl8139_private *tp, void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824{
1825 u8 tmp8;
1826#ifdef CONFIG_8139_OLD_RX_RESET
1827 int tmp_work;
1828#endif
1829
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001830 if (netif_msg_rx_err (tp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 printk(KERN_DEBUG "%s: Ethernet frame had errors, status %8.8x.\n",
1832 dev->name, rx_status);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001833 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 if (!(rx_status & RxStatusOK)) {
1835 if (rx_status & RxTooLong) {
1836 DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1837 dev->name, rx_status);
1838 /* A.C.: The chip hangs here. */
1839 }
1840 if (rx_status & (RxBadSymbol | RxBadAlign))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001841 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 if (rx_status & (RxRunt | RxTooLong))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001843 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 if (rx_status & RxCRCErr)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001845 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 } else {
1847 tp->xstats.rx_lost_in_ring++;
1848 }
1849
1850#ifndef CONFIG_8139_OLD_RX_RESET
1851 tmp8 = RTL_R8 (ChipCmd);
1852 RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1853 RTL_W8 (ChipCmd, tmp8);
1854 RTL_W32 (RxConfig, tp->rx_config);
1855 tp->cur_rx = 0;
1856#else
1857 /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1858
1859 /* disable receive */
1860 RTL_W8_F (ChipCmd, CmdTxEnb);
1861 tmp_work = 200;
1862 while (--tmp_work > 0) {
1863 udelay(1);
1864 tmp8 = RTL_R8 (ChipCmd);
1865 if (!(tmp8 & CmdRxEnb))
1866 break;
1867 }
1868 if (tmp_work <= 0)
1869 printk (KERN_WARNING PFX "rx stop wait too long\n");
1870 /* restart receive */
1871 tmp_work = 200;
1872 while (--tmp_work > 0) {
1873 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1874 udelay(1);
1875 tmp8 = RTL_R8 (ChipCmd);
1876 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1877 break;
1878 }
1879 if (tmp_work <= 0)
1880 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1881
1882 /* and reinitialize all rx related registers */
1883 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1884 /* Must enable Tx/Rx before setting transfer thresholds! */
1885 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1886
1887 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1888 RTL_W32 (RxConfig, tp->rx_config);
1889 tp->cur_rx = 0;
1890
1891 DPRINTK("init buffer addresses\n");
1892
1893 /* Lock Config[01234] and BMCR register writes */
1894 RTL_W8 (Cfg9346, Cfg9346_Lock);
1895
1896 /* init Rx ring buffer DMA address */
1897 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1898
1899 /* A.C.: Reset the multicast list. */
1900 __set_rx_mode (dev);
1901#endif
1902}
1903
1904#if RX_BUF_IDX == 3
Márton Németha9879c42008-06-15 09:52:30 +02001905static inline void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 u32 offset, unsigned int size)
1907{
1908 u32 left = RX_BUF_LEN - offset;
1909
1910 if (size > left) {
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001911 skb_copy_to_linear_data(skb, ring + offset, left);
1912 skb_copy_to_linear_data_offset(skb, left, ring, size - left);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 } else
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001914 skb_copy_to_linear_data(skb, ring + offset, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915}
1916#endif
1917
1918static void rtl8139_isr_ack(struct rtl8139_private *tp)
1919{
Pekka Enberg22f714b2005-05-12 19:38:47 -04001920 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 u16 status;
1922
1923 status = RTL_R16 (IntrStatus) & RxAckBits;
1924
1925 /* Clear out errors and receive interrupts */
1926 if (likely(status != 0)) {
1927 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001928 tp->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 if (status & RxFIFOOver)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001930 tp->dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 }
1932 RTL_W16_F (IntrStatus, RxAckBits);
1933 }
1934}
1935
1936static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1937 int budget)
1938{
Pekka Enberg22f714b2005-05-12 19:38:47 -04001939 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 int received = 0;
1941 unsigned char *rx_ring = tp->rx_ring;
1942 unsigned int cur_rx = tp->cur_rx;
1943 unsigned int rx_size = 0;
1944
1945 DPRINTK ("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x,"
1946 " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx,
1947 RTL_R16 (RxBufAddr),
1948 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
1949
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001950 while (netif_running(dev) && received < budget
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
1952 u32 ring_offset = cur_rx % RX_BUF_LEN;
1953 u32 rx_status;
1954 unsigned int pkt_size;
1955 struct sk_buff *skb;
1956
1957 rmb();
1958
1959 /* read size+status of next frame from DMA ring buffer */
Al Viroeca1ad82008-03-16 22:21:54 +00001960 rx_status = le32_to_cpu (*(__le32 *) (rx_ring + ring_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 rx_size = rx_status >> 16;
1962 pkt_size = rx_size - 4;
1963
1964 if (netif_msg_rx_status(tp))
1965 printk(KERN_DEBUG "%s: rtl8139_rx() status %4.4x, size %4.4x,"
1966 " cur %4.4x.\n", dev->name, rx_status,
1967 rx_size, cur_rx);
1968#if RTL8139_DEBUG > 2
1969 {
1970 int i;
1971 DPRINTK ("%s: Frame contents ", dev->name);
1972 for (i = 0; i < 70; i++)
1973 printk (" %2.2x",
1974 rx_ring[ring_offset + i]);
1975 printk (".\n");
1976 }
1977#endif
1978
1979 /* Packet copy from FIFO still in progress.
1980 * Theoretically, this should never happen
1981 * since EarlyRx is disabled.
1982 */
1983 if (unlikely(rx_size == 0xfff0)) {
1984 if (!tp->fifo_copy_timeout)
1985 tp->fifo_copy_timeout = jiffies + 2;
1986 else if (time_after(jiffies, tp->fifo_copy_timeout)) {
1987 DPRINTK ("%s: hung FIFO. Reset.", dev->name);
1988 rx_size = 0;
1989 goto no_early_rx;
1990 }
1991 if (netif_msg_intr(tp)) {
1992 printk(KERN_DEBUG "%s: fifo copy in progress.",
1993 dev->name);
1994 }
1995 tp->xstats.early_rx++;
1996 break;
1997 }
1998
1999no_early_rx:
2000 tp->fifo_copy_timeout = 0;
2001
2002 /* If Rx err or invalid rx_size/rx_status received
2003 * (which happens if we get lost in the ring),
2004 * Rx process gets reset, so we abort any further
2005 * Rx processing.
2006 */
2007 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
2008 (rx_size < 8) ||
2009 (!(rx_status & RxStatusOK)))) {
2010 rtl8139_rx_err (rx_status, dev, tp, ioaddr);
2011 received = -1;
2012 goto out;
2013 }
2014
2015 /* Malloc up new buffer, compatible with net-2e. */
2016 /* Omit the four octet CRC from the length. */
2017
Kevin Lo1c460af2008-08-27 11:35:13 +08002018 skb = netdev_alloc_skb(dev, pkt_size + NET_IP_ALIGN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 if (likely(skb)) {
Kevin Lo1c460af2008-08-27 11:35:13 +08002020 skb_reserve (skb, NET_IP_ALIGN); /* 16 byte align the IP fields. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021#if RX_BUF_IDX == 3
2022 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
2023#else
David S. Miller8c7b7fa2007-07-10 22:08:12 -07002024 skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025#endif
2026 skb_put (skb, pkt_size);
2027
2028 skb->protocol = eth_type_trans (skb, dev);
2029
2030 dev->last_rx = jiffies;
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002031 dev->stats.rx_bytes += pkt_size;
2032 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
2034 netif_receive_skb (skb);
2035 } else {
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002036 if (net_ratelimit())
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 printk (KERN_WARNING
2038 "%s: Memory squeeze, dropping packet.\n",
2039 dev->name);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002040 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 }
2042 received++;
2043
2044 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2045 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2046
2047 rtl8139_isr_ack(tp);
2048 }
2049
2050 if (unlikely(!received || rx_size == 0xfff0))
2051 rtl8139_isr_ack(tp);
2052
2053#if RTL8139_DEBUG > 1
2054 DPRINTK ("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x,"
2055 " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
2056 RTL_R16 (RxBufAddr),
2057 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
2058#endif
2059
2060 tp->cur_rx = cur_rx;
2061
2062 /*
2063 * The receive buffer should be mostly empty.
2064 * Tell NAPI to reenable the Rx irq.
2065 */
2066 if (tp->fifo_copy_timeout)
2067 received = budget;
2068
2069out:
2070 return received;
2071}
2072
2073
2074static void rtl8139_weird_interrupt (struct net_device *dev,
2075 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04002076 void __iomem *ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 int status, int link_changed)
2078{
2079 DPRINTK ("%s: Abnormal interrupt, status %8.8x.\n",
2080 dev->name, status);
2081
2082 assert (dev != NULL);
2083 assert (tp != NULL);
2084 assert (ioaddr != NULL);
2085
2086 /* Update the error count. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002087 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 RTL_W32 (RxMissed, 0);
2089
2090 if ((status & RxUnderrun) && link_changed &&
2091 (tp->drv_flags & HAS_LNK_CHNG)) {
2092 rtl_check_media(dev, 0);
2093 status &= ~RxUnderrun;
2094 }
2095
2096 if (status & (RxUnderrun | RxErr))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002097 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098
2099 if (status & PCSTimeout)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002100 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 if (status & RxUnderrun)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002102 dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 if (status & PCIErr) {
2104 u16 pci_cmd_status;
2105 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2106 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2107
2108 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
2109 dev->name, pci_cmd_status);
2110 }
2111}
2112
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002113static int rtl8139_poll(struct napi_struct *napi, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002115 struct rtl8139_private *tp = container_of(napi, struct rtl8139_private, napi);
2116 struct net_device *dev = tp->dev;
Pekka Enberg22f714b2005-05-12 19:38:47 -04002117 void __iomem *ioaddr = tp->mmio_addr;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002118 int work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
2120 spin_lock(&tp->rx_lock);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002121 work_done = 0;
2122 if (likely(RTL_R16(IntrStatus) & RxAckBits))
2123 work_done += rtl8139_rx(dev, tp, budget);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002125 if (work_done < budget) {
Ingo Molnarb57bd062006-12-12 13:49:35 +01002126 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 /*
2128 * Order is important since data can get interrupted
2129 * again when we think we are done.
2130 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002131 spin_lock_irqsave(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 RTL_W16_F(IntrMask, rtl8139_intr_mask);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002133 __netif_rx_complete(dev, napi);
2134 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 }
2136 spin_unlock(&tp->rx_lock);
2137
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002138 return work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139}
2140
2141/* The interrupt handler does all of the Rx thread work and cleans up
2142 after the Tx thread. */
David Howells7d12e782006-10-05 14:55:46 +01002143static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144{
2145 struct net_device *dev = (struct net_device *) dev_instance;
2146 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002147 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 u16 status, ackstat;
2149 int link_changed = 0; /* avoid bogus "uninit" warning */
2150 int handled = 0;
2151
2152 spin_lock (&tp->lock);
2153 status = RTL_R16 (IntrStatus);
2154
2155 /* shared irq? */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002156 if (unlikely((status & rtl8139_intr_mask) == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 goto out;
2158
2159 handled = 1;
2160
2161 /* h/w no longer present (hotplug?) or major error, bail */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002162 if (unlikely(status == 0xFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 goto out;
2164
2165 /* close possible race's with dev_close */
2166 if (unlikely(!netif_running(dev))) {
2167 RTL_W16 (IntrMask, 0);
2168 goto out;
2169 }
2170
2171 /* Acknowledge all of the current interrupt sources ASAP, but
2172 an first get an additional status bit from CSCR. */
2173 if (unlikely(status & RxUnderrun))
2174 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2175
2176 ackstat = status & ~(RxAckBits | TxErr);
2177 if (ackstat)
2178 RTL_W16 (IntrStatus, ackstat);
2179
2180 /* Receive packets are processed by poll routine.
2181 If not running start it now. */
2182 if (status & RxAckBits){
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002183 if (netif_rx_schedule_prep(dev, &tp->napi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002185 __netif_rx_schedule(dev, &tp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 }
2187 }
2188
2189 /* Check uncommon events with one test. */
2190 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2191 rtl8139_weird_interrupt (dev, tp, ioaddr,
2192 status, link_changed);
2193
2194 if (status & (TxOK | TxErr)) {
2195 rtl8139_tx_interrupt (dev, tp, ioaddr);
2196 if (status & TxErr)
2197 RTL_W16 (IntrStatus, TxErr);
2198 }
2199 out:
2200 spin_unlock (&tp->lock);
2201
2202 DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
2203 dev->name, RTL_R16 (IntrStatus));
2204 return IRQ_RETVAL(handled);
2205}
2206
2207#ifdef CONFIG_NET_POLL_CONTROLLER
2208/*
2209 * Polling receive - used by netconsole and other diagnostic tools
2210 * to allow network i/o with interrupts disabled.
2211 */
2212static void rtl8139_poll_controller(struct net_device *dev)
2213{
2214 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +01002215 rtl8139_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 enable_irq(dev->irq);
2217}
2218#endif
2219
2220static int rtl8139_close (struct net_device *dev)
2221{
2222 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002223 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 unsigned long flags;
2225
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002226 netif_stop_queue(dev);
2227 napi_disable(&tp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 if (netif_msg_ifdown(tp))
2230 printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n",
2231 dev->name, RTL_R16 (IntrStatus));
2232
2233 spin_lock_irqsave (&tp->lock, flags);
2234
2235 /* Stop the chip's Tx and Rx DMA processes. */
2236 RTL_W8 (ChipCmd, 0);
2237
2238 /* Disable interrupts by clearing the interrupt mask. */
2239 RTL_W16 (IntrMask, 0);
2240
2241 /* Update the error counts. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002242 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 RTL_W32 (RxMissed, 0);
2244
2245 spin_unlock_irqrestore (&tp->lock, flags);
2246
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 free_irq (dev->irq, dev);
2248
2249 rtl8139_tx_clear (tp);
2250
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04002251 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
2252 tp->rx_ring, tp->rx_ring_dma);
2253 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
2254 tp->tx_bufs, tp->tx_bufs_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 tp->rx_ring = NULL;
2256 tp->tx_bufs = NULL;
2257
2258 /* Green! Put the chip in low-power mode. */
2259 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2260
2261 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2262 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
2263
2264 return 0;
2265}
2266
2267
2268/* Get the ethtool Wake-on-LAN settings. Assumes that wol points to
2269 kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2270 other threads or interrupts aren't messing with the 8139. */
2271static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2272{
2273 struct rtl8139_private *np = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002274 void __iomem *ioaddr = np->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
2276 spin_lock_irq(&np->lock);
2277 if (rtl_chip_info[np->chipset].flags & HasLWake) {
2278 u8 cfg3 = RTL_R8 (Config3);
2279 u8 cfg5 = RTL_R8 (Config5);
2280
2281 wol->supported = WAKE_PHY | WAKE_MAGIC
2282 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2283
2284 wol->wolopts = 0;
2285 if (cfg3 & Cfg3_LinkUp)
2286 wol->wolopts |= WAKE_PHY;
2287 if (cfg3 & Cfg3_Magic)
2288 wol->wolopts |= WAKE_MAGIC;
2289 /* (KON)FIXME: See how netdev_set_wol() handles the
2290 following constants. */
2291 if (cfg5 & Cfg5_UWF)
2292 wol->wolopts |= WAKE_UCAST;
2293 if (cfg5 & Cfg5_MWF)
2294 wol->wolopts |= WAKE_MCAST;
2295 if (cfg5 & Cfg5_BWF)
2296 wol->wolopts |= WAKE_BCAST;
2297 }
2298 spin_unlock_irq(&np->lock);
2299}
2300
2301
2302/* Set the ethtool Wake-on-LAN settings. Return 0 or -errno. Assumes
2303 that wol points to kernel memory and other threads or interrupts
2304 aren't messing with the 8139. */
2305static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2306{
2307 struct rtl8139_private *np = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002308 void __iomem *ioaddr = np->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 u32 support;
2310 u8 cfg3, cfg5;
2311
2312 support = ((rtl_chip_info[np->chipset].flags & HasLWake)
2313 ? (WAKE_PHY | WAKE_MAGIC
2314 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2315 : 0);
2316 if (wol->wolopts & ~support)
2317 return -EINVAL;
2318
2319 spin_lock_irq(&np->lock);
2320 cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2321 if (wol->wolopts & WAKE_PHY)
2322 cfg3 |= Cfg3_LinkUp;
2323 if (wol->wolopts & WAKE_MAGIC)
2324 cfg3 |= Cfg3_Magic;
2325 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2326 RTL_W8 (Config3, cfg3);
2327 RTL_W8 (Cfg9346, Cfg9346_Lock);
2328
2329 cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2330 /* (KON)FIXME: These are untested. We may have to set the
2331 CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2332 documentation. */
2333 if (wol->wolopts & WAKE_UCAST)
2334 cfg5 |= Cfg5_UWF;
2335 if (wol->wolopts & WAKE_MCAST)
2336 cfg5 |= Cfg5_MWF;
2337 if (wol->wolopts & WAKE_BCAST)
2338 cfg5 |= Cfg5_BWF;
2339 RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
2340 spin_unlock_irq(&np->lock);
2341
2342 return 0;
2343}
2344
2345static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2346{
2347 struct rtl8139_private *np = netdev_priv(dev);
2348 strcpy(info->driver, DRV_NAME);
2349 strcpy(info->version, DRV_VERSION);
2350 strcpy(info->bus_info, pci_name(np->pci_dev));
2351 info->regdump_len = np->regs_len;
2352}
2353
2354static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2355{
2356 struct rtl8139_private *np = netdev_priv(dev);
2357 spin_lock_irq(&np->lock);
2358 mii_ethtool_gset(&np->mii, cmd);
2359 spin_unlock_irq(&np->lock);
2360 return 0;
2361}
2362
2363static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2364{
2365 struct rtl8139_private *np = netdev_priv(dev);
2366 int rc;
2367 spin_lock_irq(&np->lock);
2368 rc = mii_ethtool_sset(&np->mii, cmd);
2369 spin_unlock_irq(&np->lock);
2370 return rc;
2371}
2372
2373static int rtl8139_nway_reset(struct net_device *dev)
2374{
2375 struct rtl8139_private *np = netdev_priv(dev);
2376 return mii_nway_restart(&np->mii);
2377}
2378
2379static u32 rtl8139_get_link(struct net_device *dev)
2380{
2381 struct rtl8139_private *np = netdev_priv(dev);
2382 return mii_link_ok(&np->mii);
2383}
2384
2385static u32 rtl8139_get_msglevel(struct net_device *dev)
2386{
2387 struct rtl8139_private *np = netdev_priv(dev);
2388 return np->msg_enable;
2389}
2390
2391static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2392{
2393 struct rtl8139_private *np = netdev_priv(dev);
2394 np->msg_enable = datum;
2395}
2396
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397static int rtl8139_get_regs_len(struct net_device *dev)
2398{
Dave Joneseb581342008-07-15 19:54:53 -04002399 struct rtl8139_private *np;
2400 /* TODO: we are too slack to do reg dumping for pio, for now */
2401 if (use_io)
2402 return 0;
2403 np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 return np->regs_len;
2405}
2406
2407static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2408{
Dave Joneseb581342008-07-15 19:54:53 -04002409 struct rtl8139_private *np;
2410
2411 /* TODO: we are too slack to do reg dumping for pio, for now */
2412 if (use_io)
2413 return;
2414 np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415
2416 regs->version = RTL_REGS_VER;
2417
2418 spin_lock_irq(&np->lock);
2419 memcpy_fromio(regbuf, np->mmio_addr, regs->len);
2420 spin_unlock_irq(&np->lock);
2421}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002423static int rtl8139_get_sset_count(struct net_device *dev, int sset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424{
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002425 switch (sset) {
2426 case ETH_SS_STATS:
2427 return RTL_NUM_STATS;
2428 default:
2429 return -EOPNOTSUPP;
2430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431}
2432
2433static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2434{
2435 struct rtl8139_private *np = netdev_priv(dev);
2436
2437 data[0] = np->xstats.early_rx;
2438 data[1] = np->xstats.tx_buf_mapped;
2439 data[2] = np->xstats.tx_timeouts;
2440 data[3] = np->xstats.rx_lost_in_ring;
2441}
2442
2443static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2444{
2445 memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2446}
2447
Jeff Garzik7282d492006-09-13 14:30:00 -04002448static const struct ethtool_ops rtl8139_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 .get_drvinfo = rtl8139_get_drvinfo,
2450 .get_settings = rtl8139_get_settings,
2451 .set_settings = rtl8139_set_settings,
2452 .get_regs_len = rtl8139_get_regs_len,
2453 .get_regs = rtl8139_get_regs,
2454 .nway_reset = rtl8139_nway_reset,
2455 .get_link = rtl8139_get_link,
2456 .get_msglevel = rtl8139_get_msglevel,
2457 .set_msglevel = rtl8139_set_msglevel,
2458 .get_wol = rtl8139_get_wol,
2459 .set_wol = rtl8139_set_wol,
2460 .get_strings = rtl8139_get_strings,
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002461 .get_sset_count = rtl8139_get_sset_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 .get_ethtool_stats = rtl8139_get_ethtool_stats,
2463};
2464
2465static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2466{
2467 struct rtl8139_private *np = netdev_priv(dev);
2468 int rc;
2469
2470 if (!netif_running(dev))
2471 return -EINVAL;
2472
2473 spin_lock_irq(&np->lock);
2474 rc = generic_mii_ioctl(&np->mii, if_mii(rq), cmd, NULL);
2475 spin_unlock_irq(&np->lock);
2476
2477 return rc;
2478}
2479
2480
2481static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2482{
2483 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002484 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 unsigned long flags;
2486
2487 if (netif_running(dev)) {
2488 spin_lock_irqsave (&tp->lock, flags);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002489 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 RTL_W32 (RxMissed, 0);
2491 spin_unlock_irqrestore (&tp->lock, flags);
2492 }
2493
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002494 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495}
2496
2497/* Set or clear the multicast filter for this adaptor.
2498 This routine is not state sensitive and need not be SMP locked. */
2499
2500static void __set_rx_mode (struct net_device *dev)
2501{
2502 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002503 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 u32 mc_filter[2]; /* Multicast hash filter */
2505 int i, rx_mode;
2506 u32 tmp;
2507
2508 DPRINTK ("%s: rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
2509 dev->name, dev->flags, RTL_R32 (RxConfig));
2510
2511 /* Note: do not reorder, GCC is clever about common statements. */
2512 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 rx_mode =
2514 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2515 AcceptAllPhys;
2516 mc_filter[1] = mc_filter[0] = 0xffffffff;
2517 } else if ((dev->mc_count > multicast_filter_limit)
2518 || (dev->flags & IFF_ALLMULTI)) {
2519 /* Too many to filter perfectly -- accept all multicasts. */
2520 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2521 mc_filter[1] = mc_filter[0] = 0xffffffff;
2522 } else {
2523 struct dev_mc_list *mclist;
2524 rx_mode = AcceptBroadcast | AcceptMyPhys;
2525 mc_filter[1] = mc_filter[0] = 0;
2526 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2527 i++, mclist = mclist->next) {
2528 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
2529
2530 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2531 rx_mode |= AcceptMulticast;
2532 }
2533 }
2534
2535 /* We can safely update without stopping the chip. */
2536 tmp = rtl8139_rx_config | rx_mode;
2537 if (tp->rx_config != tmp) {
2538 RTL_W32_F (RxConfig, tmp);
2539 tp->rx_config = tmp;
2540 }
2541 RTL_W32_F (MAR0 + 0, mc_filter[0]);
2542 RTL_W32_F (MAR0 + 4, mc_filter[1]);
2543}
2544
2545static void rtl8139_set_rx_mode (struct net_device *dev)
2546{
2547 unsigned long flags;
2548 struct rtl8139_private *tp = netdev_priv(dev);
2549
2550 spin_lock_irqsave (&tp->lock, flags);
2551 __set_rx_mode(dev);
2552 spin_unlock_irqrestore (&tp->lock, flags);
2553}
2554
2555#ifdef CONFIG_PM
2556
2557static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2558{
2559 struct net_device *dev = pci_get_drvdata (pdev);
2560 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002561 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 unsigned long flags;
2563
2564 pci_save_state (pdev);
2565
2566 if (!netif_running (dev))
2567 return 0;
2568
2569 netif_device_detach (dev);
2570
2571 spin_lock_irqsave (&tp->lock, flags);
2572
2573 /* Disable interrupts, stop Tx and Rx. */
2574 RTL_W16 (IntrMask, 0);
2575 RTL_W8 (ChipCmd, 0);
2576
2577 /* Update the error counts. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002578 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579 RTL_W32 (RxMissed, 0);
2580
2581 spin_unlock_irqrestore (&tp->lock, flags);
2582
2583 pci_set_power_state (pdev, PCI_D3hot);
2584
2585 return 0;
2586}
2587
2588
2589static int rtl8139_resume (struct pci_dev *pdev)
2590{
2591 struct net_device *dev = pci_get_drvdata (pdev);
2592
2593 pci_restore_state (pdev);
2594 if (!netif_running (dev))
2595 return 0;
2596 pci_set_power_state (pdev, PCI_D0);
2597 rtl8139_init_ring (dev);
2598 rtl8139_hw_start (dev);
2599 netif_device_attach (dev);
2600 return 0;
2601}
2602
2603#endif /* CONFIG_PM */
2604
2605
2606static struct pci_driver rtl8139_pci_driver = {
2607 .name = DRV_NAME,
2608 .id_table = rtl8139_pci_tbl,
2609 .probe = rtl8139_init_one,
2610 .remove = __devexit_p(rtl8139_remove_one),
2611#ifdef CONFIG_PM
2612 .suspend = rtl8139_suspend,
2613 .resume = rtl8139_resume,
2614#endif /* CONFIG_PM */
2615};
2616
2617
2618static int __init rtl8139_init_module (void)
2619{
2620 /* when we're a module, we always print a version message,
2621 * even if no 8139 board is found.
2622 */
2623#ifdef MODULE
2624 printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
2625#endif
2626
Jeff Garzik29917622006-08-19 17:48:59 -04002627 return pci_register_driver(&rtl8139_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628}
2629
2630
2631static void __exit rtl8139_cleanup_module (void)
2632{
2633 pci_unregister_driver (&rtl8139_pci_driver);
2634}
2635
2636
2637module_init(rtl8139_init_module);
2638module_exit(rtl8139_cleanup_module);