?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
OMAP3: SR: Fix SR driver to check for omap-pm return values
[linux-ginger.git] / drivers / net / 8139too.c
blob4a362875502661f8d3e7bae4adf78a3952114b43
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 netdev_tx_t 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 netdev_tx_t rtl8139_start_xmit (struct sk_buff *skb,
1691 struct net_device *dev)
1692 {
1693 struct rtl8139_private *tp = netdev_priv(dev);
1694 void __iomem *ioaddr = tp->mmio_addr;
1695 unsigned int entry;
1696 unsigned int len = skb->len;
1697 unsigned long flags;
1698
1699 /* Calculate the next Tx descriptor entry. */
1700 entry = tp->cur_tx % NUM_TX_DESC;
1701
1702 /* Note: the chip doesn't have auto-pad! */
1703 if (likely(len < TX_BUF_SIZE)) {
1704 if (len < ETH_ZLEN)
1705 memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1706 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1707 dev_kfree_skb(skb);
1708 } else {
1709 dev_kfree_skb(skb);
1710 dev->stats.tx_dropped++;
1711 return NETDEV_TX_OK;
1712 }
1713
1714 spin_lock_irqsave(&tp->lock, flags);
1715 /*
1716 * Writing to TxStatus triggers a DMA transfer of the data
1717 * copied to tp->tx_buf[entry] above. Use a memory barrier
1718 * to make sure that the device sees the updated data.
1719 */
1720 wmb();
1721 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1722 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1723
1724 dev->trans_start = jiffies;
1725
1726 tp->cur_tx++;
1727
1728 if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1729 netif_stop_queue (dev);
1730 spin_unlock_irqrestore(&tp->lock, flags);
1731
1732 if (netif_msg_tx_queued(tp))
1733 pr_debug("%s: Queued Tx packet size %u to slot %d.\n",
1734 dev->name, len, entry);
1735
1736 return NETDEV_TX_OK;
1737 }
1738
1739
1740 static void rtl8139_tx_interrupt (struct net_device *dev,
1741 struct rtl8139_private *tp,
1742 void __iomem *ioaddr)
1743 {
1744 unsigned long dirty_tx, tx_left;
1745
1746 assert (dev != NULL);
1747 assert (ioaddr != NULL);
1748
1749 dirty_tx = tp->dirty_tx;
1750 tx_left = tp->cur_tx - dirty_tx;
1751 while (tx_left > 0) {
1752 int entry = dirty_tx % NUM_TX_DESC;
1753 int txstatus;
1754
1755 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1756
1757 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1758 break; /* It still hasn't been Txed */
1759
1760 /* Note: TxCarrierLost is always asserted at 100mbps. */
1761 if (txstatus & (TxOutOfWindow | TxAborted)) {
1762 /* There was an major error, log it. */
1763 if (netif_msg_tx_err(tp))
1764 pr_debug("%s: Transmit error, Tx status %8.8x.\n",
1765 dev->name, txstatus);
1766 dev->stats.tx_errors++;
1767 if (txstatus & TxAborted) {
1768 dev->stats.tx_aborted_errors++;
1769 RTL_W32 (TxConfig, TxClearAbt);
1770 RTL_W16 (IntrStatus, TxErr);
1771 wmb();
1772 }
1773 if (txstatus & TxCarrierLost)
1774 dev->stats.tx_carrier_errors++;
1775 if (txstatus & TxOutOfWindow)
1776 dev->stats.tx_window_errors++;
1777 } else {
1778 if (txstatus & TxUnderrun) {
1779 /* Add 64 to the Tx FIFO threshold. */
1780 if (tp->tx_flag < 0x00300000)
1781 tp->tx_flag += 0x00020000;
1782 dev->stats.tx_fifo_errors++;
1783 }
1784 dev->stats.collisions += (txstatus >> 24) & 15;
1785 dev->stats.tx_bytes += txstatus & 0x7ff;
1786 dev->stats.tx_packets++;
1787 }
1788
1789 dirty_tx++;
1790 tx_left--;
1791 }
1792
1793 #ifndef RTL8139_NDEBUG
1794 if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
1795 pr_err("%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
1796 dev->name, dirty_tx, tp->cur_tx);
1797 dirty_tx += NUM_TX_DESC;
1798 }
1799 #endif /* RTL8139_NDEBUG */
1800
1801 /* only wake the queue if we did work, and the queue is stopped */
1802 if (tp->dirty_tx != dirty_tx) {
1803 tp->dirty_tx = dirty_tx;
1804 mb();
1805 netif_wake_queue (dev);
1806 }
1807 }
1808
1809
1810 /* TODO: clean this up! Rx reset need not be this intensive */
1811 static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
1812 struct rtl8139_private *tp, void __iomem *ioaddr)
1813 {
1814 u8 tmp8;
1815 #ifdef CONFIG_8139_OLD_RX_RESET
1816 int tmp_work;
1817 #endif
1818
1819 if (netif_msg_rx_err (tp))
1820 pr_debug("%s: Ethernet frame had errors, status %8.8x.\n",
1821 dev->name, rx_status);
1822 dev->stats.rx_errors++;
1823 if (!(rx_status & RxStatusOK)) {
1824 if (rx_status & RxTooLong) {
1825 pr_debug("%s: Oversized Ethernet frame, status %4.4x!\n",
1826 dev->name, rx_status);
1827 /* A.C.: The chip hangs here. */
1828 }
1829 if (rx_status & (RxBadSymbol | RxBadAlign))
1830 dev->stats.rx_frame_errors++;
1831 if (rx_status & (RxRunt | RxTooLong))
1832 dev->stats.rx_length_errors++;
1833 if (rx_status & RxCRCErr)
1834 dev->stats.rx_crc_errors++;
1835 } else {
1836 tp->xstats.rx_lost_in_ring++;
1837 }
1838
1839 #ifndef CONFIG_8139_OLD_RX_RESET
1840 tmp8 = RTL_R8 (ChipCmd);
1841 RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1842 RTL_W8 (ChipCmd, tmp8);
1843 RTL_W32 (RxConfig, tp->rx_config);
1844 tp->cur_rx = 0;
1845 #else
1846 /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1847
1848 /* disable receive */
1849 RTL_W8_F (ChipCmd, CmdTxEnb);
1850 tmp_work = 200;
1851 while (--tmp_work > 0) {
1852 udelay(1);
1853 tmp8 = RTL_R8 (ChipCmd);
1854 if (!(tmp8 & CmdRxEnb))
1855 break;
1856 }
1857 if (tmp_work <= 0)
1858 pr_warning(PFX "rx stop wait too long\n");
1859 /* restart receive */
1860 tmp_work = 200;
1861 while (--tmp_work > 0) {
1862 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1863 udelay(1);
1864 tmp8 = RTL_R8 (ChipCmd);
1865 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1866 break;
1867 }
1868 if (tmp_work <= 0)
1869 pr_warning(PFX "tx/rx enable wait too long\n");
1870
1871 /* and reinitialize all rx related registers */
1872 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1873 /* Must enable Tx/Rx before setting transfer thresholds! */
1874 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1875
1876 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1877 RTL_W32 (RxConfig, tp->rx_config);
1878 tp->cur_rx = 0;
1879
1880 pr_debug("init buffer addresses\n");
1881
1882 /* Lock Config[01234] and BMCR register writes */
1883 RTL_W8 (Cfg9346, Cfg9346_Lock);
1884
1885 /* init Rx ring buffer DMA address */
1886 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1887
1888 /* A.C.: Reset the multicast list. */
1889 __set_rx_mode (dev);
1890 #endif
1891 }
1892
1893 #if RX_BUF_IDX == 3
1894 static inline void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
1895 u32 offset, unsigned int size)
1896 {
1897 u32 left = RX_BUF_LEN - offset;
1898
1899 if (size > left) {
1900 skb_copy_to_linear_data(skb, ring + offset, left);
1901 skb_copy_to_linear_data_offset(skb, left, ring, size - left);
1902 } else
1903 skb_copy_to_linear_data(skb, ring + offset, size);
1904 }
1905 #endif
1906
1907 static void rtl8139_isr_ack(struct rtl8139_private *tp)
1908 {
1909 void __iomem *ioaddr = tp->mmio_addr;
1910 u16 status;
1911
1912 status = RTL_R16 (IntrStatus) & RxAckBits;
1913
1914 /* Clear out errors and receive interrupts */
1915 if (likely(status != 0)) {
1916 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
1917 tp->dev->stats.rx_errors++;
1918 if (status & RxFIFOOver)
1919 tp->dev->stats.rx_fifo_errors++;
1920 }
1921 RTL_W16_F (IntrStatus, RxAckBits);
1922 }
1923 }
1924
1925 static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1926 int budget)
1927 {
1928 void __iomem *ioaddr = tp->mmio_addr;
1929 int received = 0;
1930 unsigned char *rx_ring = tp->rx_ring;
1931 unsigned int cur_rx = tp->cur_rx;
1932 unsigned int rx_size = 0;
1933
1934 pr_debug("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x,"
1935 " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx,
1936 RTL_R16 (RxBufAddr),
1937 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
1938
1939 while (netif_running(dev) && received < budget
1940 && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
1941 u32 ring_offset = cur_rx % RX_BUF_LEN;
1942 u32 rx_status;
1943 unsigned int pkt_size;
1944 struct sk_buff *skb;
1945
1946 rmb();
1947
1948 /* read size+status of next frame from DMA ring buffer */
1949 rx_status = le32_to_cpu (*(__le32 *) (rx_ring + ring_offset));
1950 rx_size = rx_status >> 16;
1951 pkt_size = rx_size - 4;
1952
1953 if (netif_msg_rx_status(tp))
1954 pr_debug("%s: rtl8139_rx() status %4.4x, size %4.4x,"
1955 " cur %4.4x.\n", dev->name, rx_status,
1956 rx_size, cur_rx);
1957 #if RTL8139_DEBUG > 2
1958 {
1959 int i;
1960 pr_debug("%s: Frame contents ", dev->name);
1961 for (i = 0; i < 70; i++)
1962 pr_cont(" %2.2x",
1963 rx_ring[ring_offset + i]);
1964 pr_cont(".\n");
1965 }
1966 #endif
1967
1968 /* Packet copy from FIFO still in progress.
1969 * Theoretically, this should never happen
1970 * since EarlyRx is disabled.
1971 */
1972 if (unlikely(rx_size == 0xfff0)) {
1973 if (!tp->fifo_copy_timeout)
1974 tp->fifo_copy_timeout = jiffies + 2;
1975 else if (time_after(jiffies, tp->fifo_copy_timeout)) {
1976 pr_debug("%s: hung FIFO. Reset.", dev->name);
1977 rx_size = 0;
1978 goto no_early_rx;
1979 }
1980 if (netif_msg_intr(tp)) {
1981 pr_debug("%s: fifo copy in progress.",
1982 dev->name);
1983 }
1984 tp->xstats.early_rx++;
1985 break;
1986 }
1987
1988 no_early_rx:
1989 tp->fifo_copy_timeout = 0;
1990
1991 /* If Rx err or invalid rx_size/rx_status received
1992 * (which happens if we get lost in the ring),
1993 * Rx process gets reset, so we abort any further
1994 * Rx processing.
1995 */
1996 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1997 (rx_size < 8) ||
1998 (!(rx_status & RxStatusOK)))) {
1999 rtl8139_rx_err (rx_status, dev, tp, ioaddr);
2000 received = -1;
2001 goto out;
2002 }
2003
2004 /* Malloc up new buffer, compatible with net-2e. */
2005 /* Omit the four octet CRC from the length. */
2006
2007 skb = netdev_alloc_skb(dev, pkt_size + NET_IP_ALIGN);
2008 if (likely(skb)) {
2009 skb_reserve (skb, NET_IP_ALIGN); /* 16 byte align the IP fields. */
2010 #if RX_BUF_IDX == 3
2011 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
2012 #else
2013 skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
2014 #endif
2015 skb_put (skb, pkt_size);
2016
2017 skb->protocol = eth_type_trans (skb, dev);
2018
2019 dev->stats.rx_bytes += pkt_size;
2020 dev->stats.rx_packets++;
2021
2022 netif_receive_skb (skb);
2023 } else {
2024 if (net_ratelimit())
2025 pr_warning("%s: Memory squeeze, dropping packet.\n",
2026 dev->name);
2027 dev->stats.rx_dropped++;
2028 }
2029 received++;
2030
2031 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2032 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2033
2034 rtl8139_isr_ack(tp);
2035 }
2036
2037 if (unlikely(!received || rx_size == 0xfff0))
2038 rtl8139_isr_ack(tp);
2039
2040 pr_debug("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x,"
2041 " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
2042 RTL_R16 (RxBufAddr),
2043 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
2044
2045 tp->cur_rx = cur_rx;
2046
2047 /*
2048 * The receive buffer should be mostly empty.
2049 * Tell NAPI to reenable the Rx irq.
2050 */
2051 if (tp->fifo_copy_timeout)
2052 received = budget;
2053
2054 out:
2055 return received;
2056 }
2057
2058
2059 static void rtl8139_weird_interrupt (struct net_device *dev,
2060 struct rtl8139_private *tp,
2061 void __iomem *ioaddr,
2062 int status, int link_changed)
2063 {
2064 pr_debug("%s: Abnormal interrupt, status %8.8x.\n",
2065 dev->name, status);
2066
2067 assert (dev != NULL);
2068 assert (tp != NULL);
2069 assert (ioaddr != NULL);
2070
2071 /* Update the error count. */
2072 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
2073 RTL_W32 (RxMissed, 0);
2074
2075 if ((status & RxUnderrun) && link_changed &&
2076 (tp->drv_flags & HAS_LNK_CHNG)) {
2077 rtl_check_media(dev, 0);
2078 status &= ~RxUnderrun;
2079 }
2080
2081 if (status & (RxUnderrun | RxErr))
2082 dev->stats.rx_errors++;
2083
2084 if (status & PCSTimeout)
2085 dev->stats.rx_length_errors++;
2086 if (status & RxUnderrun)
2087 dev->stats.rx_fifo_errors++;
2088 if (status & PCIErr) {
2089 u16 pci_cmd_status;
2090 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2091 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2092
2093 pr_err("%s: PCI Bus error %4.4x.\n",
2094 dev->name, pci_cmd_status);
2095 }
2096 }
2097
2098 static int rtl8139_poll(struct napi_struct *napi, int budget)
2099 {
2100 struct rtl8139_private *tp = container_of(napi, struct rtl8139_private, napi);
2101 struct net_device *dev = tp->dev;
2102 void __iomem *ioaddr = tp->mmio_addr;
2103 int work_done;
2104
2105 spin_lock(&tp->rx_lock);
2106 work_done = 0;
2107 if (likely(RTL_R16(IntrStatus) & RxAckBits))
2108 work_done += rtl8139_rx(dev, tp, budget);
2109
2110 if (work_done < budget) {
2111 unsigned long flags;
2112 /*
2113 * Order is important since data can get interrupted
2114 * again when we think we are done.
2115 */
2116 spin_lock_irqsave(&tp->lock, flags);
2117 RTL_W16_F(IntrMask, rtl8139_intr_mask);
2118 __napi_complete(napi);
2119 spin_unlock_irqrestore(&tp->lock, flags);
2120 }
2121 spin_unlock(&tp->rx_lock);
2122
2123 return work_done;
2124 }
2125
2126 /* The interrupt handler does all of the Rx thread work and cleans up
2127 after the Tx thread. */
2128 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance)
2129 {
2130 struct net_device *dev = (struct net_device *) dev_instance;
2131 struct rtl8139_private *tp = netdev_priv(dev);
2132 void __iomem *ioaddr = tp->mmio_addr;
2133 u16 status, ackstat;
2134 int link_changed = 0; /* avoid bogus "uninit" warning */
2135 int handled = 0;
2136
2137 spin_lock (&tp->lock);
2138 status = RTL_R16 (IntrStatus);
2139
2140 /* shared irq? */
2141 if (unlikely((status & rtl8139_intr_mask) == 0))
2142 goto out;
2143
2144 handled = 1;
2145
2146 /* h/w no longer present (hotplug?) or major error, bail */
2147 if (unlikely(status == 0xFFFF))
2148 goto out;
2149
2150 /* close possible race's with dev_close */
2151 if (unlikely(!netif_running(dev))) {
2152 RTL_W16 (IntrMask, 0);
2153 goto out;
2154 }
2155
2156 /* Acknowledge all of the current interrupt sources ASAP, but
2157 an first get an additional status bit from CSCR. */
2158 if (unlikely(status & RxUnderrun))
2159 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2160
2161 ackstat = status & ~(RxAckBits | TxErr);
2162 if (ackstat)
2163 RTL_W16 (IntrStatus, ackstat);
2164
2165 /* Receive packets are processed by poll routine.
2166 If not running start it now. */
2167 if (status & RxAckBits){
2168 if (napi_schedule_prep(&tp->napi)) {
2169 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
2170 __napi_schedule(&tp->napi);
2171 }
2172 }
2173
2174 /* Check uncommon events with one test. */
2175 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2176 rtl8139_weird_interrupt (dev, tp, ioaddr,
2177 status, link_changed);
2178
2179 if (status & (TxOK | TxErr)) {
2180 rtl8139_tx_interrupt (dev, tp, ioaddr);
2181 if (status & TxErr)
2182 RTL_W16 (IntrStatus, TxErr);
2183 }
2184 out:
2185 spin_unlock (&tp->lock);
2186
2187 pr_debug("%s: exiting interrupt, intr_status=%#4.4x.\n",
2188 dev->name, RTL_R16 (IntrStatus));
2189 return IRQ_RETVAL(handled);
2190 }
2191
2192 #ifdef CONFIG_NET_POLL_CONTROLLER
2193 /*
2194 * Polling receive - used by netconsole and other diagnostic tools
2195 * to allow network i/o with interrupts disabled.
2196 */
2197 static void rtl8139_poll_controller(struct net_device *dev)
2198 {
2199 disable_irq(dev->irq);
2200 rtl8139_interrupt(dev->irq, dev);
2201 enable_irq(dev->irq);
2202 }
2203 #endif
2204
2205 static int rtl8139_set_mac_address(struct net_device *dev, void *p)
2206 {
2207 struct rtl8139_private *tp = netdev_priv(dev);
2208 void __iomem *ioaddr = tp->mmio_addr;
2209 struct sockaddr *addr = p;
2210
2211 if (!is_valid_ether_addr(addr->sa_data))
2212 return -EADDRNOTAVAIL;
2213
2214 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
2215
2216 spin_lock_irq(&tp->lock);
2217
2218 RTL_W8_F(Cfg9346, Cfg9346_Unlock);
2219 RTL_W32_F(MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
2220 RTL_W32_F(MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
2221 RTL_W8_F(Cfg9346, Cfg9346_Lock);
2222
2223 spin_unlock_irq(&tp->lock);
2224
2225 return 0;
2226 }
2227
2228 static int rtl8139_close (struct net_device *dev)
2229 {
2230 struct rtl8139_private *tp = netdev_priv(dev);
2231 void __iomem *ioaddr = tp->mmio_addr;
2232 unsigned long flags;
2233
2234 netif_stop_queue(dev);
2235 napi_disable(&tp->napi);
2236
2237 if (netif_msg_ifdown(tp))
2238 pr_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 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
2251 RTL_W32 (RxMissed, 0);
2252
2253 spin_unlock_irqrestore (&tp->lock, flags);
2254
2255 free_irq (dev->irq, dev);
2256
2257 rtl8139_tx_clear (tp);
2258
2259 dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN,
2260 tp->rx_ring, tp->rx_ring_dma);
2261 dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN,
2262 tp->tx_bufs, tp->tx_bufs_dma);
2263 tp->rx_ring = NULL;
2264 tp->tx_bufs = NULL;
2265
2266 /* Green! Put the chip in low-power mode. */
2267 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2268
2269 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2270 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
2271
2272 return 0;
2273 }
2274
2275
2276 /* Get the ethtool Wake-on-LAN settings. Assumes that wol points to
2277 kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2278 other threads or interrupts aren't messing with the 8139. */
2279 static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2280 {
2281 struct rtl8139_private *tp = netdev_priv(dev);
2282 void __iomem *ioaddr = tp->mmio_addr;
2283
2284 spin_lock_irq(&tp->lock);
2285 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
2286 u8 cfg3 = RTL_R8 (Config3);
2287 u8 cfg5 = RTL_R8 (Config5);
2288
2289 wol->supported = WAKE_PHY | WAKE_MAGIC
2290 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2291
2292 wol->wolopts = 0;
2293 if (cfg3 & Cfg3_LinkUp)
2294 wol->wolopts |= WAKE_PHY;
2295 if (cfg3 & Cfg3_Magic)
2296 wol->wolopts |= WAKE_MAGIC;
2297 /* (KON)FIXME: See how netdev_set_wol() handles the
2298 following constants. */
2299 if (cfg5 & Cfg5_UWF)
2300 wol->wolopts |= WAKE_UCAST;
2301 if (cfg5 & Cfg5_MWF)
2302 wol->wolopts |= WAKE_MCAST;
2303 if (cfg5 & Cfg5_BWF)
2304 wol->wolopts |= WAKE_BCAST;
2305 }
2306 spin_unlock_irq(&tp->lock);
2307 }
2308
2309
2310 /* Set the ethtool Wake-on-LAN settings. Return 0 or -errno. Assumes
2311 that wol points to kernel memory and other threads or interrupts
2312 aren't messing with the 8139. */
2313 static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2314 {
2315 struct rtl8139_private *tp = netdev_priv(dev);
2316 void __iomem *ioaddr = tp->mmio_addr;
2317 u32 support;
2318 u8 cfg3, cfg5;
2319
2320 support = ((rtl_chip_info[tp->chipset].flags & HasLWake)
2321 ? (WAKE_PHY | WAKE_MAGIC
2322 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2323 : 0);
2324 if (wol->wolopts & ~support)
2325 return -EINVAL;
2326
2327 spin_lock_irq(&tp->lock);
2328 cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2329 if (wol->wolopts & WAKE_PHY)
2330 cfg3 |= Cfg3_LinkUp;
2331 if (wol->wolopts & WAKE_MAGIC)
2332 cfg3 |= Cfg3_Magic;
2333 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2334 RTL_W8 (Config3, cfg3);
2335 RTL_W8 (Cfg9346, Cfg9346_Lock);
2336
2337 cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2338 /* (KON)FIXME: These are untested. We may have to set the
2339 CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2340 documentation. */
2341 if (wol->wolopts & WAKE_UCAST)
2342 cfg5 |= Cfg5_UWF;
2343 if (wol->wolopts & WAKE_MCAST)
2344 cfg5 |= Cfg5_MWF;
2345 if (wol->wolopts & WAKE_BCAST)
2346 cfg5 |= Cfg5_BWF;
2347 RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
2348 spin_unlock_irq(&tp->lock);
2349
2350 return 0;
2351 }
2352
2353 static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2354 {
2355 struct rtl8139_private *tp = netdev_priv(dev);
2356 strcpy(info->driver, DRV_NAME);
2357 strcpy(info->version, DRV_VERSION);
2358 strcpy(info->bus_info, pci_name(tp->pci_dev));
2359 info->regdump_len = tp->regs_len;
2360 }
2361
2362 static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2363 {
2364 struct rtl8139_private *tp = netdev_priv(dev);
2365 spin_lock_irq(&tp->lock);
2366 mii_ethtool_gset(&tp->mii, cmd);
2367 spin_unlock_irq(&tp->lock);
2368 return 0;
2369 }
2370
2371 static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2372 {
2373 struct rtl8139_private *tp = netdev_priv(dev);
2374 int rc;
2375 spin_lock_irq(&tp->lock);
2376 rc = mii_ethtool_sset(&tp->mii, cmd);
2377 spin_unlock_irq(&tp->lock);
2378 return rc;
2379 }
2380
2381 static int rtl8139_nway_reset(struct net_device *dev)
2382 {
2383 struct rtl8139_private *tp = netdev_priv(dev);
2384 return mii_nway_restart(&tp->mii);
2385 }
2386
2387 static u32 rtl8139_get_link(struct net_device *dev)
2388 {
2389 struct rtl8139_private *tp = netdev_priv(dev);
2390 return mii_link_ok(&tp->mii);
2391 }
2392
2393 static u32 rtl8139_get_msglevel(struct net_device *dev)
2394 {
2395 struct rtl8139_private *tp = netdev_priv(dev);
2396 return tp->msg_enable;
2397 }
2398
2399 static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2400 {
2401 struct rtl8139_private *tp = netdev_priv(dev);
2402 tp->msg_enable = datum;
2403 }
2404
2405 static int rtl8139_get_regs_len(struct net_device *dev)
2406 {
2407 struct rtl8139_private *tp;
2408 /* TODO: we are too slack to do reg dumping for pio, for now */
2409 if (use_io)
2410 return 0;
2411 tp = netdev_priv(dev);
2412 return tp->regs_len;
2413 }
2414
2415 static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2416 {
2417 struct rtl8139_private *tp;
2418
2419 /* TODO: we are too slack to do reg dumping for pio, for now */
2420 if (use_io)
2421 return;
2422 tp = netdev_priv(dev);
2423
2424 regs->version = RTL_REGS_VER;
2425
2426 spin_lock_irq(&tp->lock);
2427 memcpy_fromio(regbuf, tp->mmio_addr, regs->len);
2428 spin_unlock_irq(&tp->lock);
2429 }
2430
2431 static int rtl8139_get_sset_count(struct net_device *dev, int sset)
2432 {
2433 switch (sset) {
2434 case ETH_SS_STATS:
2435 return RTL_NUM_STATS;
2436 default:
2437 return -EOPNOTSUPP;
2438 }
2439 }
2440
2441 static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2442 {
2443 struct rtl8139_private *tp = netdev_priv(dev);
2444
2445 data[0] = tp->xstats.early_rx;
2446 data[1] = tp->xstats.tx_buf_mapped;
2447 data[2] = tp->xstats.tx_timeouts;
2448 data[3] = tp->xstats.rx_lost_in_ring;
2449 }
2450
2451 static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2452 {
2453 memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2454 }
2455
2456 static const struct ethtool_ops rtl8139_ethtool_ops = {
2457 .get_drvinfo = rtl8139_get_drvinfo,
2458 .get_settings = rtl8139_get_settings,
2459 .set_settings = rtl8139_set_settings,
2460 .get_regs_len = rtl8139_get_regs_len,
2461 .get_regs = rtl8139_get_regs,
2462 .nway_reset = rtl8139_nway_reset,
2463 .get_link = rtl8139_get_link,
2464 .get_msglevel = rtl8139_get_msglevel,
2465 .set_msglevel = rtl8139_set_msglevel,
2466 .get_wol = rtl8139_get_wol,
2467 .set_wol = rtl8139_set_wol,
2468 .get_strings = rtl8139_get_strings,
2469 .get_sset_count = rtl8139_get_sset_count,
2470 .get_ethtool_stats = rtl8139_get_ethtool_stats,
2471 };
2472
2473 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2474 {
2475 struct rtl8139_private *tp = netdev_priv(dev);
2476 int rc;
2477
2478 if (!netif_running(dev))
2479 return -EINVAL;
2480
2481 spin_lock_irq(&tp->lock);
2482 rc = generic_mii_ioctl(&tp->mii, if_mii(rq), cmd, NULL);
2483 spin_unlock_irq(&tp->lock);
2484
2485 return rc;
2486 }
2487
2488
2489 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2490 {
2491 struct rtl8139_private *tp = netdev_priv(dev);
2492 void __iomem *ioaddr = tp->mmio_addr;
2493 unsigned long flags;
2494
2495 if (netif_running(dev)) {
2496 spin_lock_irqsave (&tp->lock, flags);
2497 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
2498 RTL_W32 (RxMissed, 0);
2499 spin_unlock_irqrestore (&tp->lock, flags);
2500 }
2501
2502 return &dev->stats;
2503 }
2504
2505 /* Set or clear the multicast filter for this adaptor.
2506 This routine is not state sensitive and need not be SMP locked. */
2507
2508 static void __set_rx_mode (struct net_device *dev)
2509 {
2510 struct rtl8139_private *tp = netdev_priv(dev);
2511 void __iomem *ioaddr = tp->mmio_addr;
2512 u32 mc_filter[2]; /* Multicast hash filter */
2513 int i, rx_mode;
2514 u32 tmp;
2515
2516 pr_debug("%s: rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
2517 dev->name, dev->flags, RTL_R32 (RxConfig));
2518
2519 /* Note: do not reorder, GCC is clever about common statements. */
2520 if (dev->flags & IFF_PROMISC) {
2521 rx_mode =
2522 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2523 AcceptAllPhys;
2524 mc_filter[1] = mc_filter[0] = 0xffffffff;
2525 } else if ((dev->mc_count > multicast_filter_limit)
2526 || (dev->flags & IFF_ALLMULTI)) {
2527 /* Too many to filter perfectly -- accept all multicasts. */
2528 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2529 mc_filter[1] = mc_filter[0] = 0xffffffff;
2530 } else {
2531 struct dev_mc_list *mclist;
2532 rx_mode = AcceptBroadcast | AcceptMyPhys;
2533 mc_filter[1] = mc_filter[0] = 0;
2534 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2535 i++, mclist = mclist->next) {
2536 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
2537
2538 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2539 rx_mode |= AcceptMulticast;
2540 }
2541 }
2542
2543 /* We can safely update without stopping the chip. */
2544 tmp = rtl8139_rx_config | rx_mode;
2545 if (tp->rx_config != tmp) {
2546 RTL_W32_F (RxConfig, tmp);
2547 tp->rx_config = tmp;
2548 }
2549 RTL_W32_F (MAR0 + 0, mc_filter[0]);
2550 RTL_W32_F (MAR0 + 4, mc_filter[1]);
2551 }
2552
2553 static void rtl8139_set_rx_mode (struct net_device *dev)
2554 {
2555 unsigned long flags;
2556 struct rtl8139_private *tp = netdev_priv(dev);
2557
2558 spin_lock_irqsave (&tp->lock, flags);
2559 __set_rx_mode(dev);
2560 spin_unlock_irqrestore (&tp->lock, flags);
2561 }
2562
2563 #ifdef CONFIG_PM
2564
2565 static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2566 {
2567 struct net_device *dev = pci_get_drvdata (pdev);
2568 struct rtl8139_private *tp = netdev_priv(dev);
2569 void __iomem *ioaddr = tp->mmio_addr;
2570 unsigned long flags;
2571
2572 pci_save_state (pdev);
2573
2574 if (!netif_running (dev))
2575 return 0;
2576
2577 netif_device_detach (dev);
2578
2579 spin_lock_irqsave (&tp->lock, flags);
2580
2581 /* Disable interrupts, stop Tx and Rx. */
2582 RTL_W16 (IntrMask, 0);
2583 RTL_W8 (ChipCmd, 0);
2584
2585 /* Update the error counts. */
2586 dev->stats.rx_missed_errors += RTL_R32 (RxMissed);
2587 RTL_W32 (RxMissed, 0);
2588
2589 spin_unlock_irqrestore (&tp->lock, flags);
2590
2591 pci_set_power_state (pdev, PCI_D3hot);
2592
2593 return 0;
2594 }
2595
2596
2597 static int rtl8139_resume (struct pci_dev *pdev)
2598 {
2599 struct net_device *dev = pci_get_drvdata (pdev);
2600
2601 pci_restore_state (pdev);
2602 if (!netif_running (dev))
2603 return 0;
2604 pci_set_power_state (pdev, PCI_D0);
2605 rtl8139_init_ring (dev);
2606 rtl8139_hw_start (dev);
2607 netif_device_attach (dev);
2608 return 0;
2609 }
2610
2611 #endif /* CONFIG_PM */
2612
2613
2614 static struct pci_driver rtl8139_pci_driver = {
2615 .name = DRV_NAME,
2616 .id_table = rtl8139_pci_tbl,
2617 .probe = rtl8139_init_one,
2618 .remove = __devexit_p(rtl8139_remove_one),
2619 #ifdef CONFIG_PM
2620 .suspend = rtl8139_suspend,
2621 .resume = rtl8139_resume,
2622 #endif /* CONFIG_PM */
2623 };
2624
2625
2626 static int __init rtl8139_init_module (void)
2627 {
2628 /* when we're a module, we always print a version message,
2629 * even if no 8139 board is found.
2630 */
2631 #ifdef MODULE
2632 pr_info(RTL8139_DRIVER_NAME "\n");
2633 #endif
2634
2635 return pci_register_driver(&rtl8139_pci_driver);
2636 }
2637
2638
2639 static void __exit rtl8139_cleanup_module (void)
2640 {
2641 pci_unregister_driver (&rtl8139_pci_driver);
2642 }
2643
2644
2645 module_init(rtl8139_init_module);
2646 module_exit(rtl8139_cleanup_module);
Linux for Ginger Game Console