[libata] sata_mv: fix can_queue line accidentally removed in scsi-eh patch
[linux-2.6/suspend2-2.6.18.git] / drivers / net / via-rhine.c
bloba9b2150909d60f03c42690a2ddb645d0d87dd17d
1 /* via-rhine.c: A Linux Ethernet device driver for VIA Rhine family chips. */
2 /*
3 Written 1998-2001 by Donald Becker.
5 Current Maintainer: Roger Luethi <rl@hellgate.ch>
7 This software may be used and distributed according to the terms of
8 the GNU General Public License (GPL), incorporated herein by reference.
9 Drivers based on or derived from this code fall under the GPL and must
10 retain the authorship, copyright and license notice. This file is not
11 a complete program and may only be used when the entire operating
12 system is licensed under the GPL.
14 This driver is designed for the VIA VT86C100A Rhine-I.
15 It also works with the Rhine-II (6102) and Rhine-III (6105/6105L/6105LOM
16 and management NIC 6105M).
18 The author may be reached as becker@scyld.com, or C/O
19 Scyld Computing Corporation
20 410 Severn Ave., Suite 210
21 Annapolis MD 21403
24 This driver contains some changes from the original Donald Becker
25 version. He may or may not be interested in bug reports on this
26 code. You can find his versions at:
27 http://www.scyld.com/network/via-rhine.html
30 Linux kernel version history:
32 LK1.1.0:
33 - Jeff Garzik: softnet 'n stuff
35 LK1.1.1:
36 - Justin Guyett: softnet and locking fixes
37 - Jeff Garzik: use PCI interface
39 LK1.1.2:
40 - Urban Widmark: minor cleanups, merges from Becker 1.03a/1.04 versions
42 LK1.1.3:
43 - Urban Widmark: use PCI DMA interface (with thanks to the eepro100.c
44 code) update "Theory of Operation" with
45 softnet/locking changes
46 - Dave Miller: PCI DMA and endian fixups
47 - Jeff Garzik: MOD_xxx race fixes, updated PCI resource allocation
49 LK1.1.4:
50 - Urban Widmark: fix gcc 2.95.2 problem and
51 remove writel's to fixed address 0x7c
53 LK1.1.5:
54 - Urban Widmark: mdio locking, bounce buffer changes
55 merges from Beckers 1.05 version
56 added netif_running_on/off support
58 LK1.1.6:
59 - Urban Widmark: merges from Beckers 1.08b version (VT6102 + mdio)
60 set netif_running_on/off on startup, del_timer_sync
62 LK1.1.7:
63 - Manfred Spraul: added reset into tx_timeout
65 LK1.1.9:
66 - Urban Widmark: merges from Beckers 1.10 version
67 (media selection + eeprom reload)
68 - David Vrabel: merges from D-Link "1.11" version
69 (disable WOL and PME on startup)
71 LK1.1.10:
72 - Manfred Spraul: use "singlecopy" for unaligned buffers
73 don't allocate bounce buffers for !ReqTxAlign cards
75 LK1.1.11:
76 - David Woodhouse: Set dev->base_addr before the first time we call
77 wait_for_reset(). It's a lot happier that way.
78 Free np->tx_bufs only if we actually allocated it.
80 LK1.1.12:
81 - Martin Eriksson: Allow Memory-Mapped IO to be enabled.
83 LK1.1.13 (jgarzik):
84 - Add ethtool support
85 - Replace some MII-related magic numbers with constants
87 LK1.1.14 (Ivan G.):
88 - fixes comments for Rhine-III
89 - removes W_MAX_TIMEOUT (unused)
90 - adds HasDavicomPhy for Rhine-I (basis: linuxfet driver; my card
91 is R-I and has Davicom chip, flag is referenced in kernel driver)
92 - sends chip_id as a parameter to wait_for_reset since np is not
93 initialized on first call
94 - changes mmio "else if (chip_id==VT6102)" to "else" so it will work
95 for Rhine-III's (documentation says same bit is correct)
96 - transmit frame queue message is off by one - fixed
97 - adds IntrNormalSummary to "Something Wicked" exclusion list
98 so normal interrupts will not trigger the message (src: Donald Becker)
99 (Roger Luethi)
100 - show confused chip where to continue after Tx error
101 - location of collision counter is chip specific
102 - allow selecting backoff algorithm (module parameter)
104 LK1.1.15 (jgarzik):
105 - Use new MII lib helper generic_mii_ioctl
107 LK1.1.16 (Roger Luethi)
108 - Etherleak fix
109 - Handle Tx buffer underrun
110 - Fix bugs in full duplex handling
111 - New reset code uses "force reset" cmd on Rhine-II
112 - Various clean ups
114 LK1.1.17 (Roger Luethi)
115 - Fix race in via_rhine_start_tx()
116 - On errors, wait for Tx engine to turn off before scavenging
117 - Handle Tx descriptor write-back race on Rhine-II
118 - Force flushing for PCI posted writes
119 - More reset code changes
121 LK1.1.18 (Roger Luethi)
122 - No filtering multicast in promisc mode (Edward Peng)
123 - Fix for Rhine-I Tx timeouts
125 LK1.1.19 (Roger Luethi)
126 - Increase Tx threshold for unspecified errors
128 LK1.2.0-2.6 (Roger Luethi)
129 - Massive clean-up
130 - Rewrite PHY, media handling (remove options, full_duplex, backoff)
131 - Fix Tx engine race for good
135 #define DRV_NAME "via-rhine"
136 #define DRV_VERSION "1.2.0-2.6"
137 #define DRV_RELDATE "June-10-2004"
140 /* A few user-configurable values.
141 These may be modified when a driver module is loaded. */
143 static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
144 static int max_interrupt_work = 20;
146 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
147 Setting to > 1518 effectively disables this feature. */
148 static int rx_copybreak;
151 * In case you are looking for 'options[]' or 'full_duplex[]', they
152 * are gone. Use ethtool(8) instead.
155 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
156 The Rhine has a 64 element 8390-like hash table. */
157 static const int multicast_filter_limit = 32;
160 /* Operational parameters that are set at compile time. */
162 /* Keep the ring sizes a power of two for compile efficiency.
163 The compiler will convert <unsigned>'%'<2^N> into a bit mask.
164 Making the Tx ring too large decreases the effectiveness of channel
165 bonding and packet priority.
166 There are no ill effects from too-large receive rings. */
167 #define TX_RING_SIZE 16
168 #define TX_QUEUE_LEN 10 /* Limit ring entries actually used. */
169 #define RX_RING_SIZE 16
172 /* Operational parameters that usually are not changed. */
174 /* Time in jiffies before concluding the transmitter is hung. */
175 #define TX_TIMEOUT (2*HZ)
177 #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
179 #include <linux/module.h>
180 #include <linux/moduleparam.h>
181 #include <linux/kernel.h>
182 #include <linux/string.h>
183 #include <linux/timer.h>
184 #include <linux/errno.h>
185 #include <linux/ioport.h>
186 #include <linux/slab.h>
187 #include <linux/interrupt.h>
188 #include <linux/pci.h>
189 #include <linux/dma-mapping.h>
190 #include <linux/netdevice.h>
191 #include <linux/etherdevice.h>
192 #include <linux/skbuff.h>
193 #include <linux/init.h>
194 #include <linux/delay.h>
195 #include <linux/mii.h>
196 #include <linux/ethtool.h>
197 #include <linux/crc32.h>
198 #include <linux/bitops.h>
199 #include <asm/processor.h> /* Processor type for cache alignment. */
200 #include <asm/io.h>
201 #include <asm/irq.h>
202 #include <asm/uaccess.h>
204 /* These identify the driver base version and may not be removed. */
205 static char version[] __devinitdata =
206 KERN_INFO DRV_NAME ".c:v1.10-LK" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker\n";
208 /* This driver was written to use PCI memory space. Some early versions
209 of the Rhine may only work correctly with I/O space accesses. */
210 #ifdef CONFIG_VIA_RHINE_MMIO
211 #define USE_MMIO
212 #else
213 #endif
215 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
216 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");
217 MODULE_LICENSE("GPL");
219 module_param(max_interrupt_work, int, 0);
220 module_param(debug, int, 0);
221 module_param(rx_copybreak, int, 0);
222 MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");
223 MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");
224 MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames");
227 Theory of Operation
229 I. Board Compatibility
231 This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet
232 controller.
234 II. Board-specific settings
236 Boards with this chip are functional only in a bus-master PCI slot.
238 Many operational settings are loaded from the EEPROM to the Config word at
239 offset 0x78. For most of these settings, this driver assumes that they are
240 correct.
241 If this driver is compiled to use PCI memory space operations the EEPROM
242 must be configured to enable memory ops.
244 III. Driver operation
246 IIIa. Ring buffers
248 This driver uses two statically allocated fixed-size descriptor lists
249 formed into rings by a branch from the final descriptor to the beginning of
250 the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.
252 IIIb/c. Transmit/Receive Structure
254 This driver attempts to use a zero-copy receive and transmit scheme.
256 Alas, all data buffers are required to start on a 32 bit boundary, so
257 the driver must often copy transmit packets into bounce buffers.
259 The driver allocates full frame size skbuffs for the Rx ring buffers at
260 open() time and passes the skb->data field to the chip as receive data
261 buffers. When an incoming frame is less than RX_COPYBREAK bytes long,
262 a fresh skbuff is allocated and the frame is copied to the new skbuff.
263 When the incoming frame is larger, the skbuff is passed directly up the
264 protocol stack. Buffers consumed this way are replaced by newly allocated
265 skbuffs in the last phase of rhine_rx().
267 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
268 using a full-sized skbuff for small frames vs. the copying costs of larger
269 frames. New boards are typically used in generously configured machines
270 and the underfilled buffers have negligible impact compared to the benefit of
271 a single allocation size, so the default value of zero results in never
272 copying packets. When copying is done, the cost is usually mitigated by using
273 a combined copy/checksum routine. Copying also preloads the cache, which is
274 most useful with small frames.
276 Since the VIA chips are only able to transfer data to buffers on 32 bit
277 boundaries, the IP header at offset 14 in an ethernet frame isn't
278 longword aligned for further processing. Copying these unaligned buffers
279 has the beneficial effect of 16-byte aligning the IP header.
281 IIId. Synchronization
283 The driver runs as two independent, single-threaded flows of control. One
284 is the send-packet routine, which enforces single-threaded use by the
285 dev->priv->lock spinlock. The other thread is the interrupt handler, which
286 is single threaded by the hardware and interrupt handling software.
288 The send packet thread has partial control over the Tx ring. It locks the
289 dev->priv->lock whenever it's queuing a Tx packet. If the next slot in the ring
290 is not available it stops the transmit queue by calling netif_stop_queue.
292 The interrupt handler has exclusive control over the Rx ring and records stats
293 from the Tx ring. After reaping the stats, it marks the Tx queue entry as
294 empty by incrementing the dirty_tx mark. If at least half of the entries in
295 the Rx ring are available the transmit queue is woken up if it was stopped.
297 IV. Notes
299 IVb. References
301 Preliminary VT86C100A manual from http://www.via.com.tw/
302 http://www.scyld.com/expert/100mbps.html
303 http://www.scyld.com/expert/NWay.html
304 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf
305 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF
308 IVc. Errata
310 The VT86C100A manual is not reliable information.
311 The 3043 chip does not handle unaligned transmit or receive buffers, resulting
312 in significant performance degradation for bounce buffer copies on transmit
313 and unaligned IP headers on receive.
314 The chip does not pad to minimum transmit length.
319 /* This table drives the PCI probe routines. It's mostly boilerplate in all
320 of the drivers, and will likely be provided by some future kernel.
321 Note the matching code -- the first table entry matchs all 56** cards but
322 second only the 1234 card.
325 enum rhine_revs {
326 VT86C100A = 0x00,
327 VTunknown0 = 0x20,
328 VT6102 = 0x40,
329 VT8231 = 0x50, /* Integrated MAC */
330 VT8233 = 0x60, /* Integrated MAC */
331 VT8235 = 0x74, /* Integrated MAC */
332 VT8237 = 0x78, /* Integrated MAC */
333 VTunknown1 = 0x7C,
334 VT6105 = 0x80,
335 VT6105_B0 = 0x83,
336 VT6105L = 0x8A,
337 VT6107 = 0x8C,
338 VTunknown2 = 0x8E,
339 VT6105M = 0x90, /* Management adapter */
342 enum rhine_quirks {
343 rqWOL = 0x0001, /* Wake-On-LAN support */
344 rqForceReset = 0x0002,
345 rq6patterns = 0x0040, /* 6 instead of 4 patterns for WOL */
346 rqStatusWBRace = 0x0080, /* Tx Status Writeback Error possible */
347 rqRhineI = 0x0100, /* See comment below */
350 * rqRhineI: VT86C100A (aka Rhine-I) uses different bits to enable
351 * MMIO as well as for the collision counter and the Tx FIFO underflow
352 * indicator. In addition, Tx and Rx buffers need to 4 byte aligned.
355 /* Beware of PCI posted writes */
356 #define IOSYNC do { ioread8(ioaddr + StationAddr); } while (0)
358 static struct pci_device_id rhine_pci_tbl[] =
360 {0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, 0, 0, }, /* VT86C100A */
361 {0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, 0, 0, }, /* VT6102 */
362 {0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, }, /* 6105{,L,LOM} */
363 {0x1106, 0x3053, PCI_ANY_ID, PCI_ANY_ID, 0, 0, }, /* VT6105M */
364 { } /* terminate list */
366 MODULE_DEVICE_TABLE(pci, rhine_pci_tbl);
369 /* Offsets to the device registers. */
370 enum register_offsets {
371 StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08,
372 ChipCmd1=0x09,
373 IntrStatus=0x0C, IntrEnable=0x0E,
374 MulticastFilter0=0x10, MulticastFilter1=0x14,
375 RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54,
376 MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E,
377 MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74,
378 ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B,
379 RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81,
380 StickyHW=0x83, IntrStatus2=0x84,
381 WOLcrSet=0xA0, PwcfgSet=0xA1, WOLcgSet=0xA3, WOLcrClr=0xA4,
382 WOLcrClr1=0xA6, WOLcgClr=0xA7,
383 PwrcsrSet=0xA8, PwrcsrSet1=0xA9, PwrcsrClr=0xAC, PwrcsrClr1=0xAD,
386 /* Bits in ConfigD */
387 enum backoff_bits {
388 BackOptional=0x01, BackModify=0x02,
389 BackCaptureEffect=0x04, BackRandom=0x08
392 #ifdef USE_MMIO
393 /* Registers we check that mmio and reg are the same. */
394 static const int mmio_verify_registers[] = {
395 RxConfig, TxConfig, IntrEnable, ConfigA, ConfigB, ConfigC, ConfigD,
398 #endif
400 /* Bits in the interrupt status/mask registers. */
401 enum intr_status_bits {
402 IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,
403 IntrTxDone=0x0002, IntrTxError=0x0008, IntrTxUnderrun=0x0210,
404 IntrPCIErr=0x0040,
405 IntrStatsMax=0x0080, IntrRxEarly=0x0100,
406 IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,
407 IntrTxAborted=0x2000, IntrLinkChange=0x4000,
408 IntrRxWakeUp=0x8000,
409 IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,
410 IntrTxDescRace=0x080000, /* mapped from IntrStatus2 */
411 IntrTxErrSummary=0x082218,
414 /* Bits in WOLcrSet/WOLcrClr and PwrcsrSet/PwrcsrClr */
415 enum wol_bits {
416 WOLucast = 0x10,
417 WOLmagic = 0x20,
418 WOLbmcast = 0x30,
419 WOLlnkon = 0x40,
420 WOLlnkoff = 0x80,
423 /* The Rx and Tx buffer descriptors. */
424 struct rx_desc {
425 s32 rx_status;
426 u32 desc_length; /* Chain flag, Buffer/frame length */
427 u32 addr;
428 u32 next_desc;
430 struct tx_desc {
431 s32 tx_status;
432 u32 desc_length; /* Chain flag, Tx Config, Frame length */
433 u32 addr;
434 u32 next_desc;
437 /* Initial value for tx_desc.desc_length, Buffer size goes to bits 0-10 */
438 #define TXDESC 0x00e08000
440 enum rx_status_bits {
441 RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F
444 /* Bits in *_desc.*_status */
445 enum desc_status_bits {
446 DescOwn=0x80000000
449 /* Bits in ChipCmd. */
450 enum chip_cmd_bits {
451 CmdInit=0x01, CmdStart=0x02, CmdStop=0x04, CmdRxOn=0x08,
452 CmdTxOn=0x10, Cmd1TxDemand=0x20, CmdRxDemand=0x40,
453 Cmd1EarlyRx=0x01, Cmd1EarlyTx=0x02, Cmd1FDuplex=0x04,
454 Cmd1NoTxPoll=0x08, Cmd1Reset=0x80,
457 struct rhine_private {
458 /* Descriptor rings */
459 struct rx_desc *rx_ring;
460 struct tx_desc *tx_ring;
461 dma_addr_t rx_ring_dma;
462 dma_addr_t tx_ring_dma;
464 /* The addresses of receive-in-place skbuffs. */
465 struct sk_buff *rx_skbuff[RX_RING_SIZE];
466 dma_addr_t rx_skbuff_dma[RX_RING_SIZE];
468 /* The saved address of a sent-in-place packet/buffer, for later free(). */
469 struct sk_buff *tx_skbuff[TX_RING_SIZE];
470 dma_addr_t tx_skbuff_dma[TX_RING_SIZE];
472 /* Tx bounce buffers */
473 unsigned char *tx_buf[TX_RING_SIZE];
474 unsigned char *tx_bufs;
475 dma_addr_t tx_bufs_dma;
477 struct pci_dev *pdev;
478 long pioaddr;
479 struct net_device_stats stats;
480 spinlock_t lock;
482 /* Frequently used values: keep some adjacent for cache effect. */
483 u32 quirks;
484 struct rx_desc *rx_head_desc;
485 unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */
486 unsigned int cur_tx, dirty_tx;
487 unsigned int rx_buf_sz; /* Based on MTU+slack. */
488 u8 wolopts;
490 u8 tx_thresh, rx_thresh;
492 struct mii_if_info mii_if;
493 struct work_struct tx_timeout_task;
494 struct work_struct check_media_task;
495 void __iomem *base;
498 static int mdio_read(struct net_device *dev, int phy_id, int location);
499 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
500 static int rhine_open(struct net_device *dev);
501 static void rhine_tx_timeout(struct net_device *dev);
502 static void rhine_tx_timeout_task(struct net_device *dev);
503 static void rhine_check_media_task(struct net_device *dev);
504 static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
505 static irqreturn_t rhine_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
506 static void rhine_tx(struct net_device *dev);
507 static void rhine_rx(struct net_device *dev);
508 static void rhine_error(struct net_device *dev, int intr_status);
509 static void rhine_set_rx_mode(struct net_device *dev);
510 static struct net_device_stats *rhine_get_stats(struct net_device *dev);
511 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
512 static struct ethtool_ops netdev_ethtool_ops;
513 static int rhine_close(struct net_device *dev);
514 static void rhine_shutdown (struct pci_dev *pdev);
516 #define RHINE_WAIT_FOR(condition) do { \
517 int i=1024; \
518 while (!(condition) && --i) \
520 if (debug > 1 && i < 512) \
521 printk(KERN_INFO "%s: %4d cycles used @ %s:%d\n", \
522 DRV_NAME, 1024-i, __func__, __LINE__); \
523 } while(0)
525 static inline u32 get_intr_status(struct net_device *dev)
527 struct rhine_private *rp = netdev_priv(dev);
528 void __iomem *ioaddr = rp->base;
529 u32 intr_status;
531 intr_status = ioread16(ioaddr + IntrStatus);
532 /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
533 if (rp->quirks & rqStatusWBRace)
534 intr_status |= ioread8(ioaddr + IntrStatus2) << 16;
535 return intr_status;
539 * Get power related registers into sane state.
540 * Notify user about past WOL event.
542 static void rhine_power_init(struct net_device *dev)
544 struct rhine_private *rp = netdev_priv(dev);
545 void __iomem *ioaddr = rp->base;
546 u16 wolstat;
548 if (rp->quirks & rqWOL) {
549 /* Make sure chip is in power state D0 */
550 iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW);
552 /* Disable "force PME-enable" */
553 iowrite8(0x80, ioaddr + WOLcgClr);
555 /* Clear power-event config bits (WOL) */
556 iowrite8(0xFF, ioaddr + WOLcrClr);
557 /* More recent cards can manage two additional patterns */
558 if (rp->quirks & rq6patterns)
559 iowrite8(0x03, ioaddr + WOLcrClr1);
561 /* Save power-event status bits */
562 wolstat = ioread8(ioaddr + PwrcsrSet);
563 if (rp->quirks & rq6patterns)
564 wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8;
566 /* Clear power-event status bits */
567 iowrite8(0xFF, ioaddr + PwrcsrClr);
568 if (rp->quirks & rq6patterns)
569 iowrite8(0x03, ioaddr + PwrcsrClr1);
571 if (wolstat) {
572 char *reason;
573 switch (wolstat) {
574 case WOLmagic:
575 reason = "Magic packet";
576 break;
577 case WOLlnkon:
578 reason = "Link went up";
579 break;
580 case WOLlnkoff:
581 reason = "Link went down";
582 break;
583 case WOLucast:
584 reason = "Unicast packet";
585 break;
586 case WOLbmcast:
587 reason = "Multicast/broadcast packet";
588 break;
589 default:
590 reason = "Unknown";
592 printk(KERN_INFO "%s: Woke system up. Reason: %s.\n",
593 DRV_NAME, reason);
598 static void rhine_chip_reset(struct net_device *dev)
600 struct rhine_private *rp = netdev_priv(dev);
601 void __iomem *ioaddr = rp->base;
603 iowrite8(Cmd1Reset, ioaddr + ChipCmd1);
604 IOSYNC;
606 if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) {
607 printk(KERN_INFO "%s: Reset not complete yet. "
608 "Trying harder.\n", DRV_NAME);
610 /* Force reset */
611 if (rp->quirks & rqForceReset)
612 iowrite8(0x40, ioaddr + MiscCmd);
614 /* Reset can take somewhat longer (rare) */
615 RHINE_WAIT_FOR(!(ioread8(ioaddr + ChipCmd1) & Cmd1Reset));
618 if (debug > 1)
619 printk(KERN_INFO "%s: Reset %s.\n", dev->name,
620 (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) ?
621 "failed" : "succeeded");
624 #ifdef USE_MMIO
625 static void enable_mmio(long pioaddr, u32 quirks)
627 int n;
628 if (quirks & rqRhineI) {
629 /* More recent docs say that this bit is reserved ... */
630 n = inb(pioaddr + ConfigA) | 0x20;
631 outb(n, pioaddr + ConfigA);
632 } else {
633 n = inb(pioaddr + ConfigD) | 0x80;
634 outb(n, pioaddr + ConfigD);
637 #endif
640 * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM
641 * (plus 0x6C for Rhine-I/II)
643 static void __devinit rhine_reload_eeprom(long pioaddr, struct net_device *dev)
645 struct rhine_private *rp = netdev_priv(dev);
646 void __iomem *ioaddr = rp->base;
648 outb(0x20, pioaddr + MACRegEEcsr);
649 RHINE_WAIT_FOR(!(inb(pioaddr + MACRegEEcsr) & 0x20));
651 #ifdef USE_MMIO
653 * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable
654 * MMIO. If reloading EEPROM was done first this could be avoided, but
655 * it is not known if that still works with the "win98-reboot" problem.
657 enable_mmio(pioaddr, rp->quirks);
658 #endif
660 /* Turn off EEPROM-controlled wake-up (magic packet) */
661 if (rp->quirks & rqWOL)
662 iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA);
666 #ifdef CONFIG_NET_POLL_CONTROLLER
667 static void rhine_poll(struct net_device *dev)
669 disable_irq(dev->irq);
670 rhine_interrupt(dev->irq, (void *)dev, NULL);
671 enable_irq(dev->irq);
673 #endif
675 static void rhine_hw_init(struct net_device *dev, long pioaddr)
677 struct rhine_private *rp = netdev_priv(dev);
679 /* Reset the chip to erase previous misconfiguration. */
680 rhine_chip_reset(dev);
682 /* Rhine-I needs extra time to recuperate before EEPROM reload */
683 if (rp->quirks & rqRhineI)
684 msleep(5);
686 /* Reload EEPROM controlled bytes cleared by soft reset */
687 rhine_reload_eeprom(pioaddr, dev);
690 static int __devinit rhine_init_one(struct pci_dev *pdev,
691 const struct pci_device_id *ent)
693 struct net_device *dev;
694 struct rhine_private *rp;
695 int i, rc;
696 u8 pci_rev;
697 u32 quirks;
698 long pioaddr;
699 long memaddr;
700 void __iomem *ioaddr;
701 int io_size, phy_id;
702 const char *name;
703 #ifdef USE_MMIO
704 int bar = 1;
705 #else
706 int bar = 0;
707 #endif
709 /* when built into the kernel, we only print version if device is found */
710 #ifndef MODULE
711 static int printed_version;
712 if (!printed_version++)
713 printk(version);
714 #endif
716 pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);
718 io_size = 256;
719 phy_id = 0;
720 quirks = 0;
721 name = "Rhine";
722 if (pci_rev < VTunknown0) {
723 quirks = rqRhineI;
724 io_size = 128;
726 else if (pci_rev >= VT6102) {
727 quirks = rqWOL | rqForceReset;
728 if (pci_rev < VT6105) {
729 name = "Rhine II";
730 quirks |= rqStatusWBRace; /* Rhine-II exclusive */
732 else {
733 phy_id = 1; /* Integrated PHY, phy_id fixed to 1 */
734 if (pci_rev >= VT6105_B0)
735 quirks |= rq6patterns;
736 if (pci_rev < VT6105M)
737 name = "Rhine III";
738 else
739 name = "Rhine III (Management Adapter)";
743 rc = pci_enable_device(pdev);
744 if (rc)
745 goto err_out;
747 /* this should always be supported */
748 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
749 if (rc) {
750 printk(KERN_ERR "32-bit PCI DMA addresses not supported by "
751 "the card!?\n");
752 goto err_out;
755 /* sanity check */
756 if ((pci_resource_len(pdev, 0) < io_size) ||
757 (pci_resource_len(pdev, 1) < io_size)) {
758 rc = -EIO;
759 printk(KERN_ERR "Insufficient PCI resources, aborting\n");
760 goto err_out;
763 pioaddr = pci_resource_start(pdev, 0);
764 memaddr = pci_resource_start(pdev, 1);
766 pci_set_master(pdev);
768 dev = alloc_etherdev(sizeof(struct rhine_private));
769 if (!dev) {
770 rc = -ENOMEM;
771 printk(KERN_ERR "alloc_etherdev failed\n");
772 goto err_out;
774 SET_MODULE_OWNER(dev);
775 SET_NETDEV_DEV(dev, &pdev->dev);
777 rp = netdev_priv(dev);
778 rp->quirks = quirks;
779 rp->pioaddr = pioaddr;
780 rp->pdev = pdev;
782 rc = pci_request_regions(pdev, DRV_NAME);
783 if (rc)
784 goto err_out_free_netdev;
786 ioaddr = pci_iomap(pdev, bar, io_size);
787 if (!ioaddr) {
788 rc = -EIO;
789 printk(KERN_ERR "ioremap failed for device %s, region 0x%X "
790 "@ 0x%lX\n", pci_name(pdev), io_size, memaddr);
791 goto err_out_free_res;
794 #ifdef USE_MMIO
795 enable_mmio(pioaddr, quirks);
797 /* Check that selected MMIO registers match the PIO ones */
798 i = 0;
799 while (mmio_verify_registers[i]) {
800 int reg = mmio_verify_registers[i++];
801 unsigned char a = inb(pioaddr+reg);
802 unsigned char b = readb(ioaddr+reg);
803 if (a != b) {
804 rc = -EIO;
805 printk(KERN_ERR "MMIO do not match PIO [%02x] "
806 "(%02x != %02x)\n", reg, a, b);
807 goto err_out_unmap;
810 #endif /* USE_MMIO */
812 dev->base_addr = (unsigned long)ioaddr;
813 rp->base = ioaddr;
815 /* Get chip registers into a sane state */
816 rhine_power_init(dev);
817 rhine_hw_init(dev, pioaddr);
819 for (i = 0; i < 6; i++)
820 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i);
821 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
823 if (!is_valid_ether_addr(dev->perm_addr)) {
824 rc = -EIO;
825 printk(KERN_ERR "Invalid MAC address\n");
826 goto err_out_unmap;
829 /* For Rhine-I/II, phy_id is loaded from EEPROM */
830 if (!phy_id)
831 phy_id = ioread8(ioaddr + 0x6C);
833 dev->irq = pdev->irq;
835 spin_lock_init(&rp->lock);
836 rp->mii_if.dev = dev;
837 rp->mii_if.mdio_read = mdio_read;
838 rp->mii_if.mdio_write = mdio_write;
839 rp->mii_if.phy_id_mask = 0x1f;
840 rp->mii_if.reg_num_mask = 0x1f;
842 /* The chip-specific entries in the device structure. */
843 dev->open = rhine_open;
844 dev->hard_start_xmit = rhine_start_tx;
845 dev->stop = rhine_close;
846 dev->get_stats = rhine_get_stats;
847 dev->set_multicast_list = rhine_set_rx_mode;
848 dev->do_ioctl = netdev_ioctl;
849 dev->ethtool_ops = &netdev_ethtool_ops;
850 dev->tx_timeout = rhine_tx_timeout;
851 dev->watchdog_timeo = TX_TIMEOUT;
852 #ifdef CONFIG_NET_POLL_CONTROLLER
853 dev->poll_controller = rhine_poll;
854 #endif
855 if (rp->quirks & rqRhineI)
856 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
858 INIT_WORK(&rp->tx_timeout_task,
859 (void (*)(void *))rhine_tx_timeout_task, dev);
861 INIT_WORK(&rp->check_media_task,
862 (void (*)(void *))rhine_check_media_task, dev);
864 /* dev->name not defined before register_netdev()! */
865 rc = register_netdev(dev);
866 if (rc)
867 goto err_out_unmap;
869 printk(KERN_INFO "%s: VIA %s at 0x%lx, ",
870 dev->name, name,
871 #ifdef USE_MMIO
872 memaddr
873 #else
874 (long)ioaddr
875 #endif
878 for (i = 0; i < 5; i++)
879 printk("%2.2x:", dev->dev_addr[i]);
880 printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], pdev->irq);
882 pci_set_drvdata(pdev, dev);
885 u16 mii_cmd;
886 int mii_status = mdio_read(dev, phy_id, 1);
887 mii_cmd = mdio_read(dev, phy_id, MII_BMCR) & ~BMCR_ISOLATE;
888 mdio_write(dev, phy_id, MII_BMCR, mii_cmd);
889 if (mii_status != 0xffff && mii_status != 0x0000) {
890 rp->mii_if.advertising = mdio_read(dev, phy_id, 4);
891 printk(KERN_INFO "%s: MII PHY found at address "
892 "%d, status 0x%4.4x advertising %4.4x "
893 "Link %4.4x.\n", dev->name, phy_id,
894 mii_status, rp->mii_if.advertising,
895 mdio_read(dev, phy_id, 5));
897 /* set IFF_RUNNING */
898 if (mii_status & BMSR_LSTATUS)
899 netif_carrier_on(dev);
900 else
901 netif_carrier_off(dev);
905 rp->mii_if.phy_id = phy_id;
907 return 0;
909 err_out_unmap:
910 pci_iounmap(pdev, ioaddr);
911 err_out_free_res:
912 pci_release_regions(pdev);
913 err_out_free_netdev:
914 free_netdev(dev);
915 err_out:
916 return rc;
919 static int alloc_ring(struct net_device* dev)
921 struct rhine_private *rp = netdev_priv(dev);
922 void *ring;
923 dma_addr_t ring_dma;
925 ring = pci_alloc_consistent(rp->pdev,
926 RX_RING_SIZE * sizeof(struct rx_desc) +
927 TX_RING_SIZE * sizeof(struct tx_desc),
928 &ring_dma);
929 if (!ring) {
930 printk(KERN_ERR "Could not allocate DMA memory.\n");
931 return -ENOMEM;
933 if (rp->quirks & rqRhineI) {
934 rp->tx_bufs = pci_alloc_consistent(rp->pdev,
935 PKT_BUF_SZ * TX_RING_SIZE,
936 &rp->tx_bufs_dma);
937 if (rp->tx_bufs == NULL) {
938 pci_free_consistent(rp->pdev,
939 RX_RING_SIZE * sizeof(struct rx_desc) +
940 TX_RING_SIZE * sizeof(struct tx_desc),
941 ring, ring_dma);
942 return -ENOMEM;
946 rp->rx_ring = ring;
947 rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
948 rp->rx_ring_dma = ring_dma;
949 rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
951 return 0;
954 static void free_ring(struct net_device* dev)
956 struct rhine_private *rp = netdev_priv(dev);
958 pci_free_consistent(rp->pdev,
959 RX_RING_SIZE * sizeof(struct rx_desc) +
960 TX_RING_SIZE * sizeof(struct tx_desc),
961 rp->rx_ring, rp->rx_ring_dma);
962 rp->tx_ring = NULL;
964 if (rp->tx_bufs)
965 pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE,
966 rp->tx_bufs, rp->tx_bufs_dma);
968 rp->tx_bufs = NULL;
972 static void alloc_rbufs(struct net_device *dev)
974 struct rhine_private *rp = netdev_priv(dev);
975 dma_addr_t next;
976 int i;
978 rp->dirty_rx = rp->cur_rx = 0;
980 rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
981 rp->rx_head_desc = &rp->rx_ring[0];
982 next = rp->rx_ring_dma;
984 /* Init the ring entries */
985 for (i = 0; i < RX_RING_SIZE; i++) {
986 rp->rx_ring[i].rx_status = 0;
987 rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz);
988 next += sizeof(struct rx_desc);
989 rp->rx_ring[i].next_desc = cpu_to_le32(next);
990 rp->rx_skbuff[i] = NULL;
992 /* Mark the last entry as wrapping the ring. */
993 rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma);
995 /* Fill in the Rx buffers. Handle allocation failure gracefully. */
996 for (i = 0; i < RX_RING_SIZE; i++) {
997 struct sk_buff *skb = dev_alloc_skb(rp->rx_buf_sz);
998 rp->rx_skbuff[i] = skb;
999 if (skb == NULL)
1000 break;
1001 skb->dev = dev; /* Mark as being used by this device. */
1003 rp->rx_skbuff_dma[i] =
1004 pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz,
1005 PCI_DMA_FROMDEVICE);
1007 rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);
1008 rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
1010 rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1013 static void free_rbufs(struct net_device* dev)
1015 struct rhine_private *rp = netdev_priv(dev);
1016 int i;
1018 /* Free all the skbuffs in the Rx queue. */
1019 for (i = 0; i < RX_RING_SIZE; i++) {
1020 rp->rx_ring[i].rx_status = 0;
1021 rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
1022 if (rp->rx_skbuff[i]) {
1023 pci_unmap_single(rp->pdev,
1024 rp->rx_skbuff_dma[i],
1025 rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1026 dev_kfree_skb(rp->rx_skbuff[i]);
1028 rp->rx_skbuff[i] = NULL;
1032 static void alloc_tbufs(struct net_device* dev)
1034 struct rhine_private *rp = netdev_priv(dev);
1035 dma_addr_t next;
1036 int i;
1038 rp->dirty_tx = rp->cur_tx = 0;
1039 next = rp->tx_ring_dma;
1040 for (i = 0; i < TX_RING_SIZE; i++) {
1041 rp->tx_skbuff[i] = NULL;
1042 rp->tx_ring[i].tx_status = 0;
1043 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
1044 next += sizeof(struct tx_desc);
1045 rp->tx_ring[i].next_desc = cpu_to_le32(next);
1046 rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ];
1048 rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma);
1052 static void free_tbufs(struct net_device* dev)
1054 struct rhine_private *rp = netdev_priv(dev);
1055 int i;
1057 for (i = 0; i < TX_RING_SIZE; i++) {
1058 rp->tx_ring[i].tx_status = 0;
1059 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
1060 rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
1061 if (rp->tx_skbuff[i]) {
1062 if (rp->tx_skbuff_dma[i]) {
1063 pci_unmap_single(rp->pdev,
1064 rp->tx_skbuff_dma[i],
1065 rp->tx_skbuff[i]->len,
1066 PCI_DMA_TODEVICE);
1068 dev_kfree_skb(rp->tx_skbuff[i]);
1070 rp->tx_skbuff[i] = NULL;
1071 rp->tx_buf[i] = NULL;
1075 static void rhine_check_media(struct net_device *dev, unsigned int init_media)
1077 struct rhine_private *rp = netdev_priv(dev);
1078 void __iomem *ioaddr = rp->base;
1080 mii_check_media(&rp->mii_if, debug, init_media);
1082 if (rp->mii_if.full_duplex)
1083 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,
1084 ioaddr + ChipCmd1);
1085 else
1086 iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex,
1087 ioaddr + ChipCmd1);
1088 if (debug > 1)
1089 printk(KERN_INFO "%s: force_media %d, carrier %d\n", dev->name,
1090 rp->mii_if.force_media, netif_carrier_ok(dev));
1093 /* Called after status of force_media possibly changed */
1094 void rhine_set_carrier(struct mii_if_info *mii)
1096 if (mii->force_media) {
1097 /* autoneg is off: Link is always assumed to be up */
1098 if (!netif_carrier_ok(mii->dev))
1099 netif_carrier_on(mii->dev);
1101 else /* Let MMI library update carrier status */
1102 rhine_check_media(mii->dev, 0);
1103 if (debug > 1)
1104 printk(KERN_INFO "%s: force_media %d, carrier %d\n",
1105 mii->dev->name, mii->force_media,
1106 netif_carrier_ok(mii->dev));
1109 static void rhine_check_media_task(struct net_device *dev)
1111 rhine_check_media(dev, 0);
1114 static void init_registers(struct net_device *dev)
1116 struct rhine_private *rp = netdev_priv(dev);
1117 void __iomem *ioaddr = rp->base;
1118 int i;
1120 for (i = 0; i < 6; i++)
1121 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i);
1123 /* Initialize other registers. */
1124 iowrite16(0x0006, ioaddr + PCIBusConfig); /* Tune configuration??? */
1125 /* Configure initial FIFO thresholds. */
1126 iowrite8(0x20, ioaddr + TxConfig);
1127 rp->tx_thresh = 0x20;
1128 rp->rx_thresh = 0x60; /* Written in rhine_set_rx_mode(). */
1130 iowrite32(rp->rx_ring_dma, ioaddr + RxRingPtr);
1131 iowrite32(rp->tx_ring_dma, ioaddr + TxRingPtr);
1133 rhine_set_rx_mode(dev);
1135 /* Enable interrupts by setting the interrupt mask. */
1136 iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
1137 IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
1138 IntrTxDone | IntrTxError | IntrTxUnderrun |
1139 IntrPCIErr | IntrStatsMax | IntrLinkChange,
1140 ioaddr + IntrEnable);
1142 iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8),
1143 ioaddr + ChipCmd);
1144 rhine_check_media(dev, 1);
1147 /* Enable MII link status auto-polling (required for IntrLinkChange) */
1148 static void rhine_enable_linkmon(void __iomem *ioaddr)
1150 iowrite8(0, ioaddr + MIICmd);
1151 iowrite8(MII_BMSR, ioaddr + MIIRegAddr);
1152 iowrite8(0x80, ioaddr + MIICmd);
1154 RHINE_WAIT_FOR((ioread8(ioaddr + MIIRegAddr) & 0x20));
1156 iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr);
1159 /* Disable MII link status auto-polling (required for MDIO access) */
1160 static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
1162 iowrite8(0, ioaddr + MIICmd);
1164 if (quirks & rqRhineI) {
1165 iowrite8(0x01, ioaddr + MIIRegAddr); // MII_BMSR
1167 /* Do not call from ISR! */
1168 msleep(1);
1170 /* 0x80 must be set immediately before turning it off */
1171 iowrite8(0x80, ioaddr + MIICmd);
1173 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x20);
1175 /* Heh. Now clear 0x80 again. */
1176 iowrite8(0, ioaddr + MIICmd);
1178 else
1179 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x80);
1182 /* Read and write over the MII Management Data I/O (MDIO) interface. */
1184 static int mdio_read(struct net_device *dev, int phy_id, int regnum)
1186 struct rhine_private *rp = netdev_priv(dev);
1187 void __iomem *ioaddr = rp->base;
1188 int result;
1190 rhine_disable_linkmon(ioaddr, rp->quirks);
1192 /* rhine_disable_linkmon already cleared MIICmd */
1193 iowrite8(phy_id, ioaddr + MIIPhyAddr);
1194 iowrite8(regnum, ioaddr + MIIRegAddr);
1195 iowrite8(0x40, ioaddr + MIICmd); /* Trigger read */
1196 RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x40));
1197 result = ioread16(ioaddr + MIIData);
1199 rhine_enable_linkmon(ioaddr);
1200 return result;
1203 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value)
1205 struct rhine_private *rp = netdev_priv(dev);
1206 void __iomem *ioaddr = rp->base;
1208 rhine_disable_linkmon(ioaddr, rp->quirks);
1210 /* rhine_disable_linkmon already cleared MIICmd */
1211 iowrite8(phy_id, ioaddr + MIIPhyAddr);
1212 iowrite8(regnum, ioaddr + MIIRegAddr);
1213 iowrite16(value, ioaddr + MIIData);
1214 iowrite8(0x20, ioaddr + MIICmd); /* Trigger write */
1215 RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x20));
1217 rhine_enable_linkmon(ioaddr);
1220 static int rhine_open(struct net_device *dev)
1222 struct rhine_private *rp = netdev_priv(dev);
1223 void __iomem *ioaddr = rp->base;
1224 int rc;
1226 rc = request_irq(rp->pdev->irq, &rhine_interrupt, SA_SHIRQ, dev->name,
1227 dev);
1228 if (rc)
1229 return rc;
1231 if (debug > 1)
1232 printk(KERN_DEBUG "%s: rhine_open() irq %d.\n",
1233 dev->name, rp->pdev->irq);
1235 rc = alloc_ring(dev);
1236 if (rc) {
1237 free_irq(rp->pdev->irq, dev);
1238 return rc;
1240 alloc_rbufs(dev);
1241 alloc_tbufs(dev);
1242 rhine_chip_reset(dev);
1243 init_registers(dev);
1244 if (debug > 2)
1245 printk(KERN_DEBUG "%s: Done rhine_open(), status %4.4x "
1246 "MII status: %4.4x.\n",
1247 dev->name, ioread16(ioaddr + ChipCmd),
1248 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1250 netif_start_queue(dev);
1252 return 0;
1255 static void rhine_tx_timeout(struct net_device *dev)
1257 struct rhine_private *rp = netdev_priv(dev);
1260 * Move bulk of work outside of interrupt context
1262 schedule_work(&rp->tx_timeout_task);
1265 static void rhine_tx_timeout_task(struct net_device *dev)
1267 struct rhine_private *rp = netdev_priv(dev);
1268 void __iomem *ioaddr = rp->base;
1270 printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
1271 "%4.4x, resetting...\n",
1272 dev->name, ioread16(ioaddr + IntrStatus),
1273 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1275 /* protect against concurrent rx interrupts */
1276 disable_irq(rp->pdev->irq);
1278 spin_lock(&rp->lock);
1280 /* clear all descriptors */
1281 free_tbufs(dev);
1282 free_rbufs(dev);
1283 alloc_tbufs(dev);
1284 alloc_rbufs(dev);
1286 /* Reinitialize the hardware. */
1287 rhine_chip_reset(dev);
1288 init_registers(dev);
1290 spin_unlock(&rp->lock);
1291 enable_irq(rp->pdev->irq);
1293 dev->trans_start = jiffies;
1294 rp->stats.tx_errors++;
1295 netif_wake_queue(dev);
1298 static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
1300 struct rhine_private *rp = netdev_priv(dev);
1301 void __iomem *ioaddr = rp->base;
1302 unsigned entry;
1304 /* Caution: the write order is important here, set the field
1305 with the "ownership" bits last. */
1307 /* Calculate the next Tx descriptor entry. */
1308 entry = rp->cur_tx % TX_RING_SIZE;
1310 if (skb->len < ETH_ZLEN) {
1311 skb = skb_padto(skb, ETH_ZLEN);
1312 if (skb == NULL)
1313 return 0;
1316 rp->tx_skbuff[entry] = skb;
1318 if ((rp->quirks & rqRhineI) &&
1319 (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_HW)) {
1320 /* Must use alignment buffer. */
1321 if (skb->len > PKT_BUF_SZ) {
1322 /* packet too long, drop it */
1323 dev_kfree_skb(skb);
1324 rp->tx_skbuff[entry] = NULL;
1325 rp->stats.tx_dropped++;
1326 return 0;
1328 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
1329 rp->tx_skbuff_dma[entry] = 0;
1330 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
1331 (rp->tx_buf[entry] -
1332 rp->tx_bufs));
1333 } else {
1334 rp->tx_skbuff_dma[entry] =
1335 pci_map_single(rp->pdev, skb->data, skb->len,
1336 PCI_DMA_TODEVICE);
1337 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]);
1340 rp->tx_ring[entry].desc_length =
1341 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1343 /* lock eth irq */
1344 spin_lock_irq(&rp->lock);
1345 wmb();
1346 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1347 wmb();
1349 rp->cur_tx++;
1351 /* Non-x86 Todo: explicitly flush cache lines here. */
1353 /* Wake the potentially-idle transmit channel */
1354 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1355 ioaddr + ChipCmd1);
1356 IOSYNC;
1358 if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
1359 netif_stop_queue(dev);
1361 dev->trans_start = jiffies;
1363 spin_unlock_irq(&rp->lock);
1365 if (debug > 4) {
1366 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1367 dev->name, rp->cur_tx-1, entry);
1369 return 0;
1372 /* The interrupt handler does all of the Rx thread work and cleans up
1373 after the Tx thread. */
1374 static irqreturn_t rhine_interrupt(int irq, void *dev_instance, struct pt_regs *rgs)
1376 struct net_device *dev = dev_instance;
1377 struct rhine_private *rp = netdev_priv(dev);
1378 void __iomem *ioaddr = rp->base;
1379 u32 intr_status;
1380 int boguscnt = max_interrupt_work;
1381 int handled = 0;
1383 while ((intr_status = get_intr_status(dev))) {
1384 handled = 1;
1386 /* Acknowledge all of the current interrupt sources ASAP. */
1387 if (intr_status & IntrTxDescRace)
1388 iowrite8(0x08, ioaddr + IntrStatus2);
1389 iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
1390 IOSYNC;
1392 if (debug > 4)
1393 printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n",
1394 dev->name, intr_status);
1396 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
1397 IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf))
1398 rhine_rx(dev);
1400 if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
1401 if (intr_status & IntrTxErrSummary) {
1402 /* Avoid scavenging before Tx engine turned off */
1403 RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
1404 if (debug > 2 &&
1405 ioread8(ioaddr+ChipCmd) & CmdTxOn)
1406 printk(KERN_WARNING "%s: "
1407 "rhine_interrupt() Tx engine"
1408 "still on.\n", dev->name);
1410 rhine_tx(dev);
1413 /* Abnormal error summary/uncommon events handlers. */
1414 if (intr_status & (IntrPCIErr | IntrLinkChange |
1415 IntrStatsMax | IntrTxError | IntrTxAborted |
1416 IntrTxUnderrun | IntrTxDescRace))
1417 rhine_error(dev, intr_status);
1419 if (--boguscnt < 0) {
1420 printk(KERN_WARNING "%s: Too much work at interrupt, "
1421 "status=%#8.8x.\n",
1422 dev->name, intr_status);
1423 break;
1427 if (debug > 3)
1428 printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n",
1429 dev->name, ioread16(ioaddr + IntrStatus));
1430 return IRQ_RETVAL(handled);
1433 /* This routine is logically part of the interrupt handler, but isolated
1434 for clarity. */
1435 static void rhine_tx(struct net_device *dev)
1437 struct rhine_private *rp = netdev_priv(dev);
1438 int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
1440 spin_lock(&rp->lock);
1442 /* find and cleanup dirty tx descriptors */
1443 while (rp->dirty_tx != rp->cur_tx) {
1444 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
1445 if (debug > 6)
1446 printk(KERN_DEBUG "Tx scavenge %d status %8.8x.\n",
1447 entry, txstatus);
1448 if (txstatus & DescOwn)
1449 break;
1450 if (txstatus & 0x8000) {
1451 if (debug > 1)
1452 printk(KERN_DEBUG "%s: Transmit error, "
1453 "Tx status %8.8x.\n",
1454 dev->name, txstatus);
1455 rp->stats.tx_errors++;
1456 if (txstatus & 0x0400) rp->stats.tx_carrier_errors++;
1457 if (txstatus & 0x0200) rp->stats.tx_window_errors++;
1458 if (txstatus & 0x0100) rp->stats.tx_aborted_errors++;
1459 if (txstatus & 0x0080) rp->stats.tx_heartbeat_errors++;
1460 if (((rp->quirks & rqRhineI) && txstatus & 0x0002) ||
1461 (txstatus & 0x0800) || (txstatus & 0x1000)) {
1462 rp->stats.tx_fifo_errors++;
1463 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1464 break; /* Keep the skb - we try again */
1466 /* Transmitter restarted in 'abnormal' handler. */
1467 } else {
1468 if (rp->quirks & rqRhineI)
1469 rp->stats.collisions += (txstatus >> 3) & 0x0F;
1470 else
1471 rp->stats.collisions += txstatus & 0x0F;
1472 if (debug > 6)
1473 printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
1474 (txstatus >> 3) & 0xF,
1475 txstatus & 0xF);
1476 rp->stats.tx_bytes += rp->tx_skbuff[entry]->len;
1477 rp->stats.tx_packets++;
1479 /* Free the original skb. */
1480 if (rp->tx_skbuff_dma[entry]) {
1481 pci_unmap_single(rp->pdev,
1482 rp->tx_skbuff_dma[entry],
1483 rp->tx_skbuff[entry]->len,
1484 PCI_DMA_TODEVICE);
1486 dev_kfree_skb_irq(rp->tx_skbuff[entry]);
1487 rp->tx_skbuff[entry] = NULL;
1488 entry = (++rp->dirty_tx) % TX_RING_SIZE;
1490 if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
1491 netif_wake_queue(dev);
1493 spin_unlock(&rp->lock);
1496 /* This routine is logically part of the interrupt handler, but isolated
1497 for clarity and better register allocation. */
1498 static void rhine_rx(struct net_device *dev)
1500 struct rhine_private *rp = netdev_priv(dev);
1501 int entry = rp->cur_rx % RX_RING_SIZE;
1502 int boguscnt = rp->dirty_rx + RX_RING_SIZE - rp->cur_rx;
1504 if (debug > 4) {
1505 printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
1506 dev->name, entry,
1507 le32_to_cpu(rp->rx_head_desc->rx_status));
1510 /* If EOP is set on the next entry, it's a new packet. Send it up. */
1511 while (!(rp->rx_head_desc->rx_status & cpu_to_le32(DescOwn))) {
1512 struct rx_desc *desc = rp->rx_head_desc;
1513 u32 desc_status = le32_to_cpu(desc->rx_status);
1514 int data_size = desc_status >> 16;
1516 if (debug > 4)
1517 printk(KERN_DEBUG "rhine_rx() status is %8.8x.\n",
1518 desc_status);
1519 if (--boguscnt < 0)
1520 break;
1521 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
1522 if ((desc_status & RxWholePkt) != RxWholePkt) {
1523 printk(KERN_WARNING "%s: Oversized Ethernet "
1524 "frame spanned multiple buffers, entry "
1525 "%#x length %d status %8.8x!\n",
1526 dev->name, entry, data_size,
1527 desc_status);
1528 printk(KERN_WARNING "%s: Oversized Ethernet "
1529 "frame %p vs %p.\n", dev->name,
1530 rp->rx_head_desc, &rp->rx_ring[entry]);
1531 rp->stats.rx_length_errors++;
1532 } else if (desc_status & RxErr) {
1533 /* There was a error. */
1534 if (debug > 2)
1535 printk(KERN_DEBUG "rhine_rx() Rx "
1536 "error was %8.8x.\n",
1537 desc_status);
1538 rp->stats.rx_errors++;
1539 if (desc_status & 0x0030) rp->stats.rx_length_errors++;
1540 if (desc_status & 0x0048) rp->stats.rx_fifo_errors++;
1541 if (desc_status & 0x0004) rp->stats.rx_frame_errors++;
1542 if (desc_status & 0x0002) {
1543 /* this can also be updated outside the interrupt handler */
1544 spin_lock(&rp->lock);
1545 rp->stats.rx_crc_errors++;
1546 spin_unlock(&rp->lock);
1549 } else {
1550 struct sk_buff *skb;
1551 /* Length should omit the CRC */
1552 int pkt_len = data_size - 4;
1554 /* Check if the packet is long enough to accept without
1555 copying to a minimally-sized skbuff. */
1556 if (pkt_len < rx_copybreak &&
1557 (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1558 skb->dev = dev;
1559 skb_reserve(skb, 2); /* 16 byte align the IP header */
1560 pci_dma_sync_single_for_cpu(rp->pdev,
1561 rp->rx_skbuff_dma[entry],
1562 rp->rx_buf_sz,
1563 PCI_DMA_FROMDEVICE);
1565 eth_copy_and_sum(skb,
1566 rp->rx_skbuff[entry]->data,
1567 pkt_len, 0);
1568 skb_put(skb, pkt_len);
1569 pci_dma_sync_single_for_device(rp->pdev,
1570 rp->rx_skbuff_dma[entry],
1571 rp->rx_buf_sz,
1572 PCI_DMA_FROMDEVICE);
1573 } else {
1574 skb = rp->rx_skbuff[entry];
1575 if (skb == NULL) {
1576 printk(KERN_ERR "%s: Inconsistent Rx "
1577 "descriptor chain.\n",
1578 dev->name);
1579 break;
1581 rp->rx_skbuff[entry] = NULL;
1582 skb_put(skb, pkt_len);
1583 pci_unmap_single(rp->pdev,
1584 rp->rx_skbuff_dma[entry],
1585 rp->rx_buf_sz,
1586 PCI_DMA_FROMDEVICE);
1588 skb->protocol = eth_type_trans(skb, dev);
1589 netif_rx(skb);
1590 dev->last_rx = jiffies;
1591 rp->stats.rx_bytes += pkt_len;
1592 rp->stats.rx_packets++;
1594 entry = (++rp->cur_rx) % RX_RING_SIZE;
1595 rp->rx_head_desc = &rp->rx_ring[entry];
1598 /* Refill the Rx ring buffers. */
1599 for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {
1600 struct sk_buff *skb;
1601 entry = rp->dirty_rx % RX_RING_SIZE;
1602 if (rp->rx_skbuff[entry] == NULL) {
1603 skb = dev_alloc_skb(rp->rx_buf_sz);
1604 rp->rx_skbuff[entry] = skb;
1605 if (skb == NULL)
1606 break; /* Better luck next round. */
1607 skb->dev = dev; /* Mark as being used by this device. */
1608 rp->rx_skbuff_dma[entry] =
1609 pci_map_single(rp->pdev, skb->data,
1610 rp->rx_buf_sz,
1611 PCI_DMA_FROMDEVICE);
1612 rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
1614 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
1619 * Clears the "tally counters" for CRC errors and missed frames(?).
1620 * It has been reported that some chips need a write of 0 to clear
1621 * these, for others the counters are set to 1 when written to and
1622 * instead cleared when read. So we clear them both ways ...
1624 static inline void clear_tally_counters(void __iomem *ioaddr)
1626 iowrite32(0, ioaddr + RxMissed);
1627 ioread16(ioaddr + RxCRCErrs);
1628 ioread16(ioaddr + RxMissed);
1631 static void rhine_restart_tx(struct net_device *dev) {
1632 struct rhine_private *rp = netdev_priv(dev);
1633 void __iomem *ioaddr = rp->base;
1634 int entry = rp->dirty_tx % TX_RING_SIZE;
1635 u32 intr_status;
1638 * If new errors occured, we need to sort them out before doing Tx.
1639 * In that case the ISR will be back here RSN anyway.
1641 intr_status = get_intr_status(dev);
1643 if ((intr_status & IntrTxErrSummary) == 0) {
1645 /* We know better than the chip where it should continue. */
1646 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc),
1647 ioaddr + TxRingPtr);
1649 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn,
1650 ioaddr + ChipCmd);
1651 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1652 ioaddr + ChipCmd1);
1653 IOSYNC;
1655 else {
1656 /* This should never happen */
1657 if (debug > 1)
1658 printk(KERN_WARNING "%s: rhine_restart_tx() "
1659 "Another error occured %8.8x.\n",
1660 dev->name, intr_status);
1665 static void rhine_error(struct net_device *dev, int intr_status)
1667 struct rhine_private *rp = netdev_priv(dev);
1668 void __iomem *ioaddr = rp->base;
1670 spin_lock(&rp->lock);
1672 if (intr_status & IntrLinkChange)
1673 schedule_work(&rp->check_media_task);
1674 if (intr_status & IntrStatsMax) {
1675 rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1676 rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1677 clear_tally_counters(ioaddr);
1679 if (intr_status & IntrTxAborted) {
1680 if (debug > 1)
1681 printk(KERN_INFO "%s: Abort %8.8x, frame dropped.\n",
1682 dev->name, intr_status);
1684 if (intr_status & IntrTxUnderrun) {
1685 if (rp->tx_thresh < 0xE0)
1686 iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1687 if (debug > 1)
1688 printk(KERN_INFO "%s: Transmitter underrun, Tx "
1689 "threshold now %2.2x.\n",
1690 dev->name, rp->tx_thresh);
1692 if (intr_status & IntrTxDescRace) {
1693 if (debug > 2)
1694 printk(KERN_INFO "%s: Tx descriptor write-back race.\n",
1695 dev->name);
1697 if ((intr_status & IntrTxError) &&
1698 (intr_status & (IntrTxAborted |
1699 IntrTxUnderrun | IntrTxDescRace)) == 0) {
1700 if (rp->tx_thresh < 0xE0) {
1701 iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1703 if (debug > 1)
1704 printk(KERN_INFO "%s: Unspecified error. Tx "
1705 "threshold now %2.2x.\n",
1706 dev->name, rp->tx_thresh);
1708 if (intr_status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
1709 IntrTxError))
1710 rhine_restart_tx(dev);
1712 if (intr_status & ~(IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
1713 IntrTxError | IntrTxAborted | IntrNormalSummary |
1714 IntrTxDescRace)) {
1715 if (debug > 1)
1716 printk(KERN_ERR "%s: Something Wicked happened! "
1717 "%8.8x.\n", dev->name, intr_status);
1720 spin_unlock(&rp->lock);
1723 static struct net_device_stats *rhine_get_stats(struct net_device *dev)
1725 struct rhine_private *rp = netdev_priv(dev);
1726 void __iomem *ioaddr = rp->base;
1727 unsigned long flags;
1729 spin_lock_irqsave(&rp->lock, flags);
1730 rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1731 rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1732 clear_tally_counters(ioaddr);
1733 spin_unlock_irqrestore(&rp->lock, flags);
1735 return &rp->stats;
1738 static void rhine_set_rx_mode(struct net_device *dev)
1740 struct rhine_private *rp = netdev_priv(dev);
1741 void __iomem *ioaddr = rp->base;
1742 u32 mc_filter[2]; /* Multicast hash filter */
1743 u8 rx_mode; /* Note: 0x02=accept runt, 0x01=accept errs */
1745 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1746 /* Unconditionally log net taps. */
1747 printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n",
1748 dev->name);
1749 rx_mode = 0x1C;
1750 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1751 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1752 } else if ((dev->mc_count > multicast_filter_limit)
1753 || (dev->flags & IFF_ALLMULTI)) {
1754 /* Too many to match, or accept all multicasts. */
1755 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1756 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1757 rx_mode = 0x0C;
1758 } else {
1759 struct dev_mc_list *mclist;
1760 int i;
1761 memset(mc_filter, 0, sizeof(mc_filter));
1762 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1763 i++, mclist = mclist->next) {
1764 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1766 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1768 iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1769 iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1770 rx_mode = 0x0C;
1772 iowrite8(rp->rx_thresh | rx_mode, ioaddr + RxConfig);
1775 static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1777 struct rhine_private *rp = netdev_priv(dev);
1779 strcpy(info->driver, DRV_NAME);
1780 strcpy(info->version, DRV_VERSION);
1781 strcpy(info->bus_info, pci_name(rp->pdev));
1784 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1786 struct rhine_private *rp = netdev_priv(dev);
1787 int rc;
1789 spin_lock_irq(&rp->lock);
1790 rc = mii_ethtool_gset(&rp->mii_if, cmd);
1791 spin_unlock_irq(&rp->lock);
1793 return rc;
1796 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1798 struct rhine_private *rp = netdev_priv(dev);
1799 int rc;
1801 spin_lock_irq(&rp->lock);
1802 rc = mii_ethtool_sset(&rp->mii_if, cmd);
1803 spin_unlock_irq(&rp->lock);
1804 rhine_set_carrier(&rp->mii_if);
1806 return rc;
1809 static int netdev_nway_reset(struct net_device *dev)
1811 struct rhine_private *rp = netdev_priv(dev);
1813 return mii_nway_restart(&rp->mii_if);
1816 static u32 netdev_get_link(struct net_device *dev)
1818 struct rhine_private *rp = netdev_priv(dev);
1820 return mii_link_ok(&rp->mii_if);
1823 static u32 netdev_get_msglevel(struct net_device *dev)
1825 return debug;
1828 static void netdev_set_msglevel(struct net_device *dev, u32 value)
1830 debug = value;
1833 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1835 struct rhine_private *rp = netdev_priv(dev);
1837 if (!(rp->quirks & rqWOL))
1838 return;
1840 spin_lock_irq(&rp->lock);
1841 wol->supported = WAKE_PHY | WAKE_MAGIC |
1842 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */
1843 wol->wolopts = rp->wolopts;
1844 spin_unlock_irq(&rp->lock);
1847 static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1849 struct rhine_private *rp = netdev_priv(dev);
1850 u32 support = WAKE_PHY | WAKE_MAGIC |
1851 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */
1853 if (!(rp->quirks & rqWOL))
1854 return -EINVAL;
1856 if (wol->wolopts & ~support)
1857 return -EINVAL;
1859 spin_lock_irq(&rp->lock);
1860 rp->wolopts = wol->wolopts;
1861 spin_unlock_irq(&rp->lock);
1863 return 0;
1866 static struct ethtool_ops netdev_ethtool_ops = {
1867 .get_drvinfo = netdev_get_drvinfo,
1868 .get_settings = netdev_get_settings,
1869 .set_settings = netdev_set_settings,
1870 .nway_reset = netdev_nway_reset,
1871 .get_link = netdev_get_link,
1872 .get_msglevel = netdev_get_msglevel,
1873 .set_msglevel = netdev_set_msglevel,
1874 .get_wol = rhine_get_wol,
1875 .set_wol = rhine_set_wol,
1876 .get_sg = ethtool_op_get_sg,
1877 .get_tx_csum = ethtool_op_get_tx_csum,
1878 .get_perm_addr = ethtool_op_get_perm_addr,
1881 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1883 struct rhine_private *rp = netdev_priv(dev);
1884 int rc;
1886 if (!netif_running(dev))
1887 return -EINVAL;
1889 spin_lock_irq(&rp->lock);
1890 rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
1891 spin_unlock_irq(&rp->lock);
1892 rhine_set_carrier(&rp->mii_if);
1894 return rc;
1897 static int rhine_close(struct net_device *dev)
1899 struct rhine_private *rp = netdev_priv(dev);
1900 void __iomem *ioaddr = rp->base;
1902 spin_lock_irq(&rp->lock);
1904 netif_stop_queue(dev);
1906 if (debug > 1)
1907 printk(KERN_DEBUG "%s: Shutting down ethercard, "
1908 "status was %4.4x.\n",
1909 dev->name, ioread16(ioaddr + ChipCmd));
1911 /* Switch to loopback mode to avoid hardware races. */
1912 iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
1914 /* Disable interrupts by clearing the interrupt mask. */
1915 iowrite16(0x0000, ioaddr + IntrEnable);
1917 /* Stop the chip's Tx and Rx processes. */
1918 iowrite16(CmdStop, ioaddr + ChipCmd);
1920 spin_unlock_irq(&rp->lock);
1922 free_irq(rp->pdev->irq, dev);
1924 flush_scheduled_work();
1926 free_rbufs(dev);
1927 free_tbufs(dev);
1928 free_ring(dev);
1930 return 0;
1934 static void __devexit rhine_remove_one(struct pci_dev *pdev)
1936 struct net_device *dev = pci_get_drvdata(pdev);
1937 struct rhine_private *rp = netdev_priv(dev);
1939 unregister_netdev(dev);
1941 pci_iounmap(pdev, rp->base);
1942 pci_release_regions(pdev);
1944 free_netdev(dev);
1945 pci_disable_device(pdev);
1946 pci_set_drvdata(pdev, NULL);
1949 static void rhine_shutdown (struct pci_dev *pdev)
1951 struct net_device *dev = pci_get_drvdata(pdev);
1952 struct rhine_private *rp = netdev_priv(dev);
1953 void __iomem *ioaddr = rp->base;
1955 if (!(rp->quirks & rqWOL))
1956 return; /* Nothing to do for non-WOL adapters */
1958 rhine_power_init(dev);
1960 /* Make sure we use pattern 0, 1 and not 4, 5 */
1961 if (rp->quirks & rq6patterns)
1962 iowrite8(0x04, ioaddr + 0xA7);
1964 if (rp->wolopts & WAKE_MAGIC) {
1965 iowrite8(WOLmagic, ioaddr + WOLcrSet);
1967 * Turn EEPROM-controlled wake-up back on -- some hardware may
1968 * not cooperate otherwise.
1970 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);
1973 if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST))
1974 iowrite8(WOLbmcast, ioaddr + WOLcgSet);
1976 if (rp->wolopts & WAKE_PHY)
1977 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet);
1979 if (rp->wolopts & WAKE_UCAST)
1980 iowrite8(WOLucast, ioaddr + WOLcrSet);
1982 if (rp->wolopts) {
1983 /* Enable legacy WOL (for old motherboards) */
1984 iowrite8(0x01, ioaddr + PwcfgSet);
1985 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
1988 /* Hit power state D3 (sleep) */
1989 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
1991 /* TODO: Check use of pci_enable_wake() */
1995 #ifdef CONFIG_PM
1996 static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
1998 struct net_device *dev = pci_get_drvdata(pdev);
1999 struct rhine_private *rp = netdev_priv(dev);
2000 unsigned long flags;
2002 if (!netif_running(dev))
2003 return 0;
2005 netif_device_detach(dev);
2006 pci_save_state(pdev);
2008 spin_lock_irqsave(&rp->lock, flags);
2009 rhine_shutdown(pdev);
2010 spin_unlock_irqrestore(&rp->lock, flags);
2012 free_irq(dev->irq, dev);
2013 return 0;
2016 static int rhine_resume(struct pci_dev *pdev)
2018 struct net_device *dev = pci_get_drvdata(pdev);
2019 struct rhine_private *rp = netdev_priv(dev);
2020 unsigned long flags;
2021 int ret;
2023 if (!netif_running(dev))
2024 return 0;
2026 if (request_irq(dev->irq, rhine_interrupt, SA_SHIRQ, dev->name, dev))
2027 printk(KERN_ERR "via-rhine %s: request_irq failed\n", dev->name);
2029 ret = pci_set_power_state(pdev, PCI_D0);
2030 if (debug > 1)
2031 printk(KERN_INFO "%s: Entering power state D0 %s (%d).\n",
2032 dev->name, ret ? "failed" : "succeeded", ret);
2034 pci_restore_state(pdev);
2036 spin_lock_irqsave(&rp->lock, flags);
2037 #ifdef USE_MMIO
2038 enable_mmio(rp->pioaddr, rp->quirks);
2039 #endif
2040 rhine_power_init(dev);
2041 free_tbufs(dev);
2042 free_rbufs(dev);
2043 alloc_tbufs(dev);
2044 alloc_rbufs(dev);
2045 init_registers(dev);
2046 spin_unlock_irqrestore(&rp->lock, flags);
2048 netif_device_attach(dev);
2050 return 0;
2052 #endif /* CONFIG_PM */
2054 static struct pci_driver rhine_driver = {
2055 .name = DRV_NAME,
2056 .id_table = rhine_pci_tbl,
2057 .probe = rhine_init_one,
2058 .remove = __devexit_p(rhine_remove_one),
2059 #ifdef CONFIG_PM
2060 .suspend = rhine_suspend,
2061 .resume = rhine_resume,
2062 #endif /* CONFIG_PM */
2063 .shutdown = rhine_shutdown,
2067 static int __init rhine_init(void)
2069 /* when a module, this is printed whether or not devices are found in probe */
2070 #ifdef MODULE
2071 printk(version);
2072 #endif
2073 return pci_module_init(&rhine_driver);
2077 static void __exit rhine_cleanup(void)
2079 pci_unregister_driver(&rhine_driver);
2083 module_init(rhine_init);
2084 module_exit(rhine_cleanup);