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