net: Remove unused netdev arg from some NAPI interfaces.
[linux-2.6.git] / drivers / net / via-rhine.c
1 /* via-rhine.c: A Linux Ethernet device driver for VIA Rhine family chips. */
2 /*
3         Written 1998-2001 by Donald Becker.
4
5         Current Maintainer: Roger Luethi <rl@hellgate.ch>
6
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.
13
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).
17
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
22
23
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
28         [link no longer provides useful info -jgarzik]
29
30 */
31
32 #define DRV_NAME        "via-rhine"
33 #define DRV_VERSION     "1.4.3"
34 #define DRV_RELDATE     "2007-03-06"
35
36
37 /* A few user-configurable values.
38    These may be modified when a driver module is loaded. */
39
40 static int debug = 1;   /* 1 normal messages, 0 quiet .. 7 verbose. */
41 static int max_interrupt_work = 20;
42
43 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
44    Setting to > 1518 effectively disables this feature. */
45 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
46        || defined(CONFIG_SPARC) || defined(__ia64__) \
47        || defined(__sh__) || defined(__mips__)
48 static int rx_copybreak = 1518;
49 #else
50 static int rx_copybreak;
51 #endif
52
53 /* Work-around for broken BIOSes: they are unable to get the chip back out of
54    power state D3 so PXE booting fails. bootparam(7): via-rhine.avoid_D3=1 */
55 static int avoid_D3;
56
57 /*
58  * In case you are looking for 'options[]' or 'full_duplex[]', they
59  * are gone. Use ethtool(8) instead.
60  */
61
62 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
63    The Rhine has a 64 element 8390-like hash table. */
64 static const int multicast_filter_limit = 32;
65
66
67 /* Operational parameters that are set at compile time. */
68
69 /* Keep the ring sizes a power of two for compile efficiency.
70    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
71    Making the Tx ring too large decreases the effectiveness of channel
72    bonding and packet priority.
73    There are no ill effects from too-large receive rings. */
74 #define TX_RING_SIZE    16
75 #define TX_QUEUE_LEN    10      /* Limit ring entries actually used. */
76 #define RX_RING_SIZE    64
77
78 /* Operational parameters that usually are not changed. */
79
80 /* Time in jiffies before concluding the transmitter is hung. */
81 #define TX_TIMEOUT      (2*HZ)
82
83 #define PKT_BUF_SZ      1536    /* Size of each temporary Rx buffer.*/
84
85 #include <linux/module.h>
86 #include <linux/moduleparam.h>
87 #include <linux/kernel.h>
88 #include <linux/string.h>
89 #include <linux/timer.h>
90 #include <linux/errno.h>
91 #include <linux/ioport.h>
92 #include <linux/slab.h>
93 #include <linux/interrupt.h>
94 #include <linux/pci.h>
95 #include <linux/dma-mapping.h>
96 #include <linux/netdevice.h>
97 #include <linux/etherdevice.h>
98 #include <linux/skbuff.h>
99 #include <linux/init.h>
100 #include <linux/delay.h>
101 #include <linux/mii.h>
102 #include <linux/ethtool.h>
103 #include <linux/crc32.h>
104 #include <linux/bitops.h>
105 #include <asm/processor.h>      /* Processor type for cache alignment. */
106 #include <asm/io.h>
107 #include <asm/irq.h>
108 #include <asm/uaccess.h>
109 #include <linux/dmi.h>
110
111 /* These identify the driver base version and may not be removed. */
112 static char version[] __devinitdata =
113 KERN_INFO DRV_NAME ".c:v1.10-LK" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker\n";
114
115 /* This driver was written to use PCI memory space. Some early versions
116    of the Rhine may only work correctly with I/O space accesses. */
117 #ifdef CONFIG_VIA_RHINE_MMIO
118 #define USE_MMIO
119 #else
120 #endif
121
122 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
123 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");
124 MODULE_LICENSE("GPL");
125
126 module_param(max_interrupt_work, int, 0);
127 module_param(debug, int, 0);
128 module_param(rx_copybreak, int, 0);
129 module_param(avoid_D3, bool, 0);
130 MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");
131 MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");
132 MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames");
133 MODULE_PARM_DESC(avoid_D3, "Avoid power state D3 (work-around for broken BIOSes)");
134
135 /*
136                 Theory of Operation
137
138 I. Board Compatibility
139
140 This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet
141 controller.
142
143 II. Board-specific settings
144
145 Boards with this chip are functional only in a bus-master PCI slot.
146
147 Many operational settings are loaded from the EEPROM to the Config word at
148 offset 0x78. For most of these settings, this driver assumes that they are
149 correct.
150 If this driver is compiled to use PCI memory space operations the EEPROM
151 must be configured to enable memory ops.
152
153 III. Driver operation
154
155 IIIa. Ring buffers
156
157 This driver uses two statically allocated fixed-size descriptor lists
158 formed into rings by a branch from the final descriptor to the beginning of
159 the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.
160
161 IIIb/c. Transmit/Receive Structure
162
163 This driver attempts to use a zero-copy receive and transmit scheme.
164
165 Alas, all data buffers are required to start on a 32 bit boundary, so
166 the driver must often copy transmit packets into bounce buffers.
167
168 The driver allocates full frame size skbuffs for the Rx ring buffers at
169 open() time and passes the skb->data field to the chip as receive data
170 buffers. When an incoming frame is less than RX_COPYBREAK bytes long,
171 a fresh skbuff is allocated and the frame is copied to the new skbuff.
172 When the incoming frame is larger, the skbuff is passed directly up the
173 protocol stack. Buffers consumed this way are replaced by newly allocated
174 skbuffs in the last phase of rhine_rx().
175
176 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
177 using a full-sized skbuff for small frames vs. the copying costs of larger
178 frames. New boards are typically used in generously configured machines
179 and the underfilled buffers have negligible impact compared to the benefit of
180 a single allocation size, so the default value of zero results in never
181 copying packets. When copying is done, the cost is usually mitigated by using
182 a combined copy/checksum routine. Copying also preloads the cache, which is
183 most useful with small frames.
184
185 Since the VIA chips are only able to transfer data to buffers on 32 bit
186 boundaries, the IP header at offset 14 in an ethernet frame isn't
187 longword aligned for further processing. Copying these unaligned buffers
188 has the beneficial effect of 16-byte aligning the IP header.
189
190 IIId. Synchronization
191
192 The driver runs as two independent, single-threaded flows of control. One
193 is the send-packet routine, which enforces single-threaded use by the
194 netdev_priv(dev)->lock spinlock. The other thread is the interrupt handler,
195 which is single threaded by the hardware and interrupt handling software.
196
197 The send packet thread has partial control over the Tx ring. It locks the
198 netdev_priv(dev)->lock whenever it's queuing a Tx packet. If the next slot in
199 the ring is not available it stops the transmit queue by
200 calling netif_stop_queue.
201
202 The interrupt handler has exclusive control over the Rx ring and records stats
203 from the Tx ring. After reaping the stats, it marks the Tx queue entry as
204 empty by incrementing the dirty_tx mark. If at least half of the entries in
205 the Rx ring are available the transmit queue is woken up if it was stopped.
206
207 IV. Notes
208
209 IVb. References
210
211 Preliminary VT86C100A manual from http://www.via.com.tw/
212 http://www.scyld.com/expert/100mbps.html
213 http://www.scyld.com/expert/NWay.html
214 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf
215 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF
216
217
218 IVc. Errata
219
220 The VT86C100A manual is not reliable information.
221 The 3043 chip does not handle unaligned transmit or receive buffers, resulting
222 in significant performance degradation for bounce buffer copies on transmit
223 and unaligned IP headers on receive.
224 The chip does not pad to minimum transmit length.
225
226 */
227
228
229 /* This table drives the PCI probe routines. It's mostly boilerplate in all
230    of the drivers, and will likely be provided by some future kernel.
231    Note the matching code -- the first table entry matchs all 56** cards but
232    second only the 1234 card.
233 */
234
235 enum rhine_revs {
236         VT86C100A       = 0x00,
237         VTunknown0      = 0x20,
238         VT6102          = 0x40,
239         VT8231          = 0x50, /* Integrated MAC */
240         VT8233          = 0x60, /* Integrated MAC */
241         VT8235          = 0x74, /* Integrated MAC */
242         VT8237          = 0x78, /* Integrated MAC */
243         VTunknown1      = 0x7C,
244         VT6105          = 0x80,
245         VT6105_B0       = 0x83,
246         VT6105L         = 0x8A,
247         VT6107          = 0x8C,
248         VTunknown2      = 0x8E,
249         VT6105M         = 0x90, /* Management adapter */
250 };
251
252 enum rhine_quirks {
253         rqWOL           = 0x0001,       /* Wake-On-LAN support */
254         rqForceReset    = 0x0002,
255         rq6patterns     = 0x0040,       /* 6 instead of 4 patterns for WOL */
256         rqStatusWBRace  = 0x0080,       /* Tx Status Writeback Error possible */
257         rqRhineI        = 0x0100,       /* See comment below */
258 };
259 /*
260  * rqRhineI: VT86C100A (aka Rhine-I) uses different bits to enable
261  * MMIO as well as for the collision counter and the Tx FIFO underflow
262  * indicator. In addition, Tx and Rx buffers need to 4 byte aligned.
263  */
264
265 /* Beware of PCI posted writes */
266 #define IOSYNC  do { ioread8(ioaddr + StationAddr); } while (0)
267
268 static const struct pci_device_id rhine_pci_tbl[] = {
269         { 0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, },    /* VT86C100A */
270         { 0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6102 */
271         { 0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, },    /* 6105{,L,LOM} */
272         { 0x1106, 0x3053, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6105M */
273         { }     /* terminate list */
274 };
275 MODULE_DEVICE_TABLE(pci, rhine_pci_tbl);
276
277
278 /* Offsets to the device registers. */
279 enum register_offsets {
280         StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08,
281         ChipCmd1=0x09,
282         IntrStatus=0x0C, IntrEnable=0x0E,
283         MulticastFilter0=0x10, MulticastFilter1=0x14,
284         RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54,
285         MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E,
286         MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74,
287         ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B,
288         RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81,
289         StickyHW=0x83, IntrStatus2=0x84,
290         WOLcrSet=0xA0, PwcfgSet=0xA1, WOLcgSet=0xA3, WOLcrClr=0xA4,
291         WOLcrClr1=0xA6, WOLcgClr=0xA7,
292         PwrcsrSet=0xA8, PwrcsrSet1=0xA9, PwrcsrClr=0xAC, PwrcsrClr1=0xAD,
293 };
294
295 /* Bits in ConfigD */
296 enum backoff_bits {
297         BackOptional=0x01, BackModify=0x02,
298         BackCaptureEffect=0x04, BackRandom=0x08
299 };
300
301 #ifdef USE_MMIO
302 /* Registers we check that mmio and reg are the same. */
303 static const int mmio_verify_registers[] = {
304         RxConfig, TxConfig, IntrEnable, ConfigA, ConfigB, ConfigC, ConfigD,
305         0
306 };
307 #endif
308
309 /* Bits in the interrupt status/mask registers. */
310 enum intr_status_bits {
311         IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,
312         IntrTxDone=0x0002, IntrTxError=0x0008, IntrTxUnderrun=0x0210,
313         IntrPCIErr=0x0040,
314         IntrStatsMax=0x0080, IntrRxEarly=0x0100,
315         IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,
316         IntrTxAborted=0x2000, IntrLinkChange=0x4000,
317         IntrRxWakeUp=0x8000,
318         IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,
319         IntrTxDescRace=0x080000,        /* mapped from IntrStatus2 */
320         IntrTxErrSummary=0x082218,
321 };
322
323 /* Bits in WOLcrSet/WOLcrClr and PwrcsrSet/PwrcsrClr */
324 enum wol_bits {
325         WOLucast        = 0x10,
326         WOLmagic        = 0x20,
327         WOLbmcast       = 0x30,
328         WOLlnkon        = 0x40,
329         WOLlnkoff       = 0x80,
330 };
331
332 /* The Rx and Tx buffer descriptors. */
333 struct rx_desc {
334         __le32 rx_status;
335         __le32 desc_length; /* Chain flag, Buffer/frame length */
336         __le32 addr;
337         __le32 next_desc;
338 };
339 struct tx_desc {
340         __le32 tx_status;
341         __le32 desc_length; /* Chain flag, Tx Config, Frame length */
342         __le32 addr;
343         __le32 next_desc;
344 };
345
346 /* Initial value for tx_desc.desc_length, Buffer size goes to bits 0-10 */
347 #define TXDESC          0x00e08000
348
349 enum rx_status_bits {
350         RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F
351 };
352
353 /* Bits in *_desc.*_status */
354 enum desc_status_bits {
355         DescOwn=0x80000000
356 };
357
358 /* Bits in ChipCmd. */
359 enum chip_cmd_bits {
360         CmdInit=0x01, CmdStart=0x02, CmdStop=0x04, CmdRxOn=0x08,
361         CmdTxOn=0x10, Cmd1TxDemand=0x20, CmdRxDemand=0x40,
362         Cmd1EarlyRx=0x01, Cmd1EarlyTx=0x02, Cmd1FDuplex=0x04,
363         Cmd1NoTxPoll=0x08, Cmd1Reset=0x80,
364 };
365
366 struct rhine_private {
367         /* Descriptor rings */
368         struct rx_desc *rx_ring;
369         struct tx_desc *tx_ring;
370         dma_addr_t rx_ring_dma;
371         dma_addr_t tx_ring_dma;
372
373         /* The addresses of receive-in-place skbuffs. */
374         struct sk_buff *rx_skbuff[RX_RING_SIZE];
375         dma_addr_t rx_skbuff_dma[RX_RING_SIZE];
376
377         /* The saved address of a sent-in-place packet/buffer, for later free(). */
378         struct sk_buff *tx_skbuff[TX_RING_SIZE];
379         dma_addr_t tx_skbuff_dma[TX_RING_SIZE];
380
381         /* Tx bounce buffers (Rhine-I only) */
382         unsigned char *tx_buf[TX_RING_SIZE];
383         unsigned char *tx_bufs;
384         dma_addr_t tx_bufs_dma;
385
386         struct pci_dev *pdev;
387         long pioaddr;
388         struct net_device *dev;
389         struct napi_struct napi;
390         struct net_device_stats stats;
391         spinlock_t lock;
392
393         /* Frequently used values: keep some adjacent for cache effect. */
394         u32 quirks;
395         struct rx_desc *rx_head_desc;
396         unsigned int cur_rx, dirty_rx;  /* Producer/consumer ring indices */
397         unsigned int cur_tx, dirty_tx;
398         unsigned int rx_buf_sz;         /* Based on MTU+slack. */
399         u8 wolopts;
400
401         u8 tx_thresh, rx_thresh;
402
403         struct mii_if_info mii_if;
404         void __iomem *base;
405 };
406
407 static int  mdio_read(struct net_device *dev, int phy_id, int location);
408 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
409 static int  rhine_open(struct net_device *dev);
410 static void rhine_tx_timeout(struct net_device *dev);
411 static int  rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
412 static irqreturn_t rhine_interrupt(int irq, void *dev_instance);
413 static void rhine_tx(struct net_device *dev);
414 static int rhine_rx(struct net_device *dev, int limit);
415 static void rhine_error(struct net_device *dev, int intr_status);
416 static void rhine_set_rx_mode(struct net_device *dev);
417 static struct net_device_stats *rhine_get_stats(struct net_device *dev);
418 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
419 static const struct ethtool_ops netdev_ethtool_ops;
420 static int  rhine_close(struct net_device *dev);
421 static void rhine_shutdown (struct pci_dev *pdev);
422
423 #define RHINE_WAIT_FOR(condition) do {                                  \
424         int i=1024;                                                     \
425         while (!(condition) && --i)                                     \
426                 ;                                                       \
427         if (debug > 1 && i < 512)                                       \
428                 printk(KERN_INFO "%s: %4d cycles used @ %s:%d\n",       \
429                                 DRV_NAME, 1024-i, __func__, __LINE__);  \
430 } while(0)
431
432 static inline u32 get_intr_status(struct net_device *dev)
433 {
434         struct rhine_private *rp = netdev_priv(dev);
435         void __iomem *ioaddr = rp->base;
436         u32 intr_status;
437
438         intr_status = ioread16(ioaddr + IntrStatus);
439         /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
440         if (rp->quirks & rqStatusWBRace)
441                 intr_status |= ioread8(ioaddr + IntrStatus2) << 16;
442         return intr_status;
443 }
444
445 /*
446  * Get power related registers into sane state.
447  * Notify user about past WOL event.
448  */
449 static void rhine_power_init(struct net_device *dev)
450 {
451         struct rhine_private *rp = netdev_priv(dev);
452         void __iomem *ioaddr = rp->base;
453         u16 wolstat;
454
455         if (rp->quirks & rqWOL) {
456                 /* Make sure chip is in power state D0 */
457                 iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW);
458
459                 /* Disable "force PME-enable" */
460                 iowrite8(0x80, ioaddr + WOLcgClr);
461
462                 /* Clear power-event config bits (WOL) */
463                 iowrite8(0xFF, ioaddr + WOLcrClr);
464                 /* More recent cards can manage two additional patterns */
465                 if (rp->quirks & rq6patterns)
466                         iowrite8(0x03, ioaddr + WOLcrClr1);
467
468                 /* Save power-event status bits */
469                 wolstat = ioread8(ioaddr + PwrcsrSet);
470                 if (rp->quirks & rq6patterns)
471                         wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8;
472
473                 /* Clear power-event status bits */
474                 iowrite8(0xFF, ioaddr + PwrcsrClr);
475                 if (rp->quirks & rq6patterns)
476                         iowrite8(0x03, ioaddr + PwrcsrClr1);
477
478                 if (wolstat) {
479                         char *reason;
480                         switch (wolstat) {
481                         case WOLmagic:
482                                 reason = "Magic packet";
483                                 break;
484                         case WOLlnkon:
485                                 reason = "Link went up";
486                                 break;
487                         case WOLlnkoff:
488                                 reason = "Link went down";
489                                 break;
490                         case WOLucast:
491                                 reason = "Unicast packet";
492                                 break;
493                         case WOLbmcast:
494                                 reason = "Multicast/broadcast packet";
495                                 break;
496                         default:
497                                 reason = "Unknown";
498                         }
499                         printk(KERN_INFO "%s: Woke system up. Reason: %s.\n",
500                                DRV_NAME, reason);
501                 }
502         }
503 }
504
505 static void rhine_chip_reset(struct net_device *dev)
506 {
507         struct rhine_private *rp = netdev_priv(dev);
508         void __iomem *ioaddr = rp->base;
509
510         iowrite8(Cmd1Reset, ioaddr + ChipCmd1);
511         IOSYNC;
512
513         if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) {
514                 printk(KERN_INFO "%s: Reset not complete yet. "
515                         "Trying harder.\n", DRV_NAME);
516
517                 /* Force reset */
518                 if (rp->quirks & rqForceReset)
519                         iowrite8(0x40, ioaddr + MiscCmd);
520
521                 /* Reset can take somewhat longer (rare) */
522                 RHINE_WAIT_FOR(!(ioread8(ioaddr + ChipCmd1) & Cmd1Reset));
523         }
524
525         if (debug > 1)
526                 printk(KERN_INFO "%s: Reset %s.\n", dev->name,
527                         (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) ?
528                         "failed" : "succeeded");
529 }
530
531 #ifdef USE_MMIO
532 static void enable_mmio(long pioaddr, u32 quirks)
533 {
534         int n;
535         if (quirks & rqRhineI) {
536                 /* More recent docs say that this bit is reserved ... */
537                 n = inb(pioaddr + ConfigA) | 0x20;
538                 outb(n, pioaddr + ConfigA);
539         } else {
540                 n = inb(pioaddr + ConfigD) | 0x80;
541                 outb(n, pioaddr + ConfigD);
542         }
543 }
544 #endif
545
546 /*
547  * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM
548  * (plus 0x6C for Rhine-I/II)
549  */
550 static void __devinit rhine_reload_eeprom(long pioaddr, struct net_device *dev)
551 {
552         struct rhine_private *rp = netdev_priv(dev);
553         void __iomem *ioaddr = rp->base;
554
555         outb(0x20, pioaddr + MACRegEEcsr);
556         RHINE_WAIT_FOR(!(inb(pioaddr + MACRegEEcsr) & 0x20));
557
558 #ifdef USE_MMIO
559         /*
560          * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable
561          * MMIO. If reloading EEPROM was done first this could be avoided, but
562          * it is not known if that still works with the "win98-reboot" problem.
563          */
564         enable_mmio(pioaddr, rp->quirks);
565 #endif
566
567         /* Turn off EEPROM-controlled wake-up (magic packet) */
568         if (rp->quirks & rqWOL)
569                 iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA);
570
571 }
572
573 #ifdef CONFIG_NET_POLL_CONTROLLER
574 static void rhine_poll(struct net_device *dev)
575 {
576         disable_irq(dev->irq);
577         rhine_interrupt(dev->irq, (void *)dev);
578         enable_irq(dev->irq);
579 }
580 #endif
581
582 static int rhine_napipoll(struct napi_struct *napi, int budget)
583 {
584         struct rhine_private *rp = container_of(napi, struct rhine_private, napi);
585         struct net_device *dev = rp->dev;
586         void __iomem *ioaddr = rp->base;
587         int work_done;
588
589         work_done = rhine_rx(dev, budget);
590
591         if (work_done < budget) {
592                 netif_rx_complete(napi);
593
594                 iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
595                           IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
596                           IntrTxDone | IntrTxError | IntrTxUnderrun |
597                           IntrPCIErr | IntrStatsMax | IntrLinkChange,
598                           ioaddr + IntrEnable);
599         }
600         return work_done;
601 }
602
603 static void __devinit rhine_hw_init(struct net_device *dev, long pioaddr)
604 {
605         struct rhine_private *rp = netdev_priv(dev);
606
607         /* Reset the chip to erase previous misconfiguration. */
608         rhine_chip_reset(dev);
609
610         /* Rhine-I needs extra time to recuperate before EEPROM reload */
611         if (rp->quirks & rqRhineI)
612                 msleep(5);
613
614         /* Reload EEPROM controlled bytes cleared by soft reset */
615         rhine_reload_eeprom(pioaddr, dev);
616 }
617
618 static const struct net_device_ops rhine_netdev_ops = {
619         .ndo_open                = rhine_open,
620         .ndo_stop                = rhine_close,
621         .ndo_start_xmit          = rhine_start_tx,
622         .ndo_get_stats           = rhine_get_stats,
623         .ndo_set_multicast_list  = rhine_set_rx_mode,
624         .ndo_validate_addr       = eth_validate_addr,
625         .ndo_do_ioctl            = netdev_ioctl,
626         .ndo_tx_timeout          = rhine_tx_timeout,
627 #ifdef CONFIG_NET_POLL_CONTROLLER
628         .ndo_poll_controller     = rhine_poll,
629 #endif
630 };
631
632 static int __devinit rhine_init_one(struct pci_dev *pdev,
633                                     const struct pci_device_id *ent)
634 {
635         struct net_device *dev;
636         struct rhine_private *rp;
637         int i, rc;
638         u32 quirks;
639         long pioaddr;
640         long memaddr;
641         void __iomem *ioaddr;
642         int io_size, phy_id;
643         const char *name;
644 #ifdef USE_MMIO
645         int bar = 1;
646 #else
647         int bar = 0;
648 #endif
649
650 /* when built into the kernel, we only print version if device is found */
651 #ifndef MODULE
652         static int printed_version;
653         if (!printed_version++)
654                 printk(version);
655 #endif
656
657         io_size = 256;
658         phy_id = 0;
659         quirks = 0;
660         name = "Rhine";
661         if (pdev->revision < VTunknown0) {
662                 quirks = rqRhineI;
663                 io_size = 128;
664         }
665         else if (pdev->revision >= VT6102) {
666                 quirks = rqWOL | rqForceReset;
667                 if (pdev->revision < VT6105) {
668                         name = "Rhine II";
669                         quirks |= rqStatusWBRace;       /* Rhine-II exclusive */
670                 }
671                 else {
672                         phy_id = 1;     /* Integrated PHY, phy_id fixed to 1 */
673                         if (pdev->revision >= VT6105_B0)
674                                 quirks |= rq6patterns;
675                         if (pdev->revision < VT6105M)
676                                 name = "Rhine III";
677                         else
678                                 name = "Rhine III (Management Adapter)";
679                 }
680         }
681
682         rc = pci_enable_device(pdev);
683         if (rc)
684                 goto err_out;
685
686         /* this should always be supported */
687         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
688         if (rc) {
689                 printk(KERN_ERR "32-bit PCI DMA addresses not supported by "
690                        "the card!?\n");
691                 goto err_out;
692         }
693
694         /* sanity check */
695         if ((pci_resource_len(pdev, 0) < io_size) ||
696             (pci_resource_len(pdev, 1) < io_size)) {
697                 rc = -EIO;
698                 printk(KERN_ERR "Insufficient PCI resources, aborting\n");
699                 goto err_out;
700         }
701
702         pioaddr = pci_resource_start(pdev, 0);
703         memaddr = pci_resource_start(pdev, 1);
704
705         pci_set_master(pdev);
706
707         dev = alloc_etherdev(sizeof(struct rhine_private));
708         if (!dev) {
709                 rc = -ENOMEM;
710                 printk(KERN_ERR "alloc_etherdev failed\n");
711                 goto err_out;
712         }
713         SET_NETDEV_DEV(dev, &pdev->dev);
714
715         rp = netdev_priv(dev);
716         rp->dev = dev;
717         rp->quirks = quirks;
718         rp->pioaddr = pioaddr;
719         rp->pdev = pdev;
720
721         rc = pci_request_regions(pdev, DRV_NAME);
722         if (rc)
723                 goto err_out_free_netdev;
724
725         ioaddr = pci_iomap(pdev, bar, io_size);
726         if (!ioaddr) {
727                 rc = -EIO;
728                 printk(KERN_ERR "ioremap failed for device %s, region 0x%X "
729                        "@ 0x%lX\n", pci_name(pdev), io_size, memaddr);
730                 goto err_out_free_res;
731         }
732
733 #ifdef USE_MMIO
734         enable_mmio(pioaddr, quirks);
735
736         /* Check that selected MMIO registers match the PIO ones */
737         i = 0;
738         while (mmio_verify_registers[i]) {
739                 int reg = mmio_verify_registers[i++];
740                 unsigned char a = inb(pioaddr+reg);
741                 unsigned char b = readb(ioaddr+reg);
742                 if (a != b) {
743                         rc = -EIO;
744                         printk(KERN_ERR "MMIO do not match PIO [%02x] "
745                                "(%02x != %02x)\n", reg, a, b);
746                         goto err_out_unmap;
747                 }
748         }
749 #endif /* USE_MMIO */
750
751         dev->base_addr = (unsigned long)ioaddr;
752         rp->base = ioaddr;
753
754         /* Get chip registers into a sane state */
755         rhine_power_init(dev);
756         rhine_hw_init(dev, pioaddr);
757
758         for (i = 0; i < 6; i++)
759                 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i);
760         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
761
762         if (!is_valid_ether_addr(dev->perm_addr)) {
763                 rc = -EIO;
764                 printk(KERN_ERR "Invalid MAC address\n");
765                 goto err_out_unmap;
766         }
767
768         /* For Rhine-I/II, phy_id is loaded from EEPROM */
769         if (!phy_id)
770                 phy_id = ioread8(ioaddr + 0x6C);
771
772         dev->irq = pdev->irq;
773
774         spin_lock_init(&rp->lock);
775         rp->mii_if.dev = dev;
776         rp->mii_if.mdio_read = mdio_read;
777         rp->mii_if.mdio_write = mdio_write;
778         rp->mii_if.phy_id_mask = 0x1f;
779         rp->mii_if.reg_num_mask = 0x1f;
780
781         /* The chip-specific entries in the device structure. */
782         dev->netdev_ops = &rhine_netdev_ops;
783         dev->ethtool_ops = &netdev_ethtool_ops,
784         dev->watchdog_timeo = TX_TIMEOUT;
785
786         netif_napi_add(dev, &rp->napi, rhine_napipoll, 64);
787
788         if (rp->quirks & rqRhineI)
789                 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
790
791         /* dev->name not defined before register_netdev()! */
792         rc = register_netdev(dev);
793         if (rc)
794                 goto err_out_unmap;
795
796         printk(KERN_INFO "%s: VIA %s at 0x%lx, %pM, IRQ %d.\n",
797                dev->name, name,
798 #ifdef USE_MMIO
799                memaddr,
800 #else
801                (long)ioaddr,
802 #endif
803                dev->dev_addr, pdev->irq);
804
805         pci_set_drvdata(pdev, dev);
806
807         {
808                 u16 mii_cmd;
809                 int mii_status = mdio_read(dev, phy_id, 1);
810                 mii_cmd = mdio_read(dev, phy_id, MII_BMCR) & ~BMCR_ISOLATE;
811                 mdio_write(dev, phy_id, MII_BMCR, mii_cmd);
812                 if (mii_status != 0xffff && mii_status != 0x0000) {
813                         rp->mii_if.advertising = mdio_read(dev, phy_id, 4);
814                         printk(KERN_INFO "%s: MII PHY found at address "
815                                "%d, status 0x%4.4x advertising %4.4x "
816                                "Link %4.4x.\n", dev->name, phy_id,
817                                mii_status, rp->mii_if.advertising,
818                                mdio_read(dev, phy_id, 5));
819
820                         /* set IFF_RUNNING */
821                         if (mii_status & BMSR_LSTATUS)
822                                 netif_carrier_on(dev);
823                         else
824                                 netif_carrier_off(dev);
825
826                 }
827         }
828         rp->mii_if.phy_id = phy_id;
829         if (debug > 1 && avoid_D3)
830                 printk(KERN_INFO "%s: No D3 power state at shutdown.\n",
831                        dev->name);
832
833         return 0;
834
835 err_out_unmap:
836         pci_iounmap(pdev, ioaddr);
837 err_out_free_res:
838         pci_release_regions(pdev);
839 err_out_free_netdev:
840         free_netdev(dev);
841 err_out:
842         return rc;
843 }
844
845 static int alloc_ring(struct net_device* dev)
846 {
847         struct rhine_private *rp = netdev_priv(dev);
848         void *ring;
849         dma_addr_t ring_dma;
850
851         ring = pci_alloc_consistent(rp->pdev,
852                                     RX_RING_SIZE * sizeof(struct rx_desc) +
853                                     TX_RING_SIZE * sizeof(struct tx_desc),
854                                     &ring_dma);
855         if (!ring) {
856                 printk(KERN_ERR "Could not allocate DMA memory.\n");
857                 return -ENOMEM;
858         }
859         if (rp->quirks & rqRhineI) {
860                 rp->tx_bufs = pci_alloc_consistent(rp->pdev,
861                                                    PKT_BUF_SZ * TX_RING_SIZE,
862                                                    &rp->tx_bufs_dma);
863                 if (rp->tx_bufs == NULL) {
864                         pci_free_consistent(rp->pdev,
865                                     RX_RING_SIZE * sizeof(struct rx_desc) +
866                                     TX_RING_SIZE * sizeof(struct tx_desc),
867                                     ring, ring_dma);
868                         return -ENOMEM;
869                 }
870         }
871
872         rp->rx_ring = ring;
873         rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
874         rp->rx_ring_dma = ring_dma;
875         rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
876
877         return 0;
878 }
879
880 static void free_ring(struct net_device* dev)
881 {
882         struct rhine_private *rp = netdev_priv(dev);
883
884         pci_free_consistent(rp->pdev,
885                             RX_RING_SIZE * sizeof(struct rx_desc) +
886                             TX_RING_SIZE * sizeof(struct tx_desc),
887                             rp->rx_ring, rp->rx_ring_dma);
888         rp->tx_ring = NULL;
889
890         if (rp->tx_bufs)
891                 pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE,
892                                     rp->tx_bufs, rp->tx_bufs_dma);
893
894         rp->tx_bufs = NULL;
895
896 }
897
898 static void alloc_rbufs(struct net_device *dev)
899 {
900         struct rhine_private *rp = netdev_priv(dev);
901         dma_addr_t next;
902         int i;
903
904         rp->dirty_rx = rp->cur_rx = 0;
905
906         rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
907         rp->rx_head_desc = &rp->rx_ring[0];
908         next = rp->rx_ring_dma;
909
910         /* Init the ring entries */
911         for (i = 0; i < RX_RING_SIZE; i++) {
912                 rp->rx_ring[i].rx_status = 0;
913                 rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz);
914                 next += sizeof(struct rx_desc);
915                 rp->rx_ring[i].next_desc = cpu_to_le32(next);
916                 rp->rx_skbuff[i] = NULL;
917         }
918         /* Mark the last entry as wrapping the ring. */
919         rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma);
920
921         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
922         for (i = 0; i < RX_RING_SIZE; i++) {
923                 struct sk_buff *skb = netdev_alloc_skb(dev, rp->rx_buf_sz);
924                 rp->rx_skbuff[i] = skb;
925                 if (skb == NULL)
926                         break;
927                 skb->dev = dev;                 /* Mark as being used by this device. */
928
929                 rp->rx_skbuff_dma[i] =
930                         pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz,
931                                        PCI_DMA_FROMDEVICE);
932
933                 rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);
934                 rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
935         }
936         rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
937 }
938
939 static void free_rbufs(struct net_device* dev)
940 {
941         struct rhine_private *rp = netdev_priv(dev);
942         int i;
943
944         /* Free all the skbuffs in the Rx queue. */
945         for (i = 0; i < RX_RING_SIZE; i++) {
946                 rp->rx_ring[i].rx_status = 0;
947                 rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
948                 if (rp->rx_skbuff[i]) {
949                         pci_unmap_single(rp->pdev,
950                                          rp->rx_skbuff_dma[i],
951                                          rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
952                         dev_kfree_skb(rp->rx_skbuff[i]);
953                 }
954                 rp->rx_skbuff[i] = NULL;
955         }
956 }
957
958 static void alloc_tbufs(struct net_device* dev)
959 {
960         struct rhine_private *rp = netdev_priv(dev);
961         dma_addr_t next;
962         int i;
963
964         rp->dirty_tx = rp->cur_tx = 0;
965         next = rp->tx_ring_dma;
966         for (i = 0; i < TX_RING_SIZE; i++) {
967                 rp->tx_skbuff[i] = NULL;
968                 rp->tx_ring[i].tx_status = 0;
969                 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
970                 next += sizeof(struct tx_desc);
971                 rp->tx_ring[i].next_desc = cpu_to_le32(next);
972                 if (rp->quirks & rqRhineI)
973                         rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ];
974         }
975         rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma);
976
977 }
978
979 static void free_tbufs(struct net_device* dev)
980 {
981         struct rhine_private *rp = netdev_priv(dev);
982         int i;
983
984         for (i = 0; i < TX_RING_SIZE; i++) {
985                 rp->tx_ring[i].tx_status = 0;
986                 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
987                 rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
988                 if (rp->tx_skbuff[i]) {
989                         if (rp->tx_skbuff_dma[i]) {
990                                 pci_unmap_single(rp->pdev,
991                                                  rp->tx_skbuff_dma[i],
992                                                  rp->tx_skbuff[i]->len,
993                                                  PCI_DMA_TODEVICE);
994                         }
995                         dev_kfree_skb(rp->tx_skbuff[i]);
996                 }
997                 rp->tx_skbuff[i] = NULL;
998                 rp->tx_buf[i] = NULL;
999         }
1000 }
1001
1002 static void rhine_check_media(struct net_device *dev, unsigned int init_media)
1003 {
1004         struct rhine_private *rp = netdev_priv(dev);
1005         void __iomem *ioaddr = rp->base;
1006
1007         mii_check_media(&rp->mii_if, debug, init_media);
1008
1009         if (rp->mii_if.full_duplex)
1010             iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,
1011                    ioaddr + ChipCmd1);
1012         else
1013             iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex,
1014                    ioaddr + ChipCmd1);
1015         if (debug > 1)
1016                 printk(KERN_INFO "%s: force_media %d, carrier %d\n", dev->name,
1017                         rp->mii_if.force_media, netif_carrier_ok(dev));
1018 }
1019
1020 /* Called after status of force_media possibly changed */
1021 static void rhine_set_carrier(struct mii_if_info *mii)
1022 {
1023         if (mii->force_media) {
1024                 /* autoneg is off: Link is always assumed to be up */
1025                 if (!netif_carrier_ok(mii->dev))
1026                         netif_carrier_on(mii->dev);
1027         }
1028         else    /* Let MMI library update carrier status */
1029                 rhine_check_media(mii->dev, 0);
1030         if (debug > 1)
1031                 printk(KERN_INFO "%s: force_media %d, carrier %d\n",
1032                        mii->dev->name, mii->force_media,
1033                        netif_carrier_ok(mii->dev));
1034 }
1035
1036 static void init_registers(struct net_device *dev)
1037 {
1038         struct rhine_private *rp = netdev_priv(dev);
1039         void __iomem *ioaddr = rp->base;
1040         int i;
1041
1042         for (i = 0; i < 6; i++)
1043                 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i);
1044
1045         /* Initialize other registers. */
1046         iowrite16(0x0006, ioaddr + PCIBusConfig);       /* Tune configuration??? */
1047         /* Configure initial FIFO thresholds. */
1048         iowrite8(0x20, ioaddr + TxConfig);
1049         rp->tx_thresh = 0x20;
1050         rp->rx_thresh = 0x60;           /* Written in rhine_set_rx_mode(). */
1051
1052         iowrite32(rp->rx_ring_dma, ioaddr + RxRingPtr);
1053         iowrite32(rp->tx_ring_dma, ioaddr + TxRingPtr);
1054
1055         rhine_set_rx_mode(dev);
1056
1057         napi_enable(&rp->napi);
1058
1059         /* Enable interrupts by setting the interrupt mask. */
1060         iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
1061                IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
1062                IntrTxDone | IntrTxError | IntrTxUnderrun |
1063                IntrPCIErr | IntrStatsMax | IntrLinkChange,
1064                ioaddr + IntrEnable);
1065
1066         iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8),
1067                ioaddr + ChipCmd);
1068         rhine_check_media(dev, 1);
1069 }
1070
1071 /* Enable MII link status auto-polling (required for IntrLinkChange) */
1072 static void rhine_enable_linkmon(void __iomem *ioaddr)
1073 {
1074         iowrite8(0, ioaddr + MIICmd);
1075         iowrite8(MII_BMSR, ioaddr + MIIRegAddr);
1076         iowrite8(0x80, ioaddr + MIICmd);
1077
1078         RHINE_WAIT_FOR((ioread8(ioaddr + MIIRegAddr) & 0x20));
1079
1080         iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr);
1081 }
1082
1083 /* Disable MII link status auto-polling (required for MDIO access) */
1084 static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
1085 {
1086         iowrite8(0, ioaddr + MIICmd);
1087
1088         if (quirks & rqRhineI) {
1089                 iowrite8(0x01, ioaddr + MIIRegAddr);    // MII_BMSR
1090
1091                 /* Can be called from ISR. Evil. */
1092                 mdelay(1);
1093
1094                 /* 0x80 must be set immediately before turning it off */
1095                 iowrite8(0x80, ioaddr + MIICmd);
1096
1097                 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x20);
1098
1099                 /* Heh. Now clear 0x80 again. */
1100                 iowrite8(0, ioaddr + MIICmd);
1101         }
1102         else
1103                 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x80);
1104 }
1105
1106 /* Read and write over the MII Management Data I/O (MDIO) interface. */
1107
1108 static int mdio_read(struct net_device *dev, int phy_id, int regnum)
1109 {
1110         struct rhine_private *rp = netdev_priv(dev);
1111         void __iomem *ioaddr = rp->base;
1112         int result;
1113
1114         rhine_disable_linkmon(ioaddr, rp->quirks);
1115
1116         /* rhine_disable_linkmon already cleared MIICmd */
1117         iowrite8(phy_id, ioaddr + MIIPhyAddr);
1118         iowrite8(regnum, ioaddr + MIIRegAddr);
1119         iowrite8(0x40, ioaddr + MIICmd);                /* Trigger read */
1120         RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x40));
1121         result = ioread16(ioaddr + MIIData);
1122
1123         rhine_enable_linkmon(ioaddr);
1124         return result;
1125 }
1126
1127 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value)
1128 {
1129         struct rhine_private *rp = netdev_priv(dev);
1130         void __iomem *ioaddr = rp->base;
1131
1132         rhine_disable_linkmon(ioaddr, rp->quirks);
1133
1134         /* rhine_disable_linkmon already cleared MIICmd */
1135         iowrite8(phy_id, ioaddr + MIIPhyAddr);
1136         iowrite8(regnum, ioaddr + MIIRegAddr);
1137         iowrite16(value, ioaddr + MIIData);
1138         iowrite8(0x20, ioaddr + MIICmd);                /* Trigger write */
1139         RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x20));
1140
1141         rhine_enable_linkmon(ioaddr);
1142 }
1143
1144 static int rhine_open(struct net_device *dev)
1145 {
1146         struct rhine_private *rp = netdev_priv(dev);
1147         void __iomem *ioaddr = rp->base;
1148         int rc;
1149
1150         rc = request_irq(rp->pdev->irq, &rhine_interrupt, IRQF_SHARED, dev->name,
1151                         dev);
1152         if (rc)
1153                 return rc;
1154
1155         if (debug > 1)
1156                 printk(KERN_DEBUG "%s: rhine_open() irq %d.\n",
1157                        dev->name, rp->pdev->irq);
1158
1159         rc = alloc_ring(dev);
1160         if (rc) {
1161                 free_irq(rp->pdev->irq, dev);
1162                 return rc;
1163         }
1164         alloc_rbufs(dev);
1165         alloc_tbufs(dev);
1166         rhine_chip_reset(dev);
1167         init_registers(dev);
1168         if (debug > 2)
1169                 printk(KERN_DEBUG "%s: Done rhine_open(), status %4.4x "
1170                        "MII status: %4.4x.\n",
1171                        dev->name, ioread16(ioaddr + ChipCmd),
1172                        mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1173
1174         netif_start_queue(dev);
1175
1176         return 0;
1177 }
1178
1179 static void rhine_tx_timeout(struct net_device *dev)
1180 {
1181         struct rhine_private *rp = netdev_priv(dev);
1182         void __iomem *ioaddr = rp->base;
1183
1184         printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
1185                "%4.4x, resetting...\n",
1186                dev->name, ioread16(ioaddr + IntrStatus),
1187                mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1188
1189         /* protect against concurrent rx interrupts */
1190         disable_irq(rp->pdev->irq);
1191
1192         napi_disable(&rp->napi);
1193
1194         spin_lock(&rp->lock);
1195
1196         /* clear all descriptors */
1197         free_tbufs(dev);
1198         free_rbufs(dev);
1199         alloc_tbufs(dev);
1200         alloc_rbufs(dev);
1201
1202         /* Reinitialize the hardware. */
1203         rhine_chip_reset(dev);
1204         init_registers(dev);
1205
1206         spin_unlock(&rp->lock);
1207         enable_irq(rp->pdev->irq);
1208
1209         dev->trans_start = jiffies;
1210         rp->stats.tx_errors++;
1211         netif_wake_queue(dev);
1212 }
1213
1214 static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
1215 {
1216         struct rhine_private *rp = netdev_priv(dev);
1217         void __iomem *ioaddr = rp->base;
1218         unsigned entry;
1219
1220         /* Caution: the write order is important here, set the field
1221            with the "ownership" bits last. */
1222
1223         /* Calculate the next Tx descriptor entry. */
1224         entry = rp->cur_tx % TX_RING_SIZE;
1225
1226         if (skb_padto(skb, ETH_ZLEN))
1227                 return 0;
1228
1229         rp->tx_skbuff[entry] = skb;
1230
1231         if ((rp->quirks & rqRhineI) &&
1232             (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_PARTIAL)) {
1233                 /* Must use alignment buffer. */
1234                 if (skb->len > PKT_BUF_SZ) {
1235                         /* packet too long, drop it */
1236                         dev_kfree_skb(skb);
1237                         rp->tx_skbuff[entry] = NULL;
1238                         rp->stats.tx_dropped++;
1239                         return 0;
1240                 }
1241
1242                 /* Padding is not copied and so must be redone. */
1243                 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
1244                 if (skb->len < ETH_ZLEN)
1245                         memset(rp->tx_buf[entry] + skb->len, 0,
1246                                ETH_ZLEN - skb->len);
1247                 rp->tx_skbuff_dma[entry] = 0;
1248                 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
1249                                                       (rp->tx_buf[entry] -
1250                                                        rp->tx_bufs));
1251         } else {
1252                 rp->tx_skbuff_dma[entry] =
1253                         pci_map_single(rp->pdev, skb->data, skb->len,
1254                                        PCI_DMA_TODEVICE);
1255                 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]);
1256         }
1257
1258         rp->tx_ring[entry].desc_length =
1259                 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1260
1261         /* lock eth irq */
1262         spin_lock_irq(&rp->lock);
1263         wmb();
1264         rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1265         wmb();
1266
1267         rp->cur_tx++;
1268
1269         /* Non-x86 Todo: explicitly flush cache lines here. */
1270
1271         /* Wake the potentially-idle transmit channel */
1272         iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1273                ioaddr + ChipCmd1);
1274         IOSYNC;
1275
1276         if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
1277                 netif_stop_queue(dev);
1278
1279         dev->trans_start = jiffies;
1280
1281         spin_unlock_irq(&rp->lock);
1282
1283         if (debug > 4) {
1284                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1285                        dev->name, rp->cur_tx-1, entry);
1286         }
1287         return 0;
1288 }
1289
1290 /* The interrupt handler does all of the Rx thread work and cleans up
1291    after the Tx thread. */
1292 static irqreturn_t rhine_interrupt(int irq, void *dev_instance)
1293 {
1294         struct net_device *dev = dev_instance;
1295         struct rhine_private *rp = netdev_priv(dev);
1296         void __iomem *ioaddr = rp->base;
1297         u32 intr_status;
1298         int boguscnt = max_interrupt_work;
1299         int handled = 0;
1300
1301         while ((intr_status = get_intr_status(dev))) {
1302                 handled = 1;
1303
1304                 /* Acknowledge all of the current interrupt sources ASAP. */
1305                 if (intr_status & IntrTxDescRace)
1306                         iowrite8(0x08, ioaddr + IntrStatus2);
1307                 iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
1308                 IOSYNC;
1309
1310                 if (debug > 4)
1311                         printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n",
1312                                dev->name, intr_status);
1313
1314                 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
1315                                    IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) {
1316                         iowrite16(IntrTxAborted |
1317                                   IntrTxDone | IntrTxError | IntrTxUnderrun |
1318                                   IntrPCIErr | IntrStatsMax | IntrLinkChange,
1319                                   ioaddr + IntrEnable);
1320
1321                         netif_rx_schedule(&rp->napi);
1322                 }
1323
1324                 if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
1325                         if (intr_status & IntrTxErrSummary) {
1326                                 /* Avoid scavenging before Tx engine turned off */
1327                                 RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
1328                                 if (debug > 2 &&
1329                                     ioread8(ioaddr+ChipCmd) & CmdTxOn)
1330                                         printk(KERN_WARNING "%s: "
1331                                                "rhine_interrupt() Tx engine "
1332                                                "still on.\n", dev->name);
1333                         }
1334                         rhine_tx(dev);
1335                 }
1336
1337                 /* Abnormal error summary/uncommon events handlers. */
1338                 if (intr_status & (IntrPCIErr | IntrLinkChange |
1339                                    IntrStatsMax | IntrTxError | IntrTxAborted |
1340                                    IntrTxUnderrun | IntrTxDescRace))
1341                         rhine_error(dev, intr_status);
1342
1343                 if (--boguscnt < 0) {
1344                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1345                                "status=%#8.8x.\n",
1346                                dev->name, intr_status);
1347                         break;
1348                 }
1349         }
1350
1351         if (debug > 3)
1352                 printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n",
1353                        dev->name, ioread16(ioaddr + IntrStatus));
1354         return IRQ_RETVAL(handled);
1355 }
1356
1357 /* This routine is logically part of the interrupt handler, but isolated
1358    for clarity. */
1359 static void rhine_tx(struct net_device *dev)
1360 {
1361         struct rhine_private *rp = netdev_priv(dev);
1362         int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
1363
1364         spin_lock(&rp->lock);
1365
1366         /* find and cleanup dirty tx descriptors */
1367         while (rp->dirty_tx != rp->cur_tx) {
1368                 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
1369                 if (debug > 6)
1370                         printk(KERN_DEBUG "Tx scavenge %d status %8.8x.\n",
1371                                entry, txstatus);
1372                 if (txstatus & DescOwn)
1373                         break;
1374                 if (txstatus & 0x8000) {
1375                         if (debug > 1)
1376                                 printk(KERN_DEBUG "%s: Transmit error, "
1377                                        "Tx status %8.8x.\n",
1378                                        dev->name, txstatus);
1379                         rp->stats.tx_errors++;
1380                         if (txstatus & 0x0400) rp->stats.tx_carrier_errors++;
1381                         if (txstatus & 0x0200) rp->stats.tx_window_errors++;
1382                         if (txstatus & 0x0100) rp->stats.tx_aborted_errors++;
1383                         if (txstatus & 0x0080) rp->stats.tx_heartbeat_errors++;
1384                         if (((rp->quirks & rqRhineI) && txstatus & 0x0002) ||
1385                             (txstatus & 0x0800) || (txstatus & 0x1000)) {
1386                                 rp->stats.tx_fifo_errors++;
1387                                 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1388                                 break; /* Keep the skb - we try again */
1389                         }
1390                         /* Transmitter restarted in 'abnormal' handler. */
1391                 } else {
1392                         if (rp->quirks & rqRhineI)
1393                                 rp->stats.collisions += (txstatus >> 3) & 0x0F;
1394                         else
1395                                 rp->stats.collisions += txstatus & 0x0F;
1396                         if (debug > 6)
1397                                 printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
1398                                        (txstatus >> 3) & 0xF,
1399                                        txstatus & 0xF);
1400                         rp->stats.tx_bytes += rp->tx_skbuff[entry]->len;
1401                         rp->stats.tx_packets++;
1402                 }
1403                 /* Free the original skb. */
1404                 if (rp->tx_skbuff_dma[entry]) {
1405                         pci_unmap_single(rp->pdev,
1406                                          rp->tx_skbuff_dma[entry],
1407                                          rp->tx_skbuff[entry]->len,
1408                                          PCI_DMA_TODEVICE);
1409                 }
1410                 dev_kfree_skb_irq(rp->tx_skbuff[entry]);
1411                 rp->tx_skbuff[entry] = NULL;
1412                 entry = (++rp->dirty_tx) % TX_RING_SIZE;
1413         }
1414         if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
1415                 netif_wake_queue(dev);
1416
1417         spin_unlock(&rp->lock);
1418 }
1419
1420 /* Process up to limit frames from receive ring */
1421 static int rhine_rx(struct net_device *dev, int limit)
1422 {
1423         struct rhine_private *rp = netdev_priv(dev);
1424         int count;
1425         int entry = rp->cur_rx % RX_RING_SIZE;
1426
1427         if (debug > 4) {
1428                 printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
1429                        dev->name, entry,
1430                        le32_to_cpu(rp->rx_head_desc->rx_status));
1431         }
1432
1433         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1434         for (count = 0; count < limit; ++count) {
1435                 struct rx_desc *desc = rp->rx_head_desc;
1436                 u32 desc_status = le32_to_cpu(desc->rx_status);
1437                 int data_size = desc_status >> 16;
1438
1439                 if (desc_status & DescOwn)
1440                         break;
1441
1442                 if (debug > 4)
1443                         printk(KERN_DEBUG "rhine_rx() status is %8.8x.\n",
1444                                desc_status);
1445
1446                 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
1447                         if ((desc_status & RxWholePkt) != RxWholePkt) {
1448                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1449                                        "frame spanned multiple buffers, entry "
1450                                        "%#x length %d status %8.8x!\n",
1451                                        dev->name, entry, data_size,
1452                                        desc_status);
1453                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1454                                        "frame %p vs %p.\n", dev->name,
1455                                        rp->rx_head_desc, &rp->rx_ring[entry]);
1456                                 rp->stats.rx_length_errors++;
1457                         } else if (desc_status & RxErr) {
1458                                 /* There was a error. */
1459                                 if (debug > 2)
1460                                         printk(KERN_DEBUG "rhine_rx() Rx "
1461                                                "error was %8.8x.\n",
1462                                                desc_status);
1463                                 rp->stats.rx_errors++;
1464                                 if (desc_status & 0x0030) rp->stats.rx_length_errors++;
1465                                 if (desc_status & 0x0048) rp->stats.rx_fifo_errors++;
1466                                 if (desc_status & 0x0004) rp->stats.rx_frame_errors++;
1467                                 if (desc_status & 0x0002) {
1468                                         /* this can also be updated outside the interrupt handler */
1469                                         spin_lock(&rp->lock);
1470                                         rp->stats.rx_crc_errors++;
1471                                         spin_unlock(&rp->lock);
1472                                 }
1473                         }
1474                 } else {
1475                         struct sk_buff *skb;
1476                         /* Length should omit the CRC */
1477                         int pkt_len = data_size - 4;
1478
1479                         /* Check if the packet is long enough to accept without
1480                            copying to a minimally-sized skbuff. */
1481                         if (pkt_len < rx_copybreak &&
1482                                 (skb = netdev_alloc_skb(dev, pkt_len + NET_IP_ALIGN)) != NULL) {
1483                                 skb_reserve(skb, NET_IP_ALIGN); /* 16 byte align the IP header */
1484                                 pci_dma_sync_single_for_cpu(rp->pdev,
1485                                                             rp->rx_skbuff_dma[entry],
1486                                                             rp->rx_buf_sz,
1487                                                             PCI_DMA_FROMDEVICE);
1488
1489                                 skb_copy_to_linear_data(skb,
1490                                                  rp->rx_skbuff[entry]->data,
1491                                                  pkt_len);
1492                                 skb_put(skb, pkt_len);
1493                                 pci_dma_sync_single_for_device(rp->pdev,
1494                                                                rp->rx_skbuff_dma[entry],
1495                                                                rp->rx_buf_sz,
1496                                                                PCI_DMA_FROMDEVICE);
1497                         } else {
1498                                 skb = rp->rx_skbuff[entry];
1499                                 if (skb == NULL) {
1500                                         printk(KERN_ERR "%s: Inconsistent Rx "
1501                                                "descriptor chain.\n",
1502                                                dev->name);
1503                                         break;
1504                                 }
1505                                 rp->rx_skbuff[entry] = NULL;
1506                                 skb_put(skb, pkt_len);
1507                                 pci_unmap_single(rp->pdev,
1508                                                  rp->rx_skbuff_dma[entry],
1509                                                  rp->rx_buf_sz,
1510                                                  PCI_DMA_FROMDEVICE);
1511                         }
1512                         skb->protocol = eth_type_trans(skb, dev);
1513                         netif_receive_skb(skb);
1514                         rp->stats.rx_bytes += pkt_len;
1515                         rp->stats.rx_packets++;
1516                 }
1517                 entry = (++rp->cur_rx) % RX_RING_SIZE;
1518                 rp->rx_head_desc = &rp->rx_ring[entry];
1519         }
1520
1521         /* Refill the Rx ring buffers. */
1522         for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {
1523                 struct sk_buff *skb;
1524                 entry = rp->dirty_rx % RX_RING_SIZE;
1525                 if (rp->rx_skbuff[entry] == NULL) {
1526                         skb = netdev_alloc_skb(dev, rp->rx_buf_sz);
1527                         rp->rx_skbuff[entry] = skb;
1528                         if (skb == NULL)
1529                                 break;  /* Better luck next round. */
1530                         skb->dev = dev; /* Mark as being used by this device. */
1531                         rp->rx_skbuff_dma[entry] =
1532                                 pci_map_single(rp->pdev, skb->data,
1533                                                rp->rx_buf_sz,
1534                                                PCI_DMA_FROMDEVICE);
1535                         rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
1536                 }
1537                 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
1538         }
1539
1540         return count;
1541 }
1542
1543 /*
1544  * Clears the "tally counters" for CRC errors and missed frames(?).
1545  * It has been reported that some chips need a write of 0 to clear
1546  * these, for others the counters are set to 1 when written to and
1547  * instead cleared when read. So we clear them both ways ...
1548  */
1549 static inline void clear_tally_counters(void __iomem *ioaddr)
1550 {
1551         iowrite32(0, ioaddr + RxMissed);
1552         ioread16(ioaddr + RxCRCErrs);
1553         ioread16(ioaddr + RxMissed);
1554 }
1555
1556 static void rhine_restart_tx(struct net_device *dev) {
1557         struct rhine_private *rp = netdev_priv(dev);
1558         void __iomem *ioaddr = rp->base;
1559         int entry = rp->dirty_tx % TX_RING_SIZE;
1560         u32 intr_status;
1561
1562         /*
1563          * If new errors occured, we need to sort them out before doing Tx.
1564          * In that case the ISR will be back here RSN anyway.
1565          */
1566         intr_status = get_intr_status(dev);
1567
1568         if ((intr_status & IntrTxErrSummary) == 0) {
1569
1570                 /* We know better than the chip where it should continue. */
1571                 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc),
1572                        ioaddr + TxRingPtr);
1573
1574                 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn,
1575                        ioaddr + ChipCmd);
1576                 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1577                        ioaddr + ChipCmd1);
1578                 IOSYNC;
1579         }
1580         else {
1581                 /* This should never happen */
1582                 if (debug > 1)
1583                         printk(KERN_WARNING "%s: rhine_restart_tx() "
1584                                "Another error occured %8.8x.\n",
1585                                dev->name, intr_status);
1586         }
1587
1588 }
1589
1590 static void rhine_error(struct net_device *dev, int intr_status)
1591 {
1592         struct rhine_private *rp = netdev_priv(dev);
1593         void __iomem *ioaddr = rp->base;
1594
1595         spin_lock(&rp->lock);
1596
1597         if (intr_status & IntrLinkChange)
1598                 rhine_check_media(dev, 0);
1599         if (intr_status & IntrStatsMax) {
1600                 rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1601                 rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1602                 clear_tally_counters(ioaddr);
1603         }
1604         if (intr_status & IntrTxAborted) {
1605                 if (debug > 1)
1606                         printk(KERN_INFO "%s: Abort %8.8x, frame dropped.\n",
1607                                dev->name, intr_status);
1608         }
1609         if (intr_status & IntrTxUnderrun) {
1610                 if (rp->tx_thresh < 0xE0)
1611                         iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1612                 if (debug > 1)
1613                         printk(KERN_INFO "%s: Transmitter underrun, Tx "
1614                                "threshold now %2.2x.\n",
1615                                dev->name, rp->tx_thresh);
1616         }
1617         if (intr_status & IntrTxDescRace) {
1618                 if (debug > 2)
1619                         printk(KERN_INFO "%s: Tx descriptor write-back race.\n",
1620                                dev->name);
1621         }
1622         if ((intr_status & IntrTxError) &&
1623             (intr_status & (IntrTxAborted |
1624              IntrTxUnderrun | IntrTxDescRace)) == 0) {
1625                 if (rp->tx_thresh < 0xE0) {
1626                         iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1627                 }
1628                 if (debug > 1)
1629                         printk(KERN_INFO "%s: Unspecified error. Tx "
1630                                "threshold now %2.2x.\n",
1631                                dev->name, rp->tx_thresh);
1632         }
1633         if (intr_status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
1634                            IntrTxError))
1635                 rhine_restart_tx(dev);
1636
1637         if (intr_status & ~(IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
1638                             IntrTxError | IntrTxAborted | IntrNormalSummary |
1639                             IntrTxDescRace)) {
1640                 if (debug > 1)
1641                         printk(KERN_ERR "%s: Something Wicked happened! "
1642                                "%8.8x.\n", dev->name, intr_status);
1643         }
1644
1645         spin_unlock(&rp->lock);
1646 }
1647
1648 static struct net_device_stats *rhine_get_stats(struct net_device *dev)
1649 {
1650         struct rhine_private *rp = netdev_priv(dev);
1651         void __iomem *ioaddr = rp->base;
1652         unsigned long flags;
1653
1654         spin_lock_irqsave(&rp->lock, flags);
1655         rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1656         rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1657         clear_tally_counters(ioaddr);
1658         spin_unlock_irqrestore(&rp->lock, flags);
1659
1660         return &rp->stats;
1661 }
1662
1663 static void rhine_set_rx_mode(struct net_device *dev)
1664 {
1665         struct rhine_private *rp = netdev_priv(dev);
1666         void __iomem *ioaddr = rp->base;
1667         u32 mc_filter[2];       /* Multicast hash filter */
1668         u8 rx_mode;             /* Note: 0x02=accept runt, 0x01=accept errs */
1669
1670         if (dev->flags & IFF_PROMISC) {         /* Set promiscuous. */
1671                 rx_mode = 0x1C;
1672                 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1673                 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1674         } else if ((dev->mc_count > multicast_filter_limit)
1675                    || (dev->flags & IFF_ALLMULTI)) {
1676                 /* Too many to match, or accept all multicasts. */
1677                 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1678                 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1679                 rx_mode = 0x0C;
1680         } else {
1681                 struct dev_mc_list *mclist;
1682                 int i;
1683                 memset(mc_filter, 0, sizeof(mc_filter));
1684                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1685                      i++, mclist = mclist->next) {
1686                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1687
1688                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1689                 }
1690                 iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1691                 iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1692                 rx_mode = 0x0C;
1693         }
1694         iowrite8(rp->rx_thresh | rx_mode, ioaddr + RxConfig);
1695 }
1696
1697 static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1698 {
1699         struct rhine_private *rp = netdev_priv(dev);
1700
1701         strcpy(info->driver, DRV_NAME);
1702         strcpy(info->version, DRV_VERSION);
1703         strcpy(info->bus_info, pci_name(rp->pdev));
1704 }
1705
1706 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1707 {
1708         struct rhine_private *rp = netdev_priv(dev);
1709         int rc;
1710
1711         spin_lock_irq(&rp->lock);
1712         rc = mii_ethtool_gset(&rp->mii_if, cmd);
1713         spin_unlock_irq(&rp->lock);
1714
1715         return rc;
1716 }
1717
1718 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1719 {
1720         struct rhine_private *rp = netdev_priv(dev);
1721         int rc;
1722
1723         spin_lock_irq(&rp->lock);
1724         rc = mii_ethtool_sset(&rp->mii_if, cmd);
1725         spin_unlock_irq(&rp->lock);
1726         rhine_set_carrier(&rp->mii_if);
1727
1728         return rc;
1729 }
1730
1731 static int netdev_nway_reset(struct net_device *dev)
1732 {
1733         struct rhine_private *rp = netdev_priv(dev);
1734
1735         return mii_nway_restart(&rp->mii_if);
1736 }
1737
1738 static u32 netdev_get_link(struct net_device *dev)
1739 {
1740         struct rhine_private *rp = netdev_priv(dev);
1741
1742         return mii_link_ok(&rp->mii_if);
1743 }
1744
1745 static u32 netdev_get_msglevel(struct net_device *dev)
1746 {
1747         return debug;
1748 }
1749
1750 static void netdev_set_msglevel(struct net_device *dev, u32 value)
1751 {
1752         debug = value;
1753 }
1754
1755 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1756 {
1757         struct rhine_private *rp = netdev_priv(dev);
1758
1759         if (!(rp->quirks & rqWOL))
1760                 return;
1761
1762         spin_lock_irq(&rp->lock);
1763         wol->supported = WAKE_PHY | WAKE_MAGIC |
1764                          WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;  /* Untested */
1765         wol->wolopts = rp->wolopts;
1766         spin_unlock_irq(&rp->lock);
1767 }
1768
1769 static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1770 {
1771         struct rhine_private *rp = netdev_priv(dev);
1772         u32 support = WAKE_PHY | WAKE_MAGIC |
1773                       WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;     /* Untested */
1774
1775         if (!(rp->quirks & rqWOL))
1776                 return -EINVAL;
1777
1778         if (wol->wolopts & ~support)
1779                 return -EINVAL;
1780
1781         spin_lock_irq(&rp->lock);
1782         rp->wolopts = wol->wolopts;
1783         spin_unlock_irq(&rp->lock);
1784
1785         return 0;
1786 }
1787
1788 static const struct ethtool_ops netdev_ethtool_ops = {
1789         .get_drvinfo            = netdev_get_drvinfo,
1790         .get_settings           = netdev_get_settings,
1791         .set_settings           = netdev_set_settings,
1792         .nway_reset             = netdev_nway_reset,
1793         .get_link               = netdev_get_link,
1794         .get_msglevel           = netdev_get_msglevel,
1795         .set_msglevel           = netdev_set_msglevel,
1796         .get_wol                = rhine_get_wol,
1797         .set_wol                = rhine_set_wol,
1798 };
1799
1800 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1801 {
1802         struct rhine_private *rp = netdev_priv(dev);
1803         int rc;
1804
1805         if (!netif_running(dev))
1806                 return -EINVAL;
1807
1808         spin_lock_irq(&rp->lock);
1809         rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
1810         spin_unlock_irq(&rp->lock);
1811         rhine_set_carrier(&rp->mii_if);
1812
1813         return rc;
1814 }
1815
1816 static int rhine_close(struct net_device *dev)
1817 {
1818         struct rhine_private *rp = netdev_priv(dev);
1819         void __iomem *ioaddr = rp->base;
1820
1821         spin_lock_irq(&rp->lock);
1822
1823         netif_stop_queue(dev);
1824         napi_disable(&rp->napi);
1825
1826         if (debug > 1)
1827                 printk(KERN_DEBUG "%s: Shutting down ethercard, "
1828                        "status was %4.4x.\n",
1829                        dev->name, ioread16(ioaddr + ChipCmd));
1830
1831         /* Switch to loopback mode to avoid hardware races. */
1832         iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
1833
1834         /* Disable interrupts by clearing the interrupt mask. */
1835         iowrite16(0x0000, ioaddr + IntrEnable);
1836
1837         /* Stop the chip's Tx and Rx processes. */
1838         iowrite16(CmdStop, ioaddr + ChipCmd);
1839
1840         spin_unlock_irq(&rp->lock);
1841
1842         free_irq(rp->pdev->irq, dev);
1843         free_rbufs(dev);
1844         free_tbufs(dev);
1845         free_ring(dev);
1846
1847         return 0;
1848 }
1849
1850
1851 static void __devexit rhine_remove_one(struct pci_dev *pdev)
1852 {
1853         struct net_device *dev = pci_get_drvdata(pdev);
1854         struct rhine_private *rp = netdev_priv(dev);
1855
1856         unregister_netdev(dev);
1857
1858         pci_iounmap(pdev, rp->base);
1859         pci_release_regions(pdev);
1860
1861         free_netdev(dev);
1862         pci_disable_device(pdev);
1863         pci_set_drvdata(pdev, NULL);
1864 }
1865
1866 static void rhine_shutdown (struct pci_dev *pdev)
1867 {
1868         struct net_device *dev = pci_get_drvdata(pdev);
1869         struct rhine_private *rp = netdev_priv(dev);
1870         void __iomem *ioaddr = rp->base;
1871
1872         if (!(rp->quirks & rqWOL))
1873                 return; /* Nothing to do for non-WOL adapters */
1874
1875         rhine_power_init(dev);
1876
1877         /* Make sure we use pattern 0, 1 and not 4, 5 */
1878         if (rp->quirks & rq6patterns)
1879                 iowrite8(0x04, ioaddr + WOLcgClr);
1880
1881         if (rp->wolopts & WAKE_MAGIC) {
1882                 iowrite8(WOLmagic, ioaddr + WOLcrSet);
1883                 /*
1884                  * Turn EEPROM-controlled wake-up back on -- some hardware may
1885                  * not cooperate otherwise.
1886                  */
1887                 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);
1888         }
1889
1890         if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST))
1891                 iowrite8(WOLbmcast, ioaddr + WOLcgSet);
1892
1893         if (rp->wolopts & WAKE_PHY)
1894                 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet);
1895
1896         if (rp->wolopts & WAKE_UCAST)
1897                 iowrite8(WOLucast, ioaddr + WOLcrSet);
1898
1899         if (rp->wolopts) {
1900                 /* Enable legacy WOL (for old motherboards) */
1901                 iowrite8(0x01, ioaddr + PwcfgSet);
1902                 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
1903         }
1904
1905         /* Hit power state D3 (sleep) */
1906         if (!avoid_D3)
1907                 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
1908
1909         /* TODO: Check use of pci_enable_wake() */
1910
1911 }
1912
1913 #ifdef CONFIG_PM
1914 static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
1915 {
1916         struct net_device *dev = pci_get_drvdata(pdev);
1917         struct rhine_private *rp = netdev_priv(dev);
1918         unsigned long flags;
1919
1920         if (!netif_running(dev))
1921                 return 0;
1922
1923         napi_disable(&rp->napi);
1924
1925         netif_device_detach(dev);
1926         pci_save_state(pdev);
1927
1928         spin_lock_irqsave(&rp->lock, flags);
1929         rhine_shutdown(pdev);
1930         spin_unlock_irqrestore(&rp->lock, flags);
1931
1932         free_irq(dev->irq, dev);
1933         return 0;
1934 }
1935
1936 static int rhine_resume(struct pci_dev *pdev)
1937 {
1938         struct net_device *dev = pci_get_drvdata(pdev);
1939         struct rhine_private *rp = netdev_priv(dev);
1940         unsigned long flags;
1941         int ret;
1942
1943         if (!netif_running(dev))
1944                 return 0;
1945
1946         if (request_irq(dev->irq, rhine_interrupt, IRQF_SHARED, dev->name, dev))
1947                 printk(KERN_ERR "via-rhine %s: request_irq failed\n", dev->name);
1948
1949         ret = pci_set_power_state(pdev, PCI_D0);
1950         if (debug > 1)
1951                 printk(KERN_INFO "%s: Entering power state D0 %s (%d).\n",
1952                         dev->name, ret ? "failed" : "succeeded", ret);
1953
1954         pci_restore_state(pdev);
1955
1956         spin_lock_irqsave(&rp->lock, flags);
1957 #ifdef USE_MMIO
1958         enable_mmio(rp->pioaddr, rp->quirks);
1959 #endif
1960         rhine_power_init(dev);
1961         free_tbufs(dev);
1962         free_rbufs(dev);
1963         alloc_tbufs(dev);
1964         alloc_rbufs(dev);
1965         init_registers(dev);
1966         spin_unlock_irqrestore(&rp->lock, flags);
1967
1968         netif_device_attach(dev);
1969
1970         return 0;
1971 }
1972 #endif /* CONFIG_PM */
1973
1974 static struct pci_driver rhine_driver = {
1975         .name           = DRV_NAME,
1976         .id_table       = rhine_pci_tbl,
1977         .probe          = rhine_init_one,
1978         .remove         = __devexit_p(rhine_remove_one),
1979 #ifdef CONFIG_PM
1980         .suspend        = rhine_suspend,
1981         .resume         = rhine_resume,
1982 #endif /* CONFIG_PM */
1983         .shutdown =     rhine_shutdown,
1984 };
1985
1986 static struct dmi_system_id __initdata rhine_dmi_table[] = {
1987         {
1988                 .ident = "EPIA-M",
1989                 .matches = {
1990                         DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."),
1991                         DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
1992                 },
1993         },
1994         {
1995                 .ident = "KV7",
1996                 .matches = {
1997                         DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
1998                         DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
1999                 },
2000         },
2001         { NULL }
2002 };
2003
2004 static int __init rhine_init(void)
2005 {
2006 /* when a module, this is printed whether or not devices are found in probe */
2007 #ifdef MODULE
2008         printk(version);
2009 #endif
2010         if (dmi_check_system(rhine_dmi_table)) {
2011                 /* these BIOSes fail at PXE boot if chip is in D3 */
2012                 avoid_D3 = 1;
2013                 printk(KERN_WARNING "%s: Broken BIOS detected, avoid_D3 "
2014                                     "enabled.\n",
2015                        DRV_NAME);
2016         }
2017         else if (avoid_D3)
2018                 printk(KERN_INFO "%s: avoid_D3 set.\n", DRV_NAME);
2019
2020         return pci_register_driver(&rhine_driver);
2021 }
2022
2023
2024 static void __exit rhine_cleanup(void)
2025 {
2026         pci_unregister_driver(&rhine_driver);
2027 }
2028
2029
2030 module_init(rhine_init);
2031 module_exit(rhine_cleanup);