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