blob: 7e333f73b22853d40092bd7022b836d61483fdca [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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129#ifdef RTL8139_NDEBUG
130# define assert(expr) do {} while (0)
131#else
132# define assert(expr) \
133 if(unlikely(!(expr))) { \
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000134 pr_err("Assertion failed! %s,%s,%s,line=%d\n", \
Márton Németha9879c42008-06-15 09:52:30 +0200135 #expr, __FILE__, __func__, __LINE__); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137#endif
138
139
140/* A few user-configurable values. */
141/* media options */
142#define MAX_UNITS 8
143static int media[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
144static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
145
Dave Joneseb581342008-07-15 19:54:53 -0400146/* Whether to use MMIO or PIO. Default to MMIO. */
147#ifdef CONFIG_8139TOO_PIO
148static int use_io = 1;
149#else
150static int use_io = 0;
151#endif
152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
154 The RTL chips use a 64 element hash table based on the Ethernet CRC. */
155static int multicast_filter_limit = 32;
156
157/* bitmapped message enable number */
158static int debug = -1;
159
160/*
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400161 * Receive ring size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 * Warning: 64K ring has hardware issues and may lock up.
163 */
164#if defined(CONFIG_SH_DREAMCAST)
Adrian McMenamin2192f392008-02-08 11:21:58 +0000165#define RX_BUF_IDX 0 /* 8K ring */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166#else
167#define RX_BUF_IDX 2 /* 32K ring */
168#endif
169#define RX_BUF_LEN (8192 << RX_BUF_IDX)
170#define RX_BUF_PAD 16
171#define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
172
173#if RX_BUF_LEN == 65536
174#define RX_BUF_TOT_LEN RX_BUF_LEN
175#else
176#define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
177#endif
178
179/* Number of Tx descriptor registers. */
180#define NUM_TX_DESC 4
181
182/* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
183#define MAX_ETH_FRAME_SIZE 1536
184
185/* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
186#define TX_BUF_SIZE MAX_ETH_FRAME_SIZE
187#define TX_BUF_TOT_LEN (TX_BUF_SIZE * NUM_TX_DESC)
188
189/* PCI Tuning Parameters
190 Threshold is bytes transferred to chip before transmission starts. */
191#define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
192
193/* The following settings are log_2(bytes)-4: 0 == 16 bytes .. 6==1024, 7==end of packet. */
194#define RX_FIFO_THRESH 7 /* Rx buffer level before first PCI xfer. */
195#define RX_DMA_BURST 7 /* Maximum PCI burst, '6' is 1024 */
196#define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
197#define TX_RETRY 8 /* 0-15. retries = 16 + (TX_RETRY * 16) */
198
199/* Operational parameters that usually are not changed. */
200/* Time in jiffies before concluding the transmitter is hung. */
201#define TX_TIMEOUT (6*HZ)
202
203
204enum {
205 HAS_MII_XCVR = 0x010000,
206 HAS_CHIP_XCVR = 0x020000,
207 HAS_LNK_CHNG = 0x040000,
208};
209
210#define RTL_NUM_STATS 4 /* number of ETHTOOL_GSTATS u64's */
211#define RTL_REGS_VER 1 /* version of reg. data in ETHTOOL_GREGS */
212#define RTL_MIN_IO_SIZE 0x80
213#define RTL8139B_IO_SIZE 256
214
215#define RTL8129_CAPS HAS_MII_XCVR
Márton Németha9879c42008-06-15 09:52:30 +0200216#define RTL8139_CAPS (HAS_CHIP_XCVR|HAS_LNK_CHNG)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218typedef enum {
219 RTL8139 = 0,
220 RTL8129,
221} board_t;
222
223
224/* indexed by board_t, above */
Arjan van de Venf71e1302006-03-03 21:33:57 -0500225static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 const char *name;
227 u32 hw_flags;
228} board_info[] __devinitdata = {
229 { "RealTek RTL8139", RTL8139_CAPS },
230 { "RealTek RTL8129", RTL8129_CAPS },
231};
232
233
234static struct pci_device_id rtl8139_pci_tbl[] = {
235 {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
236 {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
237 {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
238 {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
239 {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
240 {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
241 {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
242 {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
243 {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
244 {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
245 {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
246 {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
247 {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
248 {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
249 {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
250 {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
251 {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
252 {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400253 {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255#ifdef CONFIG_SH_SECUREEDGE5410
256 /* Bogus 8139 silicon reports 8129 without external PROM :-( */
257 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
258#endif
259#ifdef CONFIG_8139TOO_8129
260 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
261#endif
262
263 /* some crazy cards report invalid vendor ids like
264 * 0x0001 here. The other ids are valid and constant,
265 * so we simply don't match on the main vendor id.
266 */
267 {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
268 {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
269 {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
270
271 {0,}
272};
273MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);
274
275static struct {
276 const char str[ETH_GSTRING_LEN];
277} ethtool_stats_keys[] = {
278 { "early_rx" },
279 { "tx_buf_mapped" },
280 { "tx_timeouts" },
281 { "rx_lost_in_ring" },
282};
283
284/* The rest of these values should never change. */
285
286/* Symbolic offsets to registers. */
287enum RTL8139_registers {
Jeff Garzik28006c62007-09-15 12:36:46 -0700288 MAC0 = 0, /* Ethernet hardware address. */
289 MAR0 = 8, /* Multicast filter. */
290 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
291 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
292 RxBuf = 0x30,
293 ChipCmd = 0x37,
294 RxBufPtr = 0x38,
295 RxBufAddr = 0x3A,
296 IntrMask = 0x3C,
297 IntrStatus = 0x3E,
298 TxConfig = 0x40,
299 RxConfig = 0x44,
300 Timer = 0x48, /* A general-purpose counter. */
301 RxMissed = 0x4C, /* 24 bits valid, write clears. */
302 Cfg9346 = 0x50,
303 Config0 = 0x51,
304 Config1 = 0x52,
Mats Erik Anderssonda8de392008-07-17 01:05:43 +0200305 TimerInt = 0x54,
Jeff Garzik28006c62007-09-15 12:36:46 -0700306 MediaStatus = 0x58,
307 Config3 = 0x59,
308 Config4 = 0x5A, /* absent on RTL-8139A */
309 HltClk = 0x5B,
310 MultiIntr = 0x5C,
311 TxSummary = 0x60,
312 BasicModeCtrl = 0x62,
313 BasicModeStatus = 0x64,
314 NWayAdvert = 0x66,
315 NWayLPAR = 0x68,
316 NWayExpansion = 0x6A,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 /* Undocumented registers, but required for proper operation. */
Jeff Garzik28006c62007-09-15 12:36:46 -0700318 FIFOTMS = 0x70, /* FIFO Control and test. */
319 CSCR = 0x74, /* Chip Status and Configuration Register. */
320 PARA78 = 0x78,
Mats Erik Anderssonda8de392008-07-17 01:05:43 +0200321 FlashReg = 0xD4, /* Communication with Flash ROM, four bytes. */
Jeff Garzik28006c62007-09-15 12:36:46 -0700322 PARA7c = 0x7c, /* Magic transceiver parameter register. */
323 Config5 = 0xD8, /* absent on RTL-8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324};
325
326enum ClearBitMasks {
Jeff Garzik28006c62007-09-15 12:36:46 -0700327 MultiIntrClear = 0xF000,
328 ChipCmdClear = 0xE2,
329 Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330};
331
332enum ChipCmdBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700333 CmdReset = 0x10,
334 CmdRxEnb = 0x08,
335 CmdTxEnb = 0x04,
336 RxBufEmpty = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337};
338
339/* Interrupt register bits, using my own meaningful names. */
340enum IntrStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700341 PCIErr = 0x8000,
342 PCSTimeout = 0x4000,
343 RxFIFOOver = 0x40,
344 RxUnderrun = 0x20,
345 RxOverflow = 0x10,
346 TxErr = 0x08,
347 TxOK = 0x04,
348 RxErr = 0x02,
349 RxOK = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Jeff Garzik28006c62007-09-15 12:36:46 -0700351 RxAckBits = RxFIFOOver | RxOverflow | RxOK,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352};
353
354enum TxStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700355 TxHostOwns = 0x2000,
356 TxUnderrun = 0x4000,
357 TxStatOK = 0x8000,
358 TxOutOfWindow = 0x20000000,
359 TxAborted = 0x40000000,
360 TxCarrierLost = 0x80000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361};
362enum RxStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700363 RxMulticast = 0x8000,
364 RxPhysical = 0x4000,
365 RxBroadcast = 0x2000,
366 RxBadSymbol = 0x0020,
367 RxRunt = 0x0010,
368 RxTooLong = 0x0008,
369 RxCRCErr = 0x0004,
370 RxBadAlign = 0x0002,
371 RxStatusOK = 0x0001,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372};
373
374/* Bits in RxConfig. */
375enum rx_mode_bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700376 AcceptErr = 0x20,
377 AcceptRunt = 0x10,
378 AcceptBroadcast = 0x08,
379 AcceptMulticast = 0x04,
380 AcceptMyPhys = 0x02,
381 AcceptAllPhys = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382};
383
384/* Bits in TxConfig. */
385enum tx_config_bits {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
Jeff Garzik28006c62007-09-15 12:36:46 -0700387 TxIFGShift = 24,
388 TxIFG84 = (0 << TxIFGShift), /* 8.4us / 840ns (10 / 100Mbps) */
389 TxIFG88 = (1 << TxIFGShift), /* 8.8us / 880ns (10 / 100Mbps) */
390 TxIFG92 = (2 << TxIFGShift), /* 9.2us / 920ns (10 / 100Mbps) */
391 TxIFG96 = (3 << TxIFGShift), /* 9.6us / 960ns (10 / 100Mbps) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Jeff Garzik28006c62007-09-15 12:36:46 -0700393 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
394 TxCRC = (1 << 16), /* DISABLE Tx pkt CRC append */
395 TxClearAbt = (1 << 0), /* Clear abort (WO) */
396 TxDMAShift = 8, /* DMA burst value (0-7) is shifted X many bits */
397 TxRetryShift = 4, /* TXRR value (0-15) is shifted X many bits */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Jeff Garzik28006c62007-09-15 12:36:46 -0700399 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400};
401
402/* Bits in Config1 */
403enum Config1Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700404 Cfg1_PM_Enable = 0x01,
405 Cfg1_VPD_Enable = 0x02,
406 Cfg1_PIO = 0x04,
407 Cfg1_MMIO = 0x08,
408 LWAKE = 0x10, /* not on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 Cfg1_Driver_Load = 0x20,
Jeff Garzik28006c62007-09-15 12:36:46 -0700410 Cfg1_LED0 = 0x40,
411 Cfg1_LED1 = 0x80,
412 SLEEP = (1 << 1), /* only on 8139, 8139A */
413 PWRDN = (1 << 0), /* only on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414};
415
416/* Bits in Config3 */
417enum Config3Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700418 Cfg3_FBtBEn = (1 << 0), /* 1 = Fast Back to Back */
419 Cfg3_FuncRegEn = (1 << 1), /* 1 = enable CardBus Function registers */
420 Cfg3_CLKRUN_En = (1 << 2), /* 1 = enable CLKRUN */
421 Cfg3_CardB_En = (1 << 3), /* 1 = enable CardBus registers */
422 Cfg3_LinkUp = (1 << 4), /* 1 = wake up on link up */
423 Cfg3_Magic = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
424 Cfg3_PARM_En = (1 << 6), /* 0 = software can set twister parameters */
425 Cfg3_GNTSel = (1 << 7), /* 1 = delay 1 clock from PCI GNT signal */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426};
427
428/* Bits in Config4 */
429enum Config4Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700430 LWPTN = (1 << 2), /* not on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431};
432
433/* Bits in Config5 */
434enum Config5Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700435 Cfg5_PME_STS = (1 << 0), /* 1 = PCI reset resets PME_Status */
436 Cfg5_LANWake = (1 << 1), /* 1 = enable LANWake signal */
437 Cfg5_LDPS = (1 << 2), /* 0 = save power when link is down */
438 Cfg5_FIFOAddrPtr= (1 << 3), /* Realtek internal SRAM testing */
439 Cfg5_UWF = (1 << 4), /* 1 = accept unicast wakeup frame */
440 Cfg5_MWF = (1 << 5), /* 1 = accept multicast wakeup frame */
441 Cfg5_BWF = (1 << 6), /* 1 = accept broadcast wakeup frame */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442};
443
444enum RxConfigBits {
445 /* rx fifo threshold */
Jeff Garzik28006c62007-09-15 12:36:46 -0700446 RxCfgFIFOShift = 13,
447 RxCfgFIFONone = (7 << RxCfgFIFOShift),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
449 /* Max DMA burst */
Jeff Garzik28006c62007-09-15 12:36:46 -0700450 RxCfgDMAShift = 8,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
452
453 /* rx ring buffer length */
Jeff Garzik28006c62007-09-15 12:36:46 -0700454 RxCfgRcv8K = 0,
455 RxCfgRcv16K = (1 << 11),
456 RxCfgRcv32K = (1 << 12),
457 RxCfgRcv64K = (1 << 11) | (1 << 12),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
459 /* Disable packet wrap at end of Rx buffer. (not possible with 64k) */
Jeff Garzik28006c62007-09-15 12:36:46 -0700460 RxNoWrap = (1 << 7),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461};
462
463/* Twister tuning parameters from RealTek.
464 Completely undocumented, but required to tune bad links on some boards. */
465enum CSCRBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700466 CSCR_LinkOKBit = 0x0400,
467 CSCR_LinkChangeBit = 0x0800,
468 CSCR_LinkStatusBits = 0x0f000,
469 CSCR_LinkDownOffCmd = 0x003c0,
470 CSCR_LinkDownCmd = 0x0f3c0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471};
472
473enum Cfg9346Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700474 Cfg9346_Lock = 0x00,
475 Cfg9346_Unlock = 0xC0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476};
477
478typedef enum {
Jeff Garzik28006c62007-09-15 12:36:46 -0700479 CH_8139 = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 CH_8139_K,
481 CH_8139A,
482 CH_8139A_G,
483 CH_8139B,
484 CH_8130,
485 CH_8139C,
486 CH_8100,
487 CH_8100B_8139D,
488 CH_8101,
489} chip_t;
490
491enum chip_flags {
Jeff Garzik28006c62007-09-15 12:36:46 -0700492 HasHltClk = (1 << 0),
493 HasLWake = (1 << 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494};
495
496#define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \
497 (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
498#define HW_REVID_MASK HW_REVID(1, 1, 1, 1, 1, 1, 1)
499
500/* directly indexed by chip_t, above */
Jesper Juhl3c6bee12006-01-09 20:54:01 -0800501static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 const char *name;
503 u32 version; /* from RTL8139C/RTL8139D docs */
504 u32 flags;
505} rtl_chip_info[] = {
506 { "RTL-8139",
507 HW_REVID(1, 0, 0, 0, 0, 0, 0),
508 HasHltClk,
509 },
510
511 { "RTL-8139 rev K",
512 HW_REVID(1, 1, 0, 0, 0, 0, 0),
513 HasHltClk,
514 },
515
516 { "RTL-8139A",
517 HW_REVID(1, 1, 1, 0, 0, 0, 0),
518 HasHltClk, /* XXX undocumented? */
519 },
520
521 { "RTL-8139A rev G",
522 HW_REVID(1, 1, 1, 0, 0, 1, 0),
523 HasHltClk, /* XXX undocumented? */
524 },
525
526 { "RTL-8139B",
527 HW_REVID(1, 1, 1, 1, 0, 0, 0),
528 HasLWake,
529 },
530
531 { "RTL-8130",
532 HW_REVID(1, 1, 1, 1, 1, 0, 0),
533 HasLWake,
534 },
535
536 { "RTL-8139C",
537 HW_REVID(1, 1, 1, 0, 1, 0, 0),
538 HasLWake,
539 },
540
541 { "RTL-8100",
542 HW_REVID(1, 1, 1, 1, 0, 1, 0),
543 HasLWake,
544 },
545
546 { "RTL-8100B/8139D",
547 HW_REVID(1, 1, 1, 0, 1, 0, 1),
John W. Linville7645bae2005-10-18 21:31:00 -0400548 HasHltClk /* XXX undocumented? */
549 | HasLWake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 },
551
552 { "RTL-8101",
553 HW_REVID(1, 1, 1, 0, 1, 1, 1),
554 HasLWake,
555 },
556};
557
558struct rtl_extra_stats {
559 unsigned long early_rx;
560 unsigned long tx_buf_mapped;
561 unsigned long tx_timeouts;
562 unsigned long rx_lost_in_ring;
563};
564
565struct rtl8139_private {
Jeff Garzik28006c62007-09-15 12:36:46 -0700566 void __iomem *mmio_addr;
567 int drv_flags;
568 struct pci_dev *pci_dev;
569 u32 msg_enable;
570 struct napi_struct napi;
571 struct net_device *dev;
Jeff Garzika15e0382005-10-31 07:59:37 -0500572
Jeff Garzik28006c62007-09-15 12:36:46 -0700573 unsigned char *rx_ring;
574 unsigned int cur_rx; /* RX buf index of next pkt */
575 dma_addr_t rx_ring_dma;
Jeff Garzika15e0382005-10-31 07:59:37 -0500576
Jeff Garzik28006c62007-09-15 12:36:46 -0700577 unsigned int tx_flag;
578 unsigned long cur_tx;
579 unsigned long dirty_tx;
580 unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
581 unsigned char *tx_bufs; /* Tx bounce buffer region. */
582 dma_addr_t tx_bufs_dma;
583
584 signed char phys[4]; /* MII device addresses. */
585
586 /* Twister tune state. */
587 char twistie, twist_row, twist_col;
588
589 unsigned int watchdog_fired : 1;
590 unsigned int default_port : 4; /* Last dev->if_port value. */
591 unsigned int have_thread : 1;
592
593 spinlock_t lock;
594 spinlock_t rx_lock;
595
596 chip_t chipset;
597 u32 rx_config;
598 struct rtl_extra_stats xstats;
599
600 struct delayed_work thread;
601
602 struct mii_if_info mii;
603 unsigned int regs_len;
604 unsigned long fifo_copy_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605};
606
607MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
608MODULE_DESCRIPTION ("RealTek RTL-8139 Fast Ethernet driver");
609MODULE_LICENSE("GPL");
610MODULE_VERSION(DRV_VERSION);
611
Dave Joneseb581342008-07-15 19:54:53 -0400612module_param(use_io, int, 0);
613MODULE_PARM_DESC(use_io, "Force use of I/O access mode. 0=MMIO 1=PIO");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614module_param(multicast_filter_limit, int, 0);
615module_param_array(media, int, NULL, 0);
616module_param_array(full_duplex, int, NULL, 0);
617module_param(debug, int, 0);
618MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");
619MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
620MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
621MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
622
Pekka Enberg22f714b2005-05-12 19:38:47 -0400623static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624static int rtl8139_open (struct net_device *dev);
625static int mdio_read (struct net_device *dev, int phy_id, int location);
626static void mdio_write (struct net_device *dev, int phy_id, int location,
627 int val);
Jeff Garzika15e0382005-10-31 07:59:37 -0500628static void rtl8139_start_thread(struct rtl8139_private *tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629static void rtl8139_tx_timeout (struct net_device *dev);
630static void rtl8139_init_ring (struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000631static netdev_tx_t rtl8139_start_xmit (struct sk_buff *skb,
632 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633#ifdef CONFIG_NET_POLL_CONTROLLER
634static void rtl8139_poll_controller(struct net_device *dev);
635#endif
Jiri Pirkobda6a152009-03-13 11:48:18 -0700636static int rtl8139_set_mac_address(struct net_device *dev, void *p);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700637static int rtl8139_poll(struct napi_struct *napi, int budget);
David Howells7d12e782006-10-05 14:55:46 +0100638static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639static int rtl8139_close (struct net_device *dev);
640static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
641static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
642static void rtl8139_set_rx_mode (struct net_device *dev);
643static void __set_rx_mode (struct net_device *dev);
644static void rtl8139_hw_start (struct net_device *dev);
David Howellsc4028952006-11-22 14:57:56 +0000645static void rtl8139_thread (struct work_struct *work);
646static void rtl8139_tx_timeout_task(struct work_struct *work);
Jeff Garzik7282d492006-09-13 14:30:00 -0400647static const struct ethtool_ops rtl8139_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649/* write MMIO register, with flush */
650/* Flush avoids rtl8139 bug w/ posted MMIO writes */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400651#define RTL_W8_F(reg, val8) do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)
652#define RTL_W16_F(reg, val16) do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)
653#define RTL_W32_F(reg, val32) do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655/* write MMIO register */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400656#define RTL_W8(reg, val8) iowrite8 ((val8), ioaddr + (reg))
657#define RTL_W16(reg, val16) iowrite16 ((val16), ioaddr + (reg))
658#define RTL_W32(reg, val32) iowrite32 ((val32), ioaddr + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660/* read MMIO register */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400661#define RTL_R8(reg) ioread8 (ioaddr + (reg))
662#define RTL_R16(reg) ioread16 (ioaddr + (reg))
663#define RTL_R32(reg) ((unsigned long) ioread32 (ioaddr + (reg)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665
666static const u16 rtl8139_intr_mask =
667 PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
668 TxErr | TxOK | RxErr | RxOK;
669
670static const u16 rtl8139_norx_intr_mask =
671 PCIErr | PCSTimeout | RxUnderrun |
672 TxErr | TxOK | RxErr ;
673
674#if RX_BUF_IDX == 0
675static const unsigned int rtl8139_rx_config =
676 RxCfgRcv8K | RxNoWrap |
677 (RX_FIFO_THRESH << RxCfgFIFOShift) |
678 (RX_DMA_BURST << RxCfgDMAShift);
679#elif RX_BUF_IDX == 1
680static const unsigned int rtl8139_rx_config =
681 RxCfgRcv16K | RxNoWrap |
682 (RX_FIFO_THRESH << RxCfgFIFOShift) |
683 (RX_DMA_BURST << RxCfgDMAShift);
684#elif RX_BUF_IDX == 2
685static const unsigned int rtl8139_rx_config =
686 RxCfgRcv32K | RxNoWrap |
687 (RX_FIFO_THRESH << RxCfgFIFOShift) |
688 (RX_DMA_BURST << RxCfgDMAShift);
689#elif RX_BUF_IDX == 3
690static const unsigned int rtl8139_rx_config =
691 RxCfgRcv64K |
692 (RX_FIFO_THRESH << RxCfgFIFOShift) |
693 (RX_DMA_BURST << RxCfgDMAShift);
694#else
695#error "Invalid configuration for 8139_RXBUF_IDX"
696#endif
697
698static const unsigned int rtl8139_tx_config =
699 TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);
700
701static void __rtl8139_cleanup_dev (struct net_device *dev)
702{
703 struct rtl8139_private *tp = netdev_priv(dev);
704 struct pci_dev *pdev;
705
706 assert (dev != NULL);
707 assert (tp->pci_dev != NULL);
708 pdev = tp->pci_dev;
709
Pekka Enberg22f714b2005-05-12 19:38:47 -0400710 if (tp->mmio_addr)
711 pci_iounmap (pdev, tp->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
713 /* it's ok to call this even if we have no regions to free */
714 pci_release_regions (pdev);
715
716 free_netdev(dev);
717 pci_set_drvdata (pdev, NULL);
718}
719
720
Pekka Enberg22f714b2005-05-12 19:38:47 -0400721static void rtl8139_chip_reset (void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
723 int i;
724
725 /* Soft reset the chip. */
726 RTL_W8 (ChipCmd, CmdReset);
727
728 /* Check that the chip has finished the reset. */
729 for (i = 1000; i > 0; i--) {
730 barrier();
731 if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
732 break;
733 udelay (10);
734 }
735}
736
737
Stephen Hemminger85920d42008-11-24 14:47:01 -0800738static __devinit struct net_device * rtl8139_init_board (struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Pekka Enberg22f714b2005-05-12 19:38:47 -0400740 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 struct net_device *dev;
742 struct rtl8139_private *tp;
743 u8 tmp8;
744 int rc, disable_dev_on_err = 0;
745 unsigned int i;
746 unsigned long pio_start, pio_end, pio_flags, pio_len;
747 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
748 u32 version;
749
750 assert (pdev != NULL);
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 /* dev and priv zeroed in alloc_etherdev */
753 dev = alloc_etherdev (sizeof (*tp));
754 if (dev == NULL) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400755 dev_err(&pdev->dev, "Unable to alloc new net device\n");
Stephen Hemminger85920d42008-11-24 14:47:01 -0800756 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 SET_NETDEV_DEV(dev, &pdev->dev);
759
760 tp = netdev_priv(dev);
761 tp->pci_dev = pdev;
762
763 /* enable device (incl. PCI PM wakeup and hotplug setup) */
764 rc = pci_enable_device (pdev);
765 if (rc)
766 goto err_out;
767
768 pio_start = pci_resource_start (pdev, 0);
769 pio_end = pci_resource_end (pdev, 0);
770 pio_flags = pci_resource_flags (pdev, 0);
771 pio_len = pci_resource_len (pdev, 0);
772
773 mmio_start = pci_resource_start (pdev, 1);
774 mmio_end = pci_resource_end (pdev, 1);
775 mmio_flags = pci_resource_flags (pdev, 1);
776 mmio_len = pci_resource_len (pdev, 1);
777
778 /* set this immediately, we need to know before
779 * we talk to the chip directly */
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000780 pr_debug("PIO region size == 0x%02lX\n", pio_len);
781 pr_debug("MMIO region size == 0x%02lX\n", mmio_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Dave Jones1a4dc682008-07-15 19:54:52 -0400783retry:
Dave Joneseb581342008-07-15 19:54:53 -0400784 if (use_io) {
785 /* make sure PCI base addr 0 is PIO */
786 if (!(pio_flags & IORESOURCE_IO)) {
787 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
788 rc = -ENODEV;
789 goto err_out;
790 }
791 /* check for weird/broken PCI region reporting */
792 if (pio_len < RTL_MIN_IO_SIZE) {
793 dev_err(&pdev->dev, "Invalid PCI I/O region size(s), aborting\n");
794 rc = -ENODEV;
795 goto err_out;
796 }
797 } else {
798 /* make sure PCI base addr 1 is MMIO */
799 if (!(mmio_flags & IORESOURCE_MEM)) {
800 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
801 rc = -ENODEV;
802 goto err_out;
803 }
804 if (mmio_len < RTL_MIN_IO_SIZE) {
805 dev_err(&pdev->dev, "Invalid PCI mem region size(s), aborting\n");
806 rc = -ENODEV;
807 goto err_out;
808 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400811 rc = pci_request_regions (pdev, DRV_NAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 if (rc)
813 goto err_out;
814 disable_dev_on_err = 1;
815
816 /* enable PCI bus-mastering */
817 pci_set_master (pdev);
818
Dave Joneseb581342008-07-15 19:54:53 -0400819 if (use_io) {
820 ioaddr = pci_iomap(pdev, 0, 0);
821 if (!ioaddr) {
822 dev_err(&pdev->dev, "cannot map PIO, aborting\n");
823 rc = -EIO;
824 goto err_out;
825 }
826 dev->base_addr = pio_start;
827 tp->regs_len = pio_len;
828 } else {
829 /* ioremap MMIO region */
830 ioaddr = pci_iomap(pdev, 1, 0);
831 if (ioaddr == NULL) {
Dave Jones1a4dc682008-07-15 19:54:52 -0400832 dev_err(&pdev->dev, "cannot remap MMIO, trying PIO\n");
833 pci_release_regions(pdev);
834 use_io = 1;
835 goto retry;
Dave Joneseb581342008-07-15 19:54:53 -0400836 }
837 dev->base_addr = (long) ioaddr;
838 tp->regs_len = mmio_len;
Pekka Enberg22f714b2005-05-12 19:38:47 -0400839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 tp->mmio_addr = ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
842 /* Bring old chips out of low-power mode. */
843 RTL_W8 (HltClk, 'R');
844
845 /* check for missing/broken hardware */
846 if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400847 dev_err(&pdev->dev, "Chip not responding, ignoring board\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 rc = -EIO;
849 goto err_out;
850 }
851
852 /* identify chip attached to board */
853 version = RTL_R32 (TxConfig) & HW_REVID_MASK;
854 for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)
855 if (version == rtl_chip_info[i].version) {
856 tp->chipset = i;
857 goto match;
858 }
859
860 /* if unknown chip, assume array element #0, original RTL-8139 in this case */
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000861 dev_dbg(&pdev->dev, "unknown chip version, assuming RTL-8139\n");
862 dev_dbg(&pdev->dev, "TxConfig = 0x%lx\n", RTL_R32 (TxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 tp->chipset = 0;
864
865match:
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000866 pr_debug("chipset id (%d) == index %d, '%s'\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 version, i, rtl_chip_info[i].name);
868
869 if (tp->chipset >= CH_8139B) {
870 u8 new_tmp8 = tmp8 = RTL_R8 (Config1);
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000871 pr_debug("PCI PM wakeup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&
873 (tmp8 & LWAKE))
874 new_tmp8 &= ~LWAKE;
875 new_tmp8 |= Cfg1_PM_Enable;
876 if (new_tmp8 != tmp8) {
877 RTL_W8 (Cfg9346, Cfg9346_Unlock);
878 RTL_W8 (Config1, tmp8);
879 RTL_W8 (Cfg9346, Cfg9346_Lock);
880 }
881 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
882 tmp8 = RTL_R8 (Config4);
883 if (tmp8 & LWPTN) {
884 RTL_W8 (Cfg9346, Cfg9346_Unlock);
885 RTL_W8 (Config4, tmp8 & ~LWPTN);
886 RTL_W8 (Cfg9346, Cfg9346_Lock);
887 }
888 }
889 } else {
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000890 pr_debug("Old chip wakeup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 tmp8 = RTL_R8 (Config1);
892 tmp8 &= ~(SLEEP | PWRDN);
893 RTL_W8 (Config1, tmp8);
894 }
895
896 rtl8139_chip_reset (ioaddr);
897
Stephen Hemminger85920d42008-11-24 14:47:01 -0800898 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
900err_out:
901 __rtl8139_cleanup_dev (dev);
902 if (disable_dev_on_err)
903 pci_disable_device (pdev);
Stephen Hemminger85920d42008-11-24 14:47:01 -0800904 return ERR_PTR(rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905}
906
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800907static const struct net_device_ops rtl8139_netdev_ops = {
908 .ndo_open = rtl8139_open,
909 .ndo_stop = rtl8139_close,
910 .ndo_get_stats = rtl8139_get_stats,
Ben Hutchings635ecaa2009-07-09 17:59:01 +0000911 .ndo_change_mtu = eth_change_mtu,
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800912 .ndo_validate_addr = eth_validate_addr,
Jiri Pirkobda6a152009-03-13 11:48:18 -0700913 .ndo_set_mac_address = rtl8139_set_mac_address,
Stephen Hemminger00829822008-11-20 20:14:53 -0800914 .ndo_start_xmit = rtl8139_start_xmit,
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800915 .ndo_set_multicast_list = rtl8139_set_rx_mode,
916 .ndo_do_ioctl = netdev_ioctl,
917 .ndo_tx_timeout = rtl8139_tx_timeout,
918#ifdef CONFIG_NET_POLL_CONTROLLER
919 .ndo_poll_controller = rtl8139_poll_controller,
920#endif
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800921};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923static int __devinit rtl8139_init_one (struct pci_dev *pdev,
924 const struct pci_device_id *ent)
925{
926 struct net_device *dev = NULL;
927 struct rtl8139_private *tp;
928 int i, addr_len, option;
Pekka Enberg22f714b2005-05-12 19:38:47 -0400929 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 static int board_idx = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 assert (pdev != NULL);
933 assert (ent != NULL);
934
935 board_idx++;
936
937 /* when we're built into the kernel, the driver version message
938 * is only printed if at least one 8139 board has been found
939 */
940#ifndef MODULE
941 {
942 static int printed_version;
943 if (!printed_version++)
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000944 pr_info(RTL8139_DRIVER_NAME "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
946#endif
947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
Auke Kok44c10132007-06-08 15:46:36 -0700949 pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pdev->revision >= 0x20) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400950 dev_info(&pdev->dev,
Stephen Hemmingerde4549c2008-10-21 18:04:27 -0700951 "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip, use 8139cp\n",
Auke Kok44c10132007-06-08 15:46:36 -0700952 pdev->vendor, pdev->device, pdev->revision);
Stephen Hemmingerde4549c2008-10-21 18:04:27 -0700953 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 }
955
Dave Jones152151d2008-07-15 19:54:53 -0400956 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
957 pdev->device == PCI_DEVICE_ID_REALTEK_8139 &&
958 pdev->subsystem_vendor == PCI_VENDOR_ID_ATHEROS &&
959 pdev->subsystem_device == PCI_DEVICE_ID_REALTEK_8139) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000960 pr_info("8139too: OQO Model 2 detected. Forcing PIO\n");
Dave Jones152151d2008-07-15 19:54:53 -0400961 use_io = 1;
962 }
963
Stephen Hemminger85920d42008-11-24 14:47:01 -0800964 dev = rtl8139_init_board (pdev);
965 if (IS_ERR(dev))
966 return PTR_ERR(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968 assert (dev != NULL);
969 tp = netdev_priv(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700970 tp->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
972 ioaddr = tp->mmio_addr;
973 assert (ioaddr != NULL);
974
975 addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
976 for (i = 0; i < 3; i++)
Al Viroeca1ad82008-03-16 22:21:54 +0000977 ((__le16 *) (dev->dev_addr))[i] =
978 cpu_to_le16(read_eeprom (ioaddr, i + 7, addr_len));
John W. Linville62a720b2005-09-12 10:48:55 -0400979 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
981 /* The Rtl8139-specific entries in the device structure. */
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800982 dev->netdev_ops = &rtl8139_netdev_ops;
983 dev->ethtool_ops = &rtl8139_ethtool_ops;
984 dev->watchdog_timeo = TX_TIMEOUT;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700985 netif_napi_add(dev, &tp->napi, rtl8139_poll, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
987 /* note: the hardware is not capable of sg/csum/highdma, however
988 * through the use of skb_copy_and_csum_dev we enable these
989 * features
990 */
991 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
992
993 dev->irq = pdev->irq;
994
995 /* tp zeroed and aligned in alloc_etherdev */
996 tp = netdev_priv(dev);
997
998 /* note: tp->chipset set in rtl8139_init_board */
999 tp->drv_flags = board_info[ent->driver_data].hw_flags;
1000 tp->mmio_addr = ioaddr;
1001 tp->msg_enable =
1002 (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));
1003 spin_lock_init (&tp->lock);
1004 spin_lock_init (&tp->rx_lock);
David Howellsc4028952006-11-22 14:57:56 +00001005 INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 tp->mii.dev = dev;
1007 tp->mii.mdio_read = mdio_read;
1008 tp->mii.mdio_write = mdio_write;
1009 tp->mii.phy_id_mask = 0x3f;
1010 tp->mii.reg_num_mask = 0x1f;
1011
1012 /* dev is fully set up and ready to use now */
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001013 pr_debug("about to register device named %s (%p)...\n", dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 i = register_netdev (dev);
1015 if (i) goto err_out;
1016
1017 pci_set_drvdata (pdev, dev);
1018
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001019 pr_info("%s: %s at 0x%lx, %pM, IRQ %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 dev->name,
1021 board_info[ent->driver_data].name,
1022 dev->base_addr,
Johannes Berge1749612008-10-27 15:59:26 -07001023 dev->dev_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 dev->irq);
1025
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001026 pr_debug("%s: Identified 8139 chip type '%s'\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 dev->name, rtl_chip_info[tp->chipset].name);
1028
1029 /* Find the connected MII xcvrs.
1030 Doing this in open() would allow detecting external xcvrs later, but
1031 takes too much time. */
1032#ifdef CONFIG_8139TOO_8129
1033 if (tp->drv_flags & HAS_MII_XCVR) {
1034 int phy, phy_idx = 0;
1035 for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {
1036 int mii_status = mdio_read(dev, phy, 1);
1037 if (mii_status != 0xffff && mii_status != 0x0000) {
1038 u16 advertising = mdio_read(dev, phy, 4);
1039 tp->phys[phy_idx++] = phy;
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001040 pr_info("%s: MII transceiver %d status 0x%4.4x advertising %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 dev->name, phy, mii_status, advertising);
1042 }
1043 }
1044 if (phy_idx == 0) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001045 pr_info("%s: No MII transceivers found! Assuming SYM transceiver.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 dev->name);
1047 tp->phys[0] = 32;
1048 }
1049 } else
1050#endif
1051 tp->phys[0] = 32;
1052 tp->mii.phy_id = tp->phys[0];
1053
1054 /* The lower four bits are the media type. */
1055 option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
1056 if (option > 0) {
1057 tp->mii.full_duplex = (option & 0x210) ? 1 : 0;
1058 tp->default_port = option & 0xFF;
1059 if (tp->default_port)
1060 tp->mii.force_media = 1;
1061 }
1062 if (board_idx < MAX_UNITS && full_duplex[board_idx] > 0)
1063 tp->mii.full_duplex = full_duplex[board_idx];
1064 if (tp->mii.full_duplex) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001065 pr_info("%s: Media type forced to Full Duplex.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 /* Changing the MII-advertised media because might prevent
1067 re-connection. */
1068 tp->mii.force_media = 1;
1069 }
1070 if (tp->default_port) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001071 pr_info(" Forcing %dMbps %s-duplex operation.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 (option & 0x20 ? 100 : 10),
1073 (option & 0x10 ? "full" : "half"));
1074 mdio_write(dev, tp->phys[0], 0,
1075 ((option & 0x20) ? 0x2000 : 0) | /* 100Mbps? */
1076 ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
1077 }
1078
1079 /* Put the chip into low-power mode. */
1080 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1081 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
1082
1083 return 0;
1084
1085err_out:
1086 __rtl8139_cleanup_dev (dev);
1087 pci_disable_device (pdev);
1088 return i;
1089}
1090
1091
1092static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
1093{
1094 struct net_device *dev = pci_get_drvdata (pdev);
1095
1096 assert (dev != NULL);
1097
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001098 flush_scheduled_work();
1099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 unregister_netdev (dev);
1101
1102 __rtl8139_cleanup_dev (dev);
1103 pci_disable_device (pdev);
1104}
1105
1106
1107/* Serial EEPROM section. */
1108
1109/* EEPROM_Ctrl bits. */
1110#define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
1111#define EE_CS 0x08 /* EEPROM chip select. */
1112#define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
1113#define EE_WRITE_0 0x00
1114#define EE_WRITE_1 0x02
1115#define EE_DATA_READ 0x01 /* EEPROM chip data out. */
1116#define EE_ENB (0x80 | EE_CS)
1117
1118/* Delay between EEPROM clock transitions.
1119 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1120 */
1121
Takashi Iwai10e705f2006-03-24 03:18:23 -08001122#define eeprom_delay() (void)RTL_R32(Cfg9346)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
1124/* The EEPROM commands include the alway-set leading bit. */
1125#define EE_WRITE_CMD (5)
1126#define EE_READ_CMD (6)
1127#define EE_ERASE_CMD (7)
1128
Pekka Enberg22f714b2005-05-12 19:38:47 -04001129static int __devinit read_eeprom (void __iomem *ioaddr, int location, int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
1131 int i;
1132 unsigned retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 int read_cmd = location | (EE_READ_CMD << addr_len);
1134
Pekka Enberg22f714b2005-05-12 19:38:47 -04001135 RTL_W8 (Cfg9346, EE_ENB & ~EE_CS);
1136 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 eeprom_delay ();
1138
1139 /* Shift the read command bits out. */
1140 for (i = 4 + addr_len; i >= 0; i--) {
1141 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001142 RTL_W8 (Cfg9346, EE_ENB | dataval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 eeprom_delay ();
Pekka Enberg22f714b2005-05-12 19:38:47 -04001144 RTL_W8 (Cfg9346, EE_ENB | dataval | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 eeprom_delay ();
1146 }
Pekka Enberg22f714b2005-05-12 19:38:47 -04001147 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 eeprom_delay ();
1149
1150 for (i = 16; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001151 RTL_W8 (Cfg9346, EE_ENB | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 eeprom_delay ();
1153 retval =
Pekka Enberg22f714b2005-05-12 19:38:47 -04001154 (retval << 1) | ((RTL_R8 (Cfg9346) & EE_DATA_READ) ? 1 :
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 0);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001156 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 eeprom_delay ();
1158 }
1159
1160 /* Terminate the EEPROM access. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001161 RTL_W8 (Cfg9346, ~EE_CS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 eeprom_delay ();
1163
1164 return retval;
1165}
1166
1167/* MII serial management: mostly bogus for now. */
1168/* Read and write the MII management registers using software-generated
1169 serial MDIO protocol.
1170 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
1171 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1172 "overclocking" issues. */
1173#define MDIO_DIR 0x80
1174#define MDIO_DATA_OUT 0x04
1175#define MDIO_DATA_IN 0x02
1176#define MDIO_CLK 0x01
1177#define MDIO_WRITE0 (MDIO_DIR)
1178#define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
1179
Pekka Enberg22f714b2005-05-12 19:38:47 -04001180#define mdio_delay() RTL_R8(Config4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181
1182
Arjan van de Venf71e1302006-03-03 21:33:57 -05001183static const char mii_2_8139_map[8] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 BasicModeCtrl,
1185 BasicModeStatus,
1186 0,
1187 0,
1188 NWayAdvert,
1189 NWayLPAR,
1190 NWayExpansion,
1191 0
1192};
1193
1194
1195#ifdef CONFIG_8139TOO_8129
1196/* Syncronize the MII management interface by shifting 32 one bits out. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001197static void mdio_sync (void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198{
1199 int i;
1200
1201 for (i = 32; i >= 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001202 RTL_W8 (Config4, MDIO_WRITE1);
1203 mdio_delay ();
1204 RTL_W8 (Config4, MDIO_WRITE1 | MDIO_CLK);
1205 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 }
1207}
1208#endif
1209
1210static int mdio_read (struct net_device *dev, int phy_id, int location)
1211{
1212 struct rtl8139_private *tp = netdev_priv(dev);
1213 int retval = 0;
1214#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001215 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1217 int i;
1218#endif
1219
1220 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001221 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 return location < 8 && mii_2_8139_map[location] ?
Pekka Enberg22f714b2005-05-12 19:38:47 -04001223 RTL_R16 (mii_2_8139_map[location]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 }
1225
1226#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001227 mdio_sync (ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 /* Shift the read command bits out. */
1229 for (i = 15; i >= 0; i--) {
1230 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1231
Pekka Enberg22f714b2005-05-12 19:38:47 -04001232 RTL_W8 (Config4, MDIO_DIR | dataval);
1233 mdio_delay ();
1234 RTL_W8 (Config4, MDIO_DIR | dataval | MDIO_CLK);
1235 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 }
1237
1238 /* Read the two transition, 16 data, and wire-idle bits. */
1239 for (i = 19; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001240 RTL_W8 (Config4, 0);
1241 mdio_delay ();
1242 retval = (retval << 1) | ((RTL_R8 (Config4) & MDIO_DATA_IN) ? 1 : 0);
1243 RTL_W8 (Config4, MDIO_CLK);
1244 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
1246#endif
1247
1248 return (retval >> 1) & 0xffff;
1249}
1250
1251
1252static void mdio_write (struct net_device *dev, int phy_id, int location,
1253 int value)
1254{
1255 struct rtl8139_private *tp = netdev_priv(dev);
1256#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001257 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1259 int i;
1260#endif
1261
1262 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001263 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 if (location == 0) {
1265 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1266 RTL_W16 (BasicModeCtrl, value);
1267 RTL_W8 (Cfg9346, Cfg9346_Lock);
1268 } else if (location < 8 && mii_2_8139_map[location])
1269 RTL_W16 (mii_2_8139_map[location], value);
1270 return;
1271 }
1272
1273#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001274 mdio_sync (ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
1276 /* Shift the command bits out. */
1277 for (i = 31; i >= 0; i--) {
1278 int dataval =
1279 (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001280 RTL_W8 (Config4, dataval);
1281 mdio_delay ();
1282 RTL_W8 (Config4, dataval | MDIO_CLK);
1283 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285 /* Clear out extra bits. */
1286 for (i = 2; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001287 RTL_W8 (Config4, 0);
1288 mdio_delay ();
1289 RTL_W8 (Config4, MDIO_CLK);
1290 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 }
1292#endif
1293}
1294
1295
1296static int rtl8139_open (struct net_device *dev)
1297{
1298 struct rtl8139_private *tp = netdev_priv(dev);
1299 int retval;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001300 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001302 retval = request_irq (dev->irq, rtl8139_interrupt, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 if (retval)
1304 return retval;
1305
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001306 tp->tx_bufs = dma_alloc_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
1307 &tp->tx_bufs_dma, GFP_KERNEL);
1308 tp->rx_ring = dma_alloc_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
1309 &tp->rx_ring_dma, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1311 free_irq(dev->irq, dev);
1312
1313 if (tp->tx_bufs)
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001314 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 tp->tx_bufs, tp->tx_bufs_dma);
1316 if (tp->rx_ring)
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001317 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 tp->rx_ring, tp->rx_ring_dma);
1319
1320 return -ENOMEM;
1321
1322 }
1323
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001324 napi_enable(&tp->napi);
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 tp->mii.full_duplex = tp->mii.force_media;
1327 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1328
1329 rtl8139_init_ring (dev);
1330 rtl8139_hw_start (dev);
1331 netif_start_queue (dev);
1332
1333 if (netif_msg_ifup(tp))
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001334 pr_debug("%s: rtl8139_open() ioaddr %#llx IRQ %d"
Greg Kroah-Hartman7c7459d2006-06-12 15:13:08 -07001335 " GP Pins %2.2x %s-duplex.\n", dev->name,
1336 (unsigned long long)pci_resource_start (tp->pci_dev, 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 dev->irq, RTL_R8 (MediaStatus),
1338 tp->mii.full_duplex ? "full" : "half");
1339
Jeff Garzika15e0382005-10-31 07:59:37 -05001340 rtl8139_start_thread(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 return 0;
1343}
1344
1345
1346static void rtl_check_media (struct net_device *dev, unsigned int init_media)
1347{
1348 struct rtl8139_private *tp = netdev_priv(dev);
1349
1350 if (tp->phys[0] >= 0) {
1351 mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
1352 }
1353}
1354
1355/* Start the hardware at open or resume. */
1356static void rtl8139_hw_start (struct net_device *dev)
1357{
1358 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001359 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 u32 i;
1361 u8 tmp;
1362
1363 /* Bring old chips out of low-power mode. */
1364 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1365 RTL_W8 (HltClk, 'R');
1366
1367 rtl8139_chip_reset (ioaddr);
1368
1369 /* unlock Config[01234] and BMCR register writes */
1370 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1371 /* Restore our idea of the MAC address. */
Al Viroeca1ad82008-03-16 22:21:54 +00001372 RTL_W32_F (MAC0 + 0, le32_to_cpu (*(__le32 *) (dev->dev_addr + 0)));
1373 RTL_W32_F (MAC0 + 4, le16_to_cpu (*(__le16 *) (dev->dev_addr + 4)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
Jianjun kong3f9738f2009-04-20 23:48:25 +00001375 tp->cur_rx = 0;
1376
1377 /* init Rx ring buffer DMA address */
1378 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1379
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 /* Must enable Tx/Rx before setting transfer thresholds! */
1381 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1382
1383 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1384 RTL_W32 (RxConfig, tp->rx_config);
1385 RTL_W32 (TxConfig, rtl8139_tx_config);
1386
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 rtl_check_media (dev, 1);
1388
1389 if (tp->chipset >= CH_8139B) {
1390 /* Disable magic packet scanning, which is enabled
1391 * when PM is enabled in Config1. It can be reenabled
1392 * via ETHTOOL_SWOL if desired. */
1393 RTL_W8 (Config3, RTL_R8 (Config3) & ~Cfg3_Magic);
1394 }
1395
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001396 pr_debug("init buffer addresses\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
1398 /* Lock Config[01234] and BMCR register writes */
1399 RTL_W8 (Cfg9346, Cfg9346_Lock);
1400
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 /* init Tx buffer DMA addresses */
1402 for (i = 0; i < NUM_TX_DESC; i++)
1403 RTL_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1404
1405 RTL_W32 (RxMissed, 0);
1406
1407 rtl8139_set_rx_mode (dev);
1408
1409 /* no early-rx interrupts */
1410 RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
1411
1412 /* make sure RxTx has started */
1413 tmp = RTL_R8 (ChipCmd);
1414 if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
1415 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1416
1417 /* Enable all known interrupts by setting the interrupt mask. */
1418 RTL_W16 (IntrMask, rtl8139_intr_mask);
1419}
1420
1421
1422/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1423static void rtl8139_init_ring (struct net_device *dev)
1424{
1425 struct rtl8139_private *tp = netdev_priv(dev);
1426 int i;
1427
1428 tp->cur_rx = 0;
1429 tp->cur_tx = 0;
1430 tp->dirty_tx = 0;
1431
1432 for (i = 0; i < NUM_TX_DESC; i++)
1433 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1434}
1435
1436
1437/* This must be global for CONFIG_8139TOO_TUNE_TWISTER case */
1438static int next_tick = 3 * HZ;
1439
1440#ifndef CONFIG_8139TOO_TUNE_TWISTER
1441static inline void rtl8139_tune_twister (struct net_device *dev,
1442 struct rtl8139_private *tp) {}
1443#else
1444enum TwisterParamVals {
1445 PARA78_default = 0x78fa8388,
1446 PARA7c_default = 0xcb38de43, /* param[0][3] */
1447 PARA7c_xxx = 0xcb38de43,
1448};
1449
1450static const unsigned long param[4][4] = {
1451 {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
1452 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1453 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1454 {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
1455};
1456
1457static void rtl8139_tune_twister (struct net_device *dev,
1458 struct rtl8139_private *tp)
1459{
1460 int linkcase;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001461 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
1463 /* This is a complicated state machine to configure the "twister" for
1464 impedance/echos based on the cable length.
1465 All of this is magic and undocumented.
1466 */
1467 switch (tp->twistie) {
1468 case 1:
1469 if (RTL_R16 (CSCR) & CSCR_LinkOKBit) {
1470 /* We have link beat, let us tune the twister. */
1471 RTL_W16 (CSCR, CSCR_LinkDownOffCmd);
1472 tp->twistie = 2; /* Change to state 2. */
1473 next_tick = HZ / 10;
1474 } else {
1475 /* Just put in some reasonable defaults for when beat returns. */
1476 RTL_W16 (CSCR, CSCR_LinkDownCmd);
1477 RTL_W32 (FIFOTMS, 0x20); /* Turn on cable test mode. */
1478 RTL_W32 (PARA78, PARA78_default);
1479 RTL_W32 (PARA7c, PARA7c_default);
1480 tp->twistie = 0; /* Bail from future actions. */
1481 }
1482 break;
1483 case 2:
1484 /* Read how long it took to hear the echo. */
1485 linkcase = RTL_R16 (CSCR) & CSCR_LinkStatusBits;
1486 if (linkcase == 0x7000)
1487 tp->twist_row = 3;
1488 else if (linkcase == 0x3000)
1489 tp->twist_row = 2;
1490 else if (linkcase == 0x1000)
1491 tp->twist_row = 1;
1492 else
1493 tp->twist_row = 0;
1494 tp->twist_col = 0;
1495 tp->twistie = 3; /* Change to state 2. */
1496 next_tick = HZ / 10;
1497 break;
1498 case 3:
1499 /* Put out four tuning parameters, one per 100msec. */
1500 if (tp->twist_col == 0)
1501 RTL_W16 (FIFOTMS, 0);
1502 RTL_W32 (PARA7c, param[(int) tp->twist_row]
1503 [(int) tp->twist_col]);
1504 next_tick = HZ / 10;
1505 if (++tp->twist_col >= 4) {
1506 /* For short cables we are done.
1507 For long cables (row == 3) check for mistune. */
1508 tp->twistie =
1509 (tp->twist_row == 3) ? 4 : 0;
1510 }
1511 break;
1512 case 4:
1513 /* Special case for long cables: check for mistune. */
1514 if ((RTL_R16 (CSCR) &
1515 CSCR_LinkStatusBits) == 0x7000) {
1516 tp->twistie = 0;
1517 break;
1518 } else {
1519 RTL_W32 (PARA7c, 0xfb38de03);
1520 tp->twistie = 5;
1521 next_tick = HZ / 10;
1522 }
1523 break;
1524 case 5:
1525 /* Retune for shorter cable (column 2). */
1526 RTL_W32 (FIFOTMS, 0x20);
1527 RTL_W32 (PARA78, PARA78_default);
1528 RTL_W32 (PARA7c, PARA7c_default);
1529 RTL_W32 (FIFOTMS, 0x00);
1530 tp->twist_row = 2;
1531 tp->twist_col = 0;
1532 tp->twistie = 3;
1533 next_tick = HZ / 10;
1534 break;
1535
1536 default:
1537 /* do nothing */
1538 break;
1539 }
1540}
1541#endif /* CONFIG_8139TOO_TUNE_TWISTER */
1542
1543static inline void rtl8139_thread_iter (struct net_device *dev,
1544 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001545 void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546{
1547 int mii_lpa;
1548
1549 mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1550
1551 if (!tp->mii.force_media && mii_lpa != 0xffff) {
1552 int duplex = (mii_lpa & LPA_100FULL)
1553 || (mii_lpa & 0x01C0) == 0x0040;
1554 if (tp->mii.full_duplex != duplex) {
1555 tp->mii.full_duplex = duplex;
1556
1557 if (mii_lpa) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001558 pr_info("%s: Setting %s-duplex based on MII #%d link"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 " partner ability of %4.4x.\n",
1560 dev->name,
1561 tp->mii.full_duplex ? "full" : "half",
1562 tp->phys[0], mii_lpa);
1563 } else {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001564 pr_info("%s: media is unconnected, link down, or incompatible connection\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 dev->name);
1566 }
1567#if 0
1568 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1569 RTL_W8 (Config1, tp->mii.full_duplex ? 0x60 : 0x20);
1570 RTL_W8 (Cfg9346, Cfg9346_Lock);
1571#endif
1572 }
1573 }
1574
1575 next_tick = HZ * 60;
1576
1577 rtl8139_tune_twister (dev, tp);
1578
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001579 pr_debug("%s: Media selection tick, Link partner %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 dev->name, RTL_R16 (NWayLPAR));
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001581 pr_debug("%s: Other registers are IntMask %4.4x IntStatus %4.4x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 dev->name, RTL_R16 (IntrMask), RTL_R16 (IntrStatus));
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001583 pr_debug("%s: Chip config %2.2x %2.2x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 dev->name, RTL_R8 (Config0),
1585 RTL_R8 (Config1));
1586}
1587
David Howellsc4028952006-11-22 14:57:56 +00001588static void rtl8139_thread (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589{
David Howellsc4028952006-11-22 14:57:56 +00001590 struct rtl8139_private *tp =
1591 container_of(work, struct rtl8139_private, thread.work);
1592 struct net_device *dev = tp->mii.dev;
Francois Romieu371e8bc2006-01-31 01:04:33 +01001593 unsigned long thr_delay = next_tick;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001595 rtnl_lock();
1596
1597 if (!netif_running(dev))
1598 goto out_unlock;
1599
Francois Romieu371e8bc2006-01-31 01:04:33 +01001600 if (tp->watchdog_fired) {
1601 tp->watchdog_fired = 0;
David Howellsc4028952006-11-22 14:57:56 +00001602 rtl8139_tx_timeout_task(work);
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001603 } else
1604 rtl8139_thread_iter(dev, tp, tp->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001606 if (tp->have_thread)
1607 schedule_delayed_work(&tp->thread, thr_delay);
1608out_unlock:
1609 rtnl_unlock ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610}
1611
Jeff Garzika15e0382005-10-31 07:59:37 -05001612static void rtl8139_start_thread(struct rtl8139_private *tp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 tp->twistie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 if (tp->chipset == CH_8139_K)
1616 tp->twistie = 1;
1617 else if (tp->drv_flags & HAS_LNK_CHNG)
1618 return;
1619
Jeff Garzik38b492a2005-11-04 22:36:28 -05001620 tp->have_thread = 1;
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001621 tp->watchdog_fired = 0;
Jeff Garzika15e0382005-10-31 07:59:37 -05001622
1623 schedule_delayed_work(&tp->thread, next_tick);
1624}
1625
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
1627{
1628 tp->cur_tx = 0;
1629 tp->dirty_tx = 0;
1630
1631 /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
1632}
1633
David Howellsc4028952006-11-22 14:57:56 +00001634static void rtl8139_tx_timeout_task (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635{
David Howellsc4028952006-11-22 14:57:56 +00001636 struct rtl8139_private *tp =
1637 container_of(work, struct rtl8139_private, thread.work);
1638 struct net_device *dev = tp->mii.dev;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001639 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 int i;
1641 u8 tmp8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001643 pr_debug("%s: Transmit timeout, status %2.2x %4.4x %4.4x media %2.2x.\n",
1644 dev->name, RTL_R8 (ChipCmd),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 RTL_R16(IntrStatus), RTL_R16(IntrMask), RTL_R8(MediaStatus));
1646 /* Emit info to figure out what went wrong. */
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001647 pr_debug("%s: Tx queue start entry %ld dirty entry %ld.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 dev->name, tp->cur_tx, tp->dirty_tx);
1649 for (i = 0; i < NUM_TX_DESC; i++)
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001650 pr_debug("%s: Tx descriptor %d is %8.8lx.%s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 dev->name, i, RTL_R32 (TxStatus0 + (i * 4)),
1652 i == tp->dirty_tx % NUM_TX_DESC ?
1653 " (queue head)" : "");
1654
1655 tp->xstats.tx_timeouts++;
1656
1657 /* disable Tx ASAP, if not already */
1658 tmp8 = RTL_R8 (ChipCmd);
1659 if (tmp8 & CmdTxEnb)
1660 RTL_W8 (ChipCmd, CmdRxEnb);
1661
Francois Romieu371e8bc2006-01-31 01:04:33 +01001662 spin_lock_bh(&tp->rx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 /* Disable interrupts by clearing the interrupt mask. */
1664 RTL_W16 (IntrMask, 0x0000);
1665
1666 /* Stop a shared interrupt from scavenging while we are. */
Francois Romieu371e8bc2006-01-31 01:04:33 +01001667 spin_lock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 rtl8139_tx_clear (tp);
Francois Romieu371e8bc2006-01-31 01:04:33 +01001669 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
1671 /* ...and finally, reset everything */
1672 if (netif_running(dev)) {
1673 rtl8139_hw_start (dev);
1674 netif_wake_queue (dev);
1675 }
Francois Romieu371e8bc2006-01-31 01:04:33 +01001676 spin_unlock_bh(&tp->rx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677}
1678
Francois Romieu371e8bc2006-01-31 01:04:33 +01001679static void rtl8139_tx_timeout (struct net_device *dev)
1680{
1681 struct rtl8139_private *tp = netdev_priv(dev);
1682
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001683 tp->watchdog_fired = 1;
Francois Romieu371e8bc2006-01-31 01:04:33 +01001684 if (!tp->have_thread) {
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001685 INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
Francois Romieu371e8bc2006-01-31 01:04:33 +01001686 schedule_delayed_work(&tp->thread, next_tick);
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001687 }
Francois Romieu371e8bc2006-01-31 01:04:33 +01001688}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689
Stephen Hemminger613573252009-08-31 19:50:58 +00001690static netdev_tx_t rtl8139_start_xmit (struct sk_buff *skb,
1691 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692{
1693 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001694 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 unsigned int entry;
1696 unsigned int len = skb->len;
Arjan van de Venbce305f2006-07-05 15:00:40 +02001697 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698
1699 /* Calculate the next Tx descriptor entry. */
1700 entry = tp->cur_tx % NUM_TX_DESC;
1701
1702 /* Note: the chip doesn't have auto-pad! */
1703 if (likely(len < TX_BUF_SIZE)) {
1704 if (len < ETH_ZLEN)
1705 memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1706 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1707 dev_kfree_skb(skb);
1708 } else {
1709 dev_kfree_skb(skb);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001710 dev->stats.tx_dropped++;
Patrick McHardy6ed10652009-06-23 06:03:08 +00001711 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 }
1713
Arjan van de Venbce305f2006-07-05 15:00:40 +02001714 spin_lock_irqsave(&tp->lock, flags);
Andreas Oberritter176eaa52008-10-08 06:14:16 +00001715 /*
1716 * Writing to TxStatus triggers a DMA transfer of the data
1717 * copied to tp->tx_buf[entry] above. Use a memory barrier
1718 * to make sure that the device sees the updated data.
1719 */
1720 wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1722 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1723
1724 dev->trans_start = jiffies;
1725
1726 tp->cur_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
1728 if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1729 netif_stop_queue (dev);
Arjan van de Venbce305f2006-07-05 15:00:40 +02001730 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732 if (netif_msg_tx_queued(tp))
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001733 pr_debug("%s: Queued Tx packet size %u to slot %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 dev->name, len, entry);
1735
Patrick McHardy6ed10652009-06-23 06:03:08 +00001736 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737}
1738
1739
1740static void rtl8139_tx_interrupt (struct net_device *dev,
1741 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001742 void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743{
1744 unsigned long dirty_tx, tx_left;
1745
1746 assert (dev != NULL);
1747 assert (ioaddr != NULL);
1748
1749 dirty_tx = tp->dirty_tx;
1750 tx_left = tp->cur_tx - dirty_tx;
1751 while (tx_left > 0) {
1752 int entry = dirty_tx % NUM_TX_DESC;
1753 int txstatus;
1754
1755 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1756
1757 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1758 break; /* It still hasn't been Txed */
1759
1760 /* Note: TxCarrierLost is always asserted at 100mbps. */
1761 if (txstatus & (TxOutOfWindow | TxAborted)) {
1762 /* There was an major error, log it. */
1763 if (netif_msg_tx_err(tp))
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001764 pr_debug("%s: Transmit error, Tx status %8.8x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 dev->name, txstatus);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001766 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 if (txstatus & TxAborted) {
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001768 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 RTL_W32 (TxConfig, TxClearAbt);
1770 RTL_W16 (IntrStatus, TxErr);
1771 wmb();
1772 }
1773 if (txstatus & TxCarrierLost)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001774 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 if (txstatus & TxOutOfWindow)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001776 dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 } else {
1778 if (txstatus & TxUnderrun) {
1779 /* Add 64 to the Tx FIFO threshold. */
1780 if (tp->tx_flag < 0x00300000)
1781 tp->tx_flag += 0x00020000;
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001782 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 }
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001784 dev->stats.collisions += (txstatus >> 24) & 15;
1785 dev->stats.tx_bytes += txstatus & 0x7ff;
1786 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 }
1788
1789 dirty_tx++;
1790 tx_left--;
1791 }
1792
1793#ifndef RTL8139_NDEBUG
1794 if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001795 pr_err("%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 dev->name, dirty_tx, tp->cur_tx);
1797 dirty_tx += NUM_TX_DESC;
1798 }
1799#endif /* RTL8139_NDEBUG */
1800
1801 /* only wake the queue if we did work, and the queue is stopped */
1802 if (tp->dirty_tx != dirty_tx) {
1803 tp->dirty_tx = dirty_tx;
1804 mb();
1805 netif_wake_queue (dev);
1806 }
1807}
1808
1809
1810/* TODO: clean this up! Rx reset need not be this intensive */
1811static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001812 struct rtl8139_private *tp, void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813{
1814 u8 tmp8;
1815#ifdef CONFIG_8139_OLD_RX_RESET
1816 int tmp_work;
1817#endif
1818
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001819 if (netif_msg_rx_err (tp))
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001820 pr_debug("%s: Ethernet frame had errors, status %8.8x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 dev->name, rx_status);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001822 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 if (!(rx_status & RxStatusOK)) {
1824 if (rx_status & RxTooLong) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001825 pr_debug("%s: Oversized Ethernet frame, status %4.4x!\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 dev->name, rx_status);
1827 /* A.C.: The chip hangs here. */
1828 }
1829 if (rx_status & (RxBadSymbol | RxBadAlign))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001830 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 if (rx_status & (RxRunt | RxTooLong))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001832 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 if (rx_status & RxCRCErr)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001834 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 } else {
1836 tp->xstats.rx_lost_in_ring++;
1837 }
1838
1839#ifndef CONFIG_8139_OLD_RX_RESET
1840 tmp8 = RTL_R8 (ChipCmd);
1841 RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1842 RTL_W8 (ChipCmd, tmp8);
1843 RTL_W32 (RxConfig, tp->rx_config);
1844 tp->cur_rx = 0;
1845#else
1846 /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1847
1848 /* disable receive */
1849 RTL_W8_F (ChipCmd, CmdTxEnb);
1850 tmp_work = 200;
1851 while (--tmp_work > 0) {
1852 udelay(1);
1853 tmp8 = RTL_R8 (ChipCmd);
1854 if (!(tmp8 & CmdRxEnb))
1855 break;
1856 }
1857 if (tmp_work <= 0)
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001858 pr_warning(PFX "rx stop wait too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 /* restart receive */
1860 tmp_work = 200;
1861 while (--tmp_work > 0) {
1862 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1863 udelay(1);
1864 tmp8 = RTL_R8 (ChipCmd);
1865 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1866 break;
1867 }
1868 if (tmp_work <= 0)
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001869 pr_warning(PFX "tx/rx enable wait too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870
1871 /* and reinitialize all rx related registers */
1872 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1873 /* Must enable Tx/Rx before setting transfer thresholds! */
1874 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1875
1876 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1877 RTL_W32 (RxConfig, tp->rx_config);
1878 tp->cur_rx = 0;
1879
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001880 pr_debug("init buffer addresses\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
1882 /* Lock Config[01234] and BMCR register writes */
1883 RTL_W8 (Cfg9346, Cfg9346_Lock);
1884
1885 /* init Rx ring buffer DMA address */
1886 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1887
1888 /* A.C.: Reset the multicast list. */
1889 __set_rx_mode (dev);
1890#endif
1891}
1892
1893#if RX_BUF_IDX == 3
Márton Németha9879c42008-06-15 09:52:30 +02001894static inline void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 u32 offset, unsigned int size)
1896{
1897 u32 left = RX_BUF_LEN - offset;
1898
1899 if (size > left) {
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001900 skb_copy_to_linear_data(skb, ring + offset, left);
1901 skb_copy_to_linear_data_offset(skb, left, ring, size - left);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 } else
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001903 skb_copy_to_linear_data(skb, ring + offset, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904}
1905#endif
1906
1907static void rtl8139_isr_ack(struct rtl8139_private *tp)
1908{
Pekka Enberg22f714b2005-05-12 19:38:47 -04001909 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 u16 status;
1911
1912 status = RTL_R16 (IntrStatus) & RxAckBits;
1913
1914 /* Clear out errors and receive interrupts */
1915 if (likely(status != 0)) {
1916 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001917 tp->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 if (status & RxFIFOOver)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001919 tp->dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 }
1921 RTL_W16_F (IntrStatus, RxAckBits);
1922 }
1923}
1924
1925static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1926 int budget)
1927{
Pekka Enberg22f714b2005-05-12 19:38:47 -04001928 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 int received = 0;
1930 unsigned char *rx_ring = tp->rx_ring;
1931 unsigned int cur_rx = tp->cur_rx;
1932 unsigned int rx_size = 0;
1933
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001934 pr_debug("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x,"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx,
1936 RTL_R16 (RxBufAddr),
1937 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
1938
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001939 while (netif_running(dev) && received < budget
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
1941 u32 ring_offset = cur_rx % RX_BUF_LEN;
1942 u32 rx_status;
1943 unsigned int pkt_size;
1944 struct sk_buff *skb;
1945
1946 rmb();
1947
1948 /* read size+status of next frame from DMA ring buffer */
Al Viroeca1ad82008-03-16 22:21:54 +00001949 rx_status = le32_to_cpu (*(__le32 *) (rx_ring + ring_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 rx_size = rx_status >> 16;
1951 pkt_size = rx_size - 4;
1952
1953 if (netif_msg_rx_status(tp))
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001954 pr_debug("%s: rtl8139_rx() status %4.4x, size %4.4x,"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 " cur %4.4x.\n", dev->name, rx_status,
1956 rx_size, cur_rx);
1957#if RTL8139_DEBUG > 2
1958 {
1959 int i;
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001960 pr_debug("%s: Frame contents ", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 for (i = 0; i < 70; i++)
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001962 pr_cont(" %2.2x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 rx_ring[ring_offset + i]);
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001964 pr_cont(".\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 }
1966#endif
1967
1968 /* Packet copy from FIFO still in progress.
1969 * Theoretically, this should never happen
1970 * since EarlyRx is disabled.
1971 */
1972 if (unlikely(rx_size == 0xfff0)) {
1973 if (!tp->fifo_copy_timeout)
1974 tp->fifo_copy_timeout = jiffies + 2;
1975 else if (time_after(jiffies, tp->fifo_copy_timeout)) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001976 pr_debug("%s: hung FIFO. Reset.", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 rx_size = 0;
1978 goto no_early_rx;
1979 }
1980 if (netif_msg_intr(tp)) {
Alexander Beregalovb93d5842009-05-26 12:35:27 +00001981 pr_debug("%s: fifo copy in progress.",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 dev->name);
1983 }
1984 tp->xstats.early_rx++;
1985 break;
1986 }
1987
1988no_early_rx:
1989 tp->fifo_copy_timeout = 0;
1990
1991 /* If Rx err or invalid rx_size/rx_status received
1992 * (which happens if we get lost in the ring),
1993 * Rx process gets reset, so we abort any further
1994 * Rx processing.
1995 */
1996 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1997 (rx_size < 8) ||
1998 (!(rx_status & RxStatusOK)))) {
1999 rtl8139_rx_err (rx_status, dev, tp, ioaddr);
2000 received = -1;
2001 goto out;
2002 }
2003
2004 /* Malloc up new buffer, compatible with net-2e. */
2005 /* Omit the four octet CRC from the length. */
2006
Eric Dumazet89d71a62009-10-13 05:34:20 +00002007 skb = netdev_alloc_skb_ip_align(dev, pkt_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 if (likely(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009#if RX_BUF_IDX == 3
2010 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
2011#else
David S. Miller8c7b7fa2007-07-10 22:08:12 -07002012 skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013#endif
2014 skb_put (skb, pkt_size);
2015
2016 skb->protocol = eth_type_trans (skb, dev);
2017
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002018 dev->stats.rx_bytes += pkt_size;
2019 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020
2021 netif_receive_skb (skb);
2022 } else {
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002023 if (net_ratelimit())
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002024 pr_warning("%s: Memory squeeze, dropping packet.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 dev->name);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002026 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 }
2028 received++;
2029
2030 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2031 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2032
2033 rtl8139_isr_ack(tp);
2034 }
2035
2036 if (unlikely(!received || rx_size == 0xfff0))
2037 rtl8139_isr_ack(tp);
2038
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002039 pr_debug("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x,"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
2041 RTL_R16 (RxBufAddr),
2042 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043
2044 tp->cur_rx = cur_rx;
2045
2046 /*
2047 * The receive buffer should be mostly empty.
2048 * Tell NAPI to reenable the Rx irq.
2049 */
2050 if (tp->fifo_copy_timeout)
2051 received = budget;
2052
2053out:
2054 return received;
2055}
2056
2057
2058static void rtl8139_weird_interrupt (struct net_device *dev,
2059 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04002060 void __iomem *ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 int status, int link_changed)
2062{
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002063 pr_debug("%s: Abnormal interrupt, status %8.8x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 dev->name, status);
2065
2066 assert (dev != NULL);
2067 assert (tp != NULL);
2068 assert (ioaddr != NULL);
2069
2070 /* Update the error count. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002071 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 RTL_W32 (RxMissed, 0);
2073
2074 if ((status & RxUnderrun) && link_changed &&
2075 (tp->drv_flags & HAS_LNK_CHNG)) {
2076 rtl_check_media(dev, 0);
2077 status &= ~RxUnderrun;
2078 }
2079
2080 if (status & (RxUnderrun | RxErr))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002081 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082
2083 if (status & PCSTimeout)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002084 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 if (status & RxUnderrun)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002086 dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 if (status & PCIErr) {
2088 u16 pci_cmd_status;
2089 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2090 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2091
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002092 pr_err("%s: PCI Bus error %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 dev->name, pci_cmd_status);
2094 }
2095}
2096
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002097static int rtl8139_poll(struct napi_struct *napi, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002099 struct rtl8139_private *tp = container_of(napi, struct rtl8139_private, napi);
2100 struct net_device *dev = tp->dev;
Pekka Enberg22f714b2005-05-12 19:38:47 -04002101 void __iomem *ioaddr = tp->mmio_addr;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002102 int work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103
2104 spin_lock(&tp->rx_lock);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002105 work_done = 0;
2106 if (likely(RTL_R16(IntrStatus) & RxAckBits))
2107 work_done += rtl8139_rx(dev, tp, budget);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002109 if (work_done < budget) {
Ingo Molnarb57bd062006-12-12 13:49:35 +01002110 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 /*
2112 * Order is important since data can get interrupted
2113 * again when we think we are done.
2114 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002115 spin_lock_irqsave(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 RTL_W16_F(IntrMask, rtl8139_intr_mask);
Ben Hutchings288379f2009-01-19 16:43:59 -08002117 __napi_complete(napi);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002118 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 }
2120 spin_unlock(&tp->rx_lock);
2121
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002122 return work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123}
2124
2125/* The interrupt handler does all of the Rx thread work and cleans up
2126 after the Tx thread. */
David Howells7d12e782006-10-05 14:55:46 +01002127static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128{
2129 struct net_device *dev = (struct net_device *) dev_instance;
2130 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002131 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 u16 status, ackstat;
2133 int link_changed = 0; /* avoid bogus "uninit" warning */
2134 int handled = 0;
2135
2136 spin_lock (&tp->lock);
2137 status = RTL_R16 (IntrStatus);
2138
2139 /* shared irq? */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002140 if (unlikely((status & rtl8139_intr_mask) == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 goto out;
2142
2143 handled = 1;
2144
2145 /* h/w no longer present (hotplug?) or major error, bail */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002146 if (unlikely(status == 0xFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 goto out;
2148
2149 /* close possible race's with dev_close */
2150 if (unlikely(!netif_running(dev))) {
2151 RTL_W16 (IntrMask, 0);
2152 goto out;
2153 }
2154
2155 /* Acknowledge all of the current interrupt sources ASAP, but
2156 an first get an additional status bit from CSCR. */
2157 if (unlikely(status & RxUnderrun))
2158 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2159
2160 ackstat = status & ~(RxAckBits | TxErr);
2161 if (ackstat)
2162 RTL_W16 (IntrStatus, ackstat);
2163
2164 /* Receive packets are processed by poll routine.
2165 If not running start it now. */
2166 if (status & RxAckBits){
Ben Hutchings288379f2009-01-19 16:43:59 -08002167 if (napi_schedule_prep(&tp->napi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
Ben Hutchings288379f2009-01-19 16:43:59 -08002169 __napi_schedule(&tp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 }
2171 }
2172
2173 /* Check uncommon events with one test. */
2174 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2175 rtl8139_weird_interrupt (dev, tp, ioaddr,
2176 status, link_changed);
2177
2178 if (status & (TxOK | TxErr)) {
2179 rtl8139_tx_interrupt (dev, tp, ioaddr);
2180 if (status & TxErr)
2181 RTL_W16 (IntrStatus, TxErr);
2182 }
2183 out:
2184 spin_unlock (&tp->lock);
2185
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002186 pr_debug("%s: exiting interrupt, intr_status=%#4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 dev->name, RTL_R16 (IntrStatus));
2188 return IRQ_RETVAL(handled);
2189}
2190
2191#ifdef CONFIG_NET_POLL_CONTROLLER
2192/*
2193 * Polling receive - used by netconsole and other diagnostic tools
2194 * to allow network i/o with interrupts disabled.
2195 */
2196static void rtl8139_poll_controller(struct net_device *dev)
2197{
2198 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +01002199 rtl8139_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 enable_irq(dev->irq);
2201}
2202#endif
2203
Jiri Pirkobda6a152009-03-13 11:48:18 -07002204static int rtl8139_set_mac_address(struct net_device *dev, void *p)
2205{
2206 struct rtl8139_private *tp = netdev_priv(dev);
2207 void __iomem *ioaddr = tp->mmio_addr;
2208 struct sockaddr *addr = p;
2209
2210 if (!is_valid_ether_addr(addr->sa_data))
2211 return -EADDRNOTAVAIL;
2212
2213 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
2214
2215 spin_lock_irq(&tp->lock);
2216
2217 RTL_W8_F(Cfg9346, Cfg9346_Unlock);
2218 RTL_W32_F(MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
2219 RTL_W32_F(MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
2220 RTL_W8_F(Cfg9346, Cfg9346_Lock);
2221
2222 spin_unlock_irq(&tp->lock);
2223
2224 return 0;
2225}
2226
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227static int rtl8139_close (struct net_device *dev)
2228{
2229 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002230 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 unsigned long flags;
2232
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002233 netif_stop_queue(dev);
2234 napi_disable(&tp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 if (netif_msg_ifdown(tp))
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002237 pr_debug("%s: Shutting down ethercard, status was 0x%4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 dev->name, RTL_R16 (IntrStatus));
2239
2240 spin_lock_irqsave (&tp->lock, flags);
2241
2242 /* Stop the chip's Tx and Rx DMA processes. */
2243 RTL_W8 (ChipCmd, 0);
2244
2245 /* Disable interrupts by clearing the interrupt mask. */
2246 RTL_W16 (IntrMask, 0);
2247
2248 /* Update the error counts. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002249 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 RTL_W32 (RxMissed, 0);
2251
2252 spin_unlock_irqrestore (&tp->lock, flags);
2253
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 free_irq (dev->irq, dev);
2255
2256 rtl8139_tx_clear (tp);
2257
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04002258 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
2259 tp->rx_ring, tp->rx_ring_dma);
2260 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
2261 tp->tx_bufs, tp->tx_bufs_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 tp->rx_ring = NULL;
2263 tp->tx_bufs = NULL;
2264
2265 /* Green! Put the chip in low-power mode. */
2266 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2267
2268 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2269 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
2270
2271 return 0;
2272}
2273
2274
2275/* Get the ethtool Wake-on-LAN settings. Assumes that wol points to
2276 kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2277 other threads or interrupts aren't messing with the 8139. */
2278static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2279{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002280 struct rtl8139_private *tp = netdev_priv(dev);
2281 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002283 spin_lock_irq(&tp->lock);
2284 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 u8 cfg3 = RTL_R8 (Config3);
2286 u8 cfg5 = RTL_R8 (Config5);
2287
2288 wol->supported = WAKE_PHY | WAKE_MAGIC
2289 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2290
2291 wol->wolopts = 0;
2292 if (cfg3 & Cfg3_LinkUp)
2293 wol->wolopts |= WAKE_PHY;
2294 if (cfg3 & Cfg3_Magic)
2295 wol->wolopts |= WAKE_MAGIC;
2296 /* (KON)FIXME: See how netdev_set_wol() handles the
2297 following constants. */
2298 if (cfg5 & Cfg5_UWF)
2299 wol->wolopts |= WAKE_UCAST;
2300 if (cfg5 & Cfg5_MWF)
2301 wol->wolopts |= WAKE_MCAST;
2302 if (cfg5 & Cfg5_BWF)
2303 wol->wolopts |= WAKE_BCAST;
2304 }
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002305 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306}
2307
2308
2309/* Set the ethtool Wake-on-LAN settings. Return 0 or -errno. Assumes
2310 that wol points to kernel memory and other threads or interrupts
2311 aren't messing with the 8139. */
2312static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2313{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002314 struct rtl8139_private *tp = netdev_priv(dev);
2315 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 u32 support;
2317 u8 cfg3, cfg5;
2318
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002319 support = ((rtl_chip_info[tp->chipset].flags & HasLWake)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 ? (WAKE_PHY | WAKE_MAGIC
2321 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2322 : 0);
2323 if (wol->wolopts & ~support)
2324 return -EINVAL;
2325
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002326 spin_lock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2328 if (wol->wolopts & WAKE_PHY)
2329 cfg3 |= Cfg3_LinkUp;
2330 if (wol->wolopts & WAKE_MAGIC)
2331 cfg3 |= Cfg3_Magic;
2332 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2333 RTL_W8 (Config3, cfg3);
2334 RTL_W8 (Cfg9346, Cfg9346_Lock);
2335
2336 cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2337 /* (KON)FIXME: These are untested. We may have to set the
2338 CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2339 documentation. */
2340 if (wol->wolopts & WAKE_UCAST)
2341 cfg5 |= Cfg5_UWF;
2342 if (wol->wolopts & WAKE_MCAST)
2343 cfg5 |= Cfg5_MWF;
2344 if (wol->wolopts & WAKE_BCAST)
2345 cfg5 |= Cfg5_BWF;
2346 RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002347 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
2349 return 0;
2350}
2351
2352static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2353{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002354 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355 strcpy(info->driver, DRV_NAME);
2356 strcpy(info->version, DRV_VERSION);
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002357 strcpy(info->bus_info, pci_name(tp->pci_dev));
2358 info->regdump_len = tp->regs_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359}
2360
2361static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2362{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002363 struct rtl8139_private *tp = netdev_priv(dev);
2364 spin_lock_irq(&tp->lock);
2365 mii_ethtool_gset(&tp->mii, cmd);
2366 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367 return 0;
2368}
2369
2370static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2371{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002372 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 int rc;
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002374 spin_lock_irq(&tp->lock);
2375 rc = mii_ethtool_sset(&tp->mii, cmd);
2376 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 return rc;
2378}
2379
2380static int rtl8139_nway_reset(struct net_device *dev)
2381{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002382 struct rtl8139_private *tp = netdev_priv(dev);
2383 return mii_nway_restart(&tp->mii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384}
2385
2386static u32 rtl8139_get_link(struct net_device *dev)
2387{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002388 struct rtl8139_private *tp = netdev_priv(dev);
2389 return mii_link_ok(&tp->mii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390}
2391
2392static u32 rtl8139_get_msglevel(struct net_device *dev)
2393{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002394 struct rtl8139_private *tp = netdev_priv(dev);
2395 return tp->msg_enable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396}
2397
2398static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2399{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002400 struct rtl8139_private *tp = netdev_priv(dev);
2401 tp->msg_enable = datum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402}
2403
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404static int rtl8139_get_regs_len(struct net_device *dev)
2405{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002406 struct rtl8139_private *tp;
Dave Joneseb581342008-07-15 19:54:53 -04002407 /* TODO: we are too slack to do reg dumping for pio, for now */
2408 if (use_io)
2409 return 0;
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002410 tp = netdev_priv(dev);
2411 return tp->regs_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412}
2413
2414static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2415{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002416 struct rtl8139_private *tp;
Dave Joneseb581342008-07-15 19:54:53 -04002417
2418 /* TODO: we are too slack to do reg dumping for pio, for now */
2419 if (use_io)
2420 return;
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002421 tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422
2423 regs->version = RTL_REGS_VER;
2424
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002425 spin_lock_irq(&tp->lock);
2426 memcpy_fromio(regbuf, tp->mmio_addr, regs->len);
2427 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002430static int rtl8139_get_sset_count(struct net_device *dev, int sset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431{
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002432 switch (sset) {
2433 case ETH_SS_STATS:
2434 return RTL_NUM_STATS;
2435 default:
2436 return -EOPNOTSUPP;
2437 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438}
2439
2440static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2441{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002442 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002444 data[0] = tp->xstats.early_rx;
2445 data[1] = tp->xstats.tx_buf_mapped;
2446 data[2] = tp->xstats.tx_timeouts;
2447 data[3] = tp->xstats.rx_lost_in_ring;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448}
2449
2450static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2451{
2452 memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2453}
2454
Jeff Garzik7282d492006-09-13 14:30:00 -04002455static const struct ethtool_ops rtl8139_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 .get_drvinfo = rtl8139_get_drvinfo,
2457 .get_settings = rtl8139_get_settings,
2458 .set_settings = rtl8139_set_settings,
2459 .get_regs_len = rtl8139_get_regs_len,
2460 .get_regs = rtl8139_get_regs,
2461 .nway_reset = rtl8139_nway_reset,
2462 .get_link = rtl8139_get_link,
2463 .get_msglevel = rtl8139_get_msglevel,
2464 .set_msglevel = rtl8139_set_msglevel,
2465 .get_wol = rtl8139_get_wol,
2466 .set_wol = rtl8139_set_wol,
2467 .get_strings = rtl8139_get_strings,
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002468 .get_sset_count = rtl8139_get_sset_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 .get_ethtool_stats = rtl8139_get_ethtool_stats,
2470};
2471
2472static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2473{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002474 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 int rc;
2476
2477 if (!netif_running(dev))
2478 return -EINVAL;
2479
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002480 spin_lock_irq(&tp->lock);
2481 rc = generic_mii_ioctl(&tp->mii, if_mii(rq), cmd, NULL);
2482 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483
2484 return rc;
2485}
2486
2487
2488static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2489{
2490 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002491 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492 unsigned long flags;
2493
2494 if (netif_running(dev)) {
2495 spin_lock_irqsave (&tp->lock, flags);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002496 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 RTL_W32 (RxMissed, 0);
2498 spin_unlock_irqrestore (&tp->lock, flags);
2499 }
2500
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002501 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502}
2503
2504/* Set or clear the multicast filter for this adaptor.
2505 This routine is not state sensitive and need not be SMP locked. */
2506
2507static void __set_rx_mode (struct net_device *dev)
2508{
2509 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002510 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 u32 mc_filter[2]; /* Multicast hash filter */
2512 int i, rx_mode;
2513 u32 tmp;
2514
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002515 pr_debug("%s: rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 dev->name, dev->flags, RTL_R32 (RxConfig));
2517
2518 /* Note: do not reorder, GCC is clever about common statements. */
2519 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 rx_mode =
2521 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2522 AcceptAllPhys;
2523 mc_filter[1] = mc_filter[0] = 0xffffffff;
2524 } else if ((dev->mc_count > multicast_filter_limit)
2525 || (dev->flags & IFF_ALLMULTI)) {
2526 /* Too many to filter perfectly -- accept all multicasts. */
2527 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2528 mc_filter[1] = mc_filter[0] = 0xffffffff;
2529 } else {
2530 struct dev_mc_list *mclist;
2531 rx_mode = AcceptBroadcast | AcceptMyPhys;
2532 mc_filter[1] = mc_filter[0] = 0;
2533 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2534 i++, mclist = mclist->next) {
2535 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
2536
2537 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2538 rx_mode |= AcceptMulticast;
2539 }
2540 }
2541
2542 /* We can safely update without stopping the chip. */
2543 tmp = rtl8139_rx_config | rx_mode;
2544 if (tp->rx_config != tmp) {
2545 RTL_W32_F (RxConfig, tmp);
2546 tp->rx_config = tmp;
2547 }
2548 RTL_W32_F (MAR0 + 0, mc_filter[0]);
2549 RTL_W32_F (MAR0 + 4, mc_filter[1]);
2550}
2551
2552static void rtl8139_set_rx_mode (struct net_device *dev)
2553{
2554 unsigned long flags;
2555 struct rtl8139_private *tp = netdev_priv(dev);
2556
2557 spin_lock_irqsave (&tp->lock, flags);
2558 __set_rx_mode(dev);
2559 spin_unlock_irqrestore (&tp->lock, flags);
2560}
2561
2562#ifdef CONFIG_PM
2563
2564static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2565{
2566 struct net_device *dev = pci_get_drvdata (pdev);
2567 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002568 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 unsigned long flags;
2570
2571 pci_save_state (pdev);
2572
2573 if (!netif_running (dev))
2574 return 0;
2575
2576 netif_device_detach (dev);
2577
2578 spin_lock_irqsave (&tp->lock, flags);
2579
2580 /* Disable interrupts, stop Tx and Rx. */
2581 RTL_W16 (IntrMask, 0);
2582 RTL_W8 (ChipCmd, 0);
2583
2584 /* Update the error counts. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002585 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 RTL_W32 (RxMissed, 0);
2587
2588 spin_unlock_irqrestore (&tp->lock, flags);
2589
2590 pci_set_power_state (pdev, PCI_D3hot);
2591
2592 return 0;
2593}
2594
2595
2596static int rtl8139_resume (struct pci_dev *pdev)
2597{
2598 struct net_device *dev = pci_get_drvdata (pdev);
2599
2600 pci_restore_state (pdev);
2601 if (!netif_running (dev))
2602 return 0;
2603 pci_set_power_state (pdev, PCI_D0);
2604 rtl8139_init_ring (dev);
2605 rtl8139_hw_start (dev);
2606 netif_device_attach (dev);
2607 return 0;
2608}
2609
2610#endif /* CONFIG_PM */
2611
2612
2613static struct pci_driver rtl8139_pci_driver = {
2614 .name = DRV_NAME,
2615 .id_table = rtl8139_pci_tbl,
2616 .probe = rtl8139_init_one,
2617 .remove = __devexit_p(rtl8139_remove_one),
2618#ifdef CONFIG_PM
2619 .suspend = rtl8139_suspend,
2620 .resume = rtl8139_resume,
2621#endif /* CONFIG_PM */
2622};
2623
2624
2625static int __init rtl8139_init_module (void)
2626{
2627 /* when we're a module, we always print a version message,
2628 * even if no 8139 board is found.
2629 */
2630#ifdef MODULE
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002631 pr_info(RTL8139_DRIVER_NAME "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632#endif
2633
Jeff Garzik29917622006-08-19 17:48:59 -04002634 return pci_register_driver(&rtl8139_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635}
2636
2637
2638static void __exit rtl8139_cleanup_module (void)
2639{
2640 pci_unregister_driver (&rtl8139_pci_driver);
2641}
2642
2643
2644module_init(rtl8139_init_module);
2645module_exit(rtl8139_cleanup_module);