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