?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / net / pci-skeleton.c
blobfffc49befe042c7b514745d688cfd5817a44a9dc
1 /*
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
14 Written 1997-2000 by Donald Becker.
15 This software may be used and distributed according to the
16 terms of the GNU General Public License (GPL), incorporated
17 herein by reference. Drivers based on or derived from this
18 code fall under the GPL and must retain the authorship,
19 copyright and license notice. This file is not a complete
20 program and may only be used when the entire operating
21 system is licensed under the GPL.
22
23 This driver is for boards based on the RTL8129 and RTL8139
24 PCI ethernet chips.
25
26 The author may be reached as becker@scyld.com, or C/O Scyld
27 Computing Corporation 410 Severn Ave., Suite 210 Annapolis
28 MD 21403
29
30 Support and updates available at
31 http://www.scyld.com/network/rtl8139.html
32
33 Twister-tuning table provided by Kinston
34 <shangh@realtek.com.tw>.
35
36 -----<snip>-----
37
38 This software may be used and distributed according to the terms
39 of the GNU General Public License, incorporated herein by reference.
40
41
42 -----------------------------------------------------------------------------
43
44 Theory of Operation
45
46 I. Board Compatibility
47
48 This device driver is designed for the RealTek RTL8139 series, the RealTek
49 Fast Ethernet controllers for PCI and CardBus. This chip is used on many
50 low-end boards, sometimes with its markings changed.
51
52
53 II. Board-specific settings
54
55 PCI bus devices are configured by the system at boot time, so no jumpers
56 need to be set on the board. The system BIOS will assign the
57 PCI INTA signal to a (preferably otherwise unused) system IRQ line.
58
59 III. Driver operation
60
61 IIIa. Rx Ring buffers
62
63 The receive unit uses a single linear ring buffer rather than the more
64 common (and more efficient) descriptor-based architecture. Incoming frames
65 are sequentially stored into the Rx region, and the host copies them into
66 skbuffs.
67
68 Comment: While it is theoretically possible to process many frames in place,
69 any delay in Rx processing would cause us to drop frames. More importantly,
70 the Linux protocol stack is not designed to operate in this manner.
71
72 IIIb. Tx operation
73
74 The RTL8139 uses a fixed set of four Tx descriptors in register space.
75 In a stunningly bad design choice, Tx frames must be 32 bit aligned. Linux
76 aligns the IP header on word boundaries, and 14 byte ethernet header means
77 that almost all frames will need to be copied to an alignment buffer.
78
79 IVb. References
80
81 http://www.realtek.com.tw/cn/cn.html
82 http://www.scyld.com/expert/NWay.html
83
84 IVc. Errata
85
86 */
87
88 #include <linux/module.h>
89 #include <linux/kernel.h>
90 #include <linux/pci.h>
91 #include <linux/init.h>
92 #include <linux/ioport.h>
93 #include <linux/netdevice.h>
94 #include <linux/etherdevice.h>
95 #include <linux/delay.h>
96 #include <linux/ethtool.h>
97 #include <linux/mii.h>
98 #include <linux/crc32.h>
99 #include <asm/io.h>
100
101 #define NETDRV_VERSION "1.0.1"
102 #define MODNAME "netdrv"
103 #define NETDRV_DRIVER_LOAD_MSG "MyVendor Fast Ethernet driver " NETDRV_VERSION " loaded"
104 #define PFX MODNAME ": "
105
106 static char version[] __devinitdata =
107 KERN_INFO NETDRV_DRIVER_LOAD_MSG "\n"
108 KERN_INFO " Support available from http://foo.com/bar/baz.html\n";
109
110 /* define to 1 to enable PIO instead of MMIO */
111 #undef USE_IO_OPS
112
113 /* define to 1 to enable copious debugging info */
114 #undef NETDRV_DEBUG
115
116 /* define to 1 to disable lightweight runtime debugging checks */
117 #undef NETDRV_NDEBUG
118
119
120 #ifdef NETDRV_DEBUG
121 /* note: prints function name for you */
122 # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
123 #else
124 # define DPRINTK(fmt, args...)
125 #endif
126
127 #ifdef NETDRV_NDEBUG
128 # define assert(expr) do {} while (0)
129 #else
130 # define assert(expr) \
131 if(!(expr)) { \
132 printk( "Assertion failed! %s,%s,%s,line=%d\n", \
133 #expr,__FILE__,__FUNCTION__,__LINE__); \
134 }
135 #endif
136
137
138 /* A few user-configurable values. */
139 /* media options */
140 static int media[] = {-1, -1, -1, -1, -1, -1, -1, -1};
141
142 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
143 static int max_interrupt_work = 20;
144
145 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
146 The RTL chips use a 64 element hash table based on the Ethernet CRC. */
147 static int multicast_filter_limit = 32;
148
149 /* Size of the in-memory receive ring. */
150 #define RX_BUF_LEN_IDX 2 /* 0==8K, 1==16K, 2==32K, 3==64K */
151 #define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
152 #define RX_BUF_PAD 16
153 #define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
154 #define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
155
156 /* Number of Tx descriptor registers. */
157 #define NUM_TX_DESC 4
158
159 /* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
160 #define MAX_ETH_FRAME_SIZE 1536
161
162 /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
163 #define TX_BUF_SIZE MAX_ETH_FRAME_SIZE
164 #define TX_BUF_TOT_LEN (TX_BUF_SIZE * NUM_TX_DESC)
165
166 /* PCI Tuning Parameters
167 Threshold is bytes transferred to chip before transmission starts. */
168 #define TX_FIFO_THRESH 256 /* In bytes, rounded down to 32 byte units. */
169
170 /* The following settings are log_2(bytes)-4: 0 == 16 bytes .. 6==1024, 7==end of packet. */
171 #define RX_FIFO_THRESH 6 /* Rx buffer level before first PCI xfer. */
172 #define RX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
173 #define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
174
175
176 /* Operational parameters that usually are not changed. */
177 /* Time in jiffies before concluding the transmitter is hung. */
178 #define TX_TIMEOUT (6*HZ)
179
180
181 enum {
182 HAS_CHIP_XCVR = 0x020000,
183 HAS_LNK_CHNG = 0x040000,
184 };
185
186 #define NETDRV_MIN_IO_SIZE 0x80
187 #define RTL8139B_IO_SIZE 256
188
189 #define NETDRV_CAPS HAS_CHIP_XCVR|HAS_LNK_CHNG
190
191 typedef enum {
192 RTL8139 = 0,
193 NETDRV_CB,
194 SMC1211TX,
195 /*MPX5030,*/
196 DELTA8139,
197 ADDTRON8139,
198 } board_t;
199
200
201 /* indexed by board_t, above */
202 static struct {
203 const char *name;
204 } board_info[] __devinitdata = {
205 { "RealTek RTL8139 Fast Ethernet" },
206 { "RealTek RTL8139B PCI/CardBus" },
207 { "SMC1211TX EZCard 10/100 (RealTek RTL8139)" },
208 /* { MPX5030, "Accton MPX5030 (RealTek RTL8139)" },*/
209 { "Delta Electronics 8139 10/100BaseTX" },
210 { "Addtron Technolgy 8139 10/100BaseTX" },
211 };
212
213
214 static struct pci_device_id netdrv_pci_tbl[] = {
215 {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
216 {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, NETDRV_CB },
217 {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMC1211TX },
218 /* {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MPX5030 },*/
219 {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DELTA8139 },
220 {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ADDTRON8139 },
221 {0,}
222 };
223 MODULE_DEVICE_TABLE (pci, netdrv_pci_tbl);
224
225
226 /* The rest of these values should never change. */
227
228 /* Symbolic offsets to registers. */
229 enum NETDRV_registers {
230 MAC0 = 0, /* Ethernet hardware address. */
231 MAR0 = 8, /* Multicast filter. */
232 TxStatus0 = 0x10, /* Transmit status (Four 32bit registers). */
233 TxAddr0 = 0x20, /* Tx descriptors (also four 32bit). */
234 RxBuf = 0x30,
235 RxEarlyCnt = 0x34,
236 RxEarlyStatus = 0x36,
237 ChipCmd = 0x37,
238 RxBufPtr = 0x38,
239 RxBufAddr = 0x3A,
240 IntrMask = 0x3C,
241 IntrStatus = 0x3E,
242 TxConfig = 0x40,
243 ChipVersion = 0x43,
244 RxConfig = 0x44,
245 Timer = 0x48, /* A general-purpose counter. */
246 RxMissed = 0x4C, /* 24 bits valid, write clears. */
247 Cfg9346 = 0x50,
248 Config0 = 0x51,
249 Config1 = 0x52,
250 FlashReg = 0x54,
251 MediaStatus = 0x58,
252 Config3 = 0x59,
253 Config4 = 0x5A, /* absent on RTL-8139A */
254 HltClk = 0x5B,
255 MultiIntr = 0x5C,
256 TxSummary = 0x60,
257 BasicModeCtrl = 0x62,
258 BasicModeStatus = 0x64,
259 NWayAdvert = 0x66,
260 NWayLPAR = 0x68,
261 NWayExpansion = 0x6A,
262 /* Undocumented registers, but required for proper operation. */
263 FIFOTMS = 0x70, /* FIFO Control and test. */
264 CSCR = 0x74, /* Chip Status and Configuration Register. */
265 PARA78 = 0x78,
266 PARA7c = 0x7c, /* Magic transceiver parameter register. */
267 Config5 = 0xD8, /* absent on RTL-8139A */
268 };
269
270 enum ClearBitMasks {
271 MultiIntrClear = 0xF000,
272 ChipCmdClear = 0xE2,
273 Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
274 };
275
276 enum ChipCmdBits {
277 CmdReset = 0x10,
278 CmdRxEnb = 0x08,
279 CmdTxEnb = 0x04,
280 RxBufEmpty = 0x01,
281 };
282
283 /* Interrupt register bits, using my own meaningful names. */
284 enum IntrStatusBits {
285 PCIErr = 0x8000,
286 PCSTimeout = 0x4000,
287 RxFIFOOver = 0x40,
288 RxUnderrun = 0x20,
289 RxOverflow = 0x10,
290 TxErr = 0x08,
291 TxOK = 0x04,
292 RxErr = 0x02,
293 RxOK = 0x01,
294 };
295 enum TxStatusBits {
296 TxHostOwns = 0x2000,
297 TxUnderrun = 0x4000,
298 TxStatOK = 0x8000,
299 TxOutOfWindow = 0x20000000,
300 TxAborted = 0x40000000,
301 TxCarrierLost = 0x80000000,
302 };
303 enum RxStatusBits {
304 RxMulticast = 0x8000,
305 RxPhysical = 0x4000,
306 RxBroadcast = 0x2000,
307 RxBadSymbol = 0x0020,
308 RxRunt = 0x0010,
309 RxTooLong = 0x0008,
310 RxCRCErr = 0x0004,
311 RxBadAlign = 0x0002,
312 RxStatusOK = 0x0001,
313 };
314
315 /* Bits in RxConfig. */
316 enum rx_mode_bits {
317 AcceptErr = 0x20,
318 AcceptRunt = 0x10,
319 AcceptBroadcast = 0x08,
320 AcceptMulticast = 0x04,
321 AcceptMyPhys = 0x02,
322 AcceptAllPhys = 0x01,
323 };
324
325 /* Bits in TxConfig. */
326 enum tx_config_bits {
327 TxIFG1 = (1 << 25), /* Interframe Gap Time */
328 TxIFG0 = (1 << 24), /* Enabling these bits violates IEEE 802.3 */
329 TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
330 TxCRC = (1 << 16), /* DISABLE appending CRC to end of Tx packets */
331 TxClearAbt = (1 << 0), /* Clear abort (WO) */
332 TxDMAShift = 8, /* DMA burst value (0-7) is shift this many bits */
333
334 TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
335 };
336
337 /* Bits in Config1 */
338 enum Config1Bits {
339 Cfg1_PM_Enable = 0x01,
340 Cfg1_VPD_Enable = 0x02,
341 Cfg1_PIO = 0x04,
342 Cfg1_MMIO = 0x08,
343 Cfg1_LWAKE = 0x10,
344 Cfg1_Driver_Load = 0x20,
345 Cfg1_LED0 = 0x40,
346 Cfg1_LED1 = 0x80,
347 };
348
349 enum RxConfigBits {
350 /* Early Rx threshold, none or X/16 */
351 RxCfgEarlyRxNone = 0,
352 RxCfgEarlyRxShift = 24,
353
354 /* rx fifo threshold */
355 RxCfgFIFOShift = 13,
356 RxCfgFIFONone = (7 << RxCfgFIFOShift),
357
358 /* Max DMA burst */
359 RxCfgDMAShift = 8,
360 RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
361
362 /* rx ring buffer length */
363 RxCfgRcv8K = 0,
364 RxCfgRcv16K = (1 << 11),
365 RxCfgRcv32K = (1 << 12),
366 RxCfgRcv64K = (1 << 11) | (1 << 12),
367
368 /* Disable packet wrap at end of Rx buffer */
369 RxNoWrap = (1 << 7),
370 };
371
372
373 /* Twister tuning parameters from RealTek.
374 Completely undocumented, but required to tune bad links. */
375 enum CSCRBits {
376 CSCR_LinkOKBit = 0x0400,
377 CSCR_LinkChangeBit = 0x0800,
378 CSCR_LinkStatusBits = 0x0f000,
379 CSCR_LinkDownOffCmd = 0x003c0,
380 CSCR_LinkDownCmd = 0x0f3c0,
381 };
382
383
384 enum Cfg9346Bits {
385 Cfg9346_Lock = 0x00,
386 Cfg9346_Unlock = 0xC0,
387 };
388
389
390 #define PARA78_default 0x78fa8388
391 #define PARA7c_default 0xcb38de43 /* param[0][3] */
392 #define PARA7c_xxx 0xcb38de43
393 static const unsigned long param[4][4] = {
394 {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
395 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
396 {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
397 {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
398 };
399
400 struct ring_info {
401 struct sk_buff *skb;
402 dma_addr_t mapping;
403 };
404
405
406 typedef enum {
407 CH_8139 = 0,
408 CH_8139_K,
409 CH_8139A,
410 CH_8139B,
411 CH_8130,
412 CH_8139C,
413 } chip_t;
414
415
416 /* directly indexed by chip_t, above */
417 static const struct {
418 const char *name;
419 u8 version; /* from RTL8139C docs */
420 u32 RxConfigMask; /* should clear the bits supported by this chip */
421 } rtl_chip_info[] = {
422 { "RTL-8139",
423 0x40,
424 0xf0fe0040, /* XXX copied from RTL8139A, verify */
425 },
426
427 { "RTL-8139 rev K",
428 0x60,
429 0xf0fe0040,
430 },
431
432 { "RTL-8139A",
433 0x70,
434 0xf0fe0040,
435 },
436
437 { "RTL-8139B",
438 0x78,
439 0xf0fc0040
440 },
441
442 { "RTL-8130",
443 0x7C,
444 0xf0fe0040, /* XXX copied from RTL8139A, verify */
445 },
446
447 { "RTL-8139C",
448 0x74,
449 0xf0fc0040, /* XXX copied from RTL8139B, verify */
450 },
451
452 };
453
454
455 struct netdrv_private {
456 board_t board;
457 void *mmio_addr;
458 int drv_flags;
459 struct pci_dev *pci_dev;
460 struct timer_list timer; /* Media selection timer. */
461 unsigned char *rx_ring;
462 unsigned int cur_rx; /* Index into the Rx buffer of next Rx pkt. */
463 unsigned int tx_flag;
464 atomic_t cur_tx;
465 atomic_t dirty_tx;
466 /* The saved address of a sent-in-place packet/buffer, for skfree(). */
467 struct ring_info tx_info[NUM_TX_DESC];
468 unsigned char *tx_buf[NUM_TX_DESC]; /* Tx bounce buffers */
469 unsigned char *tx_bufs; /* Tx bounce buffer region. */
470 dma_addr_t rx_ring_dma;
471 dma_addr_t tx_bufs_dma;
472 char phys[4]; /* MII device addresses. */
473 char twistie, twist_row, twist_col; /* Twister tune state. */
474 unsigned int full_duplex:1; /* Full-duplex operation requested. */
475 unsigned int duplex_lock:1;
476 unsigned int default_port:4; /* Last dev->if_port value. */
477 unsigned int media2:4; /* Secondary monitored media port. */
478 unsigned int medialock:1; /* Don't sense media type. */
479 unsigned int mediasense:1; /* Media sensing in progress. */
480 spinlock_t lock;
481 chip_t chipset;
482 };
483
484 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
485 MODULE_DESCRIPTION ("Skeleton for a PCI Fast Ethernet driver");
486 MODULE_LICENSE("GPL");
487 module_param(multicast_filter_limit, int, 0);
488 module_param(max_interrupt_work, int, 0);
489 module_param_array(media, int, NULL, 0);
490 MODULE_PARM_DESC (multicast_filter_limit, "pci-skeleton maximum number of filtered multicast addresses");
491 MODULE_PARM_DESC (max_interrupt_work, "pci-skeleton maximum events handled per interrupt");
492 MODULE_PARM_DESC (media, "pci-skeleton: Bits 0-3: media type, bit 17: full duplex");
493
494 static int read_eeprom (void *ioaddr, int location, int addr_len);
495 static int netdrv_open (struct net_device *dev);
496 static int mdio_read (struct net_device *dev, int phy_id, int location);
497 static void mdio_write (struct net_device *dev, int phy_id, int location,
498 int val);
499 static void netdrv_timer (unsigned long data);
500 static void netdrv_tx_timeout (struct net_device *dev);
501 static void netdrv_init_ring (struct net_device *dev);
502 static int netdrv_start_xmit (struct sk_buff *skb,
503 struct net_device *dev);
504 static irqreturn_t netdrv_interrupt (int irq, void *dev_instance);
505 static int netdrv_close (struct net_device *dev);
506 static int netdrv_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
507 static void netdrv_set_rx_mode (struct net_device *dev);
508 static void netdrv_hw_start (struct net_device *dev);
509
510
511 #ifdef USE_IO_OPS
512
513 #define NETDRV_R8(reg) inb (((unsigned long)ioaddr) + (reg))
514 #define NETDRV_R16(reg) inw (((unsigned long)ioaddr) + (reg))
515 #define NETDRV_R32(reg) ((unsigned long) inl (((unsigned long)ioaddr) + (reg)))
516 #define NETDRV_W8(reg, val8) outb ((val8), ((unsigned long)ioaddr) + (reg))
517 #define NETDRV_W16(reg, val16) outw ((val16), ((unsigned long)ioaddr) + (reg))
518 #define NETDRV_W32(reg, val32) outl ((val32), ((unsigned long)ioaddr) + (reg))
519 #define NETDRV_W8_F NETDRV_W8
520 #define NETDRV_W16_F NETDRV_W16
521 #define NETDRV_W32_F NETDRV_W32
522 #undef readb
523 #undef readw
524 #undef readl
525 #undef writeb
526 #undef writew
527 #undef writel
528 #define readb(addr) inb((unsigned long)(addr))
529 #define readw(addr) inw((unsigned long)(addr))
530 #define readl(addr) inl((unsigned long)(addr))
531 #define writeb(val,addr) outb((val),(unsigned long)(addr))
532 #define writew(val,addr) outw((val),(unsigned long)(addr))
533 #define writel(val,addr) outl((val),(unsigned long)(addr))
534
535 #else
536
537 /* write MMIO register, with flush */
538 /* Flush avoids rtl8139 bug w/ posted MMIO writes */
539 #define NETDRV_W8_F(reg, val8) do { writeb ((val8), ioaddr + (reg)); readb (ioaddr + (reg)); } while (0)
540 #define NETDRV_W16_F(reg, val16) do { writew ((val16), ioaddr + (reg)); readw (ioaddr + (reg)); } while (0)
541 #define NETDRV_W32_F(reg, val32) do { writel ((val32), ioaddr + (reg)); readl (ioaddr + (reg)); } while (0)
542
543
544 #ifdef MMIO_FLUSH_AUDIT_COMPLETE
545
546 /* write MMIO register */
547 #define NETDRV_W8(reg, val8) writeb ((val8), ioaddr + (reg))
548 #define NETDRV_W16(reg, val16) writew ((val16), ioaddr + (reg))
549 #define NETDRV_W32(reg, val32) writel ((val32), ioaddr + (reg))
550
551 #else
552
553 /* write MMIO register, then flush */
554 #define NETDRV_W8 NETDRV_W8_F
555 #define NETDRV_W16 NETDRV_W16_F
556 #define NETDRV_W32 NETDRV_W32_F
557
558 #endif /* MMIO_FLUSH_AUDIT_COMPLETE */
559
560 /* read MMIO register */
561 #define NETDRV_R8(reg) readb (ioaddr + (reg))
562 #define NETDRV_R16(reg) readw (ioaddr + (reg))
563 #define NETDRV_R32(reg) ((unsigned long) readl (ioaddr + (reg)))
564
565 #endif /* USE_IO_OPS */
566
567
568 static const u16 netdrv_intr_mask =
569 PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
570 TxErr | TxOK | RxErr | RxOK;
571
572 static const unsigned int netdrv_rx_config =
573 RxCfgEarlyRxNone | RxCfgRcv32K | RxNoWrap |
574 (RX_FIFO_THRESH << RxCfgFIFOShift) |
575 (RX_DMA_BURST << RxCfgDMAShift);
576
577
578 static int __devinit netdrv_init_board (struct pci_dev *pdev,
579 struct net_device **dev_out,
580 void **ioaddr_out)
581 {
582 void *ioaddr = NULL;
583 struct net_device *dev;
584 struct netdrv_private *tp;
585 int rc, i;
586 u32 pio_start, pio_end, pio_flags, pio_len;
587 unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
588 u32 tmp;
589
590 DPRINTK ("ENTER\n");
591
592 assert (pdev != NULL);
593 assert (ioaddr_out != NULL);
594
595 *ioaddr_out = NULL;
596 *dev_out = NULL;
597
598 /* dev zeroed in alloc_etherdev */
599 dev = alloc_etherdev (sizeof (*tp));
600 if (dev == NULL) {
601 dev_err(&pdev->dev, "unable to alloc new ethernet\n");
602 DPRINTK ("EXIT, returning -ENOMEM\n");
603 return -ENOMEM;
604 }
605 SET_NETDEV_DEV(dev, &pdev->dev);
606 tp = netdev_priv(dev);
607
608 /* enable device (incl. PCI PM wakeup), and bus-mastering */
609 rc = pci_enable_device (pdev);
610 if (rc)
611 goto err_out;
612
613 pio_start = pci_resource_start (pdev, 0);
614 pio_end = pci_resource_end (pdev, 0);
615 pio_flags = pci_resource_flags (pdev, 0);
616 pio_len = pci_resource_len (pdev, 0);
617
618 mmio_start = pci_resource_start (pdev, 1);
619 mmio_end = pci_resource_end (pdev, 1);
620 mmio_flags = pci_resource_flags (pdev, 1);
621 mmio_len = pci_resource_len (pdev, 1);
622
623 /* set this immediately, we need to know before
624 * we talk to the chip directly */
625 DPRINTK("PIO region size == 0x%02X\n", pio_len);
626 DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
627
628 /* make sure PCI base addr 0 is PIO */
629 if (!(pio_flags & IORESOURCE_IO)) {
630 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
631 rc = -ENODEV;
632 goto err_out;
633 }
634
635 /* make sure PCI base addr 1 is MMIO */
636 if (!(mmio_flags & IORESOURCE_MEM)) {
637 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
638 rc = -ENODEV;
639 goto err_out;
640 }
641
642 /* check for weird/broken PCI region reporting */
643 if ((pio_len < NETDRV_MIN_IO_SIZE) ||
644 (mmio_len < NETDRV_MIN_IO_SIZE)) {
645 dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n");
646 rc = -ENODEV;
647 goto err_out;
648 }
649
650 rc = pci_request_regions (pdev, MODNAME);
651 if (rc)
652 goto err_out;
653
654 pci_set_master (pdev);
655
656 #ifdef USE_IO_OPS
657 ioaddr = (void *) pio_start;
658 #else
659 /* ioremap MMIO region */
660 ioaddr = ioremap (mmio_start, mmio_len);
661 if (ioaddr == NULL) {
662 dev_err(&pdev->dev, "cannot remap MMIO, aborting\n");
663 rc = -EIO;
664 goto err_out_free_res;
665 }
666 #endif /* USE_IO_OPS */
667
668 /* Soft reset the chip. */
669 NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
670
671 /* Check that the chip has finished the reset. */
672 for (i = 1000; i > 0; i--)
673 if ((NETDRV_R8 (ChipCmd) & CmdReset) == 0)
674 break;
675 else
676 udelay (10);
677
678 /* Bring the chip out of low-power mode. */
679 /* <insert device-specific code here> */
680
681 #ifndef USE_IO_OPS
682 /* sanity checks -- ensure PIO and MMIO registers agree */
683 assert (inb (pio_start+Config0) == readb (ioaddr+Config0));
684 assert (inb (pio_start+Config1) == readb (ioaddr+Config1));
685 assert (inb (pio_start+TxConfig) == readb (ioaddr+TxConfig));
686 assert (inb (pio_start+RxConfig) == readb (ioaddr+RxConfig));
687 #endif /* !USE_IO_OPS */
688
689 /* identify chip attached to board */
690 tmp = NETDRV_R8 (ChipVersion);
691 for (i = ARRAY_SIZE (rtl_chip_info) - 1; i >= 0; i--)
692 if (tmp == rtl_chip_info[i].version) {
693 tp->chipset = i;
694 goto match;
695 }
696
697 /* if unknown chip, assume array element #0, original RTL-8139 in this case */
698 dev_printk (KERN_DEBUG, &pdev->dev,
699 "unknown chip version, assuming RTL-8139\n");
700 dev_printk (KERN_DEBUG, &pdev->dev, "TxConfig = 0x%lx\n",
701 NETDRV_R32 (TxConfig));
702 tp->chipset = 0;
703
704 match:
705 DPRINTK ("chipset id (%d) == index %d, '%s'\n",
706 tmp,
707 tp->chipset,
708 rtl_chip_info[tp->chipset].name);
709
710 rc = register_netdev (dev);
711 if (rc)
712 goto err_out_unmap;
713
714 DPRINTK ("EXIT, returning 0\n");
715 *ioaddr_out = ioaddr;
716 *dev_out = dev;
717 return 0;
718
719 err_out_unmap:
720 #ifndef USE_IO_OPS
721 iounmap(ioaddr);
722 err_out_free_res:
723 #endif
724 pci_release_regions (pdev);
725 err_out:
726 free_netdev (dev);
727 DPRINTK ("EXIT, returning %d\n", rc);
728 return rc;
729 }
730
731
732 static int __devinit netdrv_init_one (struct pci_dev *pdev,
733 const struct pci_device_id *ent)
734 {
735 struct net_device *dev = NULL;
736 struct netdrv_private *tp;
737 int i, addr_len, option;
738 void *ioaddr = NULL;
739 static int board_idx = -1;
740 DECLARE_MAC_BUF(mac);
741
742 /* when built into the kernel, we only print version if device is found */
743 #ifndef MODULE
744 static int printed_version;
745 if (!printed_version++)
746 printk(version);
747 #endif
748
749 DPRINTK ("ENTER\n");
750
751 assert (pdev != NULL);
752 assert (ent != NULL);
753
754 board_idx++;
755
756 i = netdrv_init_board (pdev, &dev, &ioaddr);
757 if (i < 0) {
758 DPRINTK ("EXIT, returning %d\n", i);
759 return i;
760 }
761
762 tp = netdev_priv(dev);
763
764 assert (ioaddr != NULL);
765 assert (dev != NULL);
766 assert (tp != NULL);
767
768 addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
769 for (i = 0; i < 3; i++)
770 ((u16 *) (dev->dev_addr))[i] =
771 le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
772
773 /* The Rtl8139-specific entries in the device structure. */
774 dev->open = netdrv_open;
775 dev->hard_start_xmit = netdrv_start_xmit;
776 dev->stop = netdrv_close;
777 dev->set_multicast_list = netdrv_set_rx_mode;
778 dev->do_ioctl = netdrv_ioctl;
779 dev->tx_timeout = netdrv_tx_timeout;
780 dev->watchdog_timeo = TX_TIMEOUT;
781
782 dev->irq = pdev->irq;
783 dev->base_addr = (unsigned long) ioaddr;
784
785 /* dev->priv/tp zeroed and aligned in alloc_etherdev */
786 tp = netdev_priv(dev);
787
788 /* note: tp->chipset set in netdrv_init_board */
789 tp->drv_flags = PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
790 PCI_COMMAND_MASTER | NETDRV_CAPS;
791 tp->pci_dev = pdev;
792 tp->board = ent->driver_data;
793 tp->mmio_addr = ioaddr;
794 spin_lock_init(&tp->lock);
795
796 pci_set_drvdata(pdev, dev);
797
798 tp->phys[0] = 32;
799
800 printk (KERN_INFO "%s: %s at 0x%lx, %sIRQ %d\n",
801 dev->name,
802 board_info[ent->driver_data].name,
803 dev->base_addr,
804 print_mac(mac, dev->dev_addr),
805 dev->irq);
806
807 printk (KERN_DEBUG "%s: Identified 8139 chip type '%s'\n",
808 dev->name, rtl_chip_info[tp->chipset].name);
809
810 /* Put the chip into low-power mode. */
811 NETDRV_W8_F (Cfg9346, Cfg9346_Unlock);
812
813 /* The lower four bits are the media type. */
814 option = (board_idx > 7) ? 0 : media[board_idx];
815 if (option > 0) {
816 tp->full_duplex = (option & 0x200) ? 1 : 0;
817 tp->default_port = option & 15;
818 if (tp->default_port)
819 tp->medialock = 1;
820 }
821
822 if (tp->full_duplex) {
823 printk (KERN_INFO
824 "%s: Media type forced to Full Duplex.\n",
825 dev->name);
826 mdio_write (dev, tp->phys[0], MII_ADVERTISE, ADVERTISE_FULL);
827 tp->duplex_lock = 1;
828 }
829
830 DPRINTK ("EXIT - returning 0\n");
831 return 0;
832 }
833
834
835 static void __devexit netdrv_remove_one (struct pci_dev *pdev)
836 {
837 struct net_device *dev = pci_get_drvdata (pdev);
838 struct netdrv_private *np;
839
840 DPRINTK ("ENTER\n");
841
842 assert (dev != NULL);
843
844 np = netdev_priv(dev);
845 assert (np != NULL);
846
847 unregister_netdev (dev);
848
849 #ifndef USE_IO_OPS
850 iounmap (np->mmio_addr);
851 #endif /* !USE_IO_OPS */
852
853 pci_release_regions (pdev);
854
855 free_netdev (dev);
856
857 pci_set_drvdata (pdev, NULL);
858
859 pci_disable_device (pdev);
860
861 DPRINTK ("EXIT\n");
862 }
863
864
865 /* Serial EEPROM section. */
866
867 /* EEPROM_Ctrl bits. */
868 #define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
869 #define EE_CS 0x08 /* EEPROM chip select. */
870 #define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
871 #define EE_WRITE_0 0x00
872 #define EE_WRITE_1 0x02
873 #define EE_DATA_READ 0x01 /* EEPROM chip data out. */
874 #define EE_ENB (0x80 | EE_CS)
875
876 /* Delay between EEPROM clock transitions.
877 No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
878 */
879
880 #define eeprom_delay() readl(ee_addr)
881
882 /* The EEPROM commands include the alway-set leading bit. */
883 #define EE_WRITE_CMD (5)
884 #define EE_READ_CMD (6)
885 #define EE_ERASE_CMD (7)
886
887 static int __devinit read_eeprom (void *ioaddr, int location, int addr_len)
888 {
889 int i;
890 unsigned retval = 0;
891 void *ee_addr = ioaddr + Cfg9346;
892 int read_cmd = location | (EE_READ_CMD << addr_len);
893
894 DPRINTK ("ENTER\n");
895
896 writeb (EE_ENB & ~EE_CS, ee_addr);
897 writeb (EE_ENB, ee_addr);
898 eeprom_delay ();
899
900 /* Shift the read command bits out. */
901 for (i = 4 + addr_len; i >= 0; i--) {
902 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
903 writeb (EE_ENB | dataval, ee_addr);
904 eeprom_delay ();
905 writeb (EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
906 eeprom_delay ();
907 }
908 writeb (EE_ENB, ee_addr);
909 eeprom_delay ();
910
911 for (i = 16; i > 0; i--) {
912 writeb (EE_ENB | EE_SHIFT_CLK, ee_addr);
913 eeprom_delay ();
914 retval =
915 (retval << 1) | ((readb (ee_addr) & EE_DATA_READ) ? 1 :
916 0);
917 writeb (EE_ENB, ee_addr);
918 eeprom_delay ();
919 }
920
921 /* Terminate the EEPROM access. */
922 writeb (~EE_CS, ee_addr);
923 eeprom_delay ();
924
925 DPRINTK ("EXIT - returning %d\n", retval);
926 return retval;
927 }
928
929 /* MII serial management: mostly bogus for now. */
930 /* Read and write the MII management registers using software-generated
931 serial MDIO protocol.
932 The maximum data clock rate is 2.5 Mhz. The minimum timing is usually
933 met by back-to-back PCI I/O cycles, but we insert a delay to avoid
934 "overclocking" issues. */
935 #define MDIO_DIR 0x80
936 #define MDIO_DATA_OUT 0x04
937 #define MDIO_DATA_IN 0x02
938 #define MDIO_CLK 0x01
939 #define MDIO_WRITE0 (MDIO_DIR)
940 #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
941
942 #define mdio_delay() readb(mdio_addr)
943
944
945 static char mii_2_8139_map[8] = {
946 BasicModeCtrl,
947 BasicModeStatus,
948 0,
949 0,
950 NWayAdvert,
951 NWayLPAR,
952 NWayExpansion,
953 0
954 };
955
956
957 /* Syncronize the MII management interface by shifting 32 one bits out. */
958 static void mdio_sync (void *mdio_addr)
959 {
960 int i;
961
962 DPRINTK ("ENTER\n");
963
964 for (i = 32; i >= 0; i--) {
965 writeb (MDIO_WRITE1, mdio_addr);
966 mdio_delay ();
967 writeb (MDIO_WRITE1 | MDIO_CLK, mdio_addr);
968 mdio_delay ();
969 }
970
971 DPRINTK ("EXIT\n");
972 }
973
974
975 static int mdio_read (struct net_device *dev, int phy_id, int location)
976 {
977 struct netdrv_private *tp = netdev_priv(dev);
978 void *mdio_addr = tp->mmio_addr + Config4;
979 int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
980 int retval = 0;
981 int i;
982
983 DPRINTK ("ENTER\n");
984
985 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
986 DPRINTK ("EXIT after directly using 8139 internal regs\n");
987 return location < 8 && mii_2_8139_map[location] ?
988 readw (tp->mmio_addr + mii_2_8139_map[location]) : 0;
989 }
990 mdio_sync (mdio_addr);
991 /* Shift the read command bits out. */
992 for (i = 15; i >= 0; i--) {
993 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
994
995 writeb (MDIO_DIR | dataval, mdio_addr);
996 mdio_delay ();
997 writeb (MDIO_DIR | dataval | MDIO_CLK, mdio_addr);
998 mdio_delay ();
999 }
1000
1001 /* Read the two transition, 16 data, and wire-idle bits. */
1002 for (i = 19; i > 0; i--) {
1003 writeb (0, mdio_addr);
1004 mdio_delay ();
1005 retval =
1006 (retval << 1) | ((readb (mdio_addr) & MDIO_DATA_IN) ? 1
1007 : 0);
1008 writeb (MDIO_CLK, mdio_addr);
1009 mdio_delay ();
1010 }
1011
1012 DPRINTK ("EXIT, returning %d\n", (retval >> 1) & 0xffff);
1013 return (retval >> 1) & 0xffff;
1014 }
1015
1016
1017 static void mdio_write (struct net_device *dev, int phy_id, int location,
1018 int value)
1019 {
1020 struct netdrv_private *tp = netdev_priv(dev);
1021 void *mdio_addr = tp->mmio_addr + Config4;
1022 int mii_cmd =
1023 (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1024 int i;
1025
1026 DPRINTK ("ENTER\n");
1027
1028 if (phy_id > 31) { /* Really a 8139. Use internal registers. */
1029 if (location < 8 && mii_2_8139_map[location]) {
1030 writew (value,
1031 tp->mmio_addr + mii_2_8139_map[location]);
1032 readw (tp->mmio_addr + mii_2_8139_map[location]);
1033 }
1034 DPRINTK ("EXIT after directly using 8139 internal regs\n");
1035 return;
1036 }
1037 mdio_sync (mdio_addr);
1038
1039 /* Shift the command bits out. */
1040 for (i = 31; i >= 0; i--) {
1041 int dataval =
1042 (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1043 writeb (dataval, mdio_addr);
1044 mdio_delay ();
1045 writeb (dataval | MDIO_CLK, mdio_addr);
1046 mdio_delay ();
1047 }
1048
1049 /* Clear out extra bits. */
1050 for (i = 2; i > 0; i--) {
1051 writeb (0, mdio_addr);
1052 mdio_delay ();
1053 writeb (MDIO_CLK, mdio_addr);
1054 mdio_delay ();
1055 }
1056
1057 DPRINTK ("EXIT\n");
1058 }
1059
1060
1061 static int netdrv_open (struct net_device *dev)
1062 {
1063 struct netdrv_private *tp = netdev_priv(dev);
1064 int retval;
1065 #ifdef NETDRV_DEBUG
1066 void *ioaddr = tp->mmio_addr;
1067 #endif
1068
1069 DPRINTK ("ENTER\n");
1070
1071 retval = request_irq (dev->irq, netdrv_interrupt, IRQF_SHARED, dev->name, dev);
1072 if (retval) {
1073 DPRINTK ("EXIT, returning %d\n", retval);
1074 return retval;
1075 }
1076
1077 tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1078 &tp->tx_bufs_dma);
1079 tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1080 &tp->rx_ring_dma);
1081 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1082 free_irq(dev->irq, dev);
1083
1084 if (tp->tx_bufs)
1085 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1086 tp->tx_bufs, tp->tx_bufs_dma);
1087 if (tp->rx_ring)
1088 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1089 tp->rx_ring, tp->rx_ring_dma);
1090
1091 DPRINTK ("EXIT, returning -ENOMEM\n");
1092 return -ENOMEM;
1093
1094 }
1095
1096 tp->full_duplex = tp->duplex_lock;
1097 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1098
1099 netdrv_init_ring (dev);
1100 netdrv_hw_start (dev);
1101
1102 DPRINTK ("%s: netdrv_open() ioaddr %#lx IRQ %d"
1103 " GP Pins %2.2x %s-duplex.\n",
1104 dev->name, pci_resource_start (tp->pci_dev, 1),
1105 dev->irq, NETDRV_R8 (MediaStatus),
1106 tp->full_duplex ? "full" : "half");
1107
1108 /* Set the timer to switch to check for link beat and perhaps switch
1109 to an alternate media type. */
1110 init_timer (&tp->timer);
1111 tp->timer.expires = jiffies + 3 * HZ;
1112 tp->timer.data = (unsigned long) dev;
1113 tp->timer.function = &netdrv_timer;
1114 add_timer (&tp->timer);
1115
1116 DPRINTK ("EXIT, returning 0\n");
1117 return 0;
1118 }
1119
1120
1121 /* Start the hardware at open or resume. */
1122 static void netdrv_hw_start (struct net_device *dev)
1123 {
1124 struct netdrv_private *tp = netdev_priv(dev);
1125 void *ioaddr = tp->mmio_addr;
1126 u32 i;
1127
1128 DPRINTK ("ENTER\n");
1129
1130 /* Soft reset the chip. */
1131 NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
1132 udelay (100);
1133
1134 /* Check that the chip has finished the reset. */
1135 for (i = 1000; i > 0; i--)
1136 if ((NETDRV_R8 (ChipCmd) & CmdReset) == 0)
1137 break;
1138
1139 /* Restore our idea of the MAC address. */
1140 NETDRV_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
1141 NETDRV_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
1142
1143 /* Must enable Tx/Rx before setting transfer thresholds! */
1144 NETDRV_W8_F (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) |
1145 CmdRxEnb | CmdTxEnb);
1146
1147 i = netdrv_rx_config |
1148 (NETDRV_R32 (RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1149 NETDRV_W32_F (RxConfig, i);
1150
1151 /* Check this value: the documentation for IFG contradicts ifself. */
1152 NETDRV_W32 (TxConfig, (TX_DMA_BURST << TxDMAShift));
1153
1154 /* unlock Config[01234] and BMCR register writes */
1155 NETDRV_W8_F (Cfg9346, Cfg9346_Unlock);
1156 udelay (10);
1157
1158 tp->cur_rx = 0;
1159
1160 /* Lock Config[01234] and BMCR register writes */
1161 NETDRV_W8_F (Cfg9346, Cfg9346_Lock);
1162 udelay (10);
1163
1164 /* init Rx ring buffer DMA address */
1165 NETDRV_W32_F (RxBuf, tp->rx_ring_dma);
1166
1167 /* init Tx buffer DMA addresses */
1168 for (i = 0; i < NUM_TX_DESC; i++)
1169 NETDRV_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1170
1171 NETDRV_W32_F (RxMissed, 0);
1172
1173 netdrv_set_rx_mode (dev);
1174
1175 /* no early-rx interrupts */
1176 NETDRV_W16 (MultiIntr, NETDRV_R16 (MultiIntr) & MultiIntrClear);
1177
1178 /* make sure RxTx has started */
1179 NETDRV_W8_F (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) |
1180 CmdRxEnb | CmdTxEnb);
1181
1182 /* Enable all known interrupts by setting the interrupt mask. */
1183 NETDRV_W16_F (IntrMask, netdrv_intr_mask);
1184
1185 netif_start_queue (dev);
1186
1187 DPRINTK ("EXIT\n");
1188 }
1189
1190
1191 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1192 static void netdrv_init_ring (struct net_device *dev)
1193 {
1194 struct netdrv_private *tp = netdev_priv(dev);
1195 int i;
1196
1197 DPRINTK ("ENTER\n");
1198
1199 tp->cur_rx = 0;
1200 atomic_set (&tp->cur_tx, 0);
1201 atomic_set (&tp->dirty_tx, 0);
1202
1203 for (i = 0; i < NUM_TX_DESC; i++) {
1204 tp->tx_info[i].skb = NULL;
1205 tp->tx_info[i].mapping = 0;
1206 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1207 }
1208
1209 DPRINTK ("EXIT\n");
1210 }
1211
1212
1213 static void netdrv_timer (unsigned long data)
1214 {
1215 struct net_device *dev = (struct net_device *) data;
1216 struct netdrv_private *tp = netdev_priv(dev);
1217 void *ioaddr = tp->mmio_addr;
1218 int next_tick = 60 * HZ;
1219 int mii_lpa;
1220
1221 mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1222
1223 if (!tp->duplex_lock && mii_lpa != 0xffff) {
1224 int duplex = (mii_lpa & LPA_100FULL)
1225 || (mii_lpa & 0x01C0) == 0x0040;
1226 if (tp->full_duplex != duplex) {
1227 tp->full_duplex = duplex;
1228 printk (KERN_INFO
1229 "%s: Setting %s-duplex based on MII #%d link"
1230 " partner ability of %4.4x.\n", dev->name,
1231 tp->full_duplex ? "full" : "half",
1232 tp->phys[0], mii_lpa);
1233 NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1234 NETDRV_W8 (Config1, tp->full_duplex ? 0x60 : 0x20);
1235 NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1236 }
1237 }
1238
1239 DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1240 dev->name, NETDRV_R16 (NWayLPAR));
1241 DPRINTK ("%s: Other registers are IntMask %4.4x IntStatus %4.4x"
1242 " RxStatus %4.4x.\n", dev->name,
1243 NETDRV_R16 (IntrMask),
1244 NETDRV_R16 (IntrStatus),
1245 NETDRV_R32 (RxEarlyStatus));
1246 DPRINTK ("%s: Chip config %2.2x %2.2x.\n",
1247 dev->name, NETDRV_R8 (Config0),
1248 NETDRV_R8 (Config1));
1249
1250 tp->timer.expires = jiffies + next_tick;
1251 add_timer (&tp->timer);
1252 }
1253
1254
1255 static void netdrv_tx_clear (struct net_device *dev)
1256 {
1257 int i;
1258 struct netdrv_private *tp = netdev_priv(dev);
1259
1260 atomic_set (&tp->cur_tx, 0);
1261 atomic_set (&tp->dirty_tx, 0);
1262
1263 /* Dump the unsent Tx packets. */
1264 for (i = 0; i < NUM_TX_DESC; i++) {
1265 struct ring_info *rp = &tp->tx_info[i];
1266 if (rp->mapping != 0) {
1267 pci_unmap_single (tp->pci_dev, rp->mapping,
1268 rp->skb->len, PCI_DMA_TODEVICE);
1269 rp->mapping = 0;
1270 }
1271 if (rp->skb) {
1272 dev_kfree_skb (rp->skb);
1273 rp->skb = NULL;
1274 dev->stats.tx_dropped++;
1275 }
1276 }
1277 }
1278
1279
1280 static void netdrv_tx_timeout (struct net_device *dev)
1281 {
1282 struct netdrv_private *tp = netdev_priv(dev);
1283 void *ioaddr = tp->mmio_addr;
1284 int i;
1285 u8 tmp8;
1286 unsigned long flags;
1287
1288 DPRINTK ("%s: Transmit timeout, status %2.2x %4.4x "
1289 "media %2.2x.\n", dev->name,
1290 NETDRV_R8 (ChipCmd),
1291 NETDRV_R16 (IntrStatus),
1292 NETDRV_R8 (MediaStatus));
1293
1294 /* disable Tx ASAP, if not already */
1295 tmp8 = NETDRV_R8 (ChipCmd);
1296 if (tmp8 & CmdTxEnb)
1297 NETDRV_W8 (ChipCmd, tmp8 & ~CmdTxEnb);
1298
1299 /* Disable interrupts by clearing the interrupt mask. */
1300 NETDRV_W16 (IntrMask, 0x0000);
1301
1302 /* Emit info to figure out what went wrong. */
1303 printk (KERN_DEBUG "%s: Tx queue start entry %d dirty entry %d.\n",
1304 dev->name, atomic_read (&tp->cur_tx),
1305 atomic_read (&tp->dirty_tx));
1306 for (i = 0; i < NUM_TX_DESC; i++)
1307 printk (KERN_DEBUG "%s: Tx descriptor %d is %8.8lx.%s\n",
1308 dev->name, i, NETDRV_R32 (TxStatus0 + (i * 4)),
1309 i == atomic_read (&tp->dirty_tx) % NUM_TX_DESC ?
1310 " (queue head)" : "");
1311
1312 /* Stop a shared interrupt from scavenging while we are. */
1313 spin_lock_irqsave (&tp->lock, flags);
1314
1315 netdrv_tx_clear (dev);
1316
1317 spin_unlock_irqrestore (&tp->lock, flags);
1318
1319 /* ...and finally, reset everything */
1320 netdrv_hw_start (dev);
1321
1322 netif_wake_queue (dev);
1323 }
1324
1325
1326
1327 static int netdrv_start_xmit (struct sk_buff *skb, struct net_device *dev)
1328 {
1329 struct netdrv_private *tp = netdev_priv(dev);
1330 void *ioaddr = tp->mmio_addr;
1331 int entry;
1332
1333 /* Calculate the next Tx descriptor entry. */
1334 entry = atomic_read (&tp->cur_tx) % NUM_TX_DESC;
1335
1336 assert (tp->tx_info[entry].skb == NULL);
1337 assert (tp->tx_info[entry].mapping == 0);
1338
1339 tp->tx_info[entry].skb = skb;
1340 /* tp->tx_info[entry].mapping = 0; */
1341 skb_copy_from_linear_data(skb, tp->tx_buf[entry], skb->len);
1342
1343 /* Note: the chip doesn't have auto-pad! */
1344 NETDRV_W32 (TxStatus0 + (entry * sizeof(u32)),
1345 tp->tx_flag | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1346
1347 dev->trans_start = jiffies;
1348 atomic_inc (&tp->cur_tx);
1349 if ((atomic_read (&tp->cur_tx) - atomic_read (&tp->dirty_tx)) >= NUM_TX_DESC)
1350 netif_stop_queue (dev);
1351
1352 DPRINTK ("%s: Queued Tx packet at %p size %u to slot %d.\n",
1353 dev->name, skb->data, skb->len, entry);
1354
1355 return 0;
1356 }
1357
1358
1359 static void netdrv_tx_interrupt (struct net_device *dev,
1360 struct netdrv_private *tp,
1361 void *ioaddr)
1362 {
1363 int cur_tx, dirty_tx, tx_left;
1364
1365 assert (dev != NULL);
1366 assert (tp != NULL);
1367 assert (ioaddr != NULL);
1368
1369 dirty_tx = atomic_read (&tp->dirty_tx);
1370
1371 cur_tx = atomic_read (&tp->cur_tx);
1372 tx_left = cur_tx - dirty_tx;
1373 while (tx_left > 0) {
1374 int entry = dirty_tx % NUM_TX_DESC;
1375 int txstatus;
1376
1377 txstatus = NETDRV_R32 (TxStatus0 + (entry * sizeof (u32)));
1378
1379 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1380 break; /* It still hasn't been Txed */
1381
1382 /* Note: TxCarrierLost is always asserted at 100mbps. */
1383 if (txstatus & (TxOutOfWindow | TxAborted)) {
1384 /* There was an major error, log it. */
1385 DPRINTK ("%s: Transmit error, Tx status %8.8x.\n",
1386 dev->name, txstatus);
1387 dev->stats.tx_errors++;
1388 if (txstatus & TxAborted) {
1389 dev->stats.tx_aborted_errors++;
1390 NETDRV_W32 (TxConfig, TxClearAbt | (TX_DMA_BURST << TxDMAShift));
1391 }
1392 if (txstatus & TxCarrierLost)
1393 dev->stats.tx_carrier_errors++;
1394 if (txstatus & TxOutOfWindow)
1395 dev->stats.tx_window_errors++;
1396 } else {
1397 if (txstatus & TxUnderrun) {
1398 /* Add 64 to the Tx FIFO threshold. */
1399 if (tp->tx_flag < 0x00300000)
1400 tp->tx_flag += 0x00020000;
1401 dev->stats.tx_fifo_errors++;
1402 }
1403 dev->stats.collisions += (txstatus >> 24) & 15;
1404 dev->stats.tx_bytes += txstatus & 0x7ff;
1405 dev->stats.tx_packets++;
1406 }
1407
1408 /* Free the original skb. */
1409 if (tp->tx_info[entry].mapping != 0) {
1410 pci_unmap_single(tp->pci_dev,
1411 tp->tx_info[entry].mapping,
1412 tp->tx_info[entry].skb->len,
1413 PCI_DMA_TODEVICE);
1414 tp->tx_info[entry].mapping = 0;
1415 }
1416 dev_kfree_skb_irq (tp->tx_info[entry].skb);
1417 tp->tx_info[entry].skb = NULL;
1418 dirty_tx++;
1419 if (dirty_tx < 0) { /* handle signed int overflow */
1420 atomic_sub (cur_tx, &tp->cur_tx); /* XXX racy? */
1421 dirty_tx = cur_tx - tx_left + 1;
1422 }
1423 if (netif_queue_stopped (dev))
1424 netif_wake_queue (dev);
1425
1426 cur_tx = atomic_read (&tp->cur_tx);
1427 tx_left = cur_tx - dirty_tx;
1428
1429 }
1430
1431 #ifndef NETDRV_NDEBUG
1432 if (atomic_read (&tp->cur_tx) - dirty_tx > NUM_TX_DESC) {
1433 printk (KERN_ERR
1434 "%s: Out-of-sync dirty pointer, %d vs. %d.\n",
1435 dev->name, dirty_tx, atomic_read (&tp->cur_tx));
1436 dirty_tx += NUM_TX_DESC;
1437 }
1438 #endif /* NETDRV_NDEBUG */
1439
1440 atomic_set (&tp->dirty_tx, dirty_tx);
1441 }
1442
1443
1444 /* TODO: clean this up! Rx reset need not be this intensive */
1445 static void netdrv_rx_err (u32 rx_status, struct net_device *dev,
1446 struct netdrv_private *tp, void *ioaddr)
1447 {
1448 u8 tmp8;
1449 int tmp_work = 1000;
1450
1451 DPRINTK ("%s: Ethernet frame had errors, status %8.8x.\n",
1452 dev->name, rx_status);
1453 if (rx_status & RxTooLong) {
1454 DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1455 dev->name, rx_status);
1456 /* A.C.: The chip hangs here. */
1457 }
1458 dev->stats.rx_errors++;
1459 if (rx_status & (RxBadSymbol | RxBadAlign))
1460 dev->stats.rx_frame_errors++;
1461 if (rx_status & (RxRunt | RxTooLong))
1462 dev->stats.rx_length_errors++;
1463 if (rx_status & RxCRCErr)
1464 dev->stats.rx_crc_errors++;
1465 /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1466 tp->cur_rx = 0;
1467
1468 /* disable receive */
1469 tmp8 = NETDRV_R8 (ChipCmd) & ChipCmdClear;
1470 NETDRV_W8_F (ChipCmd, tmp8 | CmdTxEnb);
1471
1472 /* A.C.: Reset the multicast list. */
1473 netdrv_set_rx_mode (dev);
1474
1475 /* XXX potentially temporary hack to
1476 * restart hung receiver */
1477 while (--tmp_work > 0) {
1478 tmp8 = NETDRV_R8 (ChipCmd);
1479 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1480 break;
1481 NETDRV_W8_F (ChipCmd,
1482 (tmp8 & ChipCmdClear) | CmdRxEnb | CmdTxEnb);
1483 }
1484
1485 /* G.S.: Re-enable receiver */
1486 /* XXX temporary hack to work around receiver hang */
1487 netdrv_set_rx_mode (dev);
1488
1489 if (tmp_work <= 0)
1490 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1491 }
1492
1493
1494 /* The data sheet doesn't describe the Rx ring at all, so I'm guessing at the
1495 field alignments and semantics. */
1496 static void netdrv_rx_interrupt (struct net_device *dev,
1497 struct netdrv_private *tp, void *ioaddr)
1498 {
1499 unsigned char *rx_ring;
1500 u16 cur_rx;
1501
1502 assert (dev != NULL);
1503 assert (tp != NULL);
1504 assert (ioaddr != NULL);
1505
1506 rx_ring = tp->rx_ring;
1507 cur_rx = tp->cur_rx;
1508
1509 DPRINTK ("%s: In netdrv_rx(), current %4.4x BufAddr %4.4x,"
1510 " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
1511 NETDRV_R16 (RxBufAddr),
1512 NETDRV_R16 (RxBufPtr), NETDRV_R8 (ChipCmd));
1513
1514 while ((NETDRV_R8 (ChipCmd) & RxBufEmpty) == 0) {
1515 int ring_offset = cur_rx % RX_BUF_LEN;
1516 u32 rx_status;
1517 unsigned int rx_size;
1518 unsigned int pkt_size;
1519 struct sk_buff *skb;
1520
1521 /* read size+status of next frame from DMA ring buffer */
1522 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
1523 rx_size = rx_status >> 16;
1524 pkt_size = rx_size - 4;
1525
1526 DPRINTK ("%s: netdrv_rx() status %4.4x, size %4.4x,"
1527 " cur %4.4x.\n", dev->name, rx_status,
1528 rx_size, cur_rx);
1529 #if defined(NETDRV_DEBUG) && (NETDRV_DEBUG > 2)
1530 {
1531 int i;
1532 DPRINTK ("%s: Frame contents ", dev->name);
1533 for (i = 0; i < 70; i++)
1534 printk (" %2.2x",
1535 rx_ring[ring_offset + i]);
1536 printk (".\n");
1537 }
1538 #endif
1539
1540 /* If Rx err or invalid rx_size/rx_status received
1541 * (which happens if we get lost in the ring),
1542 * Rx process gets reset, so we abort any further
1543 * Rx processing.
1544 */
1545 if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1546 (!(rx_status & RxStatusOK))) {
1547 netdrv_rx_err (rx_status, dev, tp, ioaddr);
1548 return;
1549 }
1550
1551 /* Malloc up new buffer, compatible with net-2e. */
1552 /* Omit the four octet CRC from the length. */
1553
1554 /* TODO: consider allocating skb's outside of
1555 * interrupt context, both to speed interrupt processing,
1556 * and also to reduce the chances of having to
1557 * drop packets here under memory pressure.
1558 */
1559
1560 skb = dev_alloc_skb (pkt_size + 2);
1561 if (skb) {
1562 skb_reserve (skb, 2); /* 16 byte align the IP fields. */
1563
1564 skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
1565 skb_put (skb, pkt_size);
1566
1567 skb->protocol = eth_type_trans (skb, dev);
1568 netif_rx (skb);
1569 dev->last_rx = jiffies;
1570 dev->stats.rx_bytes += pkt_size;
1571 dev->stats.rx_packets++;
1572 } else {
1573 printk (KERN_WARNING
1574 "%s: Memory squeeze, dropping packet.\n",
1575 dev->name);
1576 dev->stats.rx_dropped++;
1577 }
1578
1579 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
1580 NETDRV_W16_F (RxBufPtr, cur_rx - 16);
1581 }
1582
1583 DPRINTK ("%s: Done netdrv_rx(), current %4.4x BufAddr %4.4x,"
1584 " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
1585 NETDRV_R16 (RxBufAddr),
1586 NETDRV_R16 (RxBufPtr), NETDRV_R8 (ChipCmd));
1587
1588 tp->cur_rx = cur_rx;
1589 }
1590
1591
1592 static void netdrv_weird_interrupt (struct net_device *dev,
1593 struct netdrv_private *tp,
1594 void *ioaddr,
1595 int status, int link_changed)
1596 {
1597 printk (KERN_DEBUG "%s: Abnormal interrupt, status %8.8x.\n",
1598 dev->name, status);
1599
1600 assert (dev != NULL);
1601 assert (tp != NULL);
1602 assert (ioaddr != NULL);
1603
1604 /* Update the error count. */
1605 dev->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1606 NETDRV_W32 (RxMissed, 0);
1607
1608 if ((status & RxUnderrun) && link_changed &&
1609 (tp->drv_flags & HAS_LNK_CHNG)) {
1610 /* Really link-change on new chips. */
1611 int lpar = NETDRV_R16 (NWayLPAR);
1612 int duplex = (lpar & 0x0100) || (lpar & 0x01C0) == 0x0040
1613 || tp->duplex_lock;
1614 if (tp->full_duplex != duplex) {
1615 tp->full_duplex = duplex;
1616 NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1617 NETDRV_W8 (Config1, tp->full_duplex ? 0x60 : 0x20);
1618 NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1619 }
1620 status &= ~RxUnderrun;
1621 }
1622
1623 /* XXX along with netdrv_rx_err, are we double-counting errors? */
1624 if (status &
1625 (RxUnderrun | RxOverflow | RxErr | RxFIFOOver))
1626 dev->stats.rx_errors++;
1627
1628 if (status & (PCSTimeout))
1629 dev->stats.rx_length_errors++;
1630 if (status & (RxUnderrun | RxFIFOOver))
1631 dev->stats.rx_fifo_errors++;
1632 if (status & RxOverflow) {
1633 dev->stats.rx_over_errors++;
1634 tp->cur_rx = NETDRV_R16 (RxBufAddr) % RX_BUF_LEN;
1635 NETDRV_W16_F (RxBufPtr, tp->cur_rx - 16);
1636 }
1637 if (status & PCIErr) {
1638 u16 pci_cmd_status;
1639 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
1640
1641 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
1642 dev->name, pci_cmd_status);
1643 }
1644 }
1645
1646
1647 /* The interrupt handler does all of the Rx thread work and cleans up
1648 after the Tx thread. */
1649 static irqreturn_t netdrv_interrupt (int irq, void *dev_instance)
1650 {
1651 struct net_device *dev = (struct net_device *) dev_instance;
1652 struct netdrv_private *tp = netdev_priv(dev);
1653 int boguscnt = max_interrupt_work;
1654 void *ioaddr = tp->mmio_addr;
1655 int status = 0, link_changed = 0; /* avoid bogus "uninit" warning */
1656 int handled = 0;
1657
1658 spin_lock (&tp->lock);
1659
1660 do {
1661 status = NETDRV_R16 (IntrStatus);
1662
1663 /* h/w no longer present (hotplug?) or major error, bail */
1664 if (status == 0xFFFF)
1665 break;
1666
1667 handled = 1;
1668 /* Acknowledge all of the current interrupt sources ASAP */
1669 NETDRV_W16_F (IntrStatus, status);
1670
1671 DPRINTK ("%s: interrupt status=%#4.4x new intstat=%#4.4x.\n",
1672 dev->name, status,
1673 NETDRV_R16 (IntrStatus));
1674
1675 if ((status &
1676 (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1677 RxFIFOOver | TxErr | TxOK | RxErr | RxOK)) == 0)
1678 break;
1679
1680 /* Check uncommon events with one test. */
1681 if (status & (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1682 RxFIFOOver | TxErr | RxErr))
1683 netdrv_weird_interrupt (dev, tp, ioaddr,
1684 status, link_changed);
1685
1686 if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver)) /* Rx interrupt */
1687 netdrv_rx_interrupt (dev, tp, ioaddr);
1688
1689 if (status & (TxOK | TxErr))
1690 netdrv_tx_interrupt (dev, tp, ioaddr);
1691
1692 boguscnt--;
1693 } while (boguscnt > 0);
1694
1695 if (boguscnt <= 0) {
1696 printk (KERN_WARNING
1697 "%s: Too much work at interrupt, "
1698 "IntrStatus=0x%4.4x.\n", dev->name,
1699 status);
1700
1701 /* Clear all interrupt sources. */
1702 NETDRV_W16 (IntrStatus, 0xffff);
1703 }
1704
1705 spin_unlock (&tp->lock);
1706
1707 DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
1708 dev->name, NETDRV_R16 (IntrStatus));
1709 return IRQ_RETVAL(handled);
1710 }
1711
1712
1713 static int netdrv_close (struct net_device *dev)
1714 {
1715 struct netdrv_private *tp = netdev_priv(dev);
1716 void *ioaddr = tp->mmio_addr;
1717 unsigned long flags;
1718
1719 DPRINTK ("ENTER\n");
1720
1721 netif_stop_queue (dev);
1722
1723 DPRINTK ("%s: Shutting down ethercard, status was 0x%4.4x.\n",
1724 dev->name, NETDRV_R16 (IntrStatus));
1725
1726 del_timer_sync (&tp->timer);
1727
1728 spin_lock_irqsave (&tp->lock, flags);
1729
1730 /* Stop the chip's Tx and Rx DMA processes. */
1731 NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear));
1732
1733 /* Disable interrupts by clearing the interrupt mask. */
1734 NETDRV_W16 (IntrMask, 0x0000);
1735
1736 /* Update the error counts. */
1737 dev->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1738 NETDRV_W32 (RxMissed, 0);
1739
1740 spin_unlock_irqrestore (&tp->lock, flags);
1741
1742 synchronize_irq (dev->irq);
1743 free_irq (dev->irq, dev);
1744
1745 netdrv_tx_clear (dev);
1746
1747 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1748 tp->rx_ring, tp->rx_ring_dma);
1749 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1750 tp->tx_bufs, tp->tx_bufs_dma);
1751 tp->rx_ring = NULL;
1752 tp->tx_bufs = NULL;
1753
1754 /* Green! Put the chip in low-power mode. */
1755 NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1756 NETDRV_W8 (Config1, 0x03);
1757 NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1758
1759 DPRINTK ("EXIT\n");
1760 return 0;
1761 }
1762
1763
1764 static int netdrv_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1765 {
1766 struct netdrv_private *tp = netdev_priv(dev);
1767 struct mii_ioctl_data *data = if_mii(rq);
1768 unsigned long flags;
1769 int rc = 0;
1770
1771 DPRINTK ("ENTER\n");
1772
1773 switch (cmd) {
1774 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
1775 data->phy_id = tp->phys[0] & 0x3f;
1776 /* Fall Through */
1777
1778 case SIOCGMIIREG: /* Read MII PHY register. */
1779 spin_lock_irqsave (&tp->lock, flags);
1780 data->val_out = mdio_read (dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1781 spin_unlock_irqrestore (&tp->lock, flags);
1782 break;
1783
1784 case SIOCSMIIREG: /* Write MII PHY register. */
1785 if (!capable (CAP_NET_ADMIN)) {
1786 rc = -EPERM;
1787 break;
1788 }
1789
1790 spin_lock_irqsave (&tp->lock, flags);
1791 mdio_write (dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1792 spin_unlock_irqrestore (&tp->lock, flags);
1793 break;
1794
1795 default:
1796 rc = -EOPNOTSUPP;
1797 break;
1798 }
1799
1800 DPRINTK ("EXIT, returning %d\n", rc);
1801 return rc;
1802 }
1803
1804 /* Set or clear the multicast filter for this adaptor.
1805 This routine is not state sensitive and need not be SMP locked. */
1806
1807 static void netdrv_set_rx_mode (struct net_device *dev)
1808 {
1809 struct netdrv_private *tp = netdev_priv(dev);
1810 void *ioaddr = tp->mmio_addr;
1811 u32 mc_filter[2]; /* Multicast hash filter */
1812 int i, rx_mode;
1813 u32 tmp;
1814
1815 DPRINTK ("ENTER\n");
1816
1817 DPRINTK ("%s: netdrv_set_rx_mode(%4.4x) done -- Rx config %8.8x.\n",
1818 dev->name, dev->flags, NETDRV_R32 (RxConfig));
1819
1820 /* Note: do not reorder, GCC is clever about common statements. */
1821 if (dev->flags & IFF_PROMISC) {
1822 rx_mode =
1823 AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
1824 AcceptAllPhys;
1825 mc_filter[1] = mc_filter[0] = 0xffffffff;
1826 } else if ((dev->mc_count > multicast_filter_limit)
1827 || (dev->flags & IFF_ALLMULTI)) {
1828 /* Too many to filter perfectly -- accept all multicasts. */
1829 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1830 mc_filter[1] = mc_filter[0] = 0xffffffff;
1831 } else {
1832 struct dev_mc_list *mclist;
1833 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1834 mc_filter[1] = mc_filter[0] = 0;
1835 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1836 i++, mclist = mclist->next) {
1837 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1838
1839 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1840 }
1841 }
1842
1843 /* if called from irq handler, lock already acquired */
1844 if (!in_irq ())
1845 spin_lock_irq (&tp->lock);
1846
1847 /* We can safely update without stopping the chip. */
1848 tmp = netdrv_rx_config | rx_mode |
1849 (NETDRV_R32 (RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1850 NETDRV_W32_F (RxConfig, tmp);
1851 NETDRV_W32_F (MAR0 + 0, mc_filter[0]);
1852 NETDRV_W32_F (MAR0 + 4, mc_filter[1]);
1853
1854 if (!in_irq ())
1855 spin_unlock_irq (&tp->lock);
1856
1857 DPRINTK ("EXIT\n");
1858 }
1859
1860
1861 #ifdef CONFIG_PM
1862
1863 static int netdrv_suspend (struct pci_dev *pdev, pm_message_t state)
1864 {
1865 struct net_device *dev = pci_get_drvdata (pdev);
1866 struct netdrv_private *tp = netdev_priv(dev);
1867 void *ioaddr = tp->mmio_addr;
1868 unsigned long flags;
1869
1870 if (!netif_running(dev))
1871 return 0;
1872 netif_device_detach (dev);
1873
1874 spin_lock_irqsave (&tp->lock, flags);
1875
1876 /* Disable interrupts, stop Tx and Rx. */
1877 NETDRV_W16 (IntrMask, 0x0000);
1878 NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear));
1879
1880 /* Update the error counts. */
1881 dev->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1882 NETDRV_W32 (RxMissed, 0);
1883
1884 spin_unlock_irqrestore (&tp->lock, flags);
1885
1886 pci_save_state (pdev);
1887 pci_set_power_state (pdev, PCI_D3hot);
1888
1889 return 0;
1890 }
1891
1892
1893 static int netdrv_resume (struct pci_dev *pdev)
1894 {
1895 struct net_device *dev = pci_get_drvdata (pdev);
1896 /*struct netdrv_private *tp = netdev_priv(dev);*/
1897
1898 if (!netif_running(dev))
1899 return 0;
1900 pci_set_power_state (pdev, PCI_D0);
1901 pci_restore_state (pdev);
1902 netif_device_attach (dev);
1903 netdrv_hw_start (dev);
1904
1905 return 0;
1906 }
1907
1908 #endif /* CONFIG_PM */
1909
1910
1911 static struct pci_driver netdrv_pci_driver = {
1912 .name = MODNAME,
1913 .id_table = netdrv_pci_tbl,
1914 .probe = netdrv_init_one,
1915 .remove = __devexit_p(netdrv_remove_one),
1916 #ifdef CONFIG_PM
1917 .suspend = netdrv_suspend,
1918 .resume = netdrv_resume,
1919 #endif /* CONFIG_PM */
1920 };
1921
1922
1923 static int __init netdrv_init_module (void)
1924 {
1925 /* when a module, this is printed whether or not devices are found in probe */
1926 #ifdef MODULE
1927 printk(version);
1928 #endif
1929 return pci_register_driver(&netdrv_pci_driver);
1930 }
1931
1932
1933 static void __exit netdrv_cleanup_module (void)
1934 {
1935 pci_unregister_driver (&netdrv_pci_driver);
1936 }
1937
1938
1939 module_init(netdrv_init_module);
1940 module_exit(netdrv_cleanup_module);
mah project overlay