blob: 4ba72933f0da57b72f069e4d95a29fc1ad8da1f1 [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
Joe Perches497159a2010-02-17 15:01:49 +000092#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#define DRV_NAME "8139too"
Andy Gospodarekd5b20692006-09-11 17:39:18 -040095#define DRV_VERSION "0.9.28"
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#include <linux/module.h>
99#include <linux/kernel.h>
100#include <linux/compiler.h>
101#include <linux/pci.h>
102#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103#include <linux/netdevice.h>
104#include <linux/etherdevice.h>
105#include <linux/rtnetlink.h>
106#include <linux/delay.h>
107#include <linux/ethtool.h>
108#include <linux/mii.h>
109#include <linux/completion.h>
110#include <linux/crc32.h>
Márton Németha9879c42008-06-15 09:52:30 +0200111#include <linux/io.h>
112#include <linux/uaccess.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +0900113#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114#include <asm/irq.h>
115
116#define RTL8139_DRIVER_NAME DRV_NAME " Fast Ethernet driver " DRV_VERSION
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118/* Default Message level */
119#define RTL8139_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
120 NETIF_MSG_PROBE | \
121 NETIF_MSG_LINK)
122
123
Olaf Hering44456d32005-07-27 11:45:17 -0700124/* define to 1, 2 or 3 to enable copious debugging info */
125#define RTL8139_DEBUG 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
127/* define to 1 to disable lightweight runtime debugging checks */
128#undef RTL8139_NDEBUG
129
130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131#ifdef RTL8139_NDEBUG
132# define assert(expr) do {} while (0)
133#else
134# define assert(expr) \
Joe Perches497159a2010-02-17 15:01:49 +0000135 if (unlikely(!(expr))) { \
136 pr_err("Assertion failed! %s,%s,%s,line=%d\n", \
137 #expr, __FILE__, __func__, __LINE__); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 }
139#endif
140
141
142/* A few user-configurable values. */
143/* media options */
144#define MAX_UNITS 8
145static int media[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
146static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
147
Dave Joneseb581342008-07-15 19:54:53 -0400148/* Whether to use MMIO or PIO. Default to MMIO. */
149#ifdef CONFIG_8139TOO_PIO
150static int use_io = 1;
151#else
152static int use_io = 0;
153#endif
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
156 The RTL chips use a 64 element hash table based on the Ethernet CRC. */
157static int multicast_filter_limit = 32;
158
159/* bitmapped message enable number */
160static int debug = -1;
161
162/*
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400163 * Receive ring size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 * Warning: 64K ring has hardware issues and may lock up.
165 */
166#if defined(CONFIG_SH_DREAMCAST)
Adrian McMenamin2192f392008-02-08 11:21:58 +0000167#define RX_BUF_IDX 0 /* 8K ring */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168#else
169#define RX_BUF_IDX 2 /* 32K ring */
170#endif
171#define RX_BUF_LEN (8192 << RX_BUF_IDX)
172#define RX_BUF_PAD 16
173#define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
174
175#if RX_BUF_LEN == 65536
176#define RX_BUF_TOT_LEN RX_BUF_LEN
177#else
178#define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
179#endif
180
181/* Number of Tx descriptor registers. */
182#define NUM_TX_DESC 4
183
184/* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
185#define MAX_ETH_FRAME_SIZE 1536
186
187/* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
188#define TX_BUF_SIZE MAX_ETH_FRAME_SIZE
189#define TX_BUF_TOT_LEN (TX_BUF_SIZE * NUM_TX_DESC)
190
191/* PCI Tuning Parameters
192 Threshold is bytes transferred to chip before transmission starts. */
193#define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
194
195/* The following settings are log_2(bytes)-4: 0 == 16 bytes .. 6==1024, 7==end of packet. */
196#define RX_FIFO_THRESH 7 /* Rx buffer level before first PCI xfer. */
197#define RX_DMA_BURST 7 /* Maximum PCI burst, '6' is 1024 */
198#define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
199#define TX_RETRY 8 /* 0-15. retries = 16 + (TX_RETRY * 16) */
200
201/* Operational parameters that usually are not changed. */
202/* Time in jiffies before concluding the transmitter is hung. */
203#define TX_TIMEOUT (6*HZ)
204
205
206enum {
207 HAS_MII_XCVR = 0x010000,
208 HAS_CHIP_XCVR = 0x020000,
209 HAS_LNK_CHNG = 0x040000,
210};
211
212#define RTL_NUM_STATS 4 /* number of ETHTOOL_GSTATS u64's */
213#define RTL_REGS_VER 1 /* version of reg. data in ETHTOOL_GREGS */
214#define RTL_MIN_IO_SIZE 0x80
215#define RTL8139B_IO_SIZE 256
216
217#define RTL8129_CAPS HAS_MII_XCVR
Márton Németha9879c42008-06-15 09:52:30 +0200218#define RTL8139_CAPS (HAS_CHIP_XCVR|HAS_LNK_CHNG)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220typedef enum {
221 RTL8139 = 0,
222 RTL8129,
223} board_t;
224
225
226/* indexed by board_t, above */
Arjan van de Venf71e1302006-03-03 21:33:57 -0500227static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 const char *name;
229 u32 hw_flags;
230} board_info[] __devinitdata = {
231 { "RealTek RTL8139", RTL8139_CAPS },
232 { "RealTek RTL8129", RTL8129_CAPS },
233};
234
235
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000236static DEFINE_PCI_DEVICE_TABLE(rtl8139_pci_tbl) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
238 {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
239 {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
240 {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
241 {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
242 {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
243 {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
244 {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
245 {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
246 {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
247 {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
248 {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
249 {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
250 {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
251 {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
252 {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
253 {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
254 {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400255 {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257#ifdef CONFIG_SH_SECUREEDGE5410
258 /* Bogus 8139 silicon reports 8129 without external PROM :-( */
259 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
260#endif
261#ifdef CONFIG_8139TOO_8129
262 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
263#endif
264
265 /* some crazy cards report invalid vendor ids like
266 * 0x0001 here. The other ids are valid and constant,
267 * so we simply don't match on the main vendor id.
268 */
269 {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
270 {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
271 {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
272
273 {0,}
274};
275MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);
276
277static struct {
278 const char str[ETH_GSTRING_LEN];
279} ethtool_stats_keys[] = {
280 { "early_rx" },
281 { "tx_buf_mapped" },
282 { "tx_timeouts" },
283 { "rx_lost_in_ring" },
284};
285
286/* The rest of these values should never change. */
287
288/* Symbolic offsets to registers. */
289enum RTL8139_registers {
Jeff Garzik28006c62007-09-15 12:36:46 -0700290 MAC0 = 0, /* Ethernet hardware address. */
291 MAR0 = 8, /* Multicast filter. */
292 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
293 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
294 RxBuf = 0x30,
295 ChipCmd = 0x37,
296 RxBufPtr = 0x38,
297 RxBufAddr = 0x3A,
298 IntrMask = 0x3C,
299 IntrStatus = 0x3E,
300 TxConfig = 0x40,
301 RxConfig = 0x44,
302 Timer = 0x48, /* A general-purpose counter. */
303 RxMissed = 0x4C, /* 24 bits valid, write clears. */
304 Cfg9346 = 0x50,
305 Config0 = 0x51,
306 Config1 = 0x52,
Mats Erik Anderssonda8de392008-07-17 01:05:43 +0200307 TimerInt = 0x54,
Jeff Garzik28006c62007-09-15 12:36:46 -0700308 MediaStatus = 0x58,
309 Config3 = 0x59,
310 Config4 = 0x5A, /* absent on RTL-8139A */
311 HltClk = 0x5B,
312 MultiIntr = 0x5C,
313 TxSummary = 0x60,
314 BasicModeCtrl = 0x62,
315 BasicModeStatus = 0x64,
316 NWayAdvert = 0x66,
317 NWayLPAR = 0x68,
318 NWayExpansion = 0x6A,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 /* Undocumented registers, but required for proper operation. */
Jeff Garzik28006c62007-09-15 12:36:46 -0700320 FIFOTMS = 0x70, /* FIFO Control and test. */
321 CSCR = 0x74, /* Chip Status and Configuration Register. */
322 PARA78 = 0x78,
Mats Erik Anderssonda8de392008-07-17 01:05:43 +0200323 FlashReg = 0xD4, /* Communication with Flash ROM, four bytes. */
Jeff Garzik28006c62007-09-15 12:36:46 -0700324 PARA7c = 0x7c, /* Magic transceiver parameter register. */
325 Config5 = 0xD8, /* absent on RTL-8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326};
327
328enum ClearBitMasks {
Jeff Garzik28006c62007-09-15 12:36:46 -0700329 MultiIntrClear = 0xF000,
330 ChipCmdClear = 0xE2,
331 Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332};
333
334enum ChipCmdBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700335 CmdReset = 0x10,
336 CmdRxEnb = 0x08,
337 CmdTxEnb = 0x04,
338 RxBufEmpty = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339};
340
341/* Interrupt register bits, using my own meaningful names. */
342enum IntrStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700343 PCIErr = 0x8000,
344 PCSTimeout = 0x4000,
345 RxFIFOOver = 0x40,
346 RxUnderrun = 0x20,
347 RxOverflow = 0x10,
348 TxErr = 0x08,
349 TxOK = 0x04,
350 RxErr = 0x02,
351 RxOK = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
Jeff Garzik28006c62007-09-15 12:36:46 -0700353 RxAckBits = RxFIFOOver | RxOverflow | RxOK,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354};
355
356enum TxStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700357 TxHostOwns = 0x2000,
358 TxUnderrun = 0x4000,
359 TxStatOK = 0x8000,
360 TxOutOfWindow = 0x20000000,
361 TxAborted = 0x40000000,
362 TxCarrierLost = 0x80000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363};
364enum RxStatusBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700365 RxMulticast = 0x8000,
366 RxPhysical = 0x4000,
367 RxBroadcast = 0x2000,
368 RxBadSymbol = 0x0020,
369 RxRunt = 0x0010,
370 RxTooLong = 0x0008,
371 RxCRCErr = 0x0004,
372 RxBadAlign = 0x0002,
373 RxStatusOK = 0x0001,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374};
375
376/* Bits in RxConfig. */
377enum rx_mode_bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700378 AcceptErr = 0x20,
379 AcceptRunt = 0x10,
380 AcceptBroadcast = 0x08,
381 AcceptMulticast = 0x04,
382 AcceptMyPhys = 0x02,
383 AcceptAllPhys = 0x01,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384};
385
386/* Bits in TxConfig. */
387enum tx_config_bits {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
Jeff Garzik28006c62007-09-15 12:36:46 -0700389 TxIFGShift = 24,
390 TxIFG84 = (0 << TxIFGShift), /* 8.4us / 840ns (10 / 100Mbps) */
391 TxIFG88 = (1 << TxIFGShift), /* 8.8us / 880ns (10 / 100Mbps) */
392 TxIFG92 = (2 << TxIFGShift), /* 9.2us / 920ns (10 / 100Mbps) */
393 TxIFG96 = (3 << TxIFGShift), /* 9.6us / 960ns (10 / 100Mbps) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Jeff Garzik28006c62007-09-15 12:36:46 -0700395 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
396 TxCRC = (1 << 16), /* DISABLE Tx pkt CRC append */
397 TxClearAbt = (1 << 0), /* Clear abort (WO) */
398 TxDMAShift = 8, /* DMA burst value (0-7) is shifted X many bits */
399 TxRetryShift = 4, /* TXRR value (0-15) is shifted X many bits */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Jeff Garzik28006c62007-09-15 12:36:46 -0700401 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402};
403
404/* Bits in Config1 */
405enum Config1Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700406 Cfg1_PM_Enable = 0x01,
407 Cfg1_VPD_Enable = 0x02,
408 Cfg1_PIO = 0x04,
409 Cfg1_MMIO = 0x08,
410 LWAKE = 0x10, /* not on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 Cfg1_Driver_Load = 0x20,
Jeff Garzik28006c62007-09-15 12:36:46 -0700412 Cfg1_LED0 = 0x40,
413 Cfg1_LED1 = 0x80,
414 SLEEP = (1 << 1), /* only on 8139, 8139A */
415 PWRDN = (1 << 0), /* only on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416};
417
418/* Bits in Config3 */
419enum Config3Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700420 Cfg3_FBtBEn = (1 << 0), /* 1 = Fast Back to Back */
421 Cfg3_FuncRegEn = (1 << 1), /* 1 = enable CardBus Function registers */
422 Cfg3_CLKRUN_En = (1 << 2), /* 1 = enable CLKRUN */
423 Cfg3_CardB_En = (1 << 3), /* 1 = enable CardBus registers */
424 Cfg3_LinkUp = (1 << 4), /* 1 = wake up on link up */
425 Cfg3_Magic = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
426 Cfg3_PARM_En = (1 << 6), /* 0 = software can set twister parameters */
427 Cfg3_GNTSel = (1 << 7), /* 1 = delay 1 clock from PCI GNT signal */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428};
429
430/* Bits in Config4 */
431enum Config4Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700432 LWPTN = (1 << 2), /* not on 8139, 8139A */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433};
434
435/* Bits in Config5 */
436enum Config5Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700437 Cfg5_PME_STS = (1 << 0), /* 1 = PCI reset resets PME_Status */
438 Cfg5_LANWake = (1 << 1), /* 1 = enable LANWake signal */
439 Cfg5_LDPS = (1 << 2), /* 0 = save power when link is down */
440 Cfg5_FIFOAddrPtr= (1 << 3), /* Realtek internal SRAM testing */
441 Cfg5_UWF = (1 << 4), /* 1 = accept unicast wakeup frame */
442 Cfg5_MWF = (1 << 5), /* 1 = accept multicast wakeup frame */
443 Cfg5_BWF = (1 << 6), /* 1 = accept broadcast wakeup frame */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444};
445
446enum RxConfigBits {
447 /* rx fifo threshold */
Jeff Garzik28006c62007-09-15 12:36:46 -0700448 RxCfgFIFOShift = 13,
449 RxCfgFIFONone = (7 << RxCfgFIFOShift),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 /* Max DMA burst */
Jeff Garzik28006c62007-09-15 12:36:46 -0700452 RxCfgDMAShift = 8,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
454
455 /* rx ring buffer length */
Jeff Garzik28006c62007-09-15 12:36:46 -0700456 RxCfgRcv8K = 0,
457 RxCfgRcv16K = (1 << 11),
458 RxCfgRcv32K = (1 << 12),
459 RxCfgRcv64K = (1 << 11) | (1 << 12),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
461 /* Disable packet wrap at end of Rx buffer. (not possible with 64k) */
Jeff Garzik28006c62007-09-15 12:36:46 -0700462 RxNoWrap = (1 << 7),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463};
464
465/* Twister tuning parameters from RealTek.
466 Completely undocumented, but required to tune bad links on some boards. */
467enum CSCRBits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700468 CSCR_LinkOKBit = 0x0400,
469 CSCR_LinkChangeBit = 0x0800,
470 CSCR_LinkStatusBits = 0x0f000,
471 CSCR_LinkDownOffCmd = 0x003c0,
472 CSCR_LinkDownCmd = 0x0f3c0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473};
474
475enum Cfg9346Bits {
Jeff Garzik28006c62007-09-15 12:36:46 -0700476 Cfg9346_Lock = 0x00,
477 Cfg9346_Unlock = 0xC0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478};
479
480typedef enum {
Jeff Garzik28006c62007-09-15 12:36:46 -0700481 CH_8139 = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 CH_8139_K,
483 CH_8139A,
484 CH_8139A_G,
485 CH_8139B,
486 CH_8130,
487 CH_8139C,
488 CH_8100,
489 CH_8100B_8139D,
490 CH_8101,
491} chip_t;
492
493enum chip_flags {
Jeff Garzik28006c62007-09-15 12:36:46 -0700494 HasHltClk = (1 << 0),
495 HasLWake = (1 << 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496};
497
498#define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \
499 (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
500#define HW_REVID_MASK HW_REVID(1, 1, 1, 1, 1, 1, 1)
501
502/* directly indexed by chip_t, above */
Jesper Juhl3c6bee12006-01-09 20:54:01 -0800503static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 const char *name;
505 u32 version; /* from RTL8139C/RTL8139D docs */
506 u32 flags;
507} rtl_chip_info[] = {
508 { "RTL-8139",
509 HW_REVID(1, 0, 0, 0, 0, 0, 0),
510 HasHltClk,
511 },
512
513 { "RTL-8139 rev K",
514 HW_REVID(1, 1, 0, 0, 0, 0, 0),
515 HasHltClk,
516 },
517
518 { "RTL-8139A",
519 HW_REVID(1, 1, 1, 0, 0, 0, 0),
520 HasHltClk, /* XXX undocumented? */
521 },
522
523 { "RTL-8139A rev G",
524 HW_REVID(1, 1, 1, 0, 0, 1, 0),
525 HasHltClk, /* XXX undocumented? */
526 },
527
528 { "RTL-8139B",
529 HW_REVID(1, 1, 1, 1, 0, 0, 0),
530 HasLWake,
531 },
532
533 { "RTL-8130",
534 HW_REVID(1, 1, 1, 1, 1, 0, 0),
535 HasLWake,
536 },
537
538 { "RTL-8139C",
539 HW_REVID(1, 1, 1, 0, 1, 0, 0),
540 HasLWake,
541 },
542
543 { "RTL-8100",
544 HW_REVID(1, 1, 1, 1, 0, 1, 0),
545 HasLWake,
546 },
547
548 { "RTL-8100B/8139D",
549 HW_REVID(1, 1, 1, 0, 1, 0, 1),
John W. Linville7645bae2005-10-18 21:31:00 -0400550 HasHltClk /* XXX undocumented? */
551 | HasLWake,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 },
553
554 { "RTL-8101",
555 HW_REVID(1, 1, 1, 0, 1, 1, 1),
556 HasLWake,
557 },
558};
559
560struct rtl_extra_stats {
561 unsigned long early_rx;
562 unsigned long tx_buf_mapped;
563 unsigned long tx_timeouts;
564 unsigned long rx_lost_in_ring;
565};
566
567struct rtl8139_private {
Jeff Garzik28006c62007-09-15 12:36:46 -0700568 void __iomem *mmio_addr;
569 int drv_flags;
570 struct pci_dev *pci_dev;
571 u32 msg_enable;
572 struct napi_struct napi;
573 struct net_device *dev;
Jeff Garzika15e0382005-10-31 07:59:37 -0500574
Jeff Garzik28006c62007-09-15 12:36:46 -0700575 unsigned char *rx_ring;
576 unsigned int cur_rx; /* RX buf index of next pkt */
577 dma_addr_t rx_ring_dma;
Jeff Garzika15e0382005-10-31 07:59:37 -0500578
Jeff Garzik28006c62007-09-15 12:36:46 -0700579 unsigned int tx_flag;
580 unsigned long cur_tx;
581 unsigned long dirty_tx;
582 unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
583 unsigned char *tx_bufs; /* Tx bounce buffer region. */
584 dma_addr_t tx_bufs_dma;
585
586 signed char phys[4]; /* MII device addresses. */
587
588 /* Twister tune state. */
589 char twistie, twist_row, twist_col;
590
591 unsigned int watchdog_fired : 1;
592 unsigned int default_port : 4; /* Last dev->if_port value. */
593 unsigned int have_thread : 1;
594
595 spinlock_t lock;
596 spinlock_t rx_lock;
597
598 chip_t chipset;
599 u32 rx_config;
600 struct rtl_extra_stats xstats;
601
602 struct delayed_work thread;
603
604 struct mii_if_info mii;
605 unsigned int regs_len;
606 unsigned long fifo_copy_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607};
608
609MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
610MODULE_DESCRIPTION ("RealTek RTL-8139 Fast Ethernet driver");
611MODULE_LICENSE("GPL");
612MODULE_VERSION(DRV_VERSION);
613
Dave Joneseb581342008-07-15 19:54:53 -0400614module_param(use_io, int, 0);
615MODULE_PARM_DESC(use_io, "Force use of I/O access mode. 0=MMIO 1=PIO");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616module_param(multicast_filter_limit, int, 0);
617module_param_array(media, int, NULL, 0);
618module_param_array(full_duplex, int, NULL, 0);
619module_param(debug, int, 0);
620MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");
621MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
622MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
623MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
624
Pekka Enberg22f714b2005-05-12 19:38:47 -0400625static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626static int rtl8139_open (struct net_device *dev);
627static int mdio_read (struct net_device *dev, int phy_id, int location);
628static void mdio_write (struct net_device *dev, int phy_id, int location,
629 int val);
Jeff Garzika15e0382005-10-31 07:59:37 -0500630static void rtl8139_start_thread(struct rtl8139_private *tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631static void rtl8139_tx_timeout (struct net_device *dev);
632static void rtl8139_init_ring (struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000633static netdev_tx_t rtl8139_start_xmit (struct sk_buff *skb,
634 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635#ifdef CONFIG_NET_POLL_CONTROLLER
636static void rtl8139_poll_controller(struct net_device *dev);
637#endif
Jiri Pirkobda6a152009-03-13 11:48:18 -0700638static int rtl8139_set_mac_address(struct net_device *dev, void *p);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700639static int rtl8139_poll(struct napi_struct *napi, int budget);
David Howells7d12e782006-10-05 14:55:46 +0100640static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641static int rtl8139_close (struct net_device *dev);
642static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
643static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
644static void rtl8139_set_rx_mode (struct net_device *dev);
645static void __set_rx_mode (struct net_device *dev);
646static void rtl8139_hw_start (struct net_device *dev);
David Howellsc4028952006-11-22 14:57:56 +0000647static void rtl8139_thread (struct work_struct *work);
648static void rtl8139_tx_timeout_task(struct work_struct *work);
Jeff Garzik7282d492006-09-13 14:30:00 -0400649static const struct ethtool_ops rtl8139_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651/* write MMIO register, with flush */
652/* Flush avoids rtl8139 bug w/ posted MMIO writes */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400653#define RTL_W8_F(reg, val8) do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)
654#define RTL_W16_F(reg, val16) do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)
655#define RTL_W32_F(reg, val32) do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657/* write MMIO register */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400658#define RTL_W8(reg, val8) iowrite8 ((val8), ioaddr + (reg))
659#define RTL_W16(reg, val16) iowrite16 ((val16), ioaddr + (reg))
660#define RTL_W32(reg, val32) iowrite32 ((val32), ioaddr + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662/* read MMIO register */
Pekka Enberg22f714b2005-05-12 19:38:47 -0400663#define RTL_R8(reg) ioread8 (ioaddr + (reg))
664#define RTL_R16(reg) ioread16 (ioaddr + (reg))
665#define RTL_R32(reg) ((unsigned long) ioread32 (ioaddr + (reg)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
667
668static const u16 rtl8139_intr_mask =
669 PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
670 TxErr | TxOK | RxErr | RxOK;
671
672static const u16 rtl8139_norx_intr_mask =
673 PCIErr | PCSTimeout | RxUnderrun |
674 TxErr | TxOK | RxErr ;
675
676#if RX_BUF_IDX == 0
677static const unsigned int rtl8139_rx_config =
678 RxCfgRcv8K | RxNoWrap |
679 (RX_FIFO_THRESH << RxCfgFIFOShift) |
680 (RX_DMA_BURST << RxCfgDMAShift);
681#elif RX_BUF_IDX == 1
682static const unsigned int rtl8139_rx_config =
683 RxCfgRcv16K | RxNoWrap |
684 (RX_FIFO_THRESH << RxCfgFIFOShift) |
685 (RX_DMA_BURST << RxCfgDMAShift);
686#elif RX_BUF_IDX == 2
687static const unsigned int rtl8139_rx_config =
688 RxCfgRcv32K | RxNoWrap |
689 (RX_FIFO_THRESH << RxCfgFIFOShift) |
690 (RX_DMA_BURST << RxCfgDMAShift);
691#elif RX_BUF_IDX == 3
692static const unsigned int rtl8139_rx_config =
693 RxCfgRcv64K |
694 (RX_FIFO_THRESH << RxCfgFIFOShift) |
695 (RX_DMA_BURST << RxCfgDMAShift);
696#else
697#error "Invalid configuration for 8139_RXBUF_IDX"
698#endif
699
700static const unsigned int rtl8139_tx_config =
701 TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);
702
703static void __rtl8139_cleanup_dev (struct net_device *dev)
704{
705 struct rtl8139_private *tp = netdev_priv(dev);
706 struct pci_dev *pdev;
707
708 assert (dev != NULL);
709 assert (tp->pci_dev != NULL);
710 pdev = tp->pci_dev;
711
Pekka Enberg22f714b2005-05-12 19:38:47 -0400712 if (tp->mmio_addr)
713 pci_iounmap (pdev, tp->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 /* it's ok to call this even if we have no regions to free */
716 pci_release_regions (pdev);
717
718 free_netdev(dev);
719 pci_set_drvdata (pdev, NULL);
720}
721
722
Pekka Enberg22f714b2005-05-12 19:38:47 -0400723static void rtl8139_chip_reset (void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
725 int i;
726
727 /* Soft reset the chip. */
728 RTL_W8 (ChipCmd, CmdReset);
729
730 /* Check that the chip has finished the reset. */
731 for (i = 1000; i > 0; i--) {
732 barrier();
733 if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
734 break;
735 udelay (10);
736 }
737}
738
739
Stephen Hemminger85920d42008-11-24 14:47:01 -0800740static __devinit struct net_device * rtl8139_init_board (struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741{
Pekka Enberg22f714b2005-05-12 19:38:47 -0400742 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 struct net_device *dev;
744 struct rtl8139_private *tp;
745 u8 tmp8;
746 int rc, disable_dev_on_err = 0;
747 unsigned int i;
748 unsigned long pio_start, pio_end, pio_flags, pio_len;
749 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
750 u32 version;
751
752 assert (pdev != NULL);
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 /* dev and priv zeroed in alloc_etherdev */
755 dev = alloc_etherdev (sizeof (*tp));
756 if (dev == NULL) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400757 dev_err(&pdev->dev, "Unable to alloc new net device\n");
Stephen Hemminger85920d42008-11-24 14:47:01 -0800758 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 SET_NETDEV_DEV(dev, &pdev->dev);
761
762 tp = netdev_priv(dev);
763 tp->pci_dev = pdev;
764
765 /* enable device (incl. PCI PM wakeup and hotplug setup) */
766 rc = pci_enable_device (pdev);
767 if (rc)
768 goto err_out;
769
770 pio_start = pci_resource_start (pdev, 0);
771 pio_end = pci_resource_end (pdev, 0);
772 pio_flags = pci_resource_flags (pdev, 0);
773 pio_len = pci_resource_len (pdev, 0);
774
775 mmio_start = pci_resource_start (pdev, 1);
776 mmio_end = pci_resource_end (pdev, 1);
777 mmio_flags = pci_resource_flags (pdev, 1);
778 mmio_len = pci_resource_len (pdev, 1);
779
780 /* set this immediately, we need to know before
781 * we talk to the chip directly */
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000782 pr_debug("PIO region size == 0x%02lX\n", pio_len);
783 pr_debug("MMIO region size == 0x%02lX\n", mmio_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Dave Jones1a4dc682008-07-15 19:54:52 -0400785retry:
Dave Joneseb581342008-07-15 19:54:53 -0400786 if (use_io) {
787 /* make sure PCI base addr 0 is PIO */
788 if (!(pio_flags & IORESOURCE_IO)) {
789 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
790 rc = -ENODEV;
791 goto err_out;
792 }
793 /* check for weird/broken PCI region reporting */
794 if (pio_len < RTL_MIN_IO_SIZE) {
795 dev_err(&pdev->dev, "Invalid PCI I/O region size(s), aborting\n");
796 rc = -ENODEV;
797 goto err_out;
798 }
799 } else {
800 /* make sure PCI base addr 1 is MMIO */
801 if (!(mmio_flags & IORESOURCE_MEM)) {
802 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
803 rc = -ENODEV;
804 goto err_out;
805 }
806 if (mmio_len < RTL_MIN_IO_SIZE) {
807 dev_err(&pdev->dev, "Invalid PCI mem region size(s), aborting\n");
808 rc = -ENODEV;
809 goto err_out;
810 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400813 rc = pci_request_regions (pdev, DRV_NAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 if (rc)
815 goto err_out;
816 disable_dev_on_err = 1;
817
818 /* enable PCI bus-mastering */
819 pci_set_master (pdev);
820
Dave Joneseb581342008-07-15 19:54:53 -0400821 if (use_io) {
822 ioaddr = pci_iomap(pdev, 0, 0);
823 if (!ioaddr) {
824 dev_err(&pdev->dev, "cannot map PIO, aborting\n");
825 rc = -EIO;
826 goto err_out;
827 }
828 dev->base_addr = pio_start;
829 tp->regs_len = pio_len;
830 } else {
831 /* ioremap MMIO region */
832 ioaddr = pci_iomap(pdev, 1, 0);
833 if (ioaddr == NULL) {
Dave Jones1a4dc682008-07-15 19:54:52 -0400834 dev_err(&pdev->dev, "cannot remap MMIO, trying PIO\n");
835 pci_release_regions(pdev);
836 use_io = 1;
837 goto retry;
Dave Joneseb581342008-07-15 19:54:53 -0400838 }
839 dev->base_addr = (long) ioaddr;
840 tp->regs_len = mmio_len;
Pekka Enberg22f714b2005-05-12 19:38:47 -0400841 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 tp->mmio_addr = ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 /* Bring old chips out of low-power mode. */
845 RTL_W8 (HltClk, 'R');
846
847 /* check for missing/broken hardware */
848 if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400849 dev_err(&pdev->dev, "Chip not responding, ignoring board\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 rc = -EIO;
851 goto err_out;
852 }
853
854 /* identify chip attached to board */
855 version = RTL_R32 (TxConfig) & HW_REVID_MASK;
856 for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)
857 if (version == rtl_chip_info[i].version) {
858 tp->chipset = i;
859 goto match;
860 }
861
862 /* if unknown chip, assume array element #0, original RTL-8139 in this case */
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000863 dev_dbg(&pdev->dev, "unknown chip version, assuming RTL-8139\n");
864 dev_dbg(&pdev->dev, "TxConfig = 0x%lx\n", RTL_R32 (TxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 tp->chipset = 0;
866
867match:
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000868 pr_debug("chipset id (%d) == index %d, '%s'\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 version, i, rtl_chip_info[i].name);
870
871 if (tp->chipset >= CH_8139B) {
872 u8 new_tmp8 = tmp8 = RTL_R8 (Config1);
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000873 pr_debug("PCI PM wakeup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&
875 (tmp8 & LWAKE))
876 new_tmp8 &= ~LWAKE;
877 new_tmp8 |= Cfg1_PM_Enable;
878 if (new_tmp8 != tmp8) {
879 RTL_W8 (Cfg9346, Cfg9346_Unlock);
880 RTL_W8 (Config1, tmp8);
881 RTL_W8 (Cfg9346, Cfg9346_Lock);
882 }
883 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
884 tmp8 = RTL_R8 (Config4);
885 if (tmp8 & LWPTN) {
886 RTL_W8 (Cfg9346, Cfg9346_Unlock);
887 RTL_W8 (Config4, tmp8 & ~LWPTN);
888 RTL_W8 (Cfg9346, Cfg9346_Lock);
889 }
890 }
891 } else {
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000892 pr_debug("Old chip wakeup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 tmp8 = RTL_R8 (Config1);
894 tmp8 &= ~(SLEEP | PWRDN);
895 RTL_W8 (Config1, tmp8);
896 }
897
898 rtl8139_chip_reset (ioaddr);
899
Stephen Hemminger85920d42008-11-24 14:47:01 -0800900 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
902err_out:
903 __rtl8139_cleanup_dev (dev);
904 if (disable_dev_on_err)
905 pci_disable_device (pdev);
Stephen Hemminger85920d42008-11-24 14:47:01 -0800906 return ERR_PTR(rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907}
908
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800909static const struct net_device_ops rtl8139_netdev_ops = {
910 .ndo_open = rtl8139_open,
911 .ndo_stop = rtl8139_close,
912 .ndo_get_stats = rtl8139_get_stats,
Ben Hutchings635ecaa2009-07-09 17:59:01 +0000913 .ndo_change_mtu = eth_change_mtu,
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800914 .ndo_validate_addr = eth_validate_addr,
Jiri Pirkobda6a152009-03-13 11:48:18 -0700915 .ndo_set_mac_address = rtl8139_set_mac_address,
Stephen Hemminger00829822008-11-20 20:14:53 -0800916 .ndo_start_xmit = rtl8139_start_xmit,
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800917 .ndo_set_multicast_list = rtl8139_set_rx_mode,
918 .ndo_do_ioctl = netdev_ioctl,
919 .ndo_tx_timeout = rtl8139_tx_timeout,
920#ifdef CONFIG_NET_POLL_CONTROLLER
921 .ndo_poll_controller = rtl8139_poll_controller,
922#endif
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800923};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
925static int __devinit rtl8139_init_one (struct pci_dev *pdev,
926 const struct pci_device_id *ent)
927{
928 struct net_device *dev = NULL;
929 struct rtl8139_private *tp;
930 int i, addr_len, option;
Pekka Enberg22f714b2005-05-12 19:38:47 -0400931 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 static int board_idx = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
934 assert (pdev != NULL);
935 assert (ent != NULL);
936
937 board_idx++;
938
939 /* when we're built into the kernel, the driver version message
940 * is only printed if at least one 8139 board has been found
941 */
942#ifndef MODULE
943 {
944 static int printed_version;
945 if (!printed_version++)
Alexander Beregalovb93d5842009-05-26 12:35:27 +0000946 pr_info(RTL8139_DRIVER_NAME "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 }
948#endif
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
Auke Kok44c10132007-06-08 15:46:36 -0700951 pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pdev->revision >= 0x20) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400952 dev_info(&pdev->dev,
Stephen Hemmingerde4549c2008-10-21 18:04:27 -0700953 "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip, use 8139cp\n",
Auke Kok44c10132007-06-08 15:46:36 -0700954 pdev->vendor, pdev->device, pdev->revision);
Stephen Hemmingerde4549c2008-10-21 18:04:27 -0700955 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 }
957
Dave Jones152151d2008-07-15 19:54:53 -0400958 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
959 pdev->device == PCI_DEVICE_ID_REALTEK_8139 &&
960 pdev->subsystem_vendor == PCI_VENDOR_ID_ATHEROS &&
961 pdev->subsystem_device == PCI_DEVICE_ID_REALTEK_8139) {
Joe Perches497159a2010-02-17 15:01:49 +0000962 pr_info("OQO Model 2 detected. Forcing PIO\n");
Dave Jones152151d2008-07-15 19:54:53 -0400963 use_io = 1;
964 }
965
Stephen Hemminger85920d42008-11-24 14:47:01 -0800966 dev = rtl8139_init_board (pdev);
967 if (IS_ERR(dev))
968 return PTR_ERR(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
970 assert (dev != NULL);
971 tp = netdev_priv(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700972 tp->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974 ioaddr = tp->mmio_addr;
975 assert (ioaddr != NULL);
976
977 addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
978 for (i = 0; i < 3; i++)
Al Viroeca1ad82008-03-16 22:21:54 +0000979 ((__le16 *) (dev->dev_addr))[i] =
980 cpu_to_le16(read_eeprom (ioaddr, i + 7, addr_len));
John W. Linville62a720b2005-09-12 10:48:55 -0400981 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982
983 /* The Rtl8139-specific entries in the device structure. */
Stephen Hemminger48dfcde2008-11-19 22:09:07 -0800984 dev->netdev_ops = &rtl8139_netdev_ops;
985 dev->ethtool_ops = &rtl8139_ethtool_ops;
986 dev->watchdog_timeo = TX_TIMEOUT;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700987 netif_napi_add(dev, &tp->napi, rtl8139_poll, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
989 /* note: the hardware is not capable of sg/csum/highdma, however
990 * through the use of skb_copy_and_csum_dev we enable these
991 * features
992 */
993 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
994
995 dev->irq = pdev->irq;
996
997 /* tp zeroed and aligned in alloc_etherdev */
998 tp = netdev_priv(dev);
999
1000 /* note: tp->chipset set in rtl8139_init_board */
1001 tp->drv_flags = board_info[ent->driver_data].hw_flags;
1002 tp->mmio_addr = ioaddr;
1003 tp->msg_enable =
1004 (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));
1005 spin_lock_init (&tp->lock);
1006 spin_lock_init (&tp->rx_lock);
David Howellsc4028952006-11-22 14:57:56 +00001007 INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 tp->mii.dev = dev;
1009 tp->mii.mdio_read = mdio_read;
1010 tp->mii.mdio_write = mdio_write;
1011 tp->mii.phy_id_mask = 0x3f;
1012 tp->mii.reg_num_mask = 0x1f;
1013
1014 /* dev is fully set up and ready to use now */
Joe Perches497159a2010-02-17 15:01:49 +00001015 pr_debug("about to register device named %s (%p)...\n",
1016 dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 i = register_netdev (dev);
1018 if (i) goto err_out;
1019
1020 pci_set_drvdata (pdev, dev);
1021
Joe Perches497159a2010-02-17 15:01:49 +00001022 netdev_info(dev, "%s at 0x%lx, %pM, IRQ %d\n",
1023 board_info[ent->driver_data].name,
1024 dev->base_addr, dev->dev_addr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
Joe Perches497159a2010-02-17 15:01:49 +00001026 netdev_dbg(dev, "Identified 8139 chip type '%s'\n",
1027 rtl_chip_info[tp->chipset].name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
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;
Joe Perches497159a2010-02-17 15:01:49 +00001040 netdev_info(dev, "MII transceiver %d status 0x%04x advertising %04x\n",
1041 phy, mii_status, advertising);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
1043 }
1044 if (phy_idx == 0) {
Joe Perches497159a2010-02-17 15:01:49 +00001045 netdev_info(dev, "No MII transceivers found! Assuming SYM transceiver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 tp->phys[0] = 32;
1047 }
1048 } else
1049#endif
1050 tp->phys[0] = 32;
1051 tp->mii.phy_id = tp->phys[0];
1052
1053 /* The lower four bits are the media type. */
1054 option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
1055 if (option > 0) {
1056 tp->mii.full_duplex = (option & 0x210) ? 1 : 0;
1057 tp->default_port = option & 0xFF;
1058 if (tp->default_port)
1059 tp->mii.force_media = 1;
1060 }
1061 if (board_idx < MAX_UNITS && full_duplex[board_idx] > 0)
1062 tp->mii.full_duplex = full_duplex[board_idx];
1063 if (tp->mii.full_duplex) {
Joe Perches497159a2010-02-17 15:01:49 +00001064 netdev_info(dev, "Media type forced to Full Duplex\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 /* Changing the MII-advertised media because might prevent
1066 re-connection. */
1067 tp->mii.force_media = 1;
1068 }
1069 if (tp->default_port) {
Joe Perches497159a2010-02-17 15:01:49 +00001070 netdev_info(dev, " Forcing %dMbps %s-duplex operation\n",
1071 (option & 0x20 ? 100 : 10),
1072 (option & 0x10 ? "full" : "half"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 mdio_write(dev, tp->phys[0], 0,
1074 ((option & 0x20) ? 0x2000 : 0) | /* 100Mbps? */
1075 ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
1076 }
1077
1078 /* Put the chip into low-power mode. */
1079 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1080 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
1081
1082 return 0;
1083
1084err_out:
1085 __rtl8139_cleanup_dev (dev);
1086 pci_disable_device (pdev);
1087 return i;
1088}
1089
1090
1091static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
1092{
1093 struct net_device *dev = pci_get_drvdata (pdev);
1094
1095 assert (dev != NULL);
1096
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001097 flush_scheduled_work();
1098
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 unregister_netdev (dev);
1100
1101 __rtl8139_cleanup_dev (dev);
1102 pci_disable_device (pdev);
1103}
1104
1105
1106/* Serial EEPROM section. */
1107
1108/* EEPROM_Ctrl bits. */
1109#define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
1110#define EE_CS 0x08 /* EEPROM chip select. */
1111#define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
1112#define EE_WRITE_0 0x00
1113#define EE_WRITE_1 0x02
1114#define EE_DATA_READ 0x01 /* EEPROM chip data out. */
1115#define EE_ENB (0x80 | EE_CS)
1116
1117/* Delay between EEPROM clock transitions.
1118 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1119 */
1120
Takashi Iwai10e705f2006-03-24 03:18:23 -08001121#define eeprom_delay() (void)RTL_R32(Cfg9346)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
1123/* The EEPROM commands include the alway-set leading bit. */
1124#define EE_WRITE_CMD (5)
1125#define EE_READ_CMD (6)
1126#define EE_ERASE_CMD (7)
1127
Pekka Enberg22f714b2005-05-12 19:38:47 -04001128static int __devinit read_eeprom (void __iomem *ioaddr, int location, int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
1130 int i;
1131 unsigned retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 int read_cmd = location | (EE_READ_CMD << addr_len);
1133
Pekka Enberg22f714b2005-05-12 19:38:47 -04001134 RTL_W8 (Cfg9346, EE_ENB & ~EE_CS);
1135 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 eeprom_delay ();
1137
1138 /* Shift the read command bits out. */
1139 for (i = 4 + addr_len; i >= 0; i--) {
1140 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001141 RTL_W8 (Cfg9346, EE_ENB | dataval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 eeprom_delay ();
Pekka Enberg22f714b2005-05-12 19:38:47 -04001143 RTL_W8 (Cfg9346, EE_ENB | dataval | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 eeprom_delay ();
1145 }
Pekka Enberg22f714b2005-05-12 19:38:47 -04001146 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 eeprom_delay ();
1148
1149 for (i = 16; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001150 RTL_W8 (Cfg9346, EE_ENB | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 eeprom_delay ();
1152 retval =
Pekka Enberg22f714b2005-05-12 19:38:47 -04001153 (retval << 1) | ((RTL_R8 (Cfg9346) & EE_DATA_READ) ? 1 :
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 0);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001155 RTL_W8 (Cfg9346, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 eeprom_delay ();
1157 }
1158
1159 /* Terminate the EEPROM access. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001160 RTL_W8 (Cfg9346, ~EE_CS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 eeprom_delay ();
1162
1163 return retval;
1164}
1165
1166/* MII serial management: mostly bogus for now. */
1167/* Read and write the MII management registers using software-generated
1168 serial MDIO protocol.
1169 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
1170 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1171 "overclocking" issues. */
1172#define MDIO_DIR 0x80
1173#define MDIO_DATA_OUT 0x04
1174#define MDIO_DATA_IN 0x02
1175#define MDIO_CLK 0x01
1176#define MDIO_WRITE0 (MDIO_DIR)
1177#define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
1178
Pekka Enberg22f714b2005-05-12 19:38:47 -04001179#define mdio_delay() RTL_R8(Config4)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
1181
Arjan van de Venf71e1302006-03-03 21:33:57 -05001182static const char mii_2_8139_map[8] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 BasicModeCtrl,
1184 BasicModeStatus,
1185 0,
1186 0,
1187 NWayAdvert,
1188 NWayLPAR,
1189 NWayExpansion,
1190 0
1191};
1192
1193
1194#ifdef CONFIG_8139TOO_8129
1195/* Syncronize the MII management interface by shifting 32 one bits out. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001196static void mdio_sync (void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197{
1198 int i;
1199
1200 for (i = 32; i >= 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001201 RTL_W8 (Config4, MDIO_WRITE1);
1202 mdio_delay ();
1203 RTL_W8 (Config4, MDIO_WRITE1 | MDIO_CLK);
1204 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 }
1206}
1207#endif
1208
1209static int mdio_read (struct net_device *dev, int phy_id, int location)
1210{
1211 struct rtl8139_private *tp = netdev_priv(dev);
1212 int retval = 0;
1213#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001214 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1216 int i;
1217#endif
1218
1219 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001220 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 return location < 8 && mii_2_8139_map[location] ?
Pekka Enberg22f714b2005-05-12 19:38:47 -04001222 RTL_R16 (mii_2_8139_map[location]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 }
1224
1225#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001226 mdio_sync (ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 /* Shift the read command bits out. */
1228 for (i = 15; i >= 0; i--) {
1229 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1230
Pekka Enberg22f714b2005-05-12 19:38:47 -04001231 RTL_W8 (Config4, MDIO_DIR | dataval);
1232 mdio_delay ();
1233 RTL_W8 (Config4, MDIO_DIR | dataval | MDIO_CLK);
1234 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 }
1236
1237 /* Read the two transition, 16 data, and wire-idle bits. */
1238 for (i = 19; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001239 RTL_W8 (Config4, 0);
1240 mdio_delay ();
1241 retval = (retval << 1) | ((RTL_R8 (Config4) & MDIO_DATA_IN) ? 1 : 0);
1242 RTL_W8 (Config4, MDIO_CLK);
1243 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 }
1245#endif
1246
1247 return (retval >> 1) & 0xffff;
1248}
1249
1250
1251static void mdio_write (struct net_device *dev, int phy_id, int location,
1252 int value)
1253{
1254 struct rtl8139_private *tp = netdev_priv(dev);
1255#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001256 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1258 int i;
1259#endif
1260
1261 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Pekka Enberg22f714b2005-05-12 19:38:47 -04001262 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 if (location == 0) {
1264 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1265 RTL_W16 (BasicModeCtrl, value);
1266 RTL_W8 (Cfg9346, Cfg9346_Lock);
1267 } else if (location < 8 && mii_2_8139_map[location])
1268 RTL_W16 (mii_2_8139_map[location], value);
1269 return;
1270 }
1271
1272#ifdef CONFIG_8139TOO_8129
Pekka Enberg22f714b2005-05-12 19:38:47 -04001273 mdio_sync (ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275 /* Shift the command bits out. */
1276 for (i = 31; i >= 0; i--) {
1277 int dataval =
1278 (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001279 RTL_W8 (Config4, dataval);
1280 mdio_delay ();
1281 RTL_W8 (Config4, dataval | MDIO_CLK);
1282 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
1284 /* Clear out extra bits. */
1285 for (i = 2; i > 0; i--) {
Pekka Enberg22f714b2005-05-12 19:38:47 -04001286 RTL_W8 (Config4, 0);
1287 mdio_delay ();
1288 RTL_W8 (Config4, MDIO_CLK);
1289 mdio_delay ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 }
1291#endif
1292}
1293
1294
1295static int rtl8139_open (struct net_device *dev)
1296{
1297 struct rtl8139_private *tp = netdev_priv(dev);
1298 int retval;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001299 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001301 retval = request_irq (dev->irq, rtl8139_interrupt, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 if (retval)
1303 return retval;
1304
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001305 tp->tx_bufs = dma_alloc_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
1306 &tp->tx_bufs_dma, GFP_KERNEL);
1307 tp->rx_ring = dma_alloc_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
1308 &tp->rx_ring_dma, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1310 free_irq(dev->irq, dev);
1311
1312 if (tp->tx_bufs)
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001313 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 tp->tx_bufs, tp->tx_bufs_dma);
1315 if (tp->rx_ring)
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04001316 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 tp->rx_ring, tp->rx_ring_dma);
1318
1319 return -ENOMEM;
1320
1321 }
1322
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001323 napi_enable(&tp->napi);
1324
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 tp->mii.full_duplex = tp->mii.force_media;
1326 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1327
1328 rtl8139_init_ring (dev);
1329 rtl8139_hw_start (dev);
1330 netif_start_queue (dev);
1331
Joe Perches497159a2010-02-17 15:01:49 +00001332 netif_dbg(tp, ifup, dev,
1333 "%s() ioaddr %#llx IRQ %d GP Pins %02x %s-duplex\n",
1334 __func__,
1335 (unsigned long long)pci_resource_start (tp->pci_dev, 1),
1336 dev->irq, RTL_R8 (MediaStatus),
1337 tp->mii.full_duplex ? "full" : "half");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
Jeff Garzika15e0382005-10-31 07:59:37 -05001339 rtl8139_start_thread(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340
1341 return 0;
1342}
1343
1344
1345static void rtl_check_media (struct net_device *dev, unsigned int init_media)
1346{
1347 struct rtl8139_private *tp = netdev_priv(dev);
1348
1349 if (tp->phys[0] >= 0) {
1350 mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
1351 }
1352}
1353
1354/* Start the hardware at open or resume. */
1355static void rtl8139_hw_start (struct net_device *dev)
1356{
1357 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001358 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 u32 i;
1360 u8 tmp;
1361
1362 /* Bring old chips out of low-power mode. */
1363 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1364 RTL_W8 (HltClk, 'R');
1365
1366 rtl8139_chip_reset (ioaddr);
1367
1368 /* unlock Config[01234] and BMCR register writes */
1369 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1370 /* Restore our idea of the MAC address. */
Al Viroeca1ad82008-03-16 22:21:54 +00001371 RTL_W32_F (MAC0 + 0, le32_to_cpu (*(__le32 *) (dev->dev_addr + 0)));
1372 RTL_W32_F (MAC0 + 4, le16_to_cpu (*(__le16 *) (dev->dev_addr + 4)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
Jianjun kong3f9738f2009-04-20 23:48:25 +00001374 tp->cur_rx = 0;
1375
1376 /* init Rx ring buffer DMA address */
1377 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1378
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 /* Must enable Tx/Rx before setting transfer thresholds! */
1380 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1381
1382 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1383 RTL_W32 (RxConfig, tp->rx_config);
1384 RTL_W32 (TxConfig, rtl8139_tx_config);
1385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 rtl_check_media (dev, 1);
1387
1388 if (tp->chipset >= CH_8139B) {
1389 /* Disable magic packet scanning, which is enabled
1390 * when PM is enabled in Config1. It can be reenabled
1391 * via ETHTOOL_SWOL if desired. */
1392 RTL_W8 (Config3, RTL_R8 (Config3) & ~Cfg3_Magic);
1393 }
1394
Joe Perches497159a2010-02-17 15:01:49 +00001395 netdev_dbg(dev, "init buffer addresses\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
1397 /* Lock Config[01234] and BMCR register writes */
1398 RTL_W8 (Cfg9346, Cfg9346_Lock);
1399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 /* init Tx buffer DMA addresses */
1401 for (i = 0; i < NUM_TX_DESC; i++)
1402 RTL_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1403
1404 RTL_W32 (RxMissed, 0);
1405
1406 rtl8139_set_rx_mode (dev);
1407
1408 /* no early-rx interrupts */
1409 RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
1410
1411 /* make sure RxTx has started */
1412 tmp = RTL_R8 (ChipCmd);
1413 if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
1414 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1415
1416 /* Enable all known interrupts by setting the interrupt mask. */
1417 RTL_W16 (IntrMask, rtl8139_intr_mask);
1418}
1419
1420
1421/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1422static void rtl8139_init_ring (struct net_device *dev)
1423{
1424 struct rtl8139_private *tp = netdev_priv(dev);
1425 int i;
1426
1427 tp->cur_rx = 0;
1428 tp->cur_tx = 0;
1429 tp->dirty_tx = 0;
1430
1431 for (i = 0; i < NUM_TX_DESC; i++)
1432 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1433}
1434
1435
1436/* This must be global for CONFIG_8139TOO_TUNE_TWISTER case */
1437static int next_tick = 3 * HZ;
1438
1439#ifndef CONFIG_8139TOO_TUNE_TWISTER
1440static inline void rtl8139_tune_twister (struct net_device *dev,
1441 struct rtl8139_private *tp) {}
1442#else
1443enum TwisterParamVals {
1444 PARA78_default = 0x78fa8388,
1445 PARA7c_default = 0xcb38de43, /* param[0][3] */
1446 PARA7c_xxx = 0xcb38de43,
1447};
1448
1449static const unsigned long param[4][4] = {
1450 {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
1451 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1452 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1453 {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
1454};
1455
1456static void rtl8139_tune_twister (struct net_device *dev,
1457 struct rtl8139_private *tp)
1458{
1459 int linkcase;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001460 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
1462 /* This is a complicated state machine to configure the "twister" for
1463 impedance/echos based on the cable length.
1464 All of this is magic and undocumented.
1465 */
1466 switch (tp->twistie) {
1467 case 1:
1468 if (RTL_R16 (CSCR) & CSCR_LinkOKBit) {
1469 /* We have link beat, let us tune the twister. */
1470 RTL_W16 (CSCR, CSCR_LinkDownOffCmd);
1471 tp->twistie = 2; /* Change to state 2. */
1472 next_tick = HZ / 10;
1473 } else {
1474 /* Just put in some reasonable defaults for when beat returns. */
1475 RTL_W16 (CSCR, CSCR_LinkDownCmd);
1476 RTL_W32 (FIFOTMS, 0x20); /* Turn on cable test mode. */
1477 RTL_W32 (PARA78, PARA78_default);
1478 RTL_W32 (PARA7c, PARA7c_default);
1479 tp->twistie = 0; /* Bail from future actions. */
1480 }
1481 break;
1482 case 2:
1483 /* Read how long it took to hear the echo. */
1484 linkcase = RTL_R16 (CSCR) & CSCR_LinkStatusBits;
1485 if (linkcase == 0x7000)
1486 tp->twist_row = 3;
1487 else if (linkcase == 0x3000)
1488 tp->twist_row = 2;
1489 else if (linkcase == 0x1000)
1490 tp->twist_row = 1;
1491 else
1492 tp->twist_row = 0;
1493 tp->twist_col = 0;
1494 tp->twistie = 3; /* Change to state 2. */
1495 next_tick = HZ / 10;
1496 break;
1497 case 3:
1498 /* Put out four tuning parameters, one per 100msec. */
1499 if (tp->twist_col == 0)
1500 RTL_W16 (FIFOTMS, 0);
1501 RTL_W32 (PARA7c, param[(int) tp->twist_row]
1502 [(int) tp->twist_col]);
1503 next_tick = HZ / 10;
1504 if (++tp->twist_col >= 4) {
1505 /* For short cables we are done.
1506 For long cables (row == 3) check for mistune. */
1507 tp->twistie =
1508 (tp->twist_row == 3) ? 4 : 0;
1509 }
1510 break;
1511 case 4:
1512 /* Special case for long cables: check for mistune. */
1513 if ((RTL_R16 (CSCR) &
1514 CSCR_LinkStatusBits) == 0x7000) {
1515 tp->twistie = 0;
1516 break;
1517 } else {
1518 RTL_W32 (PARA7c, 0xfb38de03);
1519 tp->twistie = 5;
1520 next_tick = HZ / 10;
1521 }
1522 break;
1523 case 5:
1524 /* Retune for shorter cable (column 2). */
1525 RTL_W32 (FIFOTMS, 0x20);
1526 RTL_W32 (PARA78, PARA78_default);
1527 RTL_W32 (PARA7c, PARA7c_default);
1528 RTL_W32 (FIFOTMS, 0x00);
1529 tp->twist_row = 2;
1530 tp->twist_col = 0;
1531 tp->twistie = 3;
1532 next_tick = HZ / 10;
1533 break;
1534
1535 default:
1536 /* do nothing */
1537 break;
1538 }
1539}
1540#endif /* CONFIG_8139TOO_TUNE_TWISTER */
1541
1542static inline void rtl8139_thread_iter (struct net_device *dev,
1543 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001544 void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545{
1546 int mii_lpa;
1547
1548 mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1549
1550 if (!tp->mii.force_media && mii_lpa != 0xffff) {
Joe Perches8e95a202009-12-03 07:58:21 +00001551 int duplex = ((mii_lpa & LPA_100FULL) ||
1552 (mii_lpa & 0x01C0) == 0x0040);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 if (tp->mii.full_duplex != duplex) {
1554 tp->mii.full_duplex = duplex;
1555
1556 if (mii_lpa) {
Joe Perches497159a2010-02-17 15:01:49 +00001557 netdev_info(dev, "Setting %s-duplex based on MII #%d link partner ability of %04x\n",
1558 tp->mii.full_duplex ? "full" : "half",
1559 tp->phys[0], mii_lpa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 } else {
Joe Perches497159a2010-02-17 15:01:49 +00001561 netdev_info(dev, "media is unconnected, link down, or incompatible connection\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 }
1563#if 0
1564 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1565 RTL_W8 (Config1, tp->mii.full_duplex ? 0x60 : 0x20);
1566 RTL_W8 (Cfg9346, Cfg9346_Lock);
1567#endif
1568 }
1569 }
1570
1571 next_tick = HZ * 60;
1572
1573 rtl8139_tune_twister (dev, tp);
1574
Joe Perches497159a2010-02-17 15:01:49 +00001575 netdev_dbg(dev, "Media selection tick, Link partner %04x\n",
1576 RTL_R16(NWayLPAR));
1577 netdev_dbg(dev, "Other registers are IntMask %04x IntStatus %04x\n",
1578 RTL_R16(IntrMask), RTL_R16(IntrStatus));
1579 netdev_dbg(dev, "Chip config %02x %02x\n",
1580 RTL_R8(Config0), RTL_R8(Config1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581}
1582
David Howellsc4028952006-11-22 14:57:56 +00001583static void rtl8139_thread (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584{
David Howellsc4028952006-11-22 14:57:56 +00001585 struct rtl8139_private *tp =
1586 container_of(work, struct rtl8139_private, thread.work);
1587 struct net_device *dev = tp->mii.dev;
Francois Romieu371e8bc2006-01-31 01:04:33 +01001588 unsigned long thr_delay = next_tick;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001590 rtnl_lock();
1591
1592 if (!netif_running(dev))
1593 goto out_unlock;
1594
Francois Romieu371e8bc2006-01-31 01:04:33 +01001595 if (tp->watchdog_fired) {
1596 tp->watchdog_fired = 0;
David Howellsc4028952006-11-22 14:57:56 +00001597 rtl8139_tx_timeout_task(work);
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001598 } else
1599 rtl8139_thread_iter(dev, tp, tp->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001601 if (tp->have_thread)
1602 schedule_delayed_work(&tp->thread, thr_delay);
1603out_unlock:
1604 rtnl_unlock ();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605}
1606
Jeff Garzika15e0382005-10-31 07:59:37 -05001607static void rtl8139_start_thread(struct rtl8139_private *tp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 tp->twistie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 if (tp->chipset == CH_8139_K)
1611 tp->twistie = 1;
1612 else if (tp->drv_flags & HAS_LNK_CHNG)
1613 return;
1614
Jeff Garzik38b492a2005-11-04 22:36:28 -05001615 tp->have_thread = 1;
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001616 tp->watchdog_fired = 0;
Jeff Garzika15e0382005-10-31 07:59:37 -05001617
1618 schedule_delayed_work(&tp->thread, next_tick);
1619}
1620
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
1622{
1623 tp->cur_tx = 0;
1624 tp->dirty_tx = 0;
1625
1626 /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
1627}
1628
David Howellsc4028952006-11-22 14:57:56 +00001629static void rtl8139_tx_timeout_task (struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630{
David Howellsc4028952006-11-22 14:57:56 +00001631 struct rtl8139_private *tp =
1632 container_of(work, struct rtl8139_private, thread.work);
1633 struct net_device *dev = tp->mii.dev;
Pekka Enberg22f714b2005-05-12 19:38:47 -04001634 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 int i;
1636 u8 tmp8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Joe Perches497159a2010-02-17 15:01:49 +00001638 netdev_dbg(dev, "Transmit timeout, status %02x %04x %04x media %02x\n",
1639 RTL_R8(ChipCmd), RTL_R16(IntrStatus),
1640 RTL_R16(IntrMask), RTL_R8(MediaStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 /* Emit info to figure out what went wrong. */
Joe Perches497159a2010-02-17 15:01:49 +00001642 netdev_dbg(dev, "Tx queue start entry %ld dirty entry %ld\n",
1643 tp->cur_tx, tp->dirty_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 for (i = 0; i < NUM_TX_DESC; i++)
Joe Perches497159a2010-02-17 15:01:49 +00001645 netdev_dbg(dev, "Tx descriptor %d is %08lx%s\n",
1646 i, RTL_R32(TxStatus0 + (i * 4)),
1647 i == tp->dirty_tx % NUM_TX_DESC ?
1648 " (queue head)" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
1650 tp->xstats.tx_timeouts++;
1651
1652 /* disable Tx ASAP, if not already */
1653 tmp8 = RTL_R8 (ChipCmd);
1654 if (tmp8 & CmdTxEnb)
1655 RTL_W8 (ChipCmd, CmdRxEnb);
1656
Francois Romieu371e8bc2006-01-31 01:04:33 +01001657 spin_lock_bh(&tp->rx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 /* Disable interrupts by clearing the interrupt mask. */
1659 RTL_W16 (IntrMask, 0x0000);
1660
1661 /* Stop a shared interrupt from scavenging while we are. */
Francois Romieu371e8bc2006-01-31 01:04:33 +01001662 spin_lock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 rtl8139_tx_clear (tp);
Francois Romieu371e8bc2006-01-31 01:04:33 +01001664 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 /* ...and finally, reset everything */
1667 if (netif_running(dev)) {
1668 rtl8139_hw_start (dev);
1669 netif_wake_queue (dev);
1670 }
Francois Romieu371e8bc2006-01-31 01:04:33 +01001671 spin_unlock_bh(&tp->rx_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672}
1673
Francois Romieu371e8bc2006-01-31 01:04:33 +01001674static void rtl8139_tx_timeout (struct net_device *dev)
1675{
1676 struct rtl8139_private *tp = netdev_priv(dev);
1677
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001678 tp->watchdog_fired = 1;
Francois Romieu371e8bc2006-01-31 01:04:33 +01001679 if (!tp->have_thread) {
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001680 INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
Francois Romieu371e8bc2006-01-31 01:04:33 +01001681 schedule_delayed_work(&tp->thread, next_tick);
Francois Romieu83cbb4d2007-02-15 23:37:44 +01001682 }
Francois Romieu371e8bc2006-01-31 01:04:33 +01001683}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684
Stephen Hemminger613573252009-08-31 19:50:58 +00001685static netdev_tx_t rtl8139_start_xmit (struct sk_buff *skb,
1686 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687{
1688 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04001689 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 unsigned int entry;
1691 unsigned int len = skb->len;
Arjan van de Venbce305f2006-07-05 15:00:40 +02001692 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
1694 /* Calculate the next Tx descriptor entry. */
1695 entry = tp->cur_tx % NUM_TX_DESC;
1696
1697 /* Note: the chip doesn't have auto-pad! */
1698 if (likely(len < TX_BUF_SIZE)) {
1699 if (len < ETH_ZLEN)
1700 memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1701 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1702 dev_kfree_skb(skb);
1703 } else {
1704 dev_kfree_skb(skb);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001705 dev->stats.tx_dropped++;
Patrick McHardy6ed10652009-06-23 06:03:08 +00001706 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
1708
Arjan van de Venbce305f2006-07-05 15:00:40 +02001709 spin_lock_irqsave(&tp->lock, flags);
Andreas Oberritter176eaa52008-10-08 06:14:16 +00001710 /*
1711 * Writing to TxStatus triggers a DMA transfer of the data
1712 * copied to tp->tx_buf[entry] above. Use a memory barrier
1713 * to make sure that the device sees the updated data.
1714 */
1715 wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1717 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1718
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 tp->cur_tx++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
1721 if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1722 netif_stop_queue (dev);
Arjan van de Venbce305f2006-07-05 15:00:40 +02001723 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Joe Perches497159a2010-02-17 15:01:49 +00001725 netif_dbg(tp, tx_queued, dev, "Queued Tx packet size %u to slot %d\n",
1726 len, entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
Patrick McHardy6ed10652009-06-23 06:03:08 +00001728 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729}
1730
1731
1732static void rtl8139_tx_interrupt (struct net_device *dev,
1733 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001734 void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735{
1736 unsigned long dirty_tx, tx_left;
1737
1738 assert (dev != NULL);
1739 assert (ioaddr != NULL);
1740
1741 dirty_tx = tp->dirty_tx;
1742 tx_left = tp->cur_tx - dirty_tx;
1743 while (tx_left > 0) {
1744 int entry = dirty_tx % NUM_TX_DESC;
1745 int txstatus;
1746
1747 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1748
1749 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1750 break; /* It still hasn't been Txed */
1751
1752 /* Note: TxCarrierLost is always asserted at 100mbps. */
1753 if (txstatus & (TxOutOfWindow | TxAborted)) {
1754 /* There was an major error, log it. */
Joe Perches497159a2010-02-17 15:01:49 +00001755 netif_dbg(tp, tx_err, dev, "Transmit error, Tx status %08x\n",
1756 txstatus);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001757 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 if (txstatus & TxAborted) {
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001759 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 RTL_W32 (TxConfig, TxClearAbt);
1761 RTL_W16 (IntrStatus, TxErr);
1762 wmb();
1763 }
1764 if (txstatus & TxCarrierLost)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001765 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 if (txstatus & TxOutOfWindow)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001767 dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 } else {
1769 if (txstatus & TxUnderrun) {
1770 /* Add 64 to the Tx FIFO threshold. */
1771 if (tp->tx_flag < 0x00300000)
1772 tp->tx_flag += 0x00020000;
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001773 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 }
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001775 dev->stats.collisions += (txstatus >> 24) & 15;
1776 dev->stats.tx_bytes += txstatus & 0x7ff;
1777 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 }
1779
1780 dirty_tx++;
1781 tx_left--;
1782 }
1783
1784#ifndef RTL8139_NDEBUG
1785 if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
Joe Perches497159a2010-02-17 15:01:49 +00001786 netdev_err(dev, "Out-of-sync dirty pointer, %ld vs. %ld\n",
1787 dirty_tx, tp->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 dirty_tx += NUM_TX_DESC;
1789 }
1790#endif /* RTL8139_NDEBUG */
1791
1792 /* only wake the queue if we did work, and the queue is stopped */
1793 if (tp->dirty_tx != dirty_tx) {
1794 tp->dirty_tx = dirty_tx;
1795 mb();
1796 netif_wake_queue (dev);
1797 }
1798}
1799
1800
1801/* TODO: clean this up! Rx reset need not be this intensive */
1802static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
Pekka Enberg22f714b2005-05-12 19:38:47 -04001803 struct rtl8139_private *tp, void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804{
1805 u8 tmp8;
1806#ifdef CONFIG_8139_OLD_RX_RESET
1807 int tmp_work;
1808#endif
1809
Joe Perches497159a2010-02-17 15:01:49 +00001810 netif_dbg(tp, rx_err, dev, "Ethernet frame had errors, status %08x\n",
1811 rx_status);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001812 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 if (!(rx_status & RxStatusOK)) {
1814 if (rx_status & RxTooLong) {
Joe Perches497159a2010-02-17 15:01:49 +00001815 netdev_dbg(dev, "Oversized Ethernet frame, status %04x!\n",
1816 rx_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 /* A.C.: The chip hangs here. */
1818 }
1819 if (rx_status & (RxBadSymbol | RxBadAlign))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001820 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 if (rx_status & (RxRunt | RxTooLong))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001822 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 if (rx_status & RxCRCErr)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001824 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 } else {
1826 tp->xstats.rx_lost_in_ring++;
1827 }
1828
1829#ifndef CONFIG_8139_OLD_RX_RESET
1830 tmp8 = RTL_R8 (ChipCmd);
1831 RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1832 RTL_W8 (ChipCmd, tmp8);
1833 RTL_W32 (RxConfig, tp->rx_config);
1834 tp->cur_rx = 0;
1835#else
1836 /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1837
1838 /* disable receive */
1839 RTL_W8_F (ChipCmd, CmdTxEnb);
1840 tmp_work = 200;
1841 while (--tmp_work > 0) {
1842 udelay(1);
1843 tmp8 = RTL_R8 (ChipCmd);
1844 if (!(tmp8 & CmdRxEnb))
1845 break;
1846 }
1847 if (tmp_work <= 0)
Joe Perches497159a2010-02-17 15:01:49 +00001848 netdev_warn(dev, "rx stop wait too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 /* restart receive */
1850 tmp_work = 200;
1851 while (--tmp_work > 0) {
1852 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1853 udelay(1);
1854 tmp8 = RTL_R8 (ChipCmd);
1855 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1856 break;
1857 }
1858 if (tmp_work <= 0)
Joe Perches497159a2010-02-17 15:01:49 +00001859 netdev_warn(dev, "tx/rx enable wait too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
1861 /* and reinitialize all rx related registers */
1862 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1863 /* Must enable Tx/Rx before setting transfer thresholds! */
1864 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1865
1866 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1867 RTL_W32 (RxConfig, tp->rx_config);
1868 tp->cur_rx = 0;
1869
Joe Perches497159a2010-02-17 15:01:49 +00001870 netdev_dbg(dev, "init buffer addresses\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
1872 /* Lock Config[01234] and BMCR register writes */
1873 RTL_W8 (Cfg9346, Cfg9346_Lock);
1874
1875 /* init Rx ring buffer DMA address */
1876 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1877
1878 /* A.C.: Reset the multicast list. */
1879 __set_rx_mode (dev);
1880#endif
1881}
1882
1883#if RX_BUF_IDX == 3
Márton Németha9879c42008-06-15 09:52:30 +02001884static inline void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 u32 offset, unsigned int size)
1886{
1887 u32 left = RX_BUF_LEN - offset;
1888
1889 if (size > left) {
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001890 skb_copy_to_linear_data(skb, ring + offset, left);
1891 skb_copy_to_linear_data_offset(skb, left, ring, size - left);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 } else
Arnaldo Carvalho de Melo27d7ff42007-03-31 11:55:19 -03001893 skb_copy_to_linear_data(skb, ring + offset, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895#endif
1896
1897static void rtl8139_isr_ack(struct rtl8139_private *tp)
1898{
Pekka Enberg22f714b2005-05-12 19:38:47 -04001899 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 u16 status;
1901
1902 status = RTL_R16 (IntrStatus) & RxAckBits;
1903
1904 /* Clear out errors and receive interrupts */
1905 if (likely(status != 0)) {
1906 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001907 tp->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 if (status & RxFIFOOver)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001909 tp->dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 }
1911 RTL_W16_F (IntrStatus, RxAckBits);
1912 }
1913}
1914
1915static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1916 int budget)
1917{
Pekka Enberg22f714b2005-05-12 19:38:47 -04001918 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 int received = 0;
1920 unsigned char *rx_ring = tp->rx_ring;
1921 unsigned int cur_rx = tp->cur_rx;
1922 unsigned int rx_size = 0;
1923
Joe Perches497159a2010-02-17 15:01:49 +00001924 netdev_dbg(dev, "In %s(), current %04x BufAddr %04x, free to %04x, Cmd %02x\n",
1925 __func__, (u16)cur_rx,
1926 RTL_R16(RxBufAddr), RTL_R16(RxBufPtr), RTL_R8(ChipCmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
Joe Perches8e95a202009-12-03 07:58:21 +00001928 while (netif_running(dev) && received < budget &&
1929 (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 u32 ring_offset = cur_rx % RX_BUF_LEN;
1931 u32 rx_status;
1932 unsigned int pkt_size;
1933 struct sk_buff *skb;
1934
1935 rmb();
1936
1937 /* read size+status of next frame from DMA ring buffer */
Al Viroeca1ad82008-03-16 22:21:54 +00001938 rx_status = le32_to_cpu (*(__le32 *) (rx_ring + ring_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 rx_size = rx_status >> 16;
1940 pkt_size = rx_size - 4;
1941
Joe Perches497159a2010-02-17 15:01:49 +00001942 netif_dbg(tp, rx_status, dev, "%s() status %04x, size %04x, cur %04x\n",
1943 __func__, rx_status, rx_size, cur_rx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944#if RTL8139_DEBUG > 2
Alexander Kuznetsovef9e83c2010-04-19 14:17:43 -07001945 print_hex_dump(KERN_DEBUG, "Frame contents: ",
Joe Perches497159a2010-02-17 15:01:49 +00001946 DUMP_PREFIX_OFFSET, 16, 1,
1947 &rx_ring[ring_offset], 70, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948#endif
1949
1950 /* Packet copy from FIFO still in progress.
1951 * Theoretically, this should never happen
1952 * since EarlyRx is disabled.
1953 */
1954 if (unlikely(rx_size == 0xfff0)) {
1955 if (!tp->fifo_copy_timeout)
1956 tp->fifo_copy_timeout = jiffies + 2;
1957 else if (time_after(jiffies, tp->fifo_copy_timeout)) {
Joe Perches497159a2010-02-17 15:01:49 +00001958 netdev_dbg(dev, "hung FIFO. Reset\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 rx_size = 0;
1960 goto no_early_rx;
1961 }
Joe Perches497159a2010-02-17 15:01:49 +00001962 netif_dbg(tp, intr, dev, "fifo copy in progress\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 tp->xstats.early_rx++;
1964 break;
1965 }
1966
1967no_early_rx:
1968 tp->fifo_copy_timeout = 0;
1969
1970 /* If Rx err or invalid rx_size/rx_status received
1971 * (which happens if we get lost in the ring),
1972 * Rx process gets reset, so we abort any further
1973 * Rx processing.
1974 */
1975 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1976 (rx_size < 8) ||
1977 (!(rx_status & RxStatusOK)))) {
1978 rtl8139_rx_err (rx_status, dev, tp, ioaddr);
1979 received = -1;
1980 goto out;
1981 }
1982
1983 /* Malloc up new buffer, compatible with net-2e. */
1984 /* Omit the four octet CRC from the length. */
1985
Eric Dumazet89d71a62009-10-13 05:34:20 +00001986 skb = netdev_alloc_skb_ip_align(dev, pkt_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 if (likely(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988#if RX_BUF_IDX == 3
1989 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
1990#else
David S. Miller8c7b7fa2007-07-10 22:08:12 -07001991 skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992#endif
1993 skb_put (skb, pkt_size);
1994
1995 skb->protocol = eth_type_trans (skb, dev);
1996
Paulius Zaleckase1eac922008-05-05 16:24:21 +03001997 dev->stats.rx_bytes += pkt_size;
1998 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999
2000 netif_receive_skb (skb);
2001 } else {
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002002 if (net_ratelimit())
Joe Perches497159a2010-02-17 15:01:49 +00002003 netdev_warn(dev, "Memory squeeze, dropping packet\n");
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002004 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 }
2006 received++;
2007
2008 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2009 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2010
2011 rtl8139_isr_ack(tp);
2012 }
2013
2014 if (unlikely(!received || rx_size == 0xfff0))
2015 rtl8139_isr_ack(tp);
2016
Joe Perches497159a2010-02-17 15:01:49 +00002017 netdev_dbg(dev, "Done %s(), current %04x BufAddr %04x, free to %04x, Cmd %02x\n",
2018 __func__, cur_rx,
2019 RTL_R16(RxBufAddr), RTL_R16(RxBufPtr), RTL_R8(ChipCmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020
2021 tp->cur_rx = cur_rx;
2022
2023 /*
2024 * The receive buffer should be mostly empty.
2025 * Tell NAPI to reenable the Rx irq.
2026 */
2027 if (tp->fifo_copy_timeout)
2028 received = budget;
2029
2030out:
2031 return received;
2032}
2033
2034
2035static void rtl8139_weird_interrupt (struct net_device *dev,
2036 struct rtl8139_private *tp,
Pekka Enberg22f714b2005-05-12 19:38:47 -04002037 void __iomem *ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 int status, int link_changed)
2039{
Joe Perches497159a2010-02-17 15:01:49 +00002040 netdev_dbg(dev, "Abnormal interrupt, status %08x\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041
2042 assert (dev != NULL);
2043 assert (tp != NULL);
2044 assert (ioaddr != NULL);
2045
2046 /* Update the error count. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002047 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 RTL_W32 (RxMissed, 0);
2049
2050 if ((status & RxUnderrun) && link_changed &&
2051 (tp->drv_flags & HAS_LNK_CHNG)) {
2052 rtl_check_media(dev, 0);
2053 status &= ~RxUnderrun;
2054 }
2055
2056 if (status & (RxUnderrun | RxErr))
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002057 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058
2059 if (status & PCSTimeout)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002060 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 if (status & RxUnderrun)
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002062 dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 if (status & PCIErr) {
2064 u16 pci_cmd_status;
2065 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2066 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2067
Joe Perches497159a2010-02-17 15:01:49 +00002068 netdev_err(dev, "PCI Bus error %04x\n", pci_cmd_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 }
2070}
2071
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002072static int rtl8139_poll(struct napi_struct *napi, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002074 struct rtl8139_private *tp = container_of(napi, struct rtl8139_private, napi);
2075 struct net_device *dev = tp->dev;
Pekka Enberg22f714b2005-05-12 19:38:47 -04002076 void __iomem *ioaddr = tp->mmio_addr;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002077 int work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078
2079 spin_lock(&tp->rx_lock);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002080 work_done = 0;
2081 if (likely(RTL_R16(IntrStatus) & RxAckBits))
2082 work_done += rtl8139_rx(dev, tp, budget);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002084 if (work_done < budget) {
Ingo Molnarb57bd062006-12-12 13:49:35 +01002085 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 /*
2087 * Order is important since data can get interrupted
2088 * again when we think we are done.
2089 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002090 spin_lock_irqsave(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 RTL_W16_F(IntrMask, rtl8139_intr_mask);
Ben Hutchings288379f2009-01-19 16:43:59 -08002092 __napi_complete(napi);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002093 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 }
2095 spin_unlock(&tp->rx_lock);
2096
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002097 return work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098}
2099
2100/* The interrupt handler does all of the Rx thread work and cleans up
2101 after the Tx thread. */
David Howells7d12e782006-10-05 14:55:46 +01002102static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103{
2104 struct net_device *dev = (struct net_device *) dev_instance;
2105 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002106 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 u16 status, ackstat;
2108 int link_changed = 0; /* avoid bogus "uninit" warning */
2109 int handled = 0;
2110
2111 spin_lock (&tp->lock);
2112 status = RTL_R16 (IntrStatus);
2113
2114 /* shared irq? */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002115 if (unlikely((status & rtl8139_intr_mask) == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 goto out;
2117
2118 handled = 1;
2119
2120 /* h/w no longer present (hotplug?) or major error, bail */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002121 if (unlikely(status == 0xFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 goto out;
2123
2124 /* close possible race's with dev_close */
2125 if (unlikely(!netif_running(dev))) {
2126 RTL_W16 (IntrMask, 0);
2127 goto out;
2128 }
2129
2130 /* Acknowledge all of the current interrupt sources ASAP, but
2131 an first get an additional status bit from CSCR. */
2132 if (unlikely(status & RxUnderrun))
2133 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2134
2135 ackstat = status & ~(RxAckBits | TxErr);
2136 if (ackstat)
2137 RTL_W16 (IntrStatus, ackstat);
2138
2139 /* Receive packets are processed by poll routine.
2140 If not running start it now. */
2141 if (status & RxAckBits){
Ben Hutchings288379f2009-01-19 16:43:59 -08002142 if (napi_schedule_prep(&tp->napi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
Ben Hutchings288379f2009-01-19 16:43:59 -08002144 __napi_schedule(&tp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 }
2146 }
2147
2148 /* Check uncommon events with one test. */
2149 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2150 rtl8139_weird_interrupt (dev, tp, ioaddr,
2151 status, link_changed);
2152
2153 if (status & (TxOK | TxErr)) {
2154 rtl8139_tx_interrupt (dev, tp, ioaddr);
2155 if (status & TxErr)
2156 RTL_W16 (IntrStatus, TxErr);
2157 }
2158 out:
2159 spin_unlock (&tp->lock);
2160
Joe Perches497159a2010-02-17 15:01:49 +00002161 netdev_dbg(dev, "exiting interrupt, intr_status=%#4.4x\n",
2162 RTL_R16(IntrStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 return IRQ_RETVAL(handled);
2164}
2165
2166#ifdef CONFIG_NET_POLL_CONTROLLER
2167/*
2168 * Polling receive - used by netconsole and other diagnostic tools
2169 * to allow network i/o with interrupts disabled.
2170 */
2171static void rtl8139_poll_controller(struct net_device *dev)
2172{
2173 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +01002174 rtl8139_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 enable_irq(dev->irq);
2176}
2177#endif
2178
Jiri Pirkobda6a152009-03-13 11:48:18 -07002179static int rtl8139_set_mac_address(struct net_device *dev, void *p)
2180{
2181 struct rtl8139_private *tp = netdev_priv(dev);
2182 void __iomem *ioaddr = tp->mmio_addr;
2183 struct sockaddr *addr = p;
2184
2185 if (!is_valid_ether_addr(addr->sa_data))
2186 return -EADDRNOTAVAIL;
2187
2188 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
2189
2190 spin_lock_irq(&tp->lock);
2191
2192 RTL_W8_F(Cfg9346, Cfg9346_Unlock);
2193 RTL_W32_F(MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
2194 RTL_W32_F(MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
2195 RTL_W8_F(Cfg9346, Cfg9346_Lock);
2196
2197 spin_unlock_irq(&tp->lock);
2198
2199 return 0;
2200}
2201
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202static int rtl8139_close (struct net_device *dev)
2203{
2204 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002205 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 unsigned long flags;
2207
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002208 netif_stop_queue(dev);
2209 napi_disable(&tp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210
Joe Perches497159a2010-02-17 15:01:49 +00002211 netif_dbg(tp, ifdown, dev, "Shutting down ethercard, status was 0x%04x\n",
2212 RTL_R16(IntrStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213
2214 spin_lock_irqsave (&tp->lock, flags);
2215
2216 /* Stop the chip's Tx and Rx DMA processes. */
2217 RTL_W8 (ChipCmd, 0);
2218
2219 /* Disable interrupts by clearing the interrupt mask. */
2220 RTL_W16 (IntrMask, 0);
2221
2222 /* Update the error counts. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002223 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 RTL_W32 (RxMissed, 0);
2225
2226 spin_unlock_irqrestore (&tp->lock, flags);
2227
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 free_irq (dev->irq, dev);
2229
2230 rtl8139_tx_clear (tp);
2231
Jeff Garzik6cc92cd2007-08-08 02:16:04 -04002232 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
2233 tp->rx_ring, tp->rx_ring_dma);
2234 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
2235 tp->tx_bufs, tp->tx_bufs_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 tp->rx_ring = NULL;
2237 tp->tx_bufs = NULL;
2238
2239 /* Green! Put the chip in low-power mode. */
2240 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2241
2242 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2243 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
2244
2245 return 0;
2246}
2247
2248
2249/* Get the ethtool Wake-on-LAN settings. Assumes that wol points to
2250 kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2251 other threads or interrupts aren't messing with the 8139. */
2252static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2253{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002254 struct rtl8139_private *tp = netdev_priv(dev);
2255 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002257 spin_lock_irq(&tp->lock);
2258 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 u8 cfg3 = RTL_R8 (Config3);
2260 u8 cfg5 = RTL_R8 (Config5);
2261
2262 wol->supported = WAKE_PHY | WAKE_MAGIC
2263 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2264
2265 wol->wolopts = 0;
2266 if (cfg3 & Cfg3_LinkUp)
2267 wol->wolopts |= WAKE_PHY;
2268 if (cfg3 & Cfg3_Magic)
2269 wol->wolopts |= WAKE_MAGIC;
2270 /* (KON)FIXME: See how netdev_set_wol() handles the
2271 following constants. */
2272 if (cfg5 & Cfg5_UWF)
2273 wol->wolopts |= WAKE_UCAST;
2274 if (cfg5 & Cfg5_MWF)
2275 wol->wolopts |= WAKE_MCAST;
2276 if (cfg5 & Cfg5_BWF)
2277 wol->wolopts |= WAKE_BCAST;
2278 }
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002279 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280}
2281
2282
2283/* Set the ethtool Wake-on-LAN settings. Return 0 or -errno. Assumes
2284 that wol points to kernel memory and other threads or interrupts
2285 aren't messing with the 8139. */
2286static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2287{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002288 struct rtl8139_private *tp = netdev_priv(dev);
2289 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 u32 support;
2291 u8 cfg3, cfg5;
2292
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002293 support = ((rtl_chip_info[tp->chipset].flags & HasLWake)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 ? (WAKE_PHY | WAKE_MAGIC
2295 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2296 : 0);
2297 if (wol->wolopts & ~support)
2298 return -EINVAL;
2299
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002300 spin_lock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2302 if (wol->wolopts & WAKE_PHY)
2303 cfg3 |= Cfg3_LinkUp;
2304 if (wol->wolopts & WAKE_MAGIC)
2305 cfg3 |= Cfg3_Magic;
2306 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2307 RTL_W8 (Config3, cfg3);
2308 RTL_W8 (Cfg9346, Cfg9346_Lock);
2309
2310 cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2311 /* (KON)FIXME: These are untested. We may have to set the
2312 CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2313 documentation. */
2314 if (wol->wolopts & WAKE_UCAST)
2315 cfg5 |= Cfg5_UWF;
2316 if (wol->wolopts & WAKE_MCAST)
2317 cfg5 |= Cfg5_MWF;
2318 if (wol->wolopts & WAKE_BCAST)
2319 cfg5 |= Cfg5_BWF;
2320 RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002321 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
2323 return 0;
2324}
2325
2326static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2327{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002328 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 strcpy(info->driver, DRV_NAME);
2330 strcpy(info->version, DRV_VERSION);
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002331 strcpy(info->bus_info, pci_name(tp->pci_dev));
2332 info->regdump_len = tp->regs_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333}
2334
2335static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2336{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002337 struct rtl8139_private *tp = netdev_priv(dev);
2338 spin_lock_irq(&tp->lock);
2339 mii_ethtool_gset(&tp->mii, cmd);
2340 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 return 0;
2342}
2343
2344static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2345{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002346 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 int rc;
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002348 spin_lock_irq(&tp->lock);
2349 rc = mii_ethtool_sset(&tp->mii, cmd);
2350 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 return rc;
2352}
2353
2354static int rtl8139_nway_reset(struct net_device *dev)
2355{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002356 struct rtl8139_private *tp = netdev_priv(dev);
2357 return mii_nway_restart(&tp->mii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358}
2359
2360static u32 rtl8139_get_link(struct net_device *dev)
2361{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002362 struct rtl8139_private *tp = netdev_priv(dev);
2363 return mii_link_ok(&tp->mii);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364}
2365
2366static u32 rtl8139_get_msglevel(struct net_device *dev)
2367{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002368 struct rtl8139_private *tp = netdev_priv(dev);
2369 return tp->msg_enable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370}
2371
2372static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2373{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002374 struct rtl8139_private *tp = netdev_priv(dev);
2375 tp->msg_enable = datum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376}
2377
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378static int rtl8139_get_regs_len(struct net_device *dev)
2379{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002380 struct rtl8139_private *tp;
Dave Joneseb581342008-07-15 19:54:53 -04002381 /* TODO: we are too slack to do reg dumping for pio, for now */
2382 if (use_io)
2383 return 0;
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002384 tp = netdev_priv(dev);
2385 return tp->regs_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386}
2387
2388static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2389{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002390 struct rtl8139_private *tp;
Dave Joneseb581342008-07-15 19:54:53 -04002391
2392 /* TODO: we are too slack to do reg dumping for pio, for now */
2393 if (use_io)
2394 return;
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002395 tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396
2397 regs->version = RTL_REGS_VER;
2398
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002399 spin_lock_irq(&tp->lock);
2400 memcpy_fromio(regbuf, tp->mmio_addr, regs->len);
2401 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002404static int rtl8139_get_sset_count(struct net_device *dev, int sset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405{
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002406 switch (sset) {
2407 case ETH_SS_STATS:
2408 return RTL_NUM_STATS;
2409 default:
2410 return -EOPNOTSUPP;
2411 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412}
2413
2414static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2415{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002416 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002418 data[0] = tp->xstats.early_rx;
2419 data[1] = tp->xstats.tx_buf_mapped;
2420 data[2] = tp->xstats.tx_timeouts;
2421 data[3] = tp->xstats.rx_lost_in_ring;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422}
2423
2424static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2425{
2426 memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2427}
2428
Jeff Garzik7282d492006-09-13 14:30:00 -04002429static const struct ethtool_ops rtl8139_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 .get_drvinfo = rtl8139_get_drvinfo,
2431 .get_settings = rtl8139_get_settings,
2432 .set_settings = rtl8139_set_settings,
2433 .get_regs_len = rtl8139_get_regs_len,
2434 .get_regs = rtl8139_get_regs,
2435 .nway_reset = rtl8139_nway_reset,
2436 .get_link = rtl8139_get_link,
2437 .get_msglevel = rtl8139_get_msglevel,
2438 .set_msglevel = rtl8139_set_msglevel,
2439 .get_wol = rtl8139_get_wol,
2440 .set_wol = rtl8139_set_wol,
2441 .get_strings = rtl8139_get_strings,
Jeff Garzikb9f2c042007-10-03 18:07:32 -07002442 .get_sset_count = rtl8139_get_sset_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 .get_ethtool_stats = rtl8139_get_ethtool_stats,
2444};
2445
2446static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2447{
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002448 struct rtl8139_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 int rc;
2450
2451 if (!netif_running(dev))
2452 return -EINVAL;
2453
Jianjun Kongd035fbc2009-04-20 04:05:34 +00002454 spin_lock_irq(&tp->lock);
2455 rc = generic_mii_ioctl(&tp->mii, if_mii(rq), cmd, NULL);
2456 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457
2458 return rc;
2459}
2460
2461
2462static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2463{
2464 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002465 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 unsigned long flags;
2467
2468 if (netif_running(dev)) {
2469 spin_lock_irqsave (&tp->lock, flags);
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002470 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 RTL_W32 (RxMissed, 0);
2472 spin_unlock_irqrestore (&tp->lock, flags);
2473 }
2474
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002475 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476}
2477
2478/* Set or clear the multicast filter for this adaptor.
2479 This routine is not state sensitive and need not be SMP locked. */
2480
2481static void __set_rx_mode (struct net_device *dev)
2482{
2483 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002484 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 u32 mc_filter[2]; /* Multicast hash filter */
Jiri Pirko6d55ad42010-02-05 02:48:11 +00002486 int rx_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 u32 tmp;
2488
Joe Perches497159a2010-02-17 15:01:49 +00002489 netdev_dbg(dev, "rtl8139_set_rx_mode(%04x) done -- Rx config %08lx\n",
2490 dev->flags, RTL_R32(RxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491
2492 /* Note: do not reorder, GCC is clever about common statements. */
2493 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 rx_mode =
2495 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2496 AcceptAllPhys;
2497 mc_filter[1] = mc_filter[0] = 0xffffffff;
Jiri Pirko6d55ad42010-02-05 02:48:11 +00002498 } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
Joe Perches8e95a202009-12-03 07:58:21 +00002499 (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 /* Too many to filter perfectly -- accept all multicasts. */
2501 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2502 mc_filter[1] = mc_filter[0] = 0xffffffff;
2503 } else {
Jiri Pirko22bedad32010-04-01 21:22:57 +00002504 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 rx_mode = AcceptBroadcast | AcceptMyPhys;
2506 mc_filter[1] = mc_filter[0] = 0;
Jiri Pirko22bedad32010-04-01 21:22:57 +00002507 netdev_for_each_mc_addr(ha, dev) {
2508 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509
2510 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2511 rx_mode |= AcceptMulticast;
2512 }
2513 }
2514
2515 /* We can safely update without stopping the chip. */
2516 tmp = rtl8139_rx_config | rx_mode;
2517 if (tp->rx_config != tmp) {
2518 RTL_W32_F (RxConfig, tmp);
2519 tp->rx_config = tmp;
2520 }
2521 RTL_W32_F (MAR0 + 0, mc_filter[0]);
2522 RTL_W32_F (MAR0 + 4, mc_filter[1]);
2523}
2524
2525static void rtl8139_set_rx_mode (struct net_device *dev)
2526{
2527 unsigned long flags;
2528 struct rtl8139_private *tp = netdev_priv(dev);
2529
2530 spin_lock_irqsave (&tp->lock, flags);
2531 __set_rx_mode(dev);
2532 spin_unlock_irqrestore (&tp->lock, flags);
2533}
2534
2535#ifdef CONFIG_PM
2536
2537static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2538{
2539 struct net_device *dev = pci_get_drvdata (pdev);
2540 struct rtl8139_private *tp = netdev_priv(dev);
Pekka Enberg22f714b2005-05-12 19:38:47 -04002541 void __iomem *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 unsigned long flags;
2543
2544 pci_save_state (pdev);
2545
2546 if (!netif_running (dev))
2547 return 0;
2548
2549 netif_device_detach (dev);
2550
2551 spin_lock_irqsave (&tp->lock, flags);
2552
2553 /* Disable interrupts, stop Tx and Rx. */
2554 RTL_W16 (IntrMask, 0);
2555 RTL_W8 (ChipCmd, 0);
2556
2557 /* Update the error counts. */
Paulius Zaleckase1eac922008-05-05 16:24:21 +03002558 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 RTL_W32 (RxMissed, 0);
2560
2561 spin_unlock_irqrestore (&tp->lock, flags);
2562
2563 pci_set_power_state (pdev, PCI_D3hot);
2564
2565 return 0;
2566}
2567
2568
2569static int rtl8139_resume (struct pci_dev *pdev)
2570{
2571 struct net_device *dev = pci_get_drvdata (pdev);
2572
2573 pci_restore_state (pdev);
2574 if (!netif_running (dev))
2575 return 0;
2576 pci_set_power_state (pdev, PCI_D0);
2577 rtl8139_init_ring (dev);
2578 rtl8139_hw_start (dev);
2579 netif_device_attach (dev);
2580 return 0;
2581}
2582
2583#endif /* CONFIG_PM */
2584
2585
2586static struct pci_driver rtl8139_pci_driver = {
2587 .name = DRV_NAME,
2588 .id_table = rtl8139_pci_tbl,
2589 .probe = rtl8139_init_one,
2590 .remove = __devexit_p(rtl8139_remove_one),
2591#ifdef CONFIG_PM
2592 .suspend = rtl8139_suspend,
2593 .resume = rtl8139_resume,
2594#endif /* CONFIG_PM */
2595};
2596
2597
2598static int __init rtl8139_init_module (void)
2599{
2600 /* when we're a module, we always print a version message,
2601 * even if no 8139 board is found.
2602 */
2603#ifdef MODULE
Alexander Beregalovb93d5842009-05-26 12:35:27 +00002604 pr_info(RTL8139_DRIVER_NAME "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605#endif
2606
Jeff Garzik29917622006-08-19 17:48:59 -04002607 return pci_register_driver(&rtl8139_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608}
2609
2610
2611static void __exit rtl8139_cleanup_module (void)
2612{
2613 pci_unregister_driver (&rtl8139_pci_driver);
2614}
2615
2616
2617module_init(rtl8139_init_module);
2618module_exit(rtl8139_cleanup_module);