3 8139too.c: A RealTek RTL-8139 Fast Ethernet driver for Linux.
5 Maintained by Jeff Garzik <jgarzik@pobox.com>
6 Copyright 2000-2002 Jeff Garzik
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:
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.
23 This driver is for boards based on the RTL8129 and RTL8139
26 The author may be reached as becker@scyld.com, or C/O Scyld
27 Computing Corporation 410 Severn Ave., Suite 210 Annapolis
30 Support and updates available at
31 http://www.scyld.com/network/rtl8139.html
33 Twister-tuning table provided by Kinston
34 <shangh@realtek.com.tw>.
38 This software may be used and distributed according to the terms
39 of the GNU General Public License, incorporated herein by reference.
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)
46 Tigran Aivazian - bug fixes, skbuff free cleanup
48 Martin Mares - suggestions for PCI cleanup
50 David S. Miller - PCI DMA and softnet updates
52 Ernst Gill - fixes ported from BSD driver
54 Daniel Kobras - identified specific locations of
55 posted MMIO write bugginess
57 Gerard Sharp - bug fix, testing and feedback
59 David Ford - Rx ring wrap fix
61 Dan DeMaggio - swapped RTL8139 cards with me, and allowed me
62 to find and fix a crucial bug on older chipsets.
64 Donald Becker/Chris Butterworth/Marcus Westergren -
65 Noticed various Rx packet size-related buglets.
67 Santiago Garcia Mantinan - testing and feedback
69 Jens David - 2.2.x kernel backports
71 Martin Dennett - incredibly helpful insight on undocumented
72 features of the 8139 chips
74 Jean-Jacques Michel - bug fix
76 Tobias Ringström - Rx interrupt status checking suggestion
78 Andrew Morton - Clear blocked signals, avoid
79 buffer overrun setting current->comm.
81 Kalle Olavi Niemitalo - Wake-on-LAN ioctls
83 Robert Kuebel - Save kernel thread from dying on any signal.
85 Submitting bug reports:
87 "rtl8139-diag -mmmaaavvveefN" output
88 enable RTL8139_DEBUG below, and look at 'dmesg' or kernel log
92 #define DRV_NAME "8139too"
93 #define DRV_VERSION "0.9.27"
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/ioport.h>
102 #include <linux/netdevice.h>
103 #include <linux/etherdevice.h>
104 #include <linux/rtnetlink.h>
105 #include <linux/delay.h>
106 #include <linux/ethtool.h>
107 #include <linux/mii.h>
108 #include <linux/completion.h>
109 #include <linux/crc32.h>
111 #include <asm/uaccess.h>
114 #define RTL8139_DRIVER_NAME DRV_NAME " Fast Ethernet driver " DRV_VERSION
115 #define PFX DRV_NAME ": "
117 /* Default Message level */
118 #define RTL8139_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
123 /* enable PIO instead of MMIO, if CONFIG_8139TOO_PIO is selected */
124 #ifdef CONFIG_8139TOO_PIO
128 /* define to 1, 2 or 3 to enable copious debugging info */
129 #define RTL8139_DEBUG 0
131 /* define to 1 to disable lightweight runtime debugging checks */
132 #undef RTL8139_NDEBUG
136 /* note: prints function name for you */
137 # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
139 # define DPRINTK(fmt, args...)
142 #ifdef RTL8139_NDEBUG
143 # define assert(expr) do {} while (0)
145 # define assert(expr) \
146 if(unlikely(!(expr))) { \
147 printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
148 #expr,__FILE__,__FUNCTION__,__LINE__); \
153 /* A few user-configurable values. */
156 static int media[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
157 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
159 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
160 The RTL chips use a 64 element hash table based on the Ethernet CRC. */
161 static int multicast_filter_limit = 32;
163 /* bitmapped message enable number */
164 static int debug = -1;
168 * Warning: 64K ring has hardware issues and may lock up.
170 #if defined(CONFIG_SH_DREAMCAST)
171 #define RX_BUF_IDX 1 /* 16K ring */
173 #define RX_BUF_IDX 2 /* 32K ring */
175 #define RX_BUF_LEN (8192 << RX_BUF_IDX)
176 #define RX_BUF_PAD 16
177 #define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
179 #if RX_BUF_LEN == 65536
180 #define RX_BUF_TOT_LEN RX_BUF_LEN
182 #define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
185 /* Number of Tx descriptor registers. */
186 #define NUM_TX_DESC 4
188 /* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
189 #define MAX_ETH_FRAME_SIZE 1536
191 /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
192 #define TX_BUF_SIZE MAX_ETH_FRAME_SIZE
193 #define TX_BUF_TOT_LEN (TX_BUF_SIZE * NUM_TX_DESC)
195 /* PCI Tuning Parameters
196 Threshold is bytes transferred to chip before transmission starts. */
197 #define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
199 /* The following settings are log_2(bytes)-4: 0 == 16 bytes .. 6==1024, 7==end of packet. */
200 #define RX_FIFO_THRESH 7 /* Rx buffer level before first PCI xfer. */
201 #define RX_DMA_BURST 7 /* Maximum PCI burst, '6' is 1024 */
202 #define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
203 #define TX_RETRY 8 /* 0-15. retries = 16 + (TX_RETRY * 16) */
205 /* Operational parameters that usually are not changed. */
206 /* Time in jiffies before concluding the transmitter is hung. */
207 #define TX_TIMEOUT (6*HZ)
211 HAS_MII_XCVR = 0x010000,
212 HAS_CHIP_XCVR = 0x020000,
213 HAS_LNK_CHNG = 0x040000,
216 #define RTL_NUM_STATS 4 /* number of ETHTOOL_GSTATS u64's */
217 #define RTL_REGS_VER 1 /* version of reg. data in ETHTOOL_GREGS */
218 #define RTL_MIN_IO_SIZE 0x80
219 #define RTL8139B_IO_SIZE 256
221 #define RTL8129_CAPS HAS_MII_XCVR
222 #define RTL8139_CAPS HAS_CHIP_XCVR|HAS_LNK_CHNG
230 /* indexed by board_t, above */
231 static const struct {
234 } board_info[] __devinitdata = {
235 { "RealTek RTL8139", RTL8139_CAPS },
236 { "RealTek RTL8129", RTL8129_CAPS },
240 static struct pci_device_id rtl8139_pci_tbl[] = {
241 {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
242 {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
243 {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
244 {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
245 {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
246 {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
247 {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
248 {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
249 {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
250 {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
251 {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
252 {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
253 {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
254 {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
255 {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
256 {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
257 {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
258 {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
259 {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
261 #ifdef CONFIG_SH_SECUREEDGE5410
262 /* Bogus 8139 silicon reports 8129 without external PROM :-( */
263 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
265 #ifdef CONFIG_8139TOO_8129
266 {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
269 /* some crazy cards report invalid vendor ids like
270 * 0x0001 here. The other ids are valid and constant,
271 * so we simply don't match on the main vendor id.
273 {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
274 {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
275 {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
279 MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);
282 const char str[ETH_GSTRING_LEN];
283 } ethtool_stats_keys[] = {
287 { "rx_lost_in_ring" },
290 /* The rest of these values should never change. */
292 /* Symbolic offsets to registers. */
293 enum RTL8139_registers {
294 MAC0 = 0, /* Ethernet hardware address. */
295 MAR0 = 8, /* Multicast filter. */
296 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
297 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
306 Timer = 0x48, /* A general-purpose counter. */
307 RxMissed = 0x4C, /* 24 bits valid, write clears. */
314 Config4 = 0x5A, /* absent on RTL-8139A */
318 BasicModeCtrl = 0x62,
319 BasicModeStatus = 0x64,
322 NWayExpansion = 0x6A,
323 /* Undocumented registers, but required for proper operation. */
324 FIFOTMS = 0x70, /* FIFO Control and test. */
325 CSCR = 0x74, /* Chip Status and Configuration Register. */
327 PARA7c = 0x7c, /* Magic transceiver parameter register. */
328 Config5 = 0xD8, /* absent on RTL-8139A */
332 MultiIntrClear = 0xF000,
334 Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
344 /* Interrupt register bits, using my own meaningful names. */
345 enum IntrStatusBits {
356 RxAckBits = RxFIFOOver | RxOverflow | RxOK,
363 TxOutOfWindow = 0x20000000,
364 TxAborted = 0x40000000,
365 TxCarrierLost = 0x80000000,
368 RxMulticast = 0x8000,
370 RxBroadcast = 0x2000,
371 RxBadSymbol = 0x0020,
379 /* Bits in RxConfig. */
383 AcceptBroadcast = 0x08,
384 AcceptMulticast = 0x04,
386 AcceptAllPhys = 0x01,
389 /* Bits in TxConfig. */
390 enum tx_config_bits {
392 /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
394 TxIFG84 = (0 << TxIFGShift), /* 8.4us / 840ns (10 / 100Mbps) */
395 TxIFG88 = (1 << TxIFGShift), /* 8.8us / 880ns (10 / 100Mbps) */
396 TxIFG92 = (2 << TxIFGShift), /* 9.2us / 920ns (10 / 100Mbps) */
397 TxIFG96 = (3 << TxIFGShift), /* 9.6us / 960ns (10 / 100Mbps) */
399 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
400 TxCRC = (1 << 16), /* DISABLE appending CRC to end of Tx packets */
401 TxClearAbt = (1 << 0), /* Clear abort (WO) */
402 TxDMAShift = 8, /* DMA burst value (0-7) is shifted this many bits */
403 TxRetryShift = 4, /* TXRR value (0-15) is shifted this many bits */
405 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
408 /* Bits in Config1 */
410 Cfg1_PM_Enable = 0x01,
411 Cfg1_VPD_Enable = 0x02,
414 LWAKE = 0x10, /* not on 8139, 8139A */
415 Cfg1_Driver_Load = 0x20,
418 SLEEP = (1 << 1), /* only on 8139, 8139A */
419 PWRDN = (1 << 0), /* only on 8139, 8139A */
422 /* Bits in Config3 */
424 Cfg3_FBtBEn = (1 << 0), /* 1 = Fast Back to Back */
425 Cfg3_FuncRegEn = (1 << 1), /* 1 = enable CardBus Function registers */
426 Cfg3_CLKRUN_En = (1 << 2), /* 1 = enable CLKRUN */
427 Cfg3_CardB_En = (1 << 3), /* 1 = enable CardBus registers */
428 Cfg3_LinkUp = (1 << 4), /* 1 = wake up on link up */
429 Cfg3_Magic = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
430 Cfg3_PARM_En = (1 << 6), /* 0 = software can set twister parameters */
431 Cfg3_GNTSel = (1 << 7), /* 1 = delay 1 clock from PCI GNT signal */
434 /* Bits in Config4 */
436 LWPTN = (1 << 2), /* not on 8139, 8139A */
439 /* Bits in Config5 */
441 Cfg5_PME_STS = (1 << 0), /* 1 = PCI reset resets PME_Status */
442 Cfg5_LANWake = (1 << 1), /* 1 = enable LANWake signal */
443 Cfg5_LDPS = (1 << 2), /* 0 = save power when link is down */
444 Cfg5_FIFOAddrPtr = (1 << 3), /* Realtek internal SRAM testing */
445 Cfg5_UWF = (1 << 4), /* 1 = accept unicast wakeup frame */
446 Cfg5_MWF = (1 << 5), /* 1 = accept multicast wakeup frame */
447 Cfg5_BWF = (1 << 6), /* 1 = accept broadcast wakeup frame */
451 /* rx fifo threshold */
453 RxCfgFIFONone = (7 << RxCfgFIFOShift),
457 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
459 /* rx ring buffer length */
461 RxCfgRcv16K = (1 << 11),
462 RxCfgRcv32K = (1 << 12),
463 RxCfgRcv64K = (1 << 11) | (1 << 12),
465 /* Disable packet wrap at end of Rx buffer. (not possible with 64k) */
469 /* Twister tuning parameters from RealTek.
470 Completely undocumented, but required to tune bad links on some boards. */
472 CSCR_LinkOKBit = 0x0400,
473 CSCR_LinkChangeBit = 0x0800,
474 CSCR_LinkStatusBits = 0x0f000,
475 CSCR_LinkDownOffCmd = 0x003c0,
476 CSCR_LinkDownCmd = 0x0f3c0,
481 Cfg9346_Unlock = 0xC0,
498 HasHltClk = (1 << 0),
502 #define HW_REVID(b30, b29, b28, b27, b26, b23, b22) \
503 (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
504 #define HW_REVID_MASK HW_REVID(1, 1, 1, 1, 1, 1, 1)
506 /* directly indexed by chip_t, above */
507 static const struct {
509 u32 version; /* from RTL8139C/RTL8139D docs */
511 } rtl_chip_info[] = {
513 HW_REVID(1, 0, 0, 0, 0, 0, 0),
518 HW_REVID(1, 1, 0, 0, 0, 0, 0),
523 HW_REVID(1, 1, 1, 0, 0, 0, 0),
524 HasHltClk, /* XXX undocumented? */
528 HW_REVID(1, 1, 1, 0, 0, 1, 0),
529 HasHltClk, /* XXX undocumented? */
533 HW_REVID(1, 1, 1, 1, 0, 0, 0),
538 HW_REVID(1, 1, 1, 1, 1, 0, 0),
543 HW_REVID(1, 1, 1, 0, 1, 0, 0),
548 HW_REVID(1, 1, 1, 1, 0, 1, 0),
553 HW_REVID(1, 1, 1, 0, 1, 0, 1),
554 HasHltClk /* XXX undocumented? */
559 HW_REVID(1, 1, 1, 0, 1, 1, 1),
564 struct rtl_extra_stats {
565 unsigned long early_rx;
566 unsigned long tx_buf_mapped;
567 unsigned long tx_timeouts;
568 unsigned long rx_lost_in_ring;
571 struct rtl8139_private {
572 void __iomem *mmio_addr;
574 struct pci_dev *pci_dev;
576 struct net_device_stats stats;
577 unsigned char *rx_ring;
578 unsigned int cur_rx; /* Index into the Rx buffer of next Rx pkt. */
579 unsigned int tx_flag;
580 unsigned long cur_tx;
581 unsigned long dirty_tx;
582 unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
583 unsigned char *tx_bufs; /* Tx bounce buffer region. */
584 dma_addr_t rx_ring_dma;
585 dma_addr_t tx_bufs_dma;
586 signed char phys[4]; /* MII device addresses. */
587 char twistie, twist_row, twist_col; /* Twister tune state. */
588 unsigned int watchdog_fired : 1;
589 unsigned int default_port : 4; /* Last dev->if_port value. */
590 unsigned int have_thread : 1;
595 struct rtl_extra_stats xstats;
597 struct work_struct thread;
599 struct mii_if_info mii;
600 unsigned int regs_len;
601 unsigned long fifo_copy_timeout;
604 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
605 MODULE_DESCRIPTION ("RealTek RTL-8139 Fast Ethernet driver");
606 MODULE_LICENSE("GPL");
607 MODULE_VERSION(DRV_VERSION);
609 module_param(multicast_filter_limit, int, 0);
610 module_param_array(media, int, NULL, 0);
611 module_param_array(full_duplex, int, NULL, 0);
612 module_param(debug, int, 0);
613 MODULE_PARM_DESC (debug, "8139too bitmapped message enable number");
614 MODULE_PARM_DESC (multicast_filter_limit, "8139too maximum number of filtered multicast addresses");
615 MODULE_PARM_DESC (media, "8139too: Bits 4+9: force full duplex, bit 5: 100Mbps");
616 MODULE_PARM_DESC (full_duplex, "8139too: Force full duplex for board(s) (1)");
618 static int read_eeprom (void __iomem *ioaddr, int location, int addr_len);
619 static int rtl8139_open (struct net_device *dev);
620 static int mdio_read (struct net_device *dev, int phy_id, int location);
621 static void mdio_write (struct net_device *dev, int phy_id, int location,
623 static void rtl8139_start_thread(struct rtl8139_private *tp);
624 static void rtl8139_tx_timeout (struct net_device *dev);
625 static void rtl8139_init_ring (struct net_device *dev);
626 static int rtl8139_start_xmit (struct sk_buff *skb,
627 struct net_device *dev);
628 static int rtl8139_poll(struct net_device *dev, int *budget);
629 #ifdef CONFIG_NET_POLL_CONTROLLER
630 static void rtl8139_poll_controller(struct net_device *dev);
632 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance,
633 struct pt_regs *regs);
634 static int rtl8139_close (struct net_device *dev);
635 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
636 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev);
637 static void rtl8139_set_rx_mode (struct net_device *dev);
638 static void __set_rx_mode (struct net_device *dev);
639 static void rtl8139_hw_start (struct net_device *dev);
640 static void rtl8139_thread (void *_data);
641 static void rtl8139_tx_timeout_task(void *_data);
642 static struct ethtool_ops rtl8139_ethtool_ops;
644 /* write MMIO register, with flush */
645 /* Flush avoids rtl8139 bug w/ posted MMIO writes */
646 #define RTL_W8_F(reg, val8) do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)
647 #define RTL_W16_F(reg, val16) do { iowrite16 ((val16), ioaddr + (reg)); ioread16 (ioaddr + (reg)); } while (0)
648 #define RTL_W32_F(reg, val32) do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)
651 #define MMIO_FLUSH_AUDIT_COMPLETE 1
652 #if MMIO_FLUSH_AUDIT_COMPLETE
654 /* write MMIO register */
655 #define RTL_W8(reg, val8) iowrite8 ((val8), ioaddr + (reg))
656 #define RTL_W16(reg, val16) iowrite16 ((val16), ioaddr + (reg))
657 #define RTL_W32(reg, val32) iowrite32 ((val32), ioaddr + (reg))
661 /* write MMIO register, then flush */
662 #define RTL_W8 RTL_W8_F
663 #define RTL_W16 RTL_W16_F
664 #define RTL_W32 RTL_W32_F
666 #endif /* MMIO_FLUSH_AUDIT_COMPLETE */
668 /* read MMIO register */
669 #define RTL_R8(reg) ioread8 (ioaddr + (reg))
670 #define RTL_R16(reg) ioread16 (ioaddr + (reg))
671 #define RTL_R32(reg) ((unsigned long) ioread32 (ioaddr + (reg)))
674 static const u16 rtl8139_intr_mask =
675 PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
676 TxErr | TxOK | RxErr | RxOK;
678 static const u16 rtl8139_norx_intr_mask =
679 PCIErr | PCSTimeout | RxUnderrun |
680 TxErr | TxOK | RxErr ;
683 static const unsigned int rtl8139_rx_config =
684 RxCfgRcv8K | RxNoWrap |
685 (RX_FIFO_THRESH << RxCfgFIFOShift) |
686 (RX_DMA_BURST << RxCfgDMAShift);
687 #elif RX_BUF_IDX == 1
688 static const unsigned int rtl8139_rx_config =
689 RxCfgRcv16K | RxNoWrap |
690 (RX_FIFO_THRESH << RxCfgFIFOShift) |
691 (RX_DMA_BURST << RxCfgDMAShift);
692 #elif RX_BUF_IDX == 2
693 static const unsigned int rtl8139_rx_config =
694 RxCfgRcv32K | RxNoWrap |
695 (RX_FIFO_THRESH << RxCfgFIFOShift) |
696 (RX_DMA_BURST << RxCfgDMAShift);
697 #elif RX_BUF_IDX == 3
698 static const unsigned int rtl8139_rx_config =
700 (RX_FIFO_THRESH << RxCfgFIFOShift) |
701 (RX_DMA_BURST << RxCfgDMAShift);
703 #error "Invalid configuration for 8139_RXBUF_IDX"
706 static const unsigned int rtl8139_tx_config =
707 TxIFG96 | (TX_DMA_BURST << TxDMAShift) | (TX_RETRY << TxRetryShift);
709 static void __rtl8139_cleanup_dev (struct net_device *dev)
711 struct rtl8139_private *tp = netdev_priv(dev);
712 struct pci_dev *pdev;
714 assert (dev != NULL);
715 assert (tp->pci_dev != NULL);
720 ioport_unmap (tp->mmio_addr);
723 pci_iounmap (pdev, tp->mmio_addr);
724 #endif /* USE_IO_OPS */
726 /* it's ok to call this even if we have no regions to free */
727 pci_release_regions (pdev);
730 pci_set_drvdata (pdev, NULL);
734 static void rtl8139_chip_reset (void __iomem *ioaddr)
738 /* Soft reset the chip. */
739 RTL_W8 (ChipCmd, CmdReset);
741 /* Check that the chip has finished the reset. */
742 for (i = 1000; i > 0; i--) {
744 if ((RTL_R8 (ChipCmd) & CmdReset) == 0)
751 static int __devinit rtl8139_init_board (struct pci_dev *pdev,
752 struct net_device **dev_out)
754 void __iomem *ioaddr;
755 struct net_device *dev;
756 struct rtl8139_private *tp;
758 int rc, disable_dev_on_err = 0;
760 unsigned long pio_start, pio_end, pio_flags, pio_len;
761 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
764 assert (pdev != NULL);
768 /* dev and priv zeroed in alloc_etherdev */
769 dev = alloc_etherdev (sizeof (*tp));
771 dev_printk (KERN_ERR, &pdev->dev,
772 "Unable to alloc new net device\n");
775 SET_MODULE_OWNER(dev);
776 SET_NETDEV_DEV(dev, &pdev->dev);
778 tp = netdev_priv(dev);
781 /* enable device (incl. PCI PM wakeup and hotplug setup) */
782 rc = pci_enable_device (pdev);
786 pio_start = pci_resource_start (pdev, 0);
787 pio_end = pci_resource_end (pdev, 0);
788 pio_flags = pci_resource_flags (pdev, 0);
789 pio_len = pci_resource_len (pdev, 0);
791 mmio_start = pci_resource_start (pdev, 1);
792 mmio_end = pci_resource_end (pdev, 1);
793 mmio_flags = pci_resource_flags (pdev, 1);
794 mmio_len = pci_resource_len (pdev, 1);
796 /* set this immediately, we need to know before
797 * we talk to the chip directly */
798 DPRINTK("PIO region size == 0x%02X\n", pio_len);
799 DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
802 /* make sure PCI base addr 0 is PIO */
803 if (!(pio_flags & IORESOURCE_IO)) {
804 dev_printk (KERN_ERR, &pdev->dev,
805 "region #0 not a PIO resource, aborting\n");
809 /* check for weird/broken PCI region reporting */
810 if (pio_len < RTL_MIN_IO_SIZE) {
811 dev_printk (KERN_ERR, &pdev->dev,
812 "Invalid PCI I/O region size(s), aborting\n");
817 /* make sure PCI base addr 1 is MMIO */
818 if (!(mmio_flags & IORESOURCE_MEM)) {
819 dev_printk (KERN_ERR, &pdev->dev,
820 "region #1 not an MMIO resource, aborting\n");
824 if (mmio_len < RTL_MIN_IO_SIZE) {
825 dev_printk (KERN_ERR, &pdev->dev,
826 "Invalid PCI mem region size(s), aborting\n");
832 rc = pci_request_regions (pdev, DRV_NAME);
835 disable_dev_on_err = 1;
837 /* enable PCI bus-mastering */
838 pci_set_master (pdev);
841 ioaddr = ioport_map(pio_start, pio_len);
843 dev_printk (KERN_ERR, &pdev->dev, "cannot map PIO, aborting\n");
847 dev->base_addr = pio_start;
848 tp->mmio_addr = ioaddr;
849 tp->regs_len = pio_len;
851 /* ioremap MMIO region */
852 ioaddr = pci_iomap(pdev, 1, 0);
853 if (ioaddr == NULL) {
854 dev_printk (KERN_ERR, &pdev->dev,
855 "cannot remap MMIO, aborting\n");
859 dev->base_addr = (long) ioaddr;
860 tp->mmio_addr = ioaddr;
861 tp->regs_len = mmio_len;
862 #endif /* USE_IO_OPS */
864 /* Bring old chips out of low-power mode. */
865 RTL_W8 (HltClk, 'R');
867 /* check for missing/broken hardware */
868 if (RTL_R32 (TxConfig) == 0xFFFFFFFF) {
869 dev_printk (KERN_ERR, &pdev->dev,
870 "Chip not responding, ignoring board\n");
875 /* identify chip attached to board */
876 version = RTL_R32 (TxConfig) & HW_REVID_MASK;
877 for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++)
878 if (version == rtl_chip_info[i].version) {
883 /* if unknown chip, assume array element #0, original RTL-8139 in this case */
884 dev_printk (KERN_DEBUG, &pdev->dev,
885 "unknown chip version, assuming RTL-8139\n");
886 dev_printk (KERN_DEBUG, &pdev->dev,
887 "TxConfig = 0x%lx\n", RTL_R32 (TxConfig));
891 DPRINTK ("chipset id (%d) == index %d, '%s'\n",
892 version, i, rtl_chip_info[i].name);
894 if (tp->chipset >= CH_8139B) {
895 u8 new_tmp8 = tmp8 = RTL_R8 (Config1);
896 DPRINTK("PCI PM wakeup\n");
897 if ((rtl_chip_info[tp->chipset].flags & HasLWake) &&
900 new_tmp8 |= Cfg1_PM_Enable;
901 if (new_tmp8 != tmp8) {
902 RTL_W8 (Cfg9346, Cfg9346_Unlock);
903 RTL_W8 (Config1, tmp8);
904 RTL_W8 (Cfg9346, Cfg9346_Lock);
906 if (rtl_chip_info[tp->chipset].flags & HasLWake) {
907 tmp8 = RTL_R8 (Config4);
909 RTL_W8 (Cfg9346, Cfg9346_Unlock);
910 RTL_W8 (Config4, tmp8 & ~LWPTN);
911 RTL_W8 (Cfg9346, Cfg9346_Lock);
915 DPRINTK("Old chip wakeup\n");
916 tmp8 = RTL_R8 (Config1);
917 tmp8 &= ~(SLEEP | PWRDN);
918 RTL_W8 (Config1, tmp8);
921 rtl8139_chip_reset (ioaddr);
927 __rtl8139_cleanup_dev (dev);
928 if (disable_dev_on_err)
929 pci_disable_device (pdev);
934 static int __devinit rtl8139_init_one (struct pci_dev *pdev,
935 const struct pci_device_id *ent)
937 struct net_device *dev = NULL;
938 struct rtl8139_private *tp;
939 int i, addr_len, option;
940 void __iomem *ioaddr;
941 static int board_idx = -1;
944 assert (pdev != NULL);
945 assert (ent != NULL);
949 /* when we're built into the kernel, the driver version message
950 * is only printed if at least one 8139 board has been found
954 static int printed_version;
955 if (!printed_version++)
956 printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
960 pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);
962 if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
963 pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev >= 0x20) {
964 dev_printk(KERN_INFO, &pdev->dev,
965 "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip\n",
966 pdev->vendor, pdev->device, pci_rev);
967 dev_printk(KERN_INFO, &pdev->dev,
968 "Use the \"8139cp\" driver for improved performance and stability.\n");
971 i = rtl8139_init_board (pdev, &dev);
975 assert (dev != NULL);
976 tp = netdev_priv(dev);
978 ioaddr = tp->mmio_addr;
979 assert (ioaddr != NULL);
981 addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
982 for (i = 0; i < 3; i++)
983 ((u16 *) (dev->dev_addr))[i] =
984 le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
985 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
987 /* The Rtl8139-specific entries in the device structure. */
988 dev->open = rtl8139_open;
989 dev->hard_start_xmit = rtl8139_start_xmit;
990 dev->poll = rtl8139_poll;
992 dev->stop = rtl8139_close;
993 dev->get_stats = rtl8139_get_stats;
994 dev->set_multicast_list = rtl8139_set_rx_mode;
995 dev->do_ioctl = netdev_ioctl;
996 dev->ethtool_ops = &rtl8139_ethtool_ops;
997 dev->tx_timeout = rtl8139_tx_timeout;
998 dev->watchdog_timeo = TX_TIMEOUT;
999 #ifdef CONFIG_NET_POLL_CONTROLLER
1000 dev->poll_controller = rtl8139_poll_controller;
1003 /* note: the hardware is not capable of sg/csum/highdma, however
1004 * through the use of skb_copy_and_csum_dev we enable these
1007 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
1009 dev->irq = pdev->irq;
1011 /* tp zeroed and aligned in alloc_etherdev */
1012 tp = netdev_priv(dev);
1014 /* note: tp->chipset set in rtl8139_init_board */
1015 tp->drv_flags = board_info[ent->driver_data].hw_flags;
1016 tp->mmio_addr = ioaddr;
1018 (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1));
1019 spin_lock_init (&tp->lock);
1020 spin_lock_init (&tp->rx_lock);
1021 INIT_WORK(&tp->thread, rtl8139_thread, dev);
1023 tp->mii.mdio_read = mdio_read;
1024 tp->mii.mdio_write = mdio_write;
1025 tp->mii.phy_id_mask = 0x3f;
1026 tp->mii.reg_num_mask = 0x1f;
1028 /* dev is fully set up and ready to use now */
1029 DPRINTK("about to register device named %s (%p)...\n", dev->name, dev);
1030 i = register_netdev (dev);
1031 if (i) goto err_out;
1033 pci_set_drvdata (pdev, dev);
1035 printk (KERN_INFO "%s: %s at 0x%lx, "
1036 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
1039 board_info[ent->driver_data].name,
1041 dev->dev_addr[0], dev->dev_addr[1],
1042 dev->dev_addr[2], dev->dev_addr[3],
1043 dev->dev_addr[4], dev->dev_addr[5],
1046 printk (KERN_DEBUG "%s: Identified 8139 chip type '%s'\n",
1047 dev->name, rtl_chip_info[tp->chipset].name);
1049 /* Find the connected MII xcvrs.
1050 Doing this in open() would allow detecting external xcvrs later, but
1051 takes too much time. */
1052 #ifdef CONFIG_8139TOO_8129
1053 if (tp->drv_flags & HAS_MII_XCVR) {
1054 int phy, phy_idx = 0;
1055 for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {
1056 int mii_status = mdio_read(dev, phy, 1);
1057 if (mii_status != 0xffff && mii_status != 0x0000) {
1058 u16 advertising = mdio_read(dev, phy, 4);
1059 tp->phys[phy_idx++] = phy;
1060 printk(KERN_INFO "%s: MII transceiver %d status 0x%4.4x "
1061 "advertising %4.4x.\n",
1062 dev->name, phy, mii_status, advertising);
1066 printk(KERN_INFO "%s: No MII transceivers found! Assuming SYM "
1074 tp->mii.phy_id = tp->phys[0];
1076 /* The lower four bits are the media type. */
1077 option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
1079 tp->mii.full_duplex = (option & 0x210) ? 1 : 0;
1080 tp->default_port = option & 0xFF;
1081 if (tp->default_port)
1082 tp->mii.force_media = 1;
1084 if (board_idx < MAX_UNITS && full_duplex[board_idx] > 0)
1085 tp->mii.full_duplex = full_duplex[board_idx];
1086 if (tp->mii.full_duplex) {
1087 printk(KERN_INFO "%s: Media type forced to Full Duplex.\n", dev->name);
1088 /* Changing the MII-advertised media because might prevent
1090 tp->mii.force_media = 1;
1092 if (tp->default_port) {
1093 printk(KERN_INFO " Forcing %dMbps %s-duplex operation.\n",
1094 (option & 0x20 ? 100 : 10),
1095 (option & 0x10 ? "full" : "half"));
1096 mdio_write(dev, tp->phys[0], 0,
1097 ((option & 0x20) ? 0x2000 : 0) | /* 100Mbps? */
1098 ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
1101 /* Put the chip into low-power mode. */
1102 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1103 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
1108 __rtl8139_cleanup_dev (dev);
1109 pci_disable_device (pdev);
1114 static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
1116 struct net_device *dev = pci_get_drvdata (pdev);
1118 assert (dev != NULL);
1120 unregister_netdev (dev);
1122 __rtl8139_cleanup_dev (dev);
1123 pci_disable_device (pdev);
1127 /* Serial EEPROM section. */
1129 /* EEPROM_Ctrl bits. */
1130 #define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
1131 #define EE_CS 0x08 /* EEPROM chip select. */
1132 #define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
1133 #define EE_WRITE_0 0x00
1134 #define EE_WRITE_1 0x02
1135 #define EE_DATA_READ 0x01 /* EEPROM chip data out. */
1136 #define EE_ENB (0x80 | EE_CS)
1138 /* Delay between EEPROM clock transitions.
1139 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1142 #define eeprom_delay() (void)RTL_R32(Cfg9346)
1144 /* The EEPROM commands include the alway-set leading bit. */
1145 #define EE_WRITE_CMD (5)
1146 #define EE_READ_CMD (6)
1147 #define EE_ERASE_CMD (7)
1149 static int __devinit read_eeprom (void __iomem *ioaddr, int location, int addr_len)
1152 unsigned retval = 0;
1153 int read_cmd = location | (EE_READ_CMD << addr_len);
1155 RTL_W8 (Cfg9346, EE_ENB & ~EE_CS);
1156 RTL_W8 (Cfg9346, EE_ENB);
1159 /* Shift the read command bits out. */
1160 for (i = 4 + addr_len; i >= 0; i--) {
1161 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1162 RTL_W8 (Cfg9346, EE_ENB | dataval);
1164 RTL_W8 (Cfg9346, EE_ENB | dataval | EE_SHIFT_CLK);
1167 RTL_W8 (Cfg9346, EE_ENB);
1170 for (i = 16; i > 0; i--) {
1171 RTL_W8 (Cfg9346, EE_ENB | EE_SHIFT_CLK);
1174 (retval << 1) | ((RTL_R8 (Cfg9346) & EE_DATA_READ) ? 1 :
1176 RTL_W8 (Cfg9346, EE_ENB);
1180 /* Terminate the EEPROM access. */
1181 RTL_W8 (Cfg9346, ~EE_CS);
1187 /* MII serial management: mostly bogus for now. */
1188 /* Read and write the MII management registers using software-generated
1189 serial MDIO protocol.
1190 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
1191 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
1192 "overclocking" issues. */
1193 #define MDIO_DIR 0x80
1194 #define MDIO_DATA_OUT 0x04
1195 #define MDIO_DATA_IN 0x02
1196 #define MDIO_CLK 0x01
1197 #define MDIO_WRITE0 (MDIO_DIR)
1198 #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
1200 #define mdio_delay() RTL_R8(Config4)
1203 static const char mii_2_8139_map[8] = {
1215 #ifdef CONFIG_8139TOO_8129
1216 /* Syncronize the MII management interface by shifting 32 one bits out. */
1217 static void mdio_sync (void __iomem *ioaddr)
1221 for (i = 32; i >= 0; i--) {
1222 RTL_W8 (Config4, MDIO_WRITE1);
1224 RTL_W8 (Config4, MDIO_WRITE1 | MDIO_CLK);
1230 static int mdio_read (struct net_device *dev, int phy_id, int location)
1232 struct rtl8139_private *tp = netdev_priv(dev);
1234 #ifdef CONFIG_8139TOO_8129
1235 void __iomem *ioaddr = tp->mmio_addr;
1236 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
1240 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
1241 void __iomem *ioaddr = tp->mmio_addr;
1242 return location < 8 && mii_2_8139_map[location] ?
1243 RTL_R16 (mii_2_8139_map[location]) : 0;
1246 #ifdef CONFIG_8139TOO_8129
1248 /* Shift the read command bits out. */
1249 for (i = 15; i >= 0; i--) {
1250 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1252 RTL_W8 (Config4, MDIO_DIR | dataval);
1254 RTL_W8 (Config4, MDIO_DIR | dataval | MDIO_CLK);
1258 /* Read the two transition, 16 data, and wire-idle bits. */
1259 for (i = 19; i > 0; i--) {
1260 RTL_W8 (Config4, 0);
1262 retval = (retval << 1) | ((RTL_R8 (Config4) & MDIO_DATA_IN) ? 1 : 0);
1263 RTL_W8 (Config4, MDIO_CLK);
1268 return (retval >> 1) & 0xffff;
1272 static void mdio_write (struct net_device *dev, int phy_id, int location,
1275 struct rtl8139_private *tp = netdev_priv(dev);
1276 #ifdef CONFIG_8139TOO_8129
1277 void __iomem *ioaddr = tp->mmio_addr;
1278 int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1282 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
1283 void __iomem *ioaddr = tp->mmio_addr;
1284 if (location == 0) {
1285 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1286 RTL_W16 (BasicModeCtrl, value);
1287 RTL_W8 (Cfg9346, Cfg9346_Lock);
1288 } else if (location < 8 && mii_2_8139_map[location])
1289 RTL_W16 (mii_2_8139_map[location], value);
1293 #ifdef CONFIG_8139TOO_8129
1296 /* Shift the command bits out. */
1297 for (i = 31; i >= 0; i--) {
1299 (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1300 RTL_W8 (Config4, dataval);
1302 RTL_W8 (Config4, dataval | MDIO_CLK);
1305 /* Clear out extra bits. */
1306 for (i = 2; i > 0; i--) {
1307 RTL_W8 (Config4, 0);
1309 RTL_W8 (Config4, MDIO_CLK);
1316 static int rtl8139_open (struct net_device *dev)
1318 struct rtl8139_private *tp = netdev_priv(dev);
1320 void __iomem *ioaddr = tp->mmio_addr;
1322 retval = request_irq (dev->irq, rtl8139_interrupt, IRQF_SHARED, dev->name, dev);
1326 tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1328 tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1330 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1331 free_irq(dev->irq, dev);
1334 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1335 tp->tx_bufs, tp->tx_bufs_dma);
1337 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1338 tp->rx_ring, tp->rx_ring_dma);
1344 tp->mii.full_duplex = tp->mii.force_media;
1345 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1347 rtl8139_init_ring (dev);
1348 rtl8139_hw_start (dev);
1349 netif_start_queue (dev);
1351 if (netif_msg_ifup(tp))
1352 printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#llx IRQ %d"
1353 " GP Pins %2.2x %s-duplex.\n", dev->name,
1354 (unsigned long long)pci_resource_start (tp->pci_dev, 1),
1355 dev->irq, RTL_R8 (MediaStatus),
1356 tp->mii.full_duplex ? "full" : "half");
1358 rtl8139_start_thread(tp);
1364 static void rtl_check_media (struct net_device *dev, unsigned int init_media)
1366 struct rtl8139_private *tp = netdev_priv(dev);
1368 if (tp->phys[0] >= 0) {
1369 mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
1373 /* Start the hardware at open or resume. */
1374 static void rtl8139_hw_start (struct net_device *dev)
1376 struct rtl8139_private *tp = netdev_priv(dev);
1377 void __iomem *ioaddr = tp->mmio_addr;
1381 /* Bring old chips out of low-power mode. */
1382 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
1383 RTL_W8 (HltClk, 'R');
1385 rtl8139_chip_reset (ioaddr);
1387 /* unlock Config[01234] and BMCR register writes */
1388 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1389 /* Restore our idea of the MAC address. */
1390 RTL_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
1391 RTL_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
1393 /* Must enable Tx/Rx before setting transfer thresholds! */
1394 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1396 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1397 RTL_W32 (RxConfig, tp->rx_config);
1398 RTL_W32 (TxConfig, rtl8139_tx_config);
1402 rtl_check_media (dev, 1);
1404 if (tp->chipset >= CH_8139B) {
1405 /* Disable magic packet scanning, which is enabled
1406 * when PM is enabled in Config1. It can be reenabled
1407 * via ETHTOOL_SWOL if desired. */
1408 RTL_W8 (Config3, RTL_R8 (Config3) & ~Cfg3_Magic);
1411 DPRINTK("init buffer addresses\n");
1413 /* Lock Config[01234] and BMCR register writes */
1414 RTL_W8 (Cfg9346, Cfg9346_Lock);
1416 /* init Rx ring buffer DMA address */
1417 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1419 /* init Tx buffer DMA addresses */
1420 for (i = 0; i < NUM_TX_DESC; i++)
1421 RTL_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1423 RTL_W32 (RxMissed, 0);
1425 rtl8139_set_rx_mode (dev);
1427 /* no early-rx interrupts */
1428 RTL_W16 (MultiIntr, RTL_R16 (MultiIntr) & MultiIntrClear);
1430 /* make sure RxTx has started */
1431 tmp = RTL_R8 (ChipCmd);
1432 if ((!(tmp & CmdRxEnb)) || (!(tmp & CmdTxEnb)))
1433 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1435 /* Enable all known interrupts by setting the interrupt mask. */
1436 RTL_W16 (IntrMask, rtl8139_intr_mask);
1440 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1441 static void rtl8139_init_ring (struct net_device *dev)
1443 struct rtl8139_private *tp = netdev_priv(dev);
1450 for (i = 0; i < NUM_TX_DESC; i++)
1451 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1455 /* This must be global for CONFIG_8139TOO_TUNE_TWISTER case */
1456 static int next_tick = 3 * HZ;
1458 #ifndef CONFIG_8139TOO_TUNE_TWISTER
1459 static inline void rtl8139_tune_twister (struct net_device *dev,
1460 struct rtl8139_private *tp) {}
1462 enum TwisterParamVals {
1463 PARA78_default = 0x78fa8388,
1464 PARA7c_default = 0xcb38de43, /* param[0][3] */
1465 PARA7c_xxx = 0xcb38de43,
1468 static const unsigned long param[4][4] = {
1469 {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
1470 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1471 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
1472 {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
1475 static void rtl8139_tune_twister (struct net_device *dev,
1476 struct rtl8139_private *tp)
1479 void __iomem *ioaddr = tp->mmio_addr;
1481 /* This is a complicated state machine to configure the "twister" for
1482 impedance/echos based on the cable length.
1483 All of this is magic and undocumented.
1485 switch (tp->twistie) {
1487 if (RTL_R16 (CSCR) & CSCR_LinkOKBit) {
1488 /* We have link beat, let us tune the twister. */
1489 RTL_W16 (CSCR, CSCR_LinkDownOffCmd);
1490 tp->twistie = 2; /* Change to state 2. */
1491 next_tick = HZ / 10;
1493 /* Just put in some reasonable defaults for when beat returns. */
1494 RTL_W16 (CSCR, CSCR_LinkDownCmd);
1495 RTL_W32 (FIFOTMS, 0x20); /* Turn on cable test mode. */
1496 RTL_W32 (PARA78, PARA78_default);
1497 RTL_W32 (PARA7c, PARA7c_default);
1498 tp->twistie = 0; /* Bail from future actions. */
1502 /* Read how long it took to hear the echo. */
1503 linkcase = RTL_R16 (CSCR) & CSCR_LinkStatusBits;
1504 if (linkcase == 0x7000)
1506 else if (linkcase == 0x3000)
1508 else if (linkcase == 0x1000)
1513 tp->twistie = 3; /* Change to state 2. */
1514 next_tick = HZ / 10;
1517 /* Put out four tuning parameters, one per 100msec. */
1518 if (tp->twist_col == 0)
1519 RTL_W16 (FIFOTMS, 0);
1520 RTL_W32 (PARA7c, param[(int) tp->twist_row]
1521 [(int) tp->twist_col]);
1522 next_tick = HZ / 10;
1523 if (++tp->twist_col >= 4) {
1524 /* For short cables we are done.
1525 For long cables (row == 3) check for mistune. */
1527 (tp->twist_row == 3) ? 4 : 0;
1531 /* Special case for long cables: check for mistune. */
1532 if ((RTL_R16 (CSCR) &
1533 CSCR_LinkStatusBits) == 0x7000) {
1537 RTL_W32 (PARA7c, 0xfb38de03);
1539 next_tick = HZ / 10;
1543 /* Retune for shorter cable (column 2). */
1544 RTL_W32 (FIFOTMS, 0x20);
1545 RTL_W32 (PARA78, PARA78_default);
1546 RTL_W32 (PARA7c, PARA7c_default);
1547 RTL_W32 (FIFOTMS, 0x00);
1551 next_tick = HZ / 10;
1559 #endif /* CONFIG_8139TOO_TUNE_TWISTER */
1561 static inline void rtl8139_thread_iter (struct net_device *dev,
1562 struct rtl8139_private *tp,
1563 void __iomem *ioaddr)
1567 mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1569 if (!tp->mii.force_media && mii_lpa != 0xffff) {
1570 int duplex = (mii_lpa & LPA_100FULL)
1571 || (mii_lpa & 0x01C0) == 0x0040;
1572 if (tp->mii.full_duplex != duplex) {
1573 tp->mii.full_duplex = duplex;
1577 "%s: Setting %s-duplex based on MII #%d link"
1578 " partner ability of %4.4x.\n",
1580 tp->mii.full_duplex ? "full" : "half",
1581 tp->phys[0], mii_lpa);
1583 printk(KERN_INFO"%s: media is unconnected, link down, or incompatible connection\n",
1587 RTL_W8 (Cfg9346, Cfg9346_Unlock);
1588 RTL_W8 (Config1, tp->mii.full_duplex ? 0x60 : 0x20);
1589 RTL_W8 (Cfg9346, Cfg9346_Lock);
1594 next_tick = HZ * 60;
1596 rtl8139_tune_twister (dev, tp);
1598 DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1599 dev->name, RTL_R16 (NWayLPAR));
1600 DPRINTK ("%s: Other registers are IntMask %4.4x IntStatus %4.4x\n",
1601 dev->name, RTL_R16 (IntrMask), RTL_R16 (IntrStatus));
1602 DPRINTK ("%s: Chip config %2.2x %2.2x.\n",
1603 dev->name, RTL_R8 (Config0),
1607 static void rtl8139_thread (void *_data)
1609 struct net_device *dev = _data;
1610 struct rtl8139_private *tp = netdev_priv(dev);
1611 unsigned long thr_delay = next_tick;
1613 if (tp->watchdog_fired) {
1614 tp->watchdog_fired = 0;
1615 rtl8139_tx_timeout_task(_data);
1616 } else if (rtnl_trylock()) {
1617 rtl8139_thread_iter (dev, tp, tp->mmio_addr);
1620 /* unlikely race. mitigate with fast poll. */
1624 schedule_delayed_work(&tp->thread, thr_delay);
1627 static void rtl8139_start_thread(struct rtl8139_private *tp)
1630 if (tp->chipset == CH_8139_K)
1632 else if (tp->drv_flags & HAS_LNK_CHNG)
1635 tp->have_thread = 1;
1637 schedule_delayed_work(&tp->thread, next_tick);
1640 static void rtl8139_stop_thread(struct rtl8139_private *tp)
1642 if (tp->have_thread) {
1643 cancel_rearming_delayed_work(&tp->thread);
1644 tp->have_thread = 0;
1646 flush_scheduled_work();
1649 static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
1654 /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
1657 static void rtl8139_tx_timeout_task (void *_data)
1659 struct net_device *dev = _data;
1660 struct rtl8139_private *tp = netdev_priv(dev);
1661 void __iomem *ioaddr = tp->mmio_addr;
1665 printk (KERN_DEBUG "%s: Transmit timeout, status %2.2x %4.4x %4.4x "
1666 "media %2.2x.\n", dev->name, RTL_R8 (ChipCmd),
1667 RTL_R16(IntrStatus), RTL_R16(IntrMask), RTL_R8(MediaStatus));
1668 /* Emit info to figure out what went wrong. */
1669 printk (KERN_DEBUG "%s: Tx queue start entry %ld dirty entry %ld.\n",
1670 dev->name, tp->cur_tx, tp->dirty_tx);
1671 for (i = 0; i < NUM_TX_DESC; i++)
1672 printk (KERN_DEBUG "%s: Tx descriptor %d is %8.8lx.%s\n",
1673 dev->name, i, RTL_R32 (TxStatus0 + (i * 4)),
1674 i == tp->dirty_tx % NUM_TX_DESC ?
1675 " (queue head)" : "");
1677 tp->xstats.tx_timeouts++;
1679 /* disable Tx ASAP, if not already */
1680 tmp8 = RTL_R8 (ChipCmd);
1681 if (tmp8 & CmdTxEnb)
1682 RTL_W8 (ChipCmd, CmdRxEnb);
1684 spin_lock_bh(&tp->rx_lock);
1685 /* Disable interrupts by clearing the interrupt mask. */
1686 RTL_W16 (IntrMask, 0x0000);
1688 /* Stop a shared interrupt from scavenging while we are. */
1689 spin_lock_irq(&tp->lock);
1690 rtl8139_tx_clear (tp);
1691 spin_unlock_irq(&tp->lock);
1693 /* ...and finally, reset everything */
1694 if (netif_running(dev)) {
1695 rtl8139_hw_start (dev);
1696 netif_wake_queue (dev);
1698 spin_unlock_bh(&tp->rx_lock);
1701 static void rtl8139_tx_timeout (struct net_device *dev)
1703 struct rtl8139_private *tp = netdev_priv(dev);
1705 if (!tp->have_thread) {
1706 INIT_WORK(&tp->thread, rtl8139_tx_timeout_task, dev);
1707 schedule_delayed_work(&tp->thread, next_tick);
1709 tp->watchdog_fired = 1;
1713 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
1715 struct rtl8139_private *tp = netdev_priv(dev);
1716 void __iomem *ioaddr = tp->mmio_addr;
1718 unsigned int len = skb->len;
1720 /* Calculate the next Tx descriptor entry. */
1721 entry = tp->cur_tx % NUM_TX_DESC;
1723 /* Note: the chip doesn't have auto-pad! */
1724 if (likely(len < TX_BUF_SIZE)) {
1726 memset(tp->tx_buf[entry], 0, ETH_ZLEN);
1727 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
1731 tp->stats.tx_dropped++;
1735 spin_lock_irq(&tp->lock);
1736 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)),
1737 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN));
1739 dev->trans_start = jiffies;
1744 if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx)
1745 netif_stop_queue (dev);
1746 spin_unlock_irq(&tp->lock);
1748 if (netif_msg_tx_queued(tp))
1749 printk (KERN_DEBUG "%s: Queued Tx packet size %u to slot %d.\n",
1750 dev->name, len, entry);
1756 static void rtl8139_tx_interrupt (struct net_device *dev,
1757 struct rtl8139_private *tp,
1758 void __iomem *ioaddr)
1760 unsigned long dirty_tx, tx_left;
1762 assert (dev != NULL);
1763 assert (ioaddr != NULL);
1765 dirty_tx = tp->dirty_tx;
1766 tx_left = tp->cur_tx - dirty_tx;
1767 while (tx_left > 0) {
1768 int entry = dirty_tx % NUM_TX_DESC;
1771 txstatus = RTL_R32 (TxStatus0 + (entry * sizeof (u32)));
1773 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1774 break; /* It still hasn't been Txed */
1776 /* Note: TxCarrierLost is always asserted at 100mbps. */
1777 if (txstatus & (TxOutOfWindow | TxAborted)) {
1778 /* There was an major error, log it. */
1779 if (netif_msg_tx_err(tp))
1780 printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
1781 dev->name, txstatus);
1782 tp->stats.tx_errors++;
1783 if (txstatus & TxAborted) {
1784 tp->stats.tx_aborted_errors++;
1785 RTL_W32 (TxConfig, TxClearAbt);
1786 RTL_W16 (IntrStatus, TxErr);
1789 if (txstatus & TxCarrierLost)
1790 tp->stats.tx_carrier_errors++;
1791 if (txstatus & TxOutOfWindow)
1792 tp->stats.tx_window_errors++;
1794 if (txstatus & TxUnderrun) {
1795 /* Add 64 to the Tx FIFO threshold. */
1796 if (tp->tx_flag < 0x00300000)
1797 tp->tx_flag += 0x00020000;
1798 tp->stats.tx_fifo_errors++;
1800 tp->stats.collisions += (txstatus >> 24) & 15;
1801 tp->stats.tx_bytes += txstatus & 0x7ff;
1802 tp->stats.tx_packets++;
1809 #ifndef RTL8139_NDEBUG
1810 if (tp->cur_tx - dirty_tx > NUM_TX_DESC) {
1811 printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n",
1812 dev->name, dirty_tx, tp->cur_tx);
1813 dirty_tx += NUM_TX_DESC;
1815 #endif /* RTL8139_NDEBUG */
1817 /* only wake the queue if we did work, and the queue is stopped */
1818 if (tp->dirty_tx != dirty_tx) {
1819 tp->dirty_tx = dirty_tx;
1821 netif_wake_queue (dev);
1826 /* TODO: clean this up! Rx reset need not be this intensive */
1827 static void rtl8139_rx_err (u32 rx_status, struct net_device *dev,
1828 struct rtl8139_private *tp, void __iomem *ioaddr)
1831 #ifdef CONFIG_8139_OLD_RX_RESET
1835 if (netif_msg_rx_err (tp))
1836 printk(KERN_DEBUG "%s: Ethernet frame had errors, status %8.8x.\n",
1837 dev->name, rx_status);
1838 tp->stats.rx_errors++;
1839 if (!(rx_status & RxStatusOK)) {
1840 if (rx_status & RxTooLong) {
1841 DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1842 dev->name, rx_status);
1843 /* A.C.: The chip hangs here. */
1845 if (rx_status & (RxBadSymbol | RxBadAlign))
1846 tp->stats.rx_frame_errors++;
1847 if (rx_status & (RxRunt | RxTooLong))
1848 tp->stats.rx_length_errors++;
1849 if (rx_status & RxCRCErr)
1850 tp->stats.rx_crc_errors++;
1852 tp->xstats.rx_lost_in_ring++;
1855 #ifndef CONFIG_8139_OLD_RX_RESET
1856 tmp8 = RTL_R8 (ChipCmd);
1857 RTL_W8 (ChipCmd, tmp8 & ~CmdRxEnb);
1858 RTL_W8 (ChipCmd, tmp8);
1859 RTL_W32 (RxConfig, tp->rx_config);
1862 /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1864 /* disable receive */
1865 RTL_W8_F (ChipCmd, CmdTxEnb);
1867 while (--tmp_work > 0) {
1869 tmp8 = RTL_R8 (ChipCmd);
1870 if (!(tmp8 & CmdRxEnb))
1874 printk (KERN_WARNING PFX "rx stop wait too long\n");
1875 /* restart receive */
1877 while (--tmp_work > 0) {
1878 RTL_W8_F (ChipCmd, CmdRxEnb | CmdTxEnb);
1880 tmp8 = RTL_R8 (ChipCmd);
1881 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1885 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1887 /* and reinitialize all rx related registers */
1888 RTL_W8_F (Cfg9346, Cfg9346_Unlock);
1889 /* Must enable Tx/Rx before setting transfer thresholds! */
1890 RTL_W8 (ChipCmd, CmdRxEnb | CmdTxEnb);
1892 tp->rx_config = rtl8139_rx_config | AcceptBroadcast | AcceptMyPhys;
1893 RTL_W32 (RxConfig, tp->rx_config);
1896 DPRINTK("init buffer addresses\n");
1898 /* Lock Config[01234] and BMCR register writes */
1899 RTL_W8 (Cfg9346, Cfg9346_Lock);
1901 /* init Rx ring buffer DMA address */
1902 RTL_W32_F (RxBuf, tp->rx_ring_dma);
1904 /* A.C.: Reset the multicast list. */
1905 __set_rx_mode (dev);
1910 static __inline__ void wrap_copy(struct sk_buff *skb, const unsigned char *ring,
1911 u32 offset, unsigned int size)
1913 u32 left = RX_BUF_LEN - offset;
1916 memcpy(skb->data, ring + offset, left);
1917 memcpy(skb->data+left, ring, size - left);
1919 memcpy(skb->data, ring + offset, size);
1923 static void rtl8139_isr_ack(struct rtl8139_private *tp)
1925 void __iomem *ioaddr = tp->mmio_addr;
1928 status = RTL_R16 (IntrStatus) & RxAckBits;
1930 /* Clear out errors and receive interrupts */
1931 if (likely(status != 0)) {
1932 if (unlikely(status & (RxFIFOOver | RxOverflow))) {
1933 tp->stats.rx_errors++;
1934 if (status & RxFIFOOver)
1935 tp->stats.rx_fifo_errors++;
1937 RTL_W16_F (IntrStatus, RxAckBits);
1941 static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp,
1944 void __iomem *ioaddr = tp->mmio_addr;
1946 unsigned char *rx_ring = tp->rx_ring;
1947 unsigned int cur_rx = tp->cur_rx;
1948 unsigned int rx_size = 0;
1950 DPRINTK ("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x,"
1951 " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx,
1952 RTL_R16 (RxBufAddr),
1953 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
1955 while (netif_running(dev) && received < budget
1956 && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) {
1957 u32 ring_offset = cur_rx % RX_BUF_LEN;
1959 unsigned int pkt_size;
1960 struct sk_buff *skb;
1964 /* read size+status of next frame from DMA ring buffer */
1965 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
1966 rx_size = rx_status >> 16;
1967 pkt_size = rx_size - 4;
1969 if (netif_msg_rx_status(tp))
1970 printk(KERN_DEBUG "%s: rtl8139_rx() status %4.4x, size %4.4x,"
1971 " cur %4.4x.\n", dev->name, rx_status,
1973 #if RTL8139_DEBUG > 2
1976 DPRINTK ("%s: Frame contents ", dev->name);
1977 for (i = 0; i < 70; i++)
1979 rx_ring[ring_offset + i]);
1984 /* Packet copy from FIFO still in progress.
1985 * Theoretically, this should never happen
1986 * since EarlyRx is disabled.
1988 if (unlikely(rx_size == 0xfff0)) {
1989 if (!tp->fifo_copy_timeout)
1990 tp->fifo_copy_timeout = jiffies + 2;
1991 else if (time_after(jiffies, tp->fifo_copy_timeout)) {
1992 DPRINTK ("%s: hung FIFO. Reset.", dev->name);
1996 if (netif_msg_intr(tp)) {
1997 printk(KERN_DEBUG "%s: fifo copy in progress.",
2000 tp->xstats.early_rx++;
2005 tp->fifo_copy_timeout = 0;
2007 /* If Rx err or invalid rx_size/rx_status received
2008 * (which happens if we get lost in the ring),
2009 * Rx process gets reset, so we abort any further
2012 if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
2014 (!(rx_status & RxStatusOK)))) {
2015 rtl8139_rx_err (rx_status, dev, tp, ioaddr);
2020 /* Malloc up new buffer, compatible with net-2e. */
2021 /* Omit the four octet CRC from the length. */
2023 skb = dev_alloc_skb (pkt_size + 2);
2026 skb_reserve (skb, 2); /* 16 byte align the IP fields. */
2028 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size);
2030 eth_copy_and_sum (skb, &rx_ring[ring_offset + 4], pkt_size, 0);
2032 skb_put (skb, pkt_size);
2034 skb->protocol = eth_type_trans (skb, dev);
2036 dev->last_rx = jiffies;
2037 tp->stats.rx_bytes += pkt_size;
2038 tp->stats.rx_packets++;
2040 netif_receive_skb (skb);
2042 if (net_ratelimit())
2043 printk (KERN_WARNING
2044 "%s: Memory squeeze, dropping packet.\n",
2046 tp->stats.rx_dropped++;
2050 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
2051 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16));
2053 rtl8139_isr_ack(tp);
2056 if (unlikely(!received || rx_size == 0xfff0))
2057 rtl8139_isr_ack(tp);
2059 #if RTL8139_DEBUG > 1
2060 DPRINTK ("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x,"
2061 " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
2062 RTL_R16 (RxBufAddr),
2063 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd));
2066 tp->cur_rx = cur_rx;
2069 * The receive buffer should be mostly empty.
2070 * Tell NAPI to reenable the Rx irq.
2072 if (tp->fifo_copy_timeout)
2080 static void rtl8139_weird_interrupt (struct net_device *dev,
2081 struct rtl8139_private *tp,
2082 void __iomem *ioaddr,
2083 int status, int link_changed)
2085 DPRINTK ("%s: Abnormal interrupt, status %8.8x.\n",
2088 assert (dev != NULL);
2089 assert (tp != NULL);
2090 assert (ioaddr != NULL);
2092 /* Update the error count. */
2093 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2094 RTL_W32 (RxMissed, 0);
2096 if ((status & RxUnderrun) && link_changed &&
2097 (tp->drv_flags & HAS_LNK_CHNG)) {
2098 rtl_check_media(dev, 0);
2099 status &= ~RxUnderrun;
2102 if (status & (RxUnderrun | RxErr))
2103 tp->stats.rx_errors++;
2105 if (status & PCSTimeout)
2106 tp->stats.rx_length_errors++;
2107 if (status & RxUnderrun)
2108 tp->stats.rx_fifo_errors++;
2109 if (status & PCIErr) {
2111 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
2112 pci_write_config_word (tp->pci_dev, PCI_STATUS, pci_cmd_status);
2114 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
2115 dev->name, pci_cmd_status);
2119 static int rtl8139_poll(struct net_device *dev, int *budget)
2121 struct rtl8139_private *tp = netdev_priv(dev);
2122 void __iomem *ioaddr = tp->mmio_addr;
2123 int orig_budget = min(*budget, dev->quota);
2126 spin_lock(&tp->rx_lock);
2127 if (likely(RTL_R16(IntrStatus) & RxAckBits)) {
2130 work_done = rtl8139_rx(dev, tp, orig_budget);
2131 if (likely(work_done > 0)) {
2132 *budget -= work_done;
2133 dev->quota -= work_done;
2134 done = (work_done < orig_budget);
2140 * Order is important since data can get interrupted
2141 * again when we think we are done.
2143 local_irq_disable();
2144 RTL_W16_F(IntrMask, rtl8139_intr_mask);
2145 __netif_rx_complete(dev);
2148 spin_unlock(&tp->rx_lock);
2153 /* The interrupt handler does all of the Rx thread work and cleans up
2154 after the Tx thread. */
2155 static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance,
2156 struct pt_regs *regs)
2158 struct net_device *dev = (struct net_device *) dev_instance;
2159 struct rtl8139_private *tp = netdev_priv(dev);
2160 void __iomem *ioaddr = tp->mmio_addr;
2161 u16 status, ackstat;
2162 int link_changed = 0; /* avoid bogus "uninit" warning */
2165 spin_lock (&tp->lock);
2166 status = RTL_R16 (IntrStatus);
2169 if (unlikely((status & rtl8139_intr_mask) == 0))
2174 /* h/w no longer present (hotplug?) or major error, bail */
2175 if (unlikely(status == 0xFFFF))
2178 /* close possible race's with dev_close */
2179 if (unlikely(!netif_running(dev))) {
2180 RTL_W16 (IntrMask, 0);
2184 /* Acknowledge all of the current interrupt sources ASAP, but
2185 an first get an additional status bit from CSCR. */
2186 if (unlikely(status & RxUnderrun))
2187 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
2189 ackstat = status & ~(RxAckBits | TxErr);
2191 RTL_W16 (IntrStatus, ackstat);
2193 /* Receive packets are processed by poll routine.
2194 If not running start it now. */
2195 if (status & RxAckBits){
2196 if (netif_rx_schedule_prep(dev)) {
2197 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask);
2198 __netif_rx_schedule (dev);
2202 /* Check uncommon events with one test. */
2203 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr)))
2204 rtl8139_weird_interrupt (dev, tp, ioaddr,
2205 status, link_changed);
2207 if (status & (TxOK | TxErr)) {
2208 rtl8139_tx_interrupt (dev, tp, ioaddr);
2210 RTL_W16 (IntrStatus, TxErr);
2213 spin_unlock (&tp->lock);
2215 DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
2216 dev->name, RTL_R16 (IntrStatus));
2217 return IRQ_RETVAL(handled);
2220 #ifdef CONFIG_NET_POLL_CONTROLLER
2222 * Polling receive - used by netconsole and other diagnostic tools
2223 * to allow network i/o with interrupts disabled.
2225 static void rtl8139_poll_controller(struct net_device *dev)
2227 disable_irq(dev->irq);
2228 rtl8139_interrupt(dev->irq, dev, NULL);
2229 enable_irq(dev->irq);
2233 static int rtl8139_close (struct net_device *dev)
2235 struct rtl8139_private *tp = netdev_priv(dev);
2236 void __iomem *ioaddr = tp->mmio_addr;
2237 unsigned long flags;
2239 netif_stop_queue (dev);
2241 rtl8139_stop_thread(tp);
2243 if (netif_msg_ifdown(tp))
2244 printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n",
2245 dev->name, RTL_R16 (IntrStatus));
2247 spin_lock_irqsave (&tp->lock, flags);
2249 /* Stop the chip's Tx and Rx DMA processes. */
2250 RTL_W8 (ChipCmd, 0);
2252 /* Disable interrupts by clearing the interrupt mask. */
2253 RTL_W16 (IntrMask, 0);
2255 /* Update the error counts. */
2256 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2257 RTL_W32 (RxMissed, 0);
2259 spin_unlock_irqrestore (&tp->lock, flags);
2261 synchronize_irq (dev->irq); /* racy, but that's ok here */
2262 free_irq (dev->irq, dev);
2264 rtl8139_tx_clear (tp);
2266 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
2267 tp->rx_ring, tp->rx_ring_dma);
2268 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
2269 tp->tx_bufs, tp->tx_bufs_dma);
2273 /* Green! Put the chip in low-power mode. */
2274 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2276 if (rtl_chip_info[tp->chipset].flags & HasHltClk)
2277 RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */
2283 /* Get the ethtool Wake-on-LAN settings. Assumes that wol points to
2284 kernel memory, *wol has been initialized as {ETHTOOL_GWOL}, and
2285 other threads or interrupts aren't messing with the 8139. */
2286 static void rtl8139_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2288 struct rtl8139_private *np = netdev_priv(dev);
2289 void __iomem *ioaddr = np->mmio_addr;
2291 spin_lock_irq(&np->lock);
2292 if (rtl_chip_info[np->chipset].flags & HasLWake) {
2293 u8 cfg3 = RTL_R8 (Config3);
2294 u8 cfg5 = RTL_R8 (Config5);
2296 wol->supported = WAKE_PHY | WAKE_MAGIC
2297 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;
2300 if (cfg3 & Cfg3_LinkUp)
2301 wol->wolopts |= WAKE_PHY;
2302 if (cfg3 & Cfg3_Magic)
2303 wol->wolopts |= WAKE_MAGIC;
2304 /* (KON)FIXME: See how netdev_set_wol() handles the
2305 following constants. */
2306 if (cfg5 & Cfg5_UWF)
2307 wol->wolopts |= WAKE_UCAST;
2308 if (cfg5 & Cfg5_MWF)
2309 wol->wolopts |= WAKE_MCAST;
2310 if (cfg5 & Cfg5_BWF)
2311 wol->wolopts |= WAKE_BCAST;
2313 spin_unlock_irq(&np->lock);
2317 /* Set the ethtool Wake-on-LAN settings. Return 0 or -errno. Assumes
2318 that wol points to kernel memory and other threads or interrupts
2319 aren't messing with the 8139. */
2320 static int rtl8139_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2322 struct rtl8139_private *np = netdev_priv(dev);
2323 void __iomem *ioaddr = np->mmio_addr;
2327 support = ((rtl_chip_info[np->chipset].flags & HasLWake)
2328 ? (WAKE_PHY | WAKE_MAGIC
2329 | WAKE_UCAST | WAKE_MCAST | WAKE_BCAST)
2331 if (wol->wolopts & ~support)
2334 spin_lock_irq(&np->lock);
2335 cfg3 = RTL_R8 (Config3) & ~(Cfg3_LinkUp | Cfg3_Magic);
2336 if (wol->wolopts & WAKE_PHY)
2337 cfg3 |= Cfg3_LinkUp;
2338 if (wol->wolopts & WAKE_MAGIC)
2340 RTL_W8 (Cfg9346, Cfg9346_Unlock);
2341 RTL_W8 (Config3, cfg3);
2342 RTL_W8 (Cfg9346, Cfg9346_Lock);
2344 cfg5 = RTL_R8 (Config5) & ~(Cfg5_UWF | Cfg5_MWF | Cfg5_BWF);
2345 /* (KON)FIXME: These are untested. We may have to set the
2346 CRC0, Wakeup0 and LSBCRC0 registers too, but I have no
2348 if (wol->wolopts & WAKE_UCAST)
2350 if (wol->wolopts & WAKE_MCAST)
2352 if (wol->wolopts & WAKE_BCAST)
2354 RTL_W8 (Config5, cfg5); /* need not unlock via Cfg9346 */
2355 spin_unlock_irq(&np->lock);
2360 static void rtl8139_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2362 struct rtl8139_private *np = netdev_priv(dev);
2363 strcpy(info->driver, DRV_NAME);
2364 strcpy(info->version, DRV_VERSION);
2365 strcpy(info->bus_info, pci_name(np->pci_dev));
2366 info->regdump_len = np->regs_len;
2369 static int rtl8139_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2371 struct rtl8139_private *np = netdev_priv(dev);
2372 spin_lock_irq(&np->lock);
2373 mii_ethtool_gset(&np->mii, cmd);
2374 spin_unlock_irq(&np->lock);
2378 static int rtl8139_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2380 struct rtl8139_private *np = netdev_priv(dev);
2382 spin_lock_irq(&np->lock);
2383 rc = mii_ethtool_sset(&np->mii, cmd);
2384 spin_unlock_irq(&np->lock);
2388 static int rtl8139_nway_reset(struct net_device *dev)
2390 struct rtl8139_private *np = netdev_priv(dev);
2391 return mii_nway_restart(&np->mii);
2394 static u32 rtl8139_get_link(struct net_device *dev)
2396 struct rtl8139_private *np = netdev_priv(dev);
2397 return mii_link_ok(&np->mii);
2400 static u32 rtl8139_get_msglevel(struct net_device *dev)
2402 struct rtl8139_private *np = netdev_priv(dev);
2403 return np->msg_enable;
2406 static void rtl8139_set_msglevel(struct net_device *dev, u32 datum)
2408 struct rtl8139_private *np = netdev_priv(dev);
2409 np->msg_enable = datum;
2412 /* TODO: we are too slack to do reg dumping for pio, for now */
2413 #ifdef CONFIG_8139TOO_PIO
2414 #define rtl8139_get_regs_len NULL
2415 #define rtl8139_get_regs NULL
2417 static int rtl8139_get_regs_len(struct net_device *dev)
2419 struct rtl8139_private *np = netdev_priv(dev);
2420 return np->regs_len;
2423 static void rtl8139_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
2425 struct rtl8139_private *np = netdev_priv(dev);
2427 regs->version = RTL_REGS_VER;
2429 spin_lock_irq(&np->lock);
2430 memcpy_fromio(regbuf, np->mmio_addr, regs->len);
2431 spin_unlock_irq(&np->lock);
2433 #endif /* CONFIG_8139TOO_MMIO */
2435 static int rtl8139_get_stats_count(struct net_device *dev)
2437 return RTL_NUM_STATS;
2440 static void rtl8139_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, u64 *data)
2442 struct rtl8139_private *np = netdev_priv(dev);
2444 data[0] = np->xstats.early_rx;
2445 data[1] = np->xstats.tx_buf_mapped;
2446 data[2] = np->xstats.tx_timeouts;
2447 data[3] = np->xstats.rx_lost_in_ring;
2450 static void rtl8139_get_strings(struct net_device *dev, u32 stringset, u8 *data)
2452 memcpy(data, ethtool_stats_keys, sizeof(ethtool_stats_keys));
2455 static 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_stats_count = rtl8139_get_stats_count,
2469 .get_ethtool_stats = rtl8139_get_ethtool_stats,
2470 .get_perm_addr = ethtool_op_get_perm_addr,
2473 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2475 struct rtl8139_private *np = netdev_priv(dev);
2478 if (!netif_running(dev))
2481 spin_lock_irq(&np->lock);
2482 rc = generic_mii_ioctl(&np->mii, if_mii(rq), cmd, NULL);
2483 spin_unlock_irq(&np->lock);
2489 static struct net_device_stats *rtl8139_get_stats (struct net_device *dev)
2491 struct rtl8139_private *tp = netdev_priv(dev);
2492 void __iomem *ioaddr = tp->mmio_addr;
2493 unsigned long flags;
2495 if (netif_running(dev)) {
2496 spin_lock_irqsave (&tp->lock, flags);
2497 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2498 RTL_W32 (RxMissed, 0);
2499 spin_unlock_irqrestore (&tp->lock, flags);
2505 /* Set or clear the multicast filter for this adaptor.
2506 This routine is not state sensitive and need not be SMP locked. */
2508 static void __set_rx_mode (struct net_device *dev)
2510 struct rtl8139_private *tp = netdev_priv(dev);
2511 void __iomem *ioaddr = tp->mmio_addr;
2512 u32 mc_filter[2]; /* Multicast hash filter */
2516 DPRINTK ("%s: rtl8139_set_rx_mode(%4.4x) done -- Rx config %8.8lx.\n",
2517 dev->name, dev->flags, RTL_R32 (RxConfig));
2519 /* Note: do not reorder, GCC is clever about common statements. */
2520 if (dev->flags & IFF_PROMISC) {
2521 /* Unconditionally log net taps. */
2522 printk (KERN_NOTICE "%s: Promiscuous mode enabled.\n",
2525 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
2527 mc_filter[1] = mc_filter[0] = 0xffffffff;
2528 } else if ((dev->mc_count > multicast_filter_limit)
2529 || (dev->flags & IFF_ALLMULTI)) {
2530 /* Too many to filter perfectly -- accept all multicasts. */
2531 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
2532 mc_filter[1] = mc_filter[0] = 0xffffffff;
2534 struct dev_mc_list *mclist;
2535 rx_mode = AcceptBroadcast | AcceptMyPhys;
2536 mc_filter[1] = mc_filter[0] = 0;
2537 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
2538 i++, mclist = mclist->next) {
2539 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
2541 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
2542 rx_mode |= AcceptMulticast;
2546 /* We can safely update without stopping the chip. */
2547 tmp = rtl8139_rx_config | rx_mode;
2548 if (tp->rx_config != tmp) {
2549 RTL_W32_F (RxConfig, tmp);
2550 tp->rx_config = tmp;
2552 RTL_W32_F (MAR0 + 0, mc_filter[0]);
2553 RTL_W32_F (MAR0 + 4, mc_filter[1]);
2556 static void rtl8139_set_rx_mode (struct net_device *dev)
2558 unsigned long flags;
2559 struct rtl8139_private *tp = netdev_priv(dev);
2561 spin_lock_irqsave (&tp->lock, flags);
2563 spin_unlock_irqrestore (&tp->lock, flags);
2568 static int rtl8139_suspend (struct pci_dev *pdev, pm_message_t state)
2570 struct net_device *dev = pci_get_drvdata (pdev);
2571 struct rtl8139_private *tp = netdev_priv(dev);
2572 void __iomem *ioaddr = tp->mmio_addr;
2573 unsigned long flags;
2575 pci_save_state (pdev);
2577 if (!netif_running (dev))
2580 netif_device_detach (dev);
2582 spin_lock_irqsave (&tp->lock, flags);
2584 /* Disable interrupts, stop Tx and Rx. */
2585 RTL_W16 (IntrMask, 0);
2586 RTL_W8 (ChipCmd, 0);
2588 /* Update the error counts. */
2589 tp->stats.rx_missed_errors += RTL_R32 (RxMissed);
2590 RTL_W32 (RxMissed, 0);
2592 spin_unlock_irqrestore (&tp->lock, flags);
2594 pci_set_power_state (pdev, PCI_D3hot);
2600 static int rtl8139_resume (struct pci_dev *pdev)
2602 struct net_device *dev = pci_get_drvdata (pdev);
2604 pci_restore_state (pdev);
2605 if (!netif_running (dev))
2607 pci_set_power_state (pdev, PCI_D0);
2608 rtl8139_init_ring (dev);
2609 rtl8139_hw_start (dev);
2610 netif_device_attach (dev);
2614 #endif /* CONFIG_PM */
2617 static struct pci_driver rtl8139_pci_driver = {
2619 .id_table = rtl8139_pci_tbl,
2620 .probe = rtl8139_init_one,
2621 .remove = __devexit_p(rtl8139_remove_one),
2623 .suspend = rtl8139_suspend,
2624 .resume = rtl8139_resume,
2625 #endif /* CONFIG_PM */
2629 static int __init rtl8139_init_module (void)
2631 /* when we're a module, we always print a version message,
2632 * even if no 8139 board is found.
2635 printk (KERN_INFO RTL8139_DRIVER_NAME "\n");
2638 return pci_module_init (&rtl8139_pci_driver);
2642 static void __exit rtl8139_cleanup_module (void)
2644 pci_unregister_driver (&rtl8139_pci_driver);
2648 module_init(rtl8139_init_module);
2649 module_exit(rtl8139_cleanup_module);