blob: 56f3fc45dbaa84ab9ecbc9f2e8a29902413c6ef6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2
3 drivers/net/pci-skeleton.c
4
5 Maintained by Jeff Garzik <jgarzik@pobox.com>
6
7 Original code came from 8139too.c, which in turns was based
8 originally on Donald Becker's rtl8139.c driver, versions 1.11
9 and older. This driver was originally based on rtl8139.c
10 version 1.07. Header of rtl8139.c version 1.11:
11
12 -----<snip>-----
13
Joe Perches9cd31f02010-02-17 15:01:55 +000014 Written 1997-2000 by Donald Becker.
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 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
42-----------------------------------------------------------------------------
43
44 Theory of Operation
45
46I. Board Compatibility
47
48This device driver is designed for the RealTek RTL8139 series, the RealTek
49Fast Ethernet controllers for PCI and CardBus. This chip is used on many
50low-end boards, sometimes with its markings changed.
51
52
53II. Board-specific settings
54
55PCI bus devices are configured by the system at boot time, so no jumpers
56need to be set on the board. The system BIOS will assign the
57PCI INTA signal to a (preferably otherwise unused) system IRQ line.
58
59III. Driver operation
60
61IIIa. Rx Ring buffers
62
63The receive unit uses a single linear ring buffer rather than the more
64common (and more efficient) descriptor-based architecture. Incoming frames
65are sequentially stored into the Rx region, and the host copies them into
66skbuffs.
67
68Comment: While it is theoretically possible to process many frames in place,
69any delay in Rx processing would cause us to drop frames. More importantly,
70the Linux protocol stack is not designed to operate in this manner.
71
72IIIb. Tx operation
73
74The RTL8139 uses a fixed set of four Tx descriptors in register space.
75In a stunningly bad design choice, Tx frames must be 32 bit aligned. Linux
76aligns the IP header on word boundaries, and 14 byte ethernet header means
77that almost all frames will need to be copied to an alignment buffer.
78
79IVb. References
80
81http://www.realtek.com.tw/cn/cn.html
82http://www.scyld.com/expert/NWay.html
83
84IVc. Errata
85
86*/
87
Joe Perches9cd31f02010-02-17 15:01:55 +000088#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090#include <linux/module.h>
91#include <linux/kernel.h>
92#include <linux/pci.h>
93#include <linux/init.h>
94#include <linux/ioport.h>
95#include <linux/netdevice.h>
96#include <linux/etherdevice.h>
97#include <linux/delay.h>
98#include <linux/ethtool.h>
99#include <linux/mii.h>
100#include <linux/crc32.h>
Joe Perches9cd31f02010-02-17 15:01:55 +0000101#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Andy Gospodarekd5b20692006-09-11 17:39:18 -0400103#define NETDRV_VERSION "1.0.1"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104#define MODNAME "netdrv"
105#define NETDRV_DRIVER_LOAD_MSG "MyVendor Fast Ethernet driver " NETDRV_VERSION " loaded"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107static char version[] __devinitdata =
Joe Perches9cd31f02010-02-17 15:01:55 +0000108 KERN_INFO NETDRV_DRIVER_LOAD_MSG "\n"
109 " Support available from http://foo.com/bar/baz.html\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/* define to 1 to enable PIO instead of MMIO */
112#undef USE_IO_OPS
113
114/* define to 1 to enable copious debugging info */
115#undef NETDRV_DEBUG
116
117/* define to 1 to disable lightweight runtime debugging checks */
118#undef NETDRV_NDEBUG
119
120
121#ifdef NETDRV_DEBUG
122/* note: prints function name for you */
Joe Perches9cd31f02010-02-17 15:01:55 +0000123#define DPRINTK(fmt, args...) \
124 printk(KERN_DEBUG "%s: " fmt, __func__ , ## args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125#else
Joe Perches9cd31f02010-02-17 15:01:55 +0000126#define DPRINTK(fmt, args...) \
127do { \
128 if (0) \
129 printk(KERN_DEBUG fmt, ##args); \
130} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131#endif
132
133#ifdef NETDRV_NDEBUG
Joe Perches9cd31f02010-02-17 15:01:55 +0000134#define assert(expr) do {} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#else
Joe Perches9cd31f02010-02-17 15:01:55 +0000136#define assert(expr) \
137 if (!(expr)) { \
138 printk("Assertion failed! %s,%s,%s,line=%d\n", \
139 #expr, __FILE__, __func__, __LINE__); \
140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141#endif
142
143
144/* A few user-configurable values. */
145/* media options */
146static int media[] = {-1, -1, -1, -1, -1, -1, -1, -1};
147
148/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
149static int max_interrupt_work = 20;
150
151/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
152 The RTL chips use a 64 element hash table based on the Ethernet CRC. */
153static int multicast_filter_limit = 32;
154
155/* Size of the in-memory receive ring. */
156#define RX_BUF_LEN_IDX 2 /* 0==8K, 1==16K, 2==32K, 3==64K */
Joe Perches9cd31f02010-02-17 15:01:55 +0000157#define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
158#define RX_BUF_PAD 16
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159#define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
Joe Perches9cd31f02010-02-17 15:01:55 +0000160#define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162/* Number of Tx descriptor registers. */
163#define NUM_TX_DESC 4
164
165/* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
166#define MAX_ETH_FRAME_SIZE 1536
167
168/* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
169#define TX_BUF_SIZE MAX_ETH_FRAME_SIZE
170#define TX_BUF_TOT_LEN (TX_BUF_SIZE * NUM_TX_DESC)
171
172/* PCI Tuning Parameters
173 Threshold is bytes transferred to chip before transmission starts. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000174#define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Joe Perches9cd31f02010-02-17 15:01:55 +0000176/* The following settings are log_2(bytes)-4:
177 0==16 bytes 1==32 2==64 3==128 4==256 5==512 6==1024 7==end of packet.
178*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179#define RX_FIFO_THRESH 6 /* Rx buffer level before first PCI xfer. */
180#define RX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
181#define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
182
183
184/* Operational parameters that usually are not changed. */
185/* Time in jiffies before concluding the transmitter is hung. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000186#define TX_TIMEOUT (6 * HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188enum {
189 HAS_CHIP_XCVR = 0x020000,
190 HAS_LNK_CHNG = 0x040000,
191};
192
193#define NETDRV_MIN_IO_SIZE 0x80
194#define RTL8139B_IO_SIZE 256
195
Joe Perches9cd31f02010-02-17 15:01:55 +0000196#define NETDRV_CAPS (HAS_CHIP_XCVR | HAS_LNK_CHNG)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198typedef enum {
199 RTL8139 = 0,
200 NETDRV_CB,
201 SMC1211TX,
202 /*MPX5030,*/
203 DELTA8139,
204 ADDTRON8139,
205} board_t;
206
207
208/* indexed by board_t, above */
209static struct {
210 const char *name;
211} board_info[] __devinitdata = {
212 { "RealTek RTL8139 Fast Ethernet" },
213 { "RealTek RTL8139B PCI/CardBus" },
214 { "SMC1211TX EZCard 10/100 (RealTek RTL8139)" },
215/* { MPX5030, "Accton MPX5030 (RealTek RTL8139)" },*/
216 { "Delta Electronics 8139 10/100BaseTX" },
217 { "Addtron Technolgy 8139 10/100BaseTX" },
218};
219
220
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000221static DEFINE_PCI_DEVICE_TABLE(netdrv_pci_tbl) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
223 {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, NETDRV_CB },
224 {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMC1211TX },
225/* {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MPX5030 },*/
226 {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DELTA8139 },
227 {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ADDTRON8139 },
228 {0,}
229};
Joe Perches9cd31f02010-02-17 15:01:55 +0000230MODULE_DEVICE_TABLE(pci, netdrv_pci_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232
233/* The rest of these values should never change. */
234
235/* Symbolic offsets to registers. */
236enum NETDRV_registers {
237 MAC0 = 0, /* Ethernet hardware address. */
238 MAR0 = 8, /* Multicast filter. */
239 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
240 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
241 RxBuf = 0x30,
242 RxEarlyCnt = 0x34,
243 RxEarlyStatus = 0x36,
244 ChipCmd = 0x37,
245 RxBufPtr = 0x38,
246 RxBufAddr = 0x3A,
247 IntrMask = 0x3C,
248 IntrStatus = 0x3E,
249 TxConfig = 0x40,
250 ChipVersion = 0x43,
251 RxConfig = 0x44,
252 Timer = 0x48, /* A general-purpose counter. */
253 RxMissed = 0x4C, /* 24 bits valid, write clears. */
254 Cfg9346 = 0x50,
255 Config0 = 0x51,
256 Config1 = 0x52,
257 FlashReg = 0x54,
258 MediaStatus = 0x58,
259 Config3 = 0x59,
260 Config4 = 0x5A, /* absent on RTL-8139A */
261 HltClk = 0x5B,
262 MultiIntr = 0x5C,
263 TxSummary = 0x60,
264 BasicModeCtrl = 0x62,
265 BasicModeStatus = 0x64,
266 NWayAdvert = 0x66,
267 NWayLPAR = 0x68,
268 NWayExpansion = 0x6A,
269 /* Undocumented registers, but required for proper operation. */
270 FIFOTMS = 0x70, /* FIFO Control and test. */
271 CSCR = 0x74, /* Chip Status and Configuration Register. */
272 PARA78 = 0x78,
273 PARA7c = 0x7c, /* Magic transceiver parameter register. */
274 Config5 = 0xD8, /* absent on RTL-8139A */
275};
276
277enum ClearBitMasks {
278 MultiIntrClear = 0xF000,
279 ChipCmdClear = 0xE2,
Joe Perches9cd31f02010-02-17 15:01:55 +0000280 Config1Clear = (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2) | (1 << 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281};
282
283enum ChipCmdBits {
284 CmdReset = 0x10,
285 CmdRxEnb = 0x08,
286 CmdTxEnb = 0x04,
287 RxBufEmpty = 0x01,
288};
289
290/* Interrupt register bits, using my own meaningful names. */
291enum IntrStatusBits {
292 PCIErr = 0x8000,
293 PCSTimeout = 0x4000,
294 RxFIFOOver = 0x40,
295 RxUnderrun = 0x20,
296 RxOverflow = 0x10,
297 TxErr = 0x08,
298 TxOK = 0x04,
299 RxErr = 0x02,
300 RxOK = 0x01,
301};
302enum TxStatusBits {
303 TxHostOwns = 0x2000,
304 TxUnderrun = 0x4000,
305 TxStatOK = 0x8000,
306 TxOutOfWindow = 0x20000000,
307 TxAborted = 0x40000000,
308 TxCarrierLost = 0x80000000,
309};
310enum RxStatusBits {
311 RxMulticast = 0x8000,
312 RxPhysical = 0x4000,
313 RxBroadcast = 0x2000,
314 RxBadSymbol = 0x0020,
315 RxRunt = 0x0010,
316 RxTooLong = 0x0008,
317 RxCRCErr = 0x0004,
318 RxBadAlign = 0x0002,
319 RxStatusOK = 0x0001,
320};
321
322/* Bits in RxConfig. */
323enum rx_mode_bits {
324 AcceptErr = 0x20,
325 AcceptRunt = 0x10,
326 AcceptBroadcast = 0x08,
327 AcceptMulticast = 0x04,
328 AcceptMyPhys = 0x02,
329 AcceptAllPhys = 0x01,
330};
331
332/* Bits in TxConfig. */
333enum tx_config_bits {
334 TxIFG1 = (1 << 25), /* Interframe Gap Time */
335 TxIFG0 = (1 << 24), /* Enabling these bits violates IEEE 802.3 */
336 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
337 TxCRC = (1 << 16), /* DISABLE appending CRC to end of Tx packets */
338 TxClearAbt = (1 << 0), /* Clear abort (WO) */
Joe Perches9cd31f02010-02-17 15:01:55 +0000339 TxDMAShift = 8, /* DMA burst value(0-7) is shift this many bits */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
342};
343
344/* Bits in Config1 */
345enum Config1Bits {
346 Cfg1_PM_Enable = 0x01,
347 Cfg1_VPD_Enable = 0x02,
348 Cfg1_PIO = 0x04,
349 Cfg1_MMIO = 0x08,
350 Cfg1_LWAKE = 0x10,
351 Cfg1_Driver_Load = 0x20,
352 Cfg1_LED0 = 0x40,
353 Cfg1_LED1 = 0x80,
354};
355
356enum RxConfigBits {
357 /* Early Rx threshold, none or X/16 */
358 RxCfgEarlyRxNone = 0,
359 RxCfgEarlyRxShift = 24,
360
361 /* rx fifo threshold */
362 RxCfgFIFOShift = 13,
363 RxCfgFIFONone = (7 << RxCfgFIFOShift),
364
365 /* Max DMA burst */
366 RxCfgDMAShift = 8,
367 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
368
369 /* rx ring buffer length */
370 RxCfgRcv8K = 0,
371 RxCfgRcv16K = (1 << 11),
372 RxCfgRcv32K = (1 << 12),
373 RxCfgRcv64K = (1 << 11) | (1 << 12),
374
375 /* Disable packet wrap at end of Rx buffer */
376 RxNoWrap = (1 << 7),
377};
378
379
380/* Twister tuning parameters from RealTek.
381 Completely undocumented, but required to tune bad links. */
382enum CSCRBits {
383 CSCR_LinkOKBit = 0x0400,
384 CSCR_LinkChangeBit = 0x0800,
385 CSCR_LinkStatusBits = 0x0f000,
386 CSCR_LinkDownOffCmd = 0x003c0,
387 CSCR_LinkDownCmd = 0x0f3c0,
388};
389
390
391enum Cfg9346Bits {
392 Cfg9346_Lock = 0x00,
393 Cfg9346_Unlock = 0xC0,
394};
395
396
397#define PARA78_default 0x78fa8388
398#define PARA7c_default 0xcb38de43 /* param[0][3] */
399#define PARA7c_xxx 0xcb38de43
400static const unsigned long param[4][4] = {
401 {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
402 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
403 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
404 {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
405};
406
407struct ring_info {
408 struct sk_buff *skb;
409 dma_addr_t mapping;
410};
411
412
413typedef enum {
414 CH_8139 = 0,
415 CH_8139_K,
416 CH_8139A,
417 CH_8139B,
418 CH_8130,
419 CH_8139C,
420} chip_t;
421
422
423/* directly indexed by chip_t, above */
Jesper Juhl3c6bee12006-01-09 20:54:01 -0800424static const struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 const char *name;
426 u8 version; /* from RTL8139C docs */
427 u32 RxConfigMask; /* should clear the bits supported by this chip */
428} rtl_chip_info[] = {
429 { "RTL-8139",
430 0x40,
431 0xf0fe0040, /* XXX copied from RTL8139A, verify */
432 },
433
434 { "RTL-8139 rev K",
435 0x60,
436 0xf0fe0040,
437 },
438
439 { "RTL-8139A",
440 0x70,
441 0xf0fe0040,
442 },
443
444 { "RTL-8139B",
445 0x78,
446 0xf0fc0040
447 },
448
449 { "RTL-8130",
450 0x7C,
451 0xf0fe0040, /* XXX copied from RTL8139A, verify */
452 },
453
454 { "RTL-8139C",
455 0x74,
456 0xf0fc0040, /* XXX copied from RTL8139B, verify */
457 },
458
459};
460
461
462struct netdrv_private {
463 board_t board;
464 void *mmio_addr;
465 int drv_flags;
466 struct pci_dev *pci_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 struct timer_list timer; /* Media selection timer. */
468 unsigned char *rx_ring;
469 unsigned int cur_rx; /* Index into the Rx buffer of next Rx pkt. */
470 unsigned int tx_flag;
471 atomic_t cur_tx;
472 atomic_t dirty_tx;
473 /* The saved address of a sent-in-place packet/buffer, for skfree(). */
474 struct ring_info tx_info[NUM_TX_DESC];
475 unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
476 unsigned char *tx_bufs; /* Tx bounce buffer region. */
477 dma_addr_t rx_ring_dma;
478 dma_addr_t tx_bufs_dma;
479 char phys[4]; /* MII device addresses. */
480 char twistie, twist_row, twist_col; /* Twister tune state. */
481 unsigned int full_duplex:1; /* Full-duplex operation requested. */
482 unsigned int duplex_lock:1;
483 unsigned int default_port:4; /* Last dev->if_port value. */
484 unsigned int media2:4; /* Secondary monitored media port. */
485 unsigned int medialock:1; /* Don't sense media type. */
486 unsigned int mediasense:1; /* Media sensing in progress. */
487 spinlock_t lock;
488 chip_t chipset;
489};
490
Joe Perches9cd31f02010-02-17 15:01:55 +0000491MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
492MODULE_DESCRIPTION("Skeleton for a PCI Fast Ethernet driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493MODULE_LICENSE("GPL");
Victor Fusco2f761472005-07-01 00:03:12 +0200494module_param(multicast_filter_limit, int, 0);
495module_param(max_interrupt_work, int, 0);
496module_param_array(media, int, NULL, 0);
Joe Perches9cd31f02010-02-17 15:01:55 +0000497MODULE_PARM_DESC(multicast_filter_limit,
498 MODNAME " maximum number of filtered multicast addresses");
499MODULE_PARM_DESC(max_interrupt_work,
500 MODNAME " maximum events handled per interrupt");
501MODULE_PARM_DESC(media,
502 MODNAME " Bits 0-3: media type, bit 17: full duplex");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Joe Perches9cd31f02010-02-17 15:01:55 +0000504static int read_eeprom(void *ioaddr, int location, int addr_len);
505static int netdrv_open(struct net_device *dev);
506static int mdio_read(struct net_device *dev, int phy_id, int location);
507static void mdio_write(struct net_device *dev, int phy_id, int location,
508 int val);
509static void netdrv_timer(unsigned long data);
510static void netdrv_tx_timeout(struct net_device *dev);
511static void netdrv_init_ring(struct net_device *dev);
512static int netdrv_start_xmit(struct sk_buff *skb,
513 struct net_device *dev);
514static irqreturn_t netdrv_interrupt(int irq, void *dev_instance);
515static int netdrv_close(struct net_device *dev);
516static int netdrv_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
517static void netdrv_set_rx_mode(struct net_device *dev);
518static void netdrv_hw_start(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520
521#ifdef USE_IO_OPS
522
Joe Perches9cd31f02010-02-17 15:01:55 +0000523#define NETDRV_R8(reg) inb(((unsigned long)ioaddr) + (reg))
524#define NETDRV_R16(reg) inw(((unsigned long)ioaddr) + (reg))
525#define NETDRV_R32(reg) ((unsigned long)inl(((unsigned long)ioaddr) + (reg)))
526#define NETDRV_W8(reg, val8) outb((val8), ((unsigned long)ioaddr) + (reg))
527#define NETDRV_W16(reg, val16) outw((val16), ((unsigned long)ioaddr) + (reg))
528#define NETDRV_W32(reg, val32) outl((val32), ((unsigned long)ioaddr) + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529#define NETDRV_W8_F NETDRV_W8
530#define NETDRV_W16_F NETDRV_W16
531#define NETDRV_W32_F NETDRV_W32
532#undef readb
533#undef readw
534#undef readl
535#undef writeb
536#undef writew
537#undef writel
538#define readb(addr) inb((unsigned long)(addr))
539#define readw(addr) inw((unsigned long)(addr))
540#define readl(addr) inl((unsigned long)(addr))
Joe Perches9cd31f02010-02-17 15:01:55 +0000541#define writeb(val, addr) outb((val), (unsigned long)(addr))
542#define writew(val, addr) outw((val), (unsigned long)(addr))
543#define writel(val, addr) outl((val), (unsigned long)(addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545#else
546
547/* write MMIO register, with flush */
548/* Flush avoids rtl8139 bug w/ posted MMIO writes */
Joe Perches9cd31f02010-02-17 15:01:55 +0000549#define NETDRV_W8_F(reg, val8) \
550do { \
551 writeb((val8), ioaddr + (reg)); \
552 readb(ioaddr + (reg)); \
553} while (0)
554#define NETDRV_W16_F(reg, val16) \
555do { \
556 writew((val16), ioaddr + (reg)); \
557 readw(ioaddr + (reg)); \
558} while (0)
559#define NETDRV_W32_F(reg, val32) \
560do { \
561 writel((val32), ioaddr + (reg)); \
562 readl(ioaddr + (reg)); \
563} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565
Jike Song44911bf2008-01-24 14:51:36 +0800566#ifdef MMIO_FLUSH_AUDIT_COMPLETE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568/* write MMIO register */
Joe Perches9cd31f02010-02-17 15:01:55 +0000569#define NETDRV_W8(reg, val8) writeb((val8), ioaddr + (reg))
570#define NETDRV_W16(reg, val16) writew((val16), ioaddr + (reg))
571#define NETDRV_W32(reg, val32) writel((val32), ioaddr + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573#else
574
575/* write MMIO register, then flush */
576#define NETDRV_W8 NETDRV_W8_F
577#define NETDRV_W16 NETDRV_W16_F
578#define NETDRV_W32 NETDRV_W32_F
579
580#endif /* MMIO_FLUSH_AUDIT_COMPLETE */
581
582/* read MMIO register */
Joe Perches9cd31f02010-02-17 15:01:55 +0000583#define NETDRV_R8(reg) readb(ioaddr + (reg))
584#define NETDRV_R16(reg) readw(ioaddr + (reg))
585#define NETDRV_R32(reg) ((unsigned long) readl(ioaddr + (reg)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
587#endif /* USE_IO_OPS */
588
589
590static const u16 netdrv_intr_mask =
591 PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
592 TxErr | TxOK | RxErr | RxOK;
593
594static const unsigned int netdrv_rx_config =
Joe Perches9cd31f02010-02-17 15:01:55 +0000595 RxCfgEarlyRxNone | RxCfgRcv32K | RxNoWrap |
596 (RX_FIFO_THRESH << RxCfgFIFOShift) |
597 (RX_DMA_BURST << RxCfgDMAShift);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599
Joe Perches9cd31f02010-02-17 15:01:55 +0000600static int __devinit netdrv_init_board(struct pci_dev *pdev,
601 struct net_device **dev_out,
602 void **ioaddr_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603{
604 void *ioaddr = NULL;
605 struct net_device *dev;
606 struct netdrv_private *tp;
607 int rc, i;
608 u32 pio_start, pio_end, pio_flags, pio_len;
609 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
610 u32 tmp;
611
Joe Perches9cd31f02010-02-17 15:01:55 +0000612 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Joe Perches9cd31f02010-02-17 15:01:55 +0000614 assert(pdev != NULL);
615 assert(ioaddr_out != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 *ioaddr_out = NULL;
618 *dev_out = NULL;
619
620 /* dev zeroed in alloc_etherdev */
Joe Perches9cd31f02010-02-17 15:01:55 +0000621 dev = alloc_etherdev(sizeof(*tp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 if (dev == NULL) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400623 dev_err(&pdev->dev, "unable to alloc new ethernet\n");
Joe Perches9cd31f02010-02-17 15:01:55 +0000624 DPRINTK("EXIT, returning -ENOMEM\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 return -ENOMEM;
626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 SET_NETDEV_DEV(dev, &pdev->dev);
Jike Song44911bf2008-01-24 14:51:36 +0800628 tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Joe Perches9cd31f02010-02-17 15:01:55 +0000630 /* enable device(incl. PCI PM wakeup), and bus-mastering */
631 rc = pci_enable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 if (rc)
633 goto err_out;
634
Joe Perches9cd31f02010-02-17 15:01:55 +0000635 pio_start = pci_resource_start(pdev, 0);
636 pio_end = pci_resource_end(pdev, 0);
637 pio_flags = pci_resource_flags(pdev, 0);
638 pio_len = pci_resource_len(pdev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Joe Perches9cd31f02010-02-17 15:01:55 +0000640 mmio_start = pci_resource_start(pdev, 1);
641 mmio_end = pci_resource_end(pdev, 1);
642 mmio_flags = pci_resource_flags(pdev, 1);
643 mmio_len = pci_resource_len(pdev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
645 /* set this immediately, we need to know before
646 * we talk to the chip directly */
Joe Perches9cd31f02010-02-17 15:01:55 +0000647 DPRINTK("PIO region size == %#02X\n", pio_len);
648 DPRINTK("MMIO region size == %#02lX\n", mmio_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
650 /* make sure PCI base addr 0 is PIO */
651 if (!(pio_flags & IORESOURCE_IO)) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400652 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 rc = -ENODEV;
654 goto err_out;
655 }
656
657 /* make sure PCI base addr 1 is MMIO */
658 if (!(mmio_flags & IORESOURCE_MEM)) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400659 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 rc = -ENODEV;
661 goto err_out;
662 }
663
664 /* check for weird/broken PCI region reporting */
665 if ((pio_len < NETDRV_MIN_IO_SIZE) ||
666 (mmio_len < NETDRV_MIN_IO_SIZE)) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400667 dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 rc = -ENODEV;
669 goto err_out;
670 }
671
Joe Perches9cd31f02010-02-17 15:01:55 +0000672 rc = pci_request_regions(pdev, MODNAME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 if (rc)
674 goto err_out;
675
Joe Perches9cd31f02010-02-17 15:01:55 +0000676 pci_set_master(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678#ifdef USE_IO_OPS
Joe Perches9cd31f02010-02-17 15:01:55 +0000679 ioaddr = (void *)pio_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680#else
681 /* ioremap MMIO region */
Joe Perches9cd31f02010-02-17 15:01:55 +0000682 ioaddr = ioremap(mmio_start, mmio_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 if (ioaddr == NULL) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400684 dev_err(&pdev->dev, "cannot remap MMIO, aborting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 rc = -EIO;
686 goto err_out_free_res;
687 }
688#endif /* USE_IO_OPS */
689
690 /* Soft reset the chip. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000691 NETDRV_W8(ChipCmd, (NETDRV_R8(ChipCmd) & ChipCmdClear) | CmdReset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 /* Check that the chip has finished the reset. */
694 for (i = 1000; i > 0; i--)
Joe Perches9cd31f02010-02-17 15:01:55 +0000695 if ((NETDRV_R8(ChipCmd) & CmdReset) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 break;
697 else
Joe Perches9cd31f02010-02-17 15:01:55 +0000698 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 /* Bring the chip out of low-power mode. */
701 /* <insert device-specific code here> */
702
703#ifndef USE_IO_OPS
704 /* sanity checks -- ensure PIO and MMIO registers agree */
Joe Perches9cd31f02010-02-17 15:01:55 +0000705 assert(inb(pio_start+Config0) == readb(ioaddr+Config0));
706 assert(inb(pio_start+Config1) == readb(ioaddr+Config1));
707 assert(inb(pio_start+TxConfig) == readb(ioaddr+TxConfig));
708 assert(inb(pio_start+RxConfig) == readb(ioaddr+RxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709#endif /* !USE_IO_OPS */
710
711 /* identify chip attached to board */
Joe Perches9cd31f02010-02-17 15:01:55 +0000712 tmp = NETDRV_R8(ChipVersion);
713 for (i = ARRAY_SIZE(rtl_chip_info) - 1; i >= 0; i--)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 if (tmp == rtl_chip_info[i].version) {
715 tp->chipset = i;
716 goto match;
717 }
718
719 /* if unknown chip, assume array element #0, original RTL-8139 in this case */
Joe Perches9cd31f02010-02-17 15:01:55 +0000720 dev_printk(KERN_DEBUG, &pdev->dev,
721 "unknown chip version, assuming RTL-8139\n");
722 dev_printk(KERN_DEBUG, &pdev->dev, "TxConfig = %#lx\n",
723 NETDRV_R32(TxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 tp->chipset = 0;
725
726match:
Joe Perches9cd31f02010-02-17 15:01:55 +0000727 DPRINTK("chipset id(%d) == index %d, '%s'\n",
728 tmp, tp->chipset, rtl_chip_info[tp->chipset].name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
Joe Perches9cd31f02010-02-17 15:01:55 +0000730 rc = register_netdev(dev);
Anton Blanchard5c4851c2007-03-16 17:00:21 -0500731 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 goto err_out_unmap;
733
Joe Perches9cd31f02010-02-17 15:01:55 +0000734 DPRINTK("EXIT, returning 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 *ioaddr_out = ioaddr;
736 *dev_out = dev;
737 return 0;
738
739err_out_unmap:
740#ifndef USE_IO_OPS
741 iounmap(ioaddr);
742err_out_free_res:
743#endif
Joe Perches9cd31f02010-02-17 15:01:55 +0000744 pci_release_regions(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745err_out:
Joe Perches9cd31f02010-02-17 15:01:55 +0000746 free_netdev(dev);
747 DPRINTK("EXIT, returning %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 return rc;
749}
750
Alexander Beregalov1ec847f2009-04-15 12:52:55 +0000751static const struct net_device_ops netdrv_netdev_ops = {
752 .ndo_open = netdrv_open,
753 .ndo_stop = netdrv_close,
754 .ndo_start_xmit = netdrv_start_xmit,
755 .ndo_set_multicast_list = netdrv_set_rx_mode,
756 .ndo_do_ioctl = netdrv_ioctl,
757 .ndo_tx_timeout = netdrv_tx_timeout,
758 .ndo_change_mtu = eth_change_mtu,
759 .ndo_validate_addr = eth_validate_addr,
760 .ndo_set_mac_address = eth_mac_addr,
761};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Joe Perches9cd31f02010-02-17 15:01:55 +0000763static int __devinit netdrv_init_one(struct pci_dev *pdev,
764 const struct pci_device_id *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765{
766 struct net_device *dev = NULL;
767 struct netdrv_private *tp;
768 int i, addr_len, option;
769 void *ioaddr = NULL;
770 static int board_idx = -1;
771
772/* when built into the kernel, we only print version if device is found */
773#ifndef MODULE
774 static int printed_version;
775 if (!printed_version++)
776 printk(version);
777#endif
778
Joe Perches9cd31f02010-02-17 15:01:55 +0000779 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Joe Perches9cd31f02010-02-17 15:01:55 +0000781 assert(pdev != NULL);
782 assert(ent != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 board_idx++;
785
Joe Perches9cd31f02010-02-17 15:01:55 +0000786 i = netdrv_init_board(pdev, &dev, &ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 if (i < 0) {
Joe Perches9cd31f02010-02-17 15:01:55 +0000788 DPRINTK("EXIT, returning %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return i;
790 }
791
Jike Song44911bf2008-01-24 14:51:36 +0800792 tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Joe Perches9cd31f02010-02-17 15:01:55 +0000794 assert(ioaddr != NULL);
795 assert(dev != NULL);
796 assert(tp != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Joe Perches9cd31f02010-02-17 15:01:55 +0000798 addr_len = read_eeprom(ioaddr, 0, 8) == 0x8129 ? 8 : 6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 for (i = 0; i < 3; i++)
Joe Perches9cd31f02010-02-17 15:01:55 +0000800 ((u16 *)(dev->dev_addr))[i] =
801 le16_to_cpu(read_eeprom(ioaddr, i + 7, addr_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Alexander Beregalov1ec847f2009-04-15 12:52:55 +0000803 dev->netdev_ops = &netdrv_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 dev->watchdog_timeo = TX_TIMEOUT;
805
806 dev->irq = pdev->irq;
807 dev->base_addr = (unsigned long) ioaddr;
808
Wang Chenb74ca3a2008-12-08 01:14:16 -0800809 /* netdev_priv()/tp zeroed and aligned in alloc_etherdev */
Jike Song44911bf2008-01-24 14:51:36 +0800810 tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 /* note: tp->chipset set in netdrv_init_board */
813 tp->drv_flags = PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
Joe Perches9cd31f02010-02-17 15:01:55 +0000814 PCI_COMMAND_MASTER | NETDRV_CAPS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 tp->pci_dev = pdev;
816 tp->board = ent->driver_data;
817 tp->mmio_addr = ioaddr;
818 spin_lock_init(&tp->lock);
819
820 pci_set_drvdata(pdev, dev);
821
822 tp->phys[0] = 32;
823
Joe Perches9cd31f02010-02-17 15:01:55 +0000824 netdev_info(dev, "%s at %#lx, %pM IRQ %d\n",
825 board_info[ent->driver_data].name,
826 dev->base_addr, dev->dev_addr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Joe Perches9cd31f02010-02-17 15:01:55 +0000828 netdev_printk(KERN_DEBUG, dev, "Identified 8139 chip type '%s'\n",
829 rtl_chip_info[tp->chipset].name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 /* Put the chip into low-power mode. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000832 NETDRV_W8_F(Cfg9346, Cfg9346_Unlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* The lower four bits are the media type. */
835 option = (board_idx > 7) ? 0 : media[board_idx];
836 if (option > 0) {
837 tp->full_duplex = (option & 0x200) ? 1 : 0;
838 tp->default_port = option & 15;
839 if (tp->default_port)
840 tp->medialock = 1;
841 }
842
843 if (tp->full_duplex) {
Joe Perches9cd31f02010-02-17 15:01:55 +0000844 netdev_info(dev, "Media type forced to Full Duplex\n");
845 mdio_write(dev, tp->phys[0], MII_ADVERTISE, ADVERTISE_FULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 tp->duplex_lock = 1;
847 }
848
Joe Perches9cd31f02010-02-17 15:01:55 +0000849 DPRINTK("EXIT - returning 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 return 0;
851}
852
853
Joe Perches9cd31f02010-02-17 15:01:55 +0000854static void __devexit netdrv_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
Joe Perches9cd31f02010-02-17 15:01:55 +0000856 struct net_device *dev = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 struct netdrv_private *np;
858
Joe Perches9cd31f02010-02-17 15:01:55 +0000859 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
Joe Perches9cd31f02010-02-17 15:01:55 +0000861 assert(dev != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Jike Song44911bf2008-01-24 14:51:36 +0800863 np = netdev_priv(dev);
Joe Perches9cd31f02010-02-17 15:01:55 +0000864 assert(np != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
Joe Perches9cd31f02010-02-17 15:01:55 +0000866 unregister_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868#ifndef USE_IO_OPS
Joe Perches9cd31f02010-02-17 15:01:55 +0000869 iounmap(np->mmio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870#endif /* !USE_IO_OPS */
871
Joe Perches9cd31f02010-02-17 15:01:55 +0000872 pci_release_regions(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Joe Perches9cd31f02010-02-17 15:01:55 +0000874 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
Joe Perches9cd31f02010-02-17 15:01:55 +0000876 pci_set_drvdata(pdev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Joe Perches9cd31f02010-02-17 15:01:55 +0000878 pci_disable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
Joe Perches9cd31f02010-02-17 15:01:55 +0000880 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881}
882
883
884/* Serial EEPROM section. */
885
886/* EEPROM_Ctrl bits. */
887#define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000888#define EE_CS 0x08 /* EEPROM chip select. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889#define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000890#define EE_WRITE_0 0x00
891#define EE_WRITE_1 0x02
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892#define EE_DATA_READ 0x01 /* EEPROM chip data out. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000893#define EE_ENB (0x80 | EE_CS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
895/* Delay between EEPROM clock transitions.
896 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
Joe Perches9cd31f02010-02-17 15:01:55 +0000897*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899#define eeprom_delay() readl(ee_addr)
900
901/* The EEPROM commands include the alway-set leading bit. */
902#define EE_WRITE_CMD (5)
Joe Perches9cd31f02010-02-17 15:01:55 +0000903#define EE_READ_CMD (6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904#define EE_ERASE_CMD (7)
905
Joe Perches9cd31f02010-02-17 15:01:55 +0000906static int __devinit read_eeprom(void *ioaddr, int location, int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907{
908 int i;
909 unsigned retval = 0;
910 void *ee_addr = ioaddr + Cfg9346;
911 int read_cmd = location | (EE_READ_CMD << addr_len);
912
Joe Perches9cd31f02010-02-17 15:01:55 +0000913 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914
Joe Perches9cd31f02010-02-17 15:01:55 +0000915 writeb(EE_ENB & ~EE_CS, ee_addr);
916 writeb(EE_ENB, ee_addr);
917 eeprom_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 /* Shift the read command bits out. */
920 for (i = 4 + addr_len; i >= 0; i--) {
921 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
Joe Perches9cd31f02010-02-17 15:01:55 +0000922 writeb(EE_ENB | dataval, ee_addr);
923 eeprom_delay();
924 writeb(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
925 eeprom_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 }
Joe Perches9cd31f02010-02-17 15:01:55 +0000927 writeb(EE_ENB, ee_addr);
928 eeprom_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 for (i = 16; i > 0; i--) {
Joe Perches9cd31f02010-02-17 15:01:55 +0000931 writeb(EE_ENB | EE_SHIFT_CLK, ee_addr);
932 eeprom_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 retval =
Joe Perches9cd31f02010-02-17 15:01:55 +0000934 (retval << 1) | ((readb(ee_addr) & EE_DATA_READ) ? 1 :
935 0);
936 writeb(EE_ENB, ee_addr);
937 eeprom_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 }
939
940 /* Terminate the EEPROM access. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000941 writeb(~EE_CS, ee_addr);
942 eeprom_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
Joe Perches9cd31f02010-02-17 15:01:55 +0000944 DPRINTK("EXIT - returning %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 return retval;
946}
947
948/* MII serial management: mostly bogus for now. */
949/* Read and write the MII management registers using software-generated
950 serial MDIO protocol.
951 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
952 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
953 "overclocking" issues. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000954#define MDIO_DIR 0x80
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955#define MDIO_DATA_OUT 0x04
956#define MDIO_DATA_IN 0x02
Joe Perches9cd31f02010-02-17 15:01:55 +0000957#define MDIO_CLK 0x01
958#define MDIO_WRITE0 (MDIO_DIR)
959#define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960
961#define mdio_delay() readb(mdio_addr)
962
963
964static char mii_2_8139_map[8] = {
965 BasicModeCtrl,
966 BasicModeStatus,
967 0,
968 0,
969 NWayAdvert,
970 NWayLPAR,
971 NWayExpansion,
972 0
973};
974
975
976/* Syncronize the MII management interface by shifting 32 one bits out. */
Joe Perches9cd31f02010-02-17 15:01:55 +0000977static void mdio_sync(void *mdio_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978{
979 int i;
980
Joe Perches9cd31f02010-02-17 15:01:55 +0000981 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982
983 for (i = 32; i >= 0; i--) {
Joe Perches9cd31f02010-02-17 15:01:55 +0000984 writeb(MDIO_WRITE1, mdio_addr);
985 mdio_delay();
986 writeb(MDIO_WRITE1 | MDIO_CLK, mdio_addr);
987 mdio_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 }
989
Joe Perches9cd31f02010-02-17 15:01:55 +0000990 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991}
992
993
Joe Perches9cd31f02010-02-17 15:01:55 +0000994static int mdio_read(struct net_device *dev, int phy_id, int location)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995{
Jike Song44911bf2008-01-24 14:51:36 +0800996 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 void *mdio_addr = tp->mmio_addr + Config4;
998 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
999 int retval = 0;
1000 int i;
1001
Joe Perches9cd31f02010-02-17 15:01:55 +00001002 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
1004 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001005 DPRINTK("EXIT after directly using 8139 internal regs\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 return location < 8 && mii_2_8139_map[location] ?
Joe Perches9cd31f02010-02-17 15:01:55 +00001007 readw(tp->mmio_addr + mii_2_8139_map[location]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 }
Joe Perches9cd31f02010-02-17 15:01:55 +00001009 mdio_sync(mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 /* Shift the read command bits out. */
1011 for (i = 15; i >= 0; i--) {
1012 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1013
Joe Perches9cd31f02010-02-17 15:01:55 +00001014 writeb(MDIO_DIR | dataval, mdio_addr);
1015 mdio_delay();
1016 writeb(MDIO_DIR | dataval | MDIO_CLK, mdio_addr);
1017 mdio_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
1019
1020 /* Read the two transition, 16 data, and wire-idle bits. */
1021 for (i = 19; i > 0; i--) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001022 writeb(0, mdio_addr);
1023 mdio_delay();
1024 retval = ((retval << 1) | ((readb(mdio_addr) & MDIO_DATA_IN))
1025 ? 1 : 0);
1026 writeb(MDIO_CLK, mdio_addr);
1027 mdio_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 }
1029
Joe Perches9cd31f02010-02-17 15:01:55 +00001030 DPRINTK("EXIT, returning %d\n", (retval >> 1) & 0xffff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 return (retval >> 1) & 0xffff;
1032}
1033
1034
Joe Perches9cd31f02010-02-17 15:01:55 +00001035static void mdio_write(struct net_device *dev, int phy_id, int location,
1036 int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037{
Jike Song44911bf2008-01-24 14:51:36 +08001038 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 void *mdio_addr = tp->mmio_addr + Config4;
1040 int mii_cmd =
Joe Perches9cd31f02010-02-17 15:01:55 +00001041 (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 int i;
1043
Joe Perches9cd31f02010-02-17 15:01:55 +00001044 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
1046 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
1047 if (location < 8 && mii_2_8139_map[location]) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001048 writew(value,
1049 tp->mmio_addr + mii_2_8139_map[location]);
1050 readw(tp->mmio_addr + mii_2_8139_map[location]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 }
Joe Perches9cd31f02010-02-17 15:01:55 +00001052 DPRINTK("EXIT after directly using 8139 internal regs\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 return;
1054 }
Joe Perches9cd31f02010-02-17 15:01:55 +00001055 mdio_sync(mdio_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 /* Shift the command bits out. */
1058 for (i = 31; i >= 0; i--) {
1059 int dataval =
Joe Perches9cd31f02010-02-17 15:01:55 +00001060 (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1061 writeb(dataval, mdio_addr);
1062 mdio_delay();
1063 writeb(dataval | MDIO_CLK, mdio_addr);
1064 mdio_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 }
1066
1067 /* Clear out extra bits. */
1068 for (i = 2; i > 0; i--) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001069 writeb(0, mdio_addr);
1070 mdio_delay();
1071 writeb(MDIO_CLK, mdio_addr);
1072 mdio_delay();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 }
1074
Joe Perches9cd31f02010-02-17 15:01:55 +00001075 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076}
1077
1078
Joe Perches9cd31f02010-02-17 15:01:55 +00001079static int netdrv_open(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
Jike Song44911bf2008-01-24 14:51:36 +08001081 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 void *ioaddr = tp->mmio_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
Joe Perches9cd31f02010-02-17 15:01:55 +00001085 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
Joe Perches9cd31f02010-02-17 15:01:55 +00001087 retval = request_irq(dev->irq, netdrv_interrupt, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 if (retval) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001089 DPRINTK("EXIT, returning %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 return retval;
1091 }
1092
1093 tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1094 &tp->tx_bufs_dma);
1095 tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1096 &tp->rx_ring_dma);
1097 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1098 free_irq(dev->irq, dev);
1099
1100 if (tp->tx_bufs)
1101 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1102 tp->tx_bufs, tp->tx_bufs_dma);
1103 if (tp->rx_ring)
1104 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1105 tp->rx_ring, tp->rx_ring_dma);
1106
Joe Perches9cd31f02010-02-17 15:01:55 +00001107 DPRINTK("EXIT, returning -ENOMEM\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 return -ENOMEM;
1109
1110 }
1111
1112 tp->full_duplex = tp->duplex_lock;
1113 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1114
Joe Perches9cd31f02010-02-17 15:01:55 +00001115 netdrv_init_ring(dev);
1116 netdrv_hw_start(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
Joe Perches9cd31f02010-02-17 15:01:55 +00001118 netdev_dbg(dev, "ioaddr %#llx IRQ %d GP Pins %02x %s-duplex\n",
1119 (unsigned long long)pci_resource_start(tp->pci_dev, 1),
1120 dev->irq, NETDRV_R8(MediaStatus),
1121 tp->full_duplex ? "full" : "half");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
1123 /* Set the timer to switch to check for link beat and perhaps switch
1124 to an alternate media type. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001125 init_timer(&tp->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 tp->timer.expires = jiffies + 3 * HZ;
1127 tp->timer.data = (unsigned long) dev;
1128 tp->timer.function = &netdrv_timer;
Joe Perches9cd31f02010-02-17 15:01:55 +00001129 add_timer(&tp->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
Joe Perches9cd31f02010-02-17 15:01:55 +00001131 DPRINTK("EXIT, returning 0\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 return 0;
1133}
1134
1135
1136/* Start the hardware at open or resume. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001137static void netdrv_hw_start(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138{
Jike Song44911bf2008-01-24 14:51:36 +08001139 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 void *ioaddr = tp->mmio_addr;
1141 u32 i;
1142
Joe Perches9cd31f02010-02-17 15:01:55 +00001143 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
1145 /* Soft reset the chip. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001146 NETDRV_W8(ChipCmd, (NETDRV_R8(ChipCmd) & ChipCmdClear) | CmdReset);
1147 udelay(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
1149 /* Check that the chip has finished the reset. */
1150 for (i = 1000; i > 0; i--)
Joe Perches9cd31f02010-02-17 15:01:55 +00001151 if ((NETDRV_R8(ChipCmd) & CmdReset) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 break;
1153
1154 /* Restore our idea of the MAC address. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001155 NETDRV_W32_F(MAC0 + 0, cpu_to_le32(*(u32 *)(dev->dev_addr + 0)));
1156 NETDRV_W32_F(MAC0 + 4, cpu_to_le32(*(u32 *)(dev->dev_addr + 4)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 /* Must enable Tx/Rx before setting transfer thresholds! */
Joe Perches9cd31f02010-02-17 15:01:55 +00001159 NETDRV_W8_F(ChipCmd, (NETDRV_R8(ChipCmd) & ChipCmdClear) |
1160 CmdRxEnb | CmdTxEnb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 i = netdrv_rx_config |
Joe Perches9cd31f02010-02-17 15:01:55 +00001163 (NETDRV_R32(RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1164 NETDRV_W32_F(RxConfig, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
1166 /* Check this value: the documentation for IFG contradicts ifself. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001167 NETDRV_W32(TxConfig, (TX_DMA_BURST << TxDMAShift));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168
1169 /* unlock Config[01234] and BMCR register writes */
Joe Perches9cd31f02010-02-17 15:01:55 +00001170 NETDRV_W8_F(Cfg9346, Cfg9346_Unlock);
1171 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
1173 tp->cur_rx = 0;
1174
1175 /* Lock Config[01234] and BMCR register writes */
Joe Perches9cd31f02010-02-17 15:01:55 +00001176 NETDRV_W8_F(Cfg9346, Cfg9346_Lock);
1177 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 /* init Rx ring buffer DMA address */
Joe Perches9cd31f02010-02-17 15:01:55 +00001180 NETDRV_W32_F(RxBuf, tp->rx_ring_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181
1182 /* init Tx buffer DMA addresses */
1183 for (i = 0; i < NUM_TX_DESC; i++)
Joe Perches9cd31f02010-02-17 15:01:55 +00001184 NETDRV_W32_F(TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Joe Perches9cd31f02010-02-17 15:01:55 +00001186 NETDRV_W32_F(RxMissed, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
Joe Perches9cd31f02010-02-17 15:01:55 +00001188 netdrv_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
1190 /* no early-rx interrupts */
Joe Perches9cd31f02010-02-17 15:01:55 +00001191 NETDRV_W16(MultiIntr, NETDRV_R16(MultiIntr) & MultiIntrClear);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193 /* make sure RxTx has started */
Joe Perches9cd31f02010-02-17 15:01:55 +00001194 NETDRV_W8_F(ChipCmd, (NETDRV_R8(ChipCmd) & ChipCmdClear) |
1195 CmdRxEnb | CmdTxEnb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
1197 /* Enable all known interrupts by setting the interrupt mask. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001198 NETDRV_W16_F(IntrMask, netdrv_intr_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
Joe Perches9cd31f02010-02-17 15:01:55 +00001200 netif_start_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201
Joe Perches9cd31f02010-02-17 15:01:55 +00001202 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203}
1204
1205
1206/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001207static void netdrv_init_ring(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208{
Jike Song44911bf2008-01-24 14:51:36 +08001209 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 int i;
1211
Joe Perches9cd31f02010-02-17 15:01:55 +00001212 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
1214 tp->cur_rx = 0;
Joe Perches9cd31f02010-02-17 15:01:55 +00001215 atomic_set(&tp->cur_tx, 0);
1216 atomic_set(&tp->dirty_tx, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
1218 for (i = 0; i < NUM_TX_DESC; i++) {
1219 tp->tx_info[i].skb = NULL;
1220 tp->tx_info[i].mapping = 0;
1221 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1222 }
1223
Joe Perches9cd31f02010-02-17 15:01:55 +00001224 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225}
1226
1227
Joe Perches9cd31f02010-02-17 15:01:55 +00001228static void netdrv_timer(unsigned long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
1230 struct net_device *dev = (struct net_device *) data;
Jike Song44911bf2008-01-24 14:51:36 +08001231 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 void *ioaddr = tp->mmio_addr;
1233 int next_tick = 60 * HZ;
1234 int mii_lpa;
1235
Joe Perches9cd31f02010-02-17 15:01:55 +00001236 mii_lpa = mdio_read(dev, tp->phys[0], MII_LPA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
1238 if (!tp->duplex_lock && mii_lpa != 0xffff) {
Joe Perches8e95a202009-12-03 07:58:21 +00001239 int duplex = ((mii_lpa & LPA_100FULL) ||
Joe Perches9cd31f02010-02-17 15:01:55 +00001240 (mii_lpa & 0x01C0) == 0x0040);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 if (tp->full_duplex != duplex) {
1242 tp->full_duplex = duplex;
Joe Perches9cd31f02010-02-17 15:01:55 +00001243 netdev_info(dev, "Setting %s-duplex based on MII #%d link partner ability of %04x\n",
1244 tp->full_duplex ? "full" : "half",
1245 tp->phys[0], mii_lpa);
1246 NETDRV_W8(Cfg9346, Cfg9346_Unlock);
1247 NETDRV_W8(Config1, tp->full_duplex ? 0x60 : 0x20);
1248 NETDRV_W8(Cfg9346, Cfg9346_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 }
1250 }
1251
Joe Perches9cd31f02010-02-17 15:01:55 +00001252 netdev_dbg(dev, "Media selection tick, Link partner %04x\n",
1253 NETDRV_R16(NWayLPAR));
1254 netdev_dbg(dev, "Other registers are IntMask %04x IntStatus %04x RxStatus %04lx\n",
1255 NETDRV_R16(IntrMask),
1256 NETDRV_R16(IntrStatus),
1257 NETDRV_R32(RxEarlyStatus));
1258 netdev_dbg(dev, "Chip config %02x %02x\n",
1259 NETDRV_R8(Config0), NETDRV_R8(Config1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 tp->timer.expires = jiffies + next_tick;
Joe Perches9cd31f02010-02-17 15:01:55 +00001262 add_timer(&tp->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263}
1264
1265
Joe Perches9cd31f02010-02-17 15:01:55 +00001266static void netdrv_tx_clear(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267{
1268 int i;
Jike Song44911bf2008-01-24 14:51:36 +08001269 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
Joe Perches9cd31f02010-02-17 15:01:55 +00001271 atomic_set(&tp->cur_tx, 0);
1272 atomic_set(&tp->dirty_tx, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274 /* Dump the unsent Tx packets. */
1275 for (i = 0; i < NUM_TX_DESC; i++) {
1276 struct ring_info *rp = &tp->tx_info[i];
1277 if (rp->mapping != 0) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001278 pci_unmap_single(tp->pci_dev, rp->mapping,
1279 rp->skb->len, PCI_DMA_TODEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 rp->mapping = 0;
1281 }
1282 if (rp->skb) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001283 dev_kfree_skb(rp->skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 rp->skb = NULL;
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001285 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
1287 }
1288}
1289
1290
Joe Perches9cd31f02010-02-17 15:01:55 +00001291static void netdrv_tx_timeout(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292{
Jike Song44911bf2008-01-24 14:51:36 +08001293 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 void *ioaddr = tp->mmio_addr;
1295 int i;
1296 u8 tmp8;
1297 unsigned long flags;
1298
Joe Perches9cd31f02010-02-17 15:01:55 +00001299 netdev_dbg(dev, "Transmit timeout, status %02x %04x media %02x\n",
1300 NETDRV_R8(ChipCmd),
1301 NETDRV_R16(IntrStatus),
1302 NETDRV_R8(MediaStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
1304 /* disable Tx ASAP, if not already */
Joe Perches9cd31f02010-02-17 15:01:55 +00001305 tmp8 = NETDRV_R8(ChipCmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 if (tmp8 & CmdTxEnb)
Joe Perches9cd31f02010-02-17 15:01:55 +00001307 NETDRV_W8(ChipCmd, tmp8 & ~CmdTxEnb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 /* Disable interrupts by clearing the interrupt mask. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001310 NETDRV_W16(IntrMask, 0x0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
1312 /* Emit info to figure out what went wrong. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001313 netdev_dbg(dev, "Tx queue start entry %d dirty entry %d\n",
1314 atomic_read(&tp->cur_tx),
1315 atomic_read(&tp->dirty_tx));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 for (i = 0; i < NUM_TX_DESC; i++)
Joe Perches9cd31f02010-02-17 15:01:55 +00001317 netdev_dbg(dev, "Tx descriptor %d is %08lx%s\n",
1318 i, NETDRV_R32(TxStatus0 + (i * 4)),
1319 i == atomic_read(&tp->dirty_tx) % NUM_TX_DESC ?
1320 "(queue head)" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
1322 /* Stop a shared interrupt from scavenging while we are. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001323 spin_lock_irqsave(&tp->lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001324
Joe Perches9cd31f02010-02-17 15:01:55 +00001325 netdrv_tx_clear(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Joe Perches9cd31f02010-02-17 15:01:55 +00001327 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328
1329 /* ...and finally, reset everything */
Joe Perches9cd31f02010-02-17 15:01:55 +00001330 netdrv_hw_start(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
Joe Perches9cd31f02010-02-17 15:01:55 +00001332 netif_wake_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333}
1334
1335
1336
Joe Perches9cd31f02010-02-17 15:01:55 +00001337static int netdrv_start_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338{
Jike Song44911bf2008-01-24 14:51:36 +08001339 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 void *ioaddr = tp->mmio_addr;
1341 int entry;
1342
1343 /* Calculate the next Tx descriptor entry. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001344 entry = atomic_read(&tp->cur_tx) % NUM_TX_DESC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
Joe Perches9cd31f02010-02-17 15:01:55 +00001346 assert(tp->tx_info[entry].skb == NULL);
1347 assert(tp->tx_info[entry].mapping == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
1349 tp->tx_info[entry].skb = skb;
1350 /* tp->tx_info[entry].mapping = 0; */
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -03001351 skb_copy_from_linear_data(skb, tp->tx_buf[entry], skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352
1353 /* Note: the chip doesn't have auto-pad! */
Joe Perches9cd31f02010-02-17 15:01:55 +00001354 NETDRV_W32(TxStatus0 + (entry * sizeof(u32)),
1355 tp->tx_flag | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Joe Perches9cd31f02010-02-17 15:01:55 +00001357 atomic_inc(&tp->cur_tx);
1358 if ((atomic_read(&tp->cur_tx) - atomic_read(&tp->dirty_tx)) >= NUM_TX_DESC)
1359 netif_stop_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
Joe Perches9cd31f02010-02-17 15:01:55 +00001361 netdev_dbg(dev, "Queued Tx packet at %p size %u to slot %d\n",
1362 skb->data, skb->len, entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Patrick McHardy6ed10652009-06-23 06:03:08 +00001364 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365}
1366
1367
Joe Perches9cd31f02010-02-17 15:01:55 +00001368static void netdrv_tx_interrupt(struct net_device *dev,
1369 struct netdrv_private *tp,
1370 void *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371{
1372 int cur_tx, dirty_tx, tx_left;
1373
Joe Perches9cd31f02010-02-17 15:01:55 +00001374 assert(dev != NULL);
1375 assert(tp != NULL);
1376 assert(ioaddr != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377
Joe Perches9cd31f02010-02-17 15:01:55 +00001378 dirty_tx = atomic_read(&tp->dirty_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
Joe Perches9cd31f02010-02-17 15:01:55 +00001380 cur_tx = atomic_read(&tp->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 tx_left = cur_tx - dirty_tx;
1382 while (tx_left > 0) {
1383 int entry = dirty_tx % NUM_TX_DESC;
1384 int txstatus;
1385
Joe Perches9cd31f02010-02-17 15:01:55 +00001386 txstatus = NETDRV_R32(TxStatus0 + (entry * sizeof(u32)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
1388 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1389 break; /* It still hasn't been Txed */
1390
1391 /* Note: TxCarrierLost is always asserted at 100mbps. */
1392 if (txstatus & (TxOutOfWindow | TxAborted)) {
1393 /* There was an major error, log it. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001394 netdev_dbg(dev, "Transmit error, Tx status %#08x\n",
1395 txstatus);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001396 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 if (txstatus & TxAborted) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001398 dev->stats.tx_aborted_errors++;
Joe Perches9cd31f02010-02-17 15:01:55 +00001399 NETDRV_W32(TxConfig, TxClearAbt | (TX_DMA_BURST << TxDMAShift));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 }
1401 if (txstatus & TxCarrierLost)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001402 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 if (txstatus & TxOutOfWindow)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001404 dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 } else {
1406 if (txstatus & TxUnderrun) {
1407 /* Add 64 to the Tx FIFO threshold. */
1408 if (tp->tx_flag < 0x00300000)
1409 tp->tx_flag += 0x00020000;
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001410 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 }
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001412 dev->stats.collisions += (txstatus >> 24) & 15;
1413 dev->stats.tx_bytes += txstatus & 0x7ff;
1414 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 }
1416
1417 /* Free the original skb. */
1418 if (tp->tx_info[entry].mapping != 0) {
1419 pci_unmap_single(tp->pci_dev,
1420 tp->tx_info[entry].mapping,
1421 tp->tx_info[entry].skb->len,
1422 PCI_DMA_TODEVICE);
1423 tp->tx_info[entry].mapping = 0;
1424 }
Joe Perches9cd31f02010-02-17 15:01:55 +00001425 dev_kfree_skb_irq(tp->tx_info[entry].skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 tp->tx_info[entry].skb = NULL;
1427 dirty_tx++;
1428 if (dirty_tx < 0) { /* handle signed int overflow */
Joe Perches9cd31f02010-02-17 15:01:55 +00001429 atomic_sub(cur_tx, &tp->cur_tx); /* XXX racy? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 dirty_tx = cur_tx - tx_left + 1;
1431 }
Joe Perches9cd31f02010-02-17 15:01:55 +00001432 if (netif_queue_stopped(dev))
1433 netif_wake_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Joe Perches9cd31f02010-02-17 15:01:55 +00001435 cur_tx = atomic_read(&tp->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 tx_left = cur_tx - dirty_tx;
1437
1438 }
1439
1440#ifndef NETDRV_NDEBUG
Joe Perches9cd31f02010-02-17 15:01:55 +00001441 if (atomic_read(&tp->cur_tx) - dirty_tx > NUM_TX_DESC) {
1442 netdev_err(dev, "Out-of-sync dirty pointer, %d vs. %d\n",
1443 dirty_tx, atomic_read(&tp->cur_tx));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 dirty_tx += NUM_TX_DESC;
1445 }
1446#endif /* NETDRV_NDEBUG */
1447
Joe Perches9cd31f02010-02-17 15:01:55 +00001448 atomic_set(&tp->dirty_tx, dirty_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449}
1450
1451
1452/* TODO: clean this up! Rx reset need not be this intensive */
Joe Perches9cd31f02010-02-17 15:01:55 +00001453static void netdrv_rx_err(u32 rx_status, struct net_device *dev,
1454 struct netdrv_private *tp, void *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455{
1456 u8 tmp8;
1457 int tmp_work = 1000;
1458
Joe Perches9cd31f02010-02-17 15:01:55 +00001459 netdev_dbg(dev, "Ethernet frame had errors, status %08x\n", rx_status);
1460 if (rx_status & RxTooLong)
1461 netdev_dbg(dev, "Oversized Ethernet frame, status %04x!\n",
1462 rx_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 /* A.C.: The chip hangs here. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001464 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 if (rx_status & (RxBadSymbol | RxBadAlign))
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001466 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 if (rx_status & (RxRunt | RxTooLong))
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001468 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 if (rx_status & RxCRCErr)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001470 dev->stats.rx_crc_errors++;
Joe Perches9cd31f02010-02-17 15:01:55 +00001471 /* Reset the receiver, based on RealTek recommendation.(Bug?) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 tp->cur_rx = 0;
1473
1474 /* disable receive */
Joe Perches9cd31f02010-02-17 15:01:55 +00001475 tmp8 = NETDRV_R8(ChipCmd) & ChipCmdClear;
1476 NETDRV_W8_F(ChipCmd, tmp8 | CmdTxEnb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
1478 /* A.C.: Reset the multicast list. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001479 netdrv_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
1481 /* XXX potentially temporary hack to
1482 * restart hung receiver */
1483 while (--tmp_work > 0) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001484 tmp8 = NETDRV_R8(ChipCmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1486 break;
Joe Perches9cd31f02010-02-17 15:01:55 +00001487 NETDRV_W8_F(ChipCmd,
1488 (tmp8 & ChipCmdClear) | CmdRxEnb | CmdTxEnb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 }
1490
1491 /* G.S.: Re-enable receiver */
1492 /* XXX temporary hack to work around receiver hang */
Joe Perches9cd31f02010-02-17 15:01:55 +00001493 netdrv_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
1495 if (tmp_work <= 0)
Joe Perches9cd31f02010-02-17 15:01:55 +00001496 netdev_warn(dev, "tx/rx enable wait too long\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497}
1498
1499
1500/* The data sheet doesn't describe the Rx ring at all, so I'm guessing at the
1501 field alignments and semantics. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001502static void netdrv_rx_interrupt(struct net_device *dev,
1503 struct netdrv_private *tp, void *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
1505 unsigned char *rx_ring;
1506 u16 cur_rx;
1507
Joe Perches9cd31f02010-02-17 15:01:55 +00001508 assert(dev != NULL);
1509 assert(tp != NULL);
1510 assert(ioaddr != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511
1512 rx_ring = tp->rx_ring;
1513 cur_rx = tp->cur_rx;
1514
Joe Perches9cd31f02010-02-17 15:01:55 +00001515 netdev_dbg(dev, "In netdrv_rx(), current %04x BufAddr %04x, free to %04x, Cmd %02x\n",
1516 cur_rx, NETDRV_R16(RxBufAddr),
1517 NETDRV_R16(RxBufPtr), NETDRV_R8(ChipCmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
Joe Perches9cd31f02010-02-17 15:01:55 +00001519 while ((NETDRV_R8(ChipCmd) & RxBufEmpty) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 int ring_offset = cur_rx % RX_BUF_LEN;
1521 u32 rx_status;
1522 unsigned int rx_size;
1523 unsigned int pkt_size;
1524 struct sk_buff *skb;
1525
1526 /* read size+status of next frame from DMA ring buffer */
Joe Perches9cd31f02010-02-17 15:01:55 +00001527 rx_status = le32_to_cpu(*(u32 *)(rx_ring + ring_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 rx_size = rx_status >> 16;
1529 pkt_size = rx_size - 4;
1530
Joe Perches9cd31f02010-02-17 15:01:55 +00001531 netdev_dbg(dev, "netdrv_rx() status %04x, size %04x, cur %04x\n",
1532 rx_status, rx_size, cur_rx);
Jike Song44911bf2008-01-24 14:51:36 +08001533#if defined(NETDRV_DEBUG) && (NETDRV_DEBUG > 2)
Joe Perches9cd31f02010-02-17 15:01:55 +00001534 print_hex_dump_bytes("Frame contents: ", HEX_DUMP_OFFSET,
1535 &rx_ring[ring_offset], 70);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536#endif
1537
1538 /* If Rx err or invalid rx_size/rx_status received
Joe Perches9cd31f02010-02-17 15:01:55 +00001539 *(which happens if we get lost in the ring),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 * Rx process gets reset, so we abort any further
1541 * Rx processing.
1542 */
1543 if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1544 (!(rx_status & RxStatusOK))) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001545 netdrv_rx_err(rx_status, dev, tp, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 return;
1547 }
1548
1549 /* Malloc up new buffer, compatible with net-2e. */
1550 /* Omit the four octet CRC from the length. */
1551
1552 /* TODO: consider allocating skb's outside of
1553 * interrupt context, both to speed interrupt processing,
1554 * and also to reduce the chances of having to
1555 * drop packets here under memory pressure.
1556 */
1557
Joe Perches9cd31f02010-02-17 15:01:55 +00001558 skb = dev_alloc_skb(pkt_size + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 if (skb) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001560 skb_reserve(skb, 2); /* 16 byte align the IP fields. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Joe Perches9cd31f02010-02-17 15:01:55 +00001562 skb_copy_to_linear_data(skb, &rx_ring[ring_offset + 4], pkt_size);
1563 skb_put(skb, pkt_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
Joe Perches9cd31f02010-02-17 15:01:55 +00001565 skb->protocol = eth_type_trans(skb, dev);
1566 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001567 dev->stats.rx_bytes += pkt_size;
1568 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 } else {
Joe Perches9cd31f02010-02-17 15:01:55 +00001570 netdev_warn(dev, "Memory squeeze, dropping packet\n");
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001571 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 }
1573
1574 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
Joe Perches9cd31f02010-02-17 15:01:55 +00001575 NETDRV_W16_F(RxBufPtr, cur_rx - 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 }
1577
Joe Perches9cd31f02010-02-17 15:01:55 +00001578 netdev_dbg(dev, "Done netdrv_rx(), current %04x BufAddr %04x, free to %04x, Cmd %02x\n",
1579 cur_rx, NETDRV_R16(RxBufAddr),
1580 NETDRV_R16(RxBufPtr), NETDRV_R8(ChipCmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
1582 tp->cur_rx = cur_rx;
1583}
1584
1585
Joe Perches9cd31f02010-02-17 15:01:55 +00001586static void netdrv_weird_interrupt(struct net_device *dev,
1587 struct netdrv_private *tp,
1588 void *ioaddr,
1589 int status, int link_changed)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590{
Joe Perches9cd31f02010-02-17 15:01:55 +00001591 netdev_printk(KERN_DEBUG, dev, "Abnormal interrupt, status %08x\n",
1592 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Joe Perches9cd31f02010-02-17 15:01:55 +00001594 assert(dev != NULL);
1595 assert(tp != NULL);
1596 assert(ioaddr != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
1598 /* Update the error count. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001599 dev->stats.rx_missed_errors += NETDRV_R32(RxMissed);
1600 NETDRV_W32(RxMissed, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
1602 if ((status & RxUnderrun) && link_changed &&
1603 (tp->drv_flags & HAS_LNK_CHNG)) {
1604 /* Really link-change on new chips. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001605 int lpar = NETDRV_R16(NWayLPAR);
Joe Perches8e95a202009-12-03 07:58:21 +00001606 int duplex = ((lpar & 0x0100) || (lpar & 0x01C0) == 0x0040 ||
Joe Perches9cd31f02010-02-17 15:01:55 +00001607 tp->duplex_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 if (tp->full_duplex != duplex) {
1609 tp->full_duplex = duplex;
Joe Perches9cd31f02010-02-17 15:01:55 +00001610 NETDRV_W8(Cfg9346, Cfg9346_Unlock);
1611 NETDRV_W8(Config1, tp->full_duplex ? 0x60 : 0x20);
1612 NETDRV_W8(Cfg9346, Cfg9346_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 }
1614 status &= ~RxUnderrun;
1615 }
1616
1617 /* XXX along with netdrv_rx_err, are we double-counting errors? */
Joe Perches9cd31f02010-02-17 15:01:55 +00001618 if (status & (RxUnderrun | RxOverflow | RxErr | RxFIFOOver))
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001619 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
1621 if (status & (PCSTimeout))
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001622 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 if (status & (RxUnderrun | RxFIFOOver))
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001624 dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 if (status & RxOverflow) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001626 dev->stats.rx_over_errors++;
Joe Perches9cd31f02010-02-17 15:01:55 +00001627 tp->cur_rx = NETDRV_R16(RxBufAddr) % RX_BUF_LEN;
1628 NETDRV_W16_F(RxBufPtr, tp->cur_rx - 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 }
1630 if (status & PCIErr) {
1631 u16 pci_cmd_status;
Joe Perches9cd31f02010-02-17 15:01:55 +00001632 pci_read_config_word(tp->pci_dev, PCI_STATUS, &pci_cmd_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
Joe Perches9cd31f02010-02-17 15:01:55 +00001634 netdev_err(dev, "PCI Bus error %04x\n", pci_cmd_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 }
1636}
1637
1638
1639/* The interrupt handler does all of the Rx thread work and cleans up
1640 after the Tx thread. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001641static irqreturn_t netdrv_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642{
1643 struct net_device *dev = (struct net_device *) dev_instance;
Jike Song44911bf2008-01-24 14:51:36 +08001644 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 int boguscnt = max_interrupt_work;
1646 void *ioaddr = tp->mmio_addr;
1647 int status = 0, link_changed = 0; /* avoid bogus "uninit" warning */
1648 int handled = 0;
1649
Joe Perches9cd31f02010-02-17 15:01:55 +00001650 spin_lock(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
1652 do {
Joe Perches9cd31f02010-02-17 15:01:55 +00001653 status = NETDRV_R16(IntrStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
Joe Perches9cd31f02010-02-17 15:01:55 +00001655 /* h/w no longer present(hotplug?) or major error, bail */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 if (status == 0xFFFF)
1657 break;
1658
1659 handled = 1;
1660 /* Acknowledge all of the current interrupt sources ASAP */
Joe Perches9cd31f02010-02-17 15:01:55 +00001661 NETDRV_W16_F(IntrStatus, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Joe Perches9cd31f02010-02-17 15:01:55 +00001663 netdev_dbg(dev, "interrupt status=%#04x new intstat=%#04x\n",
1664 status, NETDRV_R16(IntrStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 if ((status &
1667 (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1668 RxFIFOOver | TxErr | TxOK | RxErr | RxOK)) == 0)
1669 break;
1670
1671 /* Check uncommon events with one test. */
1672 if (status & (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
Joe Perches9cd31f02010-02-17 15:01:55 +00001673 RxFIFOOver | TxErr | RxErr))
1674 netdrv_weird_interrupt(dev, tp, ioaddr,
1675 status, link_changed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676
1677 if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver)) /* Rx interrupt */
Joe Perches9cd31f02010-02-17 15:01:55 +00001678 netdrv_rx_interrupt(dev, tp, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
1680 if (status & (TxOK | TxErr))
Joe Perches9cd31f02010-02-17 15:01:55 +00001681 netdrv_tx_interrupt(dev, tp, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682
1683 boguscnt--;
1684 } while (boguscnt > 0);
1685
1686 if (boguscnt <= 0) {
Joe Perches9cd31f02010-02-17 15:01:55 +00001687 netdev_warn(dev, "Too much work at interrupt, IntrStatus=%#04x\n",
1688 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689
1690 /* Clear all interrupt sources. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001691 NETDRV_W16(IntrStatus, 0xffff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 }
1693
Joe Perches9cd31f02010-02-17 15:01:55 +00001694 spin_unlock(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
Joe Perches9cd31f02010-02-17 15:01:55 +00001696 netdev_dbg(dev, "exiting interrupt, intr_status=%#04x\n",
1697 NETDRV_R16(IntrStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 return IRQ_RETVAL(handled);
1699}
1700
1701
Joe Perches9cd31f02010-02-17 15:01:55 +00001702static int netdrv_close(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703{
Jike Song44911bf2008-01-24 14:51:36 +08001704 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 void *ioaddr = tp->mmio_addr;
1706 unsigned long flags;
1707
Joe Perches9cd31f02010-02-17 15:01:55 +00001708 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
Joe Perches9cd31f02010-02-17 15:01:55 +00001710 netif_stop_queue(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711
Joe Perches9cd31f02010-02-17 15:01:55 +00001712 netdev_dbg(dev, "Shutting down ethercard, status was %#04x\n",
1713 NETDRV_R16(IntrStatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
Joe Perches9cd31f02010-02-17 15:01:55 +00001715 del_timer_sync(&tp->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
Joe Perches9cd31f02010-02-17 15:01:55 +00001717 spin_lock_irqsave(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
1719 /* Stop the chip's Tx and Rx DMA processes. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001720 NETDRV_W8(ChipCmd, (NETDRV_R8(ChipCmd) & ChipCmdClear));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721
1722 /* Disable interrupts by clearing the interrupt mask. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001723 NETDRV_W16(IntrMask, 0x0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
1725 /* Update the error counts. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001726 dev->stats.rx_missed_errors += NETDRV_R32(RxMissed);
1727 NETDRV_W32(RxMissed, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
Joe Perches9cd31f02010-02-17 15:01:55 +00001729 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730
Joe Perches9cd31f02010-02-17 15:01:55 +00001731 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
Joe Perches9cd31f02010-02-17 15:01:55 +00001733 netdrv_tx_clear(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
1735 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1736 tp->rx_ring, tp->rx_ring_dma);
1737 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1738 tp->tx_bufs, tp->tx_bufs_dma);
1739 tp->rx_ring = NULL;
1740 tp->tx_bufs = NULL;
1741
1742 /* Green! Put the chip in low-power mode. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001743 NETDRV_W8(Cfg9346, Cfg9346_Unlock);
1744 NETDRV_W8(Config1, 0x03);
1745 NETDRV_W8(Cfg9346, Cfg9346_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
Joe Perches9cd31f02010-02-17 15:01:55 +00001747 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 return 0;
1749}
1750
1751
Joe Perches9cd31f02010-02-17 15:01:55 +00001752static int netdrv_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753{
Jike Song44911bf2008-01-24 14:51:36 +08001754 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 struct mii_ioctl_data *data = if_mii(rq);
1756 unsigned long flags;
1757 int rc = 0;
1758
Joe Perches9cd31f02010-02-17 15:01:55 +00001759 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
1761 switch (cmd) {
1762 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
1763 data->phy_id = tp->phys[0] & 0x3f;
1764 /* Fall Through */
1765
1766 case SIOCGMIIREG: /* Read MII PHY register. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001767 spin_lock_irqsave(&tp->lock, flags);
1768 data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1769 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 break;
1771
1772 case SIOCSMIIREG: /* Write MII PHY register. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001773 spin_lock_irqsave(&tp->lock, flags);
1774 mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1775 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 break;
1777
1778 default:
1779 rc = -EOPNOTSUPP;
1780 break;
1781 }
1782
Joe Perches9cd31f02010-02-17 15:01:55 +00001783 DPRINTK("EXIT, returning %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 return rc;
1785}
1786
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787/* Set or clear the multicast filter for this adaptor.
1788 This routine is not state sensitive and need not be SMP locked. */
1789
Joe Perches9cd31f02010-02-17 15:01:55 +00001790static void netdrv_set_rx_mode(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791{
Jike Song44911bf2008-01-24 14:51:36 +08001792 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 void *ioaddr = tp->mmio_addr;
1794 u32 mc_filter[2]; /* Multicast hash filter */
Jiri Pirkof9dcbcc2010-02-23 09:19:49 +00001795 int rx_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 u32 tmp;
1797
Joe Perches9cd31f02010-02-17 15:01:55 +00001798 DPRINTK("ENTER\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
Joe Perches9cd31f02010-02-17 15:01:55 +00001800 netdev_dbg(dev, "%s(%04x) done -- Rx config %08lx\n",
1801 __func__, dev->flags, NETDRV_R32(RxConfig));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
1803 /* Note: do not reorder, GCC is clever about common statements. */
1804 if (dev->flags & IFF_PROMISC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 rx_mode =
Joe Perches9cd31f02010-02-17 15:01:55 +00001806 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
1807 AcceptAllPhys;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 mc_filter[1] = mc_filter[0] = 0xffffffff;
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001809 } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
Joe Perches8e95a202009-12-03 07:58:21 +00001810 (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 /* Too many to filter perfectly -- accept all multicasts. */
1812 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1813 mc_filter[1] = mc_filter[0] = 0xffffffff;
1814 } else {
Jiri Pirko22bedad32010-04-01 21:22:57 +00001815 struct netdev_hw_addr *ha;
Jiri Pirkof9dcbcc2010-02-23 09:19:49 +00001816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1818 mc_filter[1] = mc_filter[0] = 0;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001819 netdev_for_each_mc_addr(ha, dev) {
1820 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821
1822 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1823 }
1824 }
1825
1826 /* if called from irq handler, lock already acquired */
Joe Perches9cd31f02010-02-17 15:01:55 +00001827 if (!in_irq())
1828 spin_lock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829
1830 /* We can safely update without stopping the chip. */
1831 tmp = netdrv_rx_config | rx_mode |
Joe Perches9cd31f02010-02-17 15:01:55 +00001832 (NETDRV_R32(RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1833 NETDRV_W32_F(RxConfig, tmp);
1834 NETDRV_W32_F(MAR0 + 0, mc_filter[0]);
1835 NETDRV_W32_F(MAR0 + 4, mc_filter[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836
Joe Perches9cd31f02010-02-17 15:01:55 +00001837 if (!in_irq())
1838 spin_unlock_irq(&tp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839
Joe Perches9cd31f02010-02-17 15:01:55 +00001840 DPRINTK("EXIT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841}
1842
1843
1844#ifdef CONFIG_PM
1845
Joe Perches9cd31f02010-02-17 15:01:55 +00001846static int netdrv_suspend(struct pci_dev *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847{
Joe Perches9cd31f02010-02-17 15:01:55 +00001848 struct net_device *dev = pci_get_drvdata(pdev);
Jike Song44911bf2008-01-24 14:51:36 +08001849 struct netdrv_private *tp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 void *ioaddr = tp->mmio_addr;
1851 unsigned long flags;
1852
1853 if (!netif_running(dev))
1854 return 0;
Joe Perches9cd31f02010-02-17 15:01:55 +00001855 netif_device_detach(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
Joe Perches9cd31f02010-02-17 15:01:55 +00001857 spin_lock_irqsave(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858
1859 /* Disable interrupts, stop Tx and Rx. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001860 NETDRV_W16(IntrMask, 0x0000);
1861 NETDRV_W8(ChipCmd, (NETDRV_R8(ChipCmd) & ChipCmdClear));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862
1863 /* Update the error counts. */
Joe Perches9cd31f02010-02-17 15:01:55 +00001864 dev->stats.rx_missed_errors += NETDRV_R32(RxMissed);
1865 NETDRV_W32(RxMissed, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
Joe Perches9cd31f02010-02-17 15:01:55 +00001867 spin_unlock_irqrestore(&tp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
Joe Perches9cd31f02010-02-17 15:01:55 +00001869 pci_save_state(pdev);
1870 pci_set_power_state(pdev, PCI_D3hot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
1872 return 0;
1873}
1874
1875
Joe Perches9cd31f02010-02-17 15:01:55 +00001876static int netdrv_resume(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877{
Joe Perches9cd31f02010-02-17 15:01:55 +00001878 struct net_device *dev = pci_get_drvdata(pdev);
Jike Song44911bf2008-01-24 14:51:36 +08001879 /*struct netdrv_private *tp = netdev_priv(dev);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
1881 if (!netif_running(dev))
1882 return 0;
Joe Perches9cd31f02010-02-17 15:01:55 +00001883 pci_set_power_state(pdev, PCI_D0);
1884 pci_restore_state(pdev);
1885 netif_device_attach(dev);
1886 netdrv_hw_start(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
1888 return 0;
1889}
1890
1891#endif /* CONFIG_PM */
1892
1893
1894static struct pci_driver netdrv_pci_driver = {
1895 .name = MODNAME,
1896 .id_table = netdrv_pci_tbl,
1897 .probe = netdrv_init_one,
1898 .remove = __devexit_p(netdrv_remove_one),
1899#ifdef CONFIG_PM
1900 .suspend = netdrv_suspend,
1901 .resume = netdrv_resume,
1902#endif /* CONFIG_PM */
1903};
1904
1905
Joe Perches9cd31f02010-02-17 15:01:55 +00001906static int __init netdrv_init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
1908/* when a module, this is printed whether or not devices are found in probe */
1909#ifdef MODULE
1910 printk(version);
1911#endif
Jeff Garzik29917622006-08-19 17:48:59 -04001912 return pci_register_driver(&netdrv_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913}
1914
1915
Joe Perches9cd31f02010-02-17 15:01:55 +00001916static void __exit netdrv_cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917{
Joe Perches9cd31f02010-02-17 15:01:55 +00001918 pci_unregister_driver(&netdrv_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919}
1920
1921
1922module_init(netdrv_init_module);
1923module_exit(netdrv_cleanup_module);