blob: 88c30a58b4bda50d0b5fb610916365076cbdf1c5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
Jeff Garzik03a8c662006-06-27 07:57:22 -040028 [link no longer provides useful info -jgarzik]
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30*/
31
32#define DRV_NAME "via-rhine"
Roger Luethie84df482007-03-06 19:57:37 +010033#define DRV_VERSION "1.4.3"
34#define DRV_RELDATE "2007-03-06"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36
37/* A few user-configurable values.
38 These may be modified when a driver module is loaded. */
39
40static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
41static 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. */
Dustin Marquessb47157f2007-08-10 14:05:15 -070045#if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
46 || defined(CONFIG_SPARC) || defined(__ia64__) \
47 || defined(__sh__) || defined(__mips__)
48static int rx_copybreak = 1518;
49#else
Linus Torvalds1da177e2005-04-16 15:20:36 -070050static int rx_copybreak;
Dustin Marquessb47157f2007-08-10 14:05:15 -070051#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Roger Luethib933b4d2006-08-14 23:00:21 -070053/* 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 */
55static int avoid_D3;
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057/*
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. */
64static 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. */
Roger Luethi633949a2006-08-14 23:00:17 -070076#define RX_RING_SIZE 64
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
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>
Domen Puncer1e7f0bd2005-06-26 18:22:14 -040095#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#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>
Roger Luethie84df482007-03-06 19:57:37 +0100109#include <linux/dmi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/* These identify the driver base version and may not be removed. */
Stephen Hemmingerc8de1fc2009-02-26 10:19:31 +0000112static const char version[] __devinitconst =
113 KERN_INFO DRV_NAME ".c:v1.10-LK" DRV_VERSION " " DRV_RELDATE
114 " Written by Donald Becker\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
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
123MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
124MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");
125MODULE_LICENSE("GPL");
126
127module_param(max_interrupt_work, int, 0);
128module_param(debug, int, 0);
129module_param(rx_copybreak, int, 0);
Roger Luethib933b4d2006-08-14 23:00:21 -0700130module_param(avoid_D3, bool, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");
132MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");
133MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames");
Roger Luethib933b4d2006-08-14 23:00:21 -0700134MODULE_PARM_DESC(avoid_D3, "Avoid power state D3 (work-around for broken BIOSes)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136/*
137 Theory of Operation
138
139I. Board Compatibility
140
141This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet
142controller.
143
144II. Board-specific settings
145
146Boards with this chip are functional only in a bus-master PCI slot.
147
148Many operational settings are loaded from the EEPROM to the Config word at
149offset 0x78. For most of these settings, this driver assumes that they are
150correct.
151If this driver is compiled to use PCI memory space operations the EEPROM
152must be configured to enable memory ops.
153
154III. Driver operation
155
156IIIa. Ring buffers
157
158This driver uses two statically allocated fixed-size descriptor lists
159formed into rings by a branch from the final descriptor to the beginning of
160the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.
161
162IIIb/c. Transmit/Receive Structure
163
164This driver attempts to use a zero-copy receive and transmit scheme.
165
166Alas, all data buffers are required to start on a 32 bit boundary, so
167the driver must often copy transmit packets into bounce buffers.
168
169The driver allocates full frame size skbuffs for the Rx ring buffers at
170open() time and passes the skb->data field to the chip as receive data
171buffers. When an incoming frame is less than RX_COPYBREAK bytes long,
172a fresh skbuff is allocated and the frame is copied to the new skbuff.
173When the incoming frame is larger, the skbuff is passed directly up the
174protocol stack. Buffers consumed this way are replaced by newly allocated
175skbuffs in the last phase of rhine_rx().
176
177The RX_COPYBREAK value is chosen to trade-off the memory wasted by
178using a full-sized skbuff for small frames vs. the copying costs of larger
179frames. New boards are typically used in generously configured machines
180and the underfilled buffers have negligible impact compared to the benefit of
181a single allocation size, so the default value of zero results in never
182copying packets. When copying is done, the cost is usually mitigated by using
183a combined copy/checksum routine. Copying also preloads the cache, which is
184most useful with small frames.
185
186Since the VIA chips are only able to transfer data to buffers on 32 bit
187boundaries, the IP header at offset 14 in an ethernet frame isn't
188longword aligned for further processing. Copying these unaligned buffers
189has the beneficial effect of 16-byte aligning the IP header.
190
191IIId. Synchronization
192
193The driver runs as two independent, single-threaded flows of control. One
194is the send-packet routine, which enforces single-threaded use by the
Wang Chenb74ca3a2008-12-08 01:14:16 -0800195netdev_priv(dev)->lock spinlock. The other thread is the interrupt handler,
196which is single threaded by the hardware and interrupt handling software.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198The send packet thread has partial control over the Tx ring. It locks the
Wang Chenb74ca3a2008-12-08 01:14:16 -0800199netdev_priv(dev)->lock whenever it's queuing a Tx packet. If the next slot in
200the ring is not available it stops the transmit queue by
201calling netif_stop_queue.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203The interrupt handler has exclusive control over the Rx ring and records stats
204from the Tx ring. After reaping the stats, it marks the Tx queue entry as
205empty by incrementing the dirty_tx mark. If at least half of the entries in
206the Rx ring are available the transmit queue is woken up if it was stopped.
207
208IV. Notes
209
210IVb. References
211
212Preliminary VT86C100A manual from http://www.via.com.tw/
213http://www.scyld.com/expert/100mbps.html
214http://www.scyld.com/expert/NWay.html
215ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf
216ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF
217
218
219IVc. Errata
220
221The VT86C100A manual is not reliable information.
222The 3043 chip does not handle unaligned transmit or receive buffers, resulting
223in significant performance degradation for bounce buffer copies on transmit
224and unaligned IP headers on receive.
225The 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
236enum 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
253enum 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
Jeff Garzik46009c82006-06-27 09:12:38 -0400269static const struct pci_device_id 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 { } /* terminate list */
275};
276MODULE_DEVICE_TABLE(pci, rhine_pci_tbl);
277
278
279/* Offsets to the device registers. */
280enum 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 */
297enum 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. */
304static 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. */
311enum 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 */
325enum 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. */
334struct rx_desc {
Al Viro53c03f52007-08-23 02:33:30 -0400335 __le32 rx_status;
336 __le32 desc_length; /* Chain flag, Buffer/frame length */
337 __le32 addr;
338 __le32 next_desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339};
340struct tx_desc {
Al Viro53c03f52007-08-23 02:33:30 -0400341 __le32 tx_status;
342 __le32 desc_length; /* Chain flag, Tx Config, Frame length */
343 __le32 addr;
344 __le32 next_desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345};
346
347/* Initial value for tx_desc.desc_length, Buffer size goes to bits 0-10 */
348#define TXDESC 0x00e08000
349
350enum rx_status_bits {
351 RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F
352};
353
354/* Bits in *_desc.*_status */
355enum desc_status_bits {
356 DescOwn=0x80000000
357};
358
359/* Bits in ChipCmd. */
360enum 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
367struct 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
Roger Luethi4be5de22006-04-04 20:49:16 +0200382 /* Tx bounce buffers (Rhine-I only) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 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;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700389 struct net_device *dev;
390 struct napi_struct napi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 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
407static int mdio_read(struct net_device *dev, int phy_id, int location);
408static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
409static int rhine_open(struct net_device *dev);
410static void rhine_tx_timeout(struct net_device *dev);
411static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100412static irqreturn_t rhine_interrupt(int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413static void rhine_tx(struct net_device *dev);
Roger Luethi633949a2006-08-14 23:00:17 -0700414static int rhine_rx(struct net_device *dev, int limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415static void rhine_error(struct net_device *dev, int intr_status);
416static void rhine_set_rx_mode(struct net_device *dev);
417static struct net_device_stats *rhine_get_stats(struct net_device *dev);
418static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
Jeff Garzik7282d492006-09-13 14:30:00 -0400419static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420static int rhine_close(struct net_device *dev);
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -0700421static void rhine_shutdown (struct pci_dev *pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
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
432static 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 */
449static 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
505static 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
532static 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 */
550static 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
574static void rhine_poll(struct net_device *dev)
575{
576 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +0100577 rhine_interrupt(dev->irq, (void *)dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 enable_irq(dev->irq);
579}
580#endif
581
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700582static int rhine_napipoll(struct napi_struct *napi, int budget)
Roger Luethi633949a2006-08-14 23:00:17 -0700583{
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700584 struct rhine_private *rp = container_of(napi, struct rhine_private, napi);
585 struct net_device *dev = rp->dev;
Roger Luethi633949a2006-08-14 23:00:17 -0700586 void __iomem *ioaddr = rp->base;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700587 int work_done;
Roger Luethi633949a2006-08-14 23:00:17 -0700588
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700589 work_done = rhine_rx(dev, budget);
Roger Luethi633949a2006-08-14 23:00:17 -0700590
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700591 if (work_done < budget) {
Ben Hutchings288379f2009-01-19 16:43:59 -0800592 napi_complete(napi);
Roger Luethi633949a2006-08-14 23:00:17 -0700593
594 iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
595 IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
596 IntrTxDone | IntrTxError | IntrTxUnderrun |
597 IntrPCIErr | IntrStatsMax | IntrLinkChange,
598 ioaddr + IntrEnable);
Roger Luethi633949a2006-08-14 23:00:17 -0700599 }
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700600 return work_done;
Roger Luethi633949a2006-08-14 23:00:17 -0700601}
Roger Luethi633949a2006-08-14 23:00:17 -0700602
Adrian Bunkde4e7c82008-01-30 22:02:05 +0200603static void __devinit rhine_hw_init(struct net_device *dev, long pioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
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
Stephen Hemminger5d1d07d2008-11-21 17:30:11 -0800618static 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,
Ben Hutchings635ecaa2009-07-09 17:59:01 +0000624 .ndo_change_mtu = eth_change_mtu,
Stephen Hemminger5d1d07d2008-11-21 17:30:11 -0800625 .ndo_validate_addr = eth_validate_addr,
Stephen Hemmingerfe96aaa2009-01-09 11:13:14 +0000626 .ndo_set_mac_address = eth_mac_addr,
Stephen Hemminger5d1d07d2008-11-21 17:30:11 -0800627 .ndo_do_ioctl = netdev_ioctl,
628 .ndo_tx_timeout = rhine_tx_timeout,
629#ifdef CONFIG_NET_POLL_CONTROLLER
630 .ndo_poll_controller = rhine_poll,
631#endif
632};
633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634static int __devinit rhine_init_one(struct pci_dev *pdev,
635 const struct pci_device_id *ent)
636{
637 struct net_device *dev;
638 struct rhine_private *rp;
639 int i, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 u32 quirks;
641 long pioaddr;
642 long memaddr;
643 void __iomem *ioaddr;
644 int io_size, phy_id;
645 const char *name;
646#ifdef USE_MMIO
647 int bar = 1;
648#else
649 int bar = 0;
650#endif
651
652/* when built into the kernel, we only print version if device is found */
653#ifndef MODULE
654 static int printed_version;
655 if (!printed_version++)
656 printk(version);
657#endif
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 io_size = 256;
660 phy_id = 0;
661 quirks = 0;
662 name = "Rhine";
Auke Kok44c10132007-06-08 15:46:36 -0700663 if (pdev->revision < VTunknown0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 quirks = rqRhineI;
665 io_size = 128;
666 }
Auke Kok44c10132007-06-08 15:46:36 -0700667 else if (pdev->revision >= VT6102) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 quirks = rqWOL | rqForceReset;
Auke Kok44c10132007-06-08 15:46:36 -0700669 if (pdev->revision < VT6105) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 name = "Rhine II";
671 quirks |= rqStatusWBRace; /* Rhine-II exclusive */
672 }
673 else {
674 phy_id = 1; /* Integrated PHY, phy_id fixed to 1 */
Auke Kok44c10132007-06-08 15:46:36 -0700675 if (pdev->revision >= VT6105_B0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 quirks |= rq6patterns;
Auke Kok44c10132007-06-08 15:46:36 -0700677 if (pdev->revision < VT6105M)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 name = "Rhine III";
679 else
680 name = "Rhine III (Management Adapter)";
681 }
682 }
683
684 rc = pci_enable_device(pdev);
685 if (rc)
686 goto err_out;
687
688 /* this should always be supported */
Yang Hongyang284901a2009-04-06 19:01:15 -0700689 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 if (rc) {
691 printk(KERN_ERR "32-bit PCI DMA addresses not supported by "
692 "the card!?\n");
693 goto err_out;
694 }
695
696 /* sanity check */
697 if ((pci_resource_len(pdev, 0) < io_size) ||
698 (pci_resource_len(pdev, 1) < io_size)) {
699 rc = -EIO;
700 printk(KERN_ERR "Insufficient PCI resources, aborting\n");
701 goto err_out;
702 }
703
704 pioaddr = pci_resource_start(pdev, 0);
705 memaddr = pci_resource_start(pdev, 1);
706
707 pci_set_master(pdev);
708
709 dev = alloc_etherdev(sizeof(struct rhine_private));
710 if (!dev) {
711 rc = -ENOMEM;
712 printk(KERN_ERR "alloc_etherdev failed\n");
713 goto err_out;
714 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 SET_NETDEV_DEV(dev, &pdev->dev);
716
717 rp = netdev_priv(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700718 rp->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 rp->quirks = quirks;
720 rp->pioaddr = pioaddr;
721 rp->pdev = pdev;
722
723 rc = pci_request_regions(pdev, DRV_NAME);
724 if (rc)
725 goto err_out_free_netdev;
726
727 ioaddr = pci_iomap(pdev, bar, io_size);
728 if (!ioaddr) {
729 rc = -EIO;
730 printk(KERN_ERR "ioremap failed for device %s, region 0x%X "
731 "@ 0x%lX\n", pci_name(pdev), io_size, memaddr);
732 goto err_out_free_res;
733 }
734
735#ifdef USE_MMIO
736 enable_mmio(pioaddr, quirks);
737
738 /* Check that selected MMIO registers match the PIO ones */
739 i = 0;
740 while (mmio_verify_registers[i]) {
741 int reg = mmio_verify_registers[i++];
742 unsigned char a = inb(pioaddr+reg);
743 unsigned char b = readb(ioaddr+reg);
744 if (a != b) {
745 rc = -EIO;
746 printk(KERN_ERR "MMIO do not match PIO [%02x] "
747 "(%02x != %02x)\n", reg, a, b);
748 goto err_out_unmap;
749 }
750 }
751#endif /* USE_MMIO */
752
753 dev->base_addr = (unsigned long)ioaddr;
754 rp->base = ioaddr;
755
756 /* Get chip registers into a sane state */
757 rhine_power_init(dev);
758 rhine_hw_init(dev, pioaddr);
759
760 for (i = 0; i < 6; i++)
761 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i);
John W. Linvilleb81e8e12005-09-12 10:48:58 -0400762 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
John W. Linvilleb81e8e12005-09-12 10:48:58 -0400764 if (!is_valid_ether_addr(dev->perm_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 rc = -EIO;
766 printk(KERN_ERR "Invalid MAC address\n");
767 goto err_out_unmap;
768 }
769
770 /* For Rhine-I/II, phy_id is loaded from EEPROM */
771 if (!phy_id)
772 phy_id = ioread8(ioaddr + 0x6C);
773
774 dev->irq = pdev->irq;
775
776 spin_lock_init(&rp->lock);
777 rp->mii_if.dev = dev;
778 rp->mii_if.mdio_read = mdio_read;
779 rp->mii_if.mdio_write = mdio_write;
780 rp->mii_if.phy_id_mask = 0x1f;
781 rp->mii_if.reg_num_mask = 0x1f;
782
783 /* The chip-specific entries in the device structure. */
Stephen Hemminger5d1d07d2008-11-21 17:30:11 -0800784 dev->netdev_ops = &rhine_netdev_ops;
785 dev->ethtool_ops = &netdev_ethtool_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 dev->watchdog_timeo = TX_TIMEOUT;
Stephen Hemminger5d1d07d2008-11-21 17:30:11 -0800787
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700788 netif_napi_add(dev, &rp->napi, rhine_napipoll, 64);
Francois Romieu32b0f532008-07-11 00:30:14 +0200789
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 if (rp->quirks & rqRhineI)
791 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
792
793 /* dev->name not defined before register_netdev()! */
794 rc = register_netdev(dev);
795 if (rc)
796 goto err_out_unmap;
797
Johannes Berge1749612008-10-27 15:59:26 -0700798 printk(KERN_INFO "%s: VIA %s at 0x%lx, %pM, IRQ %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 dev->name, name,
800#ifdef USE_MMIO
Joe Perches0795af52007-10-03 17:59:30 -0700801 memaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802#else
Joe Perches0795af52007-10-03 17:59:30 -0700803 (long)ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804#endif
Johannes Berge1749612008-10-27 15:59:26 -0700805 dev->dev_addr, pdev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807 pci_set_drvdata(pdev, dev);
808
809 {
810 u16 mii_cmd;
811 int mii_status = mdio_read(dev, phy_id, 1);
812 mii_cmd = mdio_read(dev, phy_id, MII_BMCR) & ~BMCR_ISOLATE;
813 mdio_write(dev, phy_id, MII_BMCR, mii_cmd);
814 if (mii_status != 0xffff && mii_status != 0x0000) {
815 rp->mii_if.advertising = mdio_read(dev, phy_id, 4);
816 printk(KERN_INFO "%s: MII PHY found at address "
817 "%d, status 0x%4.4x advertising %4.4x "
818 "Link %4.4x.\n", dev->name, phy_id,
819 mii_status, rp->mii_if.advertising,
820 mdio_read(dev, phy_id, 5));
821
822 /* set IFF_RUNNING */
823 if (mii_status & BMSR_LSTATUS)
824 netif_carrier_on(dev);
825 else
826 netif_carrier_off(dev);
827
828 }
829 }
830 rp->mii_if.phy_id = phy_id;
Roger Luethib933b4d2006-08-14 23:00:21 -0700831 if (debug > 1 && avoid_D3)
832 printk(KERN_INFO "%s: No D3 power state at shutdown.\n",
833 dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 return 0;
836
837err_out_unmap:
838 pci_iounmap(pdev, ioaddr);
839err_out_free_res:
840 pci_release_regions(pdev);
841err_out_free_netdev:
842 free_netdev(dev);
843err_out:
844 return rc;
845}
846
847static int alloc_ring(struct net_device* dev)
848{
849 struct rhine_private *rp = netdev_priv(dev);
850 void *ring;
851 dma_addr_t ring_dma;
852
853 ring = pci_alloc_consistent(rp->pdev,
854 RX_RING_SIZE * sizeof(struct rx_desc) +
855 TX_RING_SIZE * sizeof(struct tx_desc),
856 &ring_dma);
857 if (!ring) {
858 printk(KERN_ERR "Could not allocate DMA memory.\n");
859 return -ENOMEM;
860 }
861 if (rp->quirks & rqRhineI) {
862 rp->tx_bufs = pci_alloc_consistent(rp->pdev,
863 PKT_BUF_SZ * TX_RING_SIZE,
864 &rp->tx_bufs_dma);
865 if (rp->tx_bufs == NULL) {
866 pci_free_consistent(rp->pdev,
867 RX_RING_SIZE * sizeof(struct rx_desc) +
868 TX_RING_SIZE * sizeof(struct tx_desc),
869 ring, ring_dma);
870 return -ENOMEM;
871 }
872 }
873
874 rp->rx_ring = ring;
875 rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
876 rp->rx_ring_dma = ring_dma;
877 rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
878
879 return 0;
880}
881
882static void free_ring(struct net_device* dev)
883{
884 struct rhine_private *rp = netdev_priv(dev);
885
886 pci_free_consistent(rp->pdev,
887 RX_RING_SIZE * sizeof(struct rx_desc) +
888 TX_RING_SIZE * sizeof(struct tx_desc),
889 rp->rx_ring, rp->rx_ring_dma);
890 rp->tx_ring = NULL;
891
892 if (rp->tx_bufs)
893 pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE,
894 rp->tx_bufs, rp->tx_bufs_dma);
895
896 rp->tx_bufs = NULL;
897
898}
899
900static void alloc_rbufs(struct net_device *dev)
901{
902 struct rhine_private *rp = netdev_priv(dev);
903 dma_addr_t next;
904 int i;
905
906 rp->dirty_rx = rp->cur_rx = 0;
907
908 rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
909 rp->rx_head_desc = &rp->rx_ring[0];
910 next = rp->rx_ring_dma;
911
912 /* Init the ring entries */
913 for (i = 0; i < RX_RING_SIZE; i++) {
914 rp->rx_ring[i].rx_status = 0;
915 rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz);
916 next += sizeof(struct rx_desc);
917 rp->rx_ring[i].next_desc = cpu_to_le32(next);
918 rp->rx_skbuff[i] = NULL;
919 }
920 /* Mark the last entry as wrapping the ring. */
921 rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma);
922
923 /* Fill in the Rx buffers. Handle allocation failure gracefully. */
924 for (i = 0; i < RX_RING_SIZE; i++) {
Kevin Lob26b5552008-08-27 11:35:09 +0800925 struct sk_buff *skb = netdev_alloc_skb(dev, rp->rx_buf_sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 rp->rx_skbuff[i] = skb;
927 if (skb == NULL)
928 break;
929 skb->dev = dev; /* Mark as being used by this device. */
930
931 rp->rx_skbuff_dma[i] =
David S. Miller689be432005-06-28 15:25:31 -0700932 pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 PCI_DMA_FROMDEVICE);
934
935 rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);
936 rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
937 }
938 rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
939}
940
941static void free_rbufs(struct net_device* dev)
942{
943 struct rhine_private *rp = netdev_priv(dev);
944 int i;
945
946 /* Free all the skbuffs in the Rx queue. */
947 for (i = 0; i < RX_RING_SIZE; i++) {
948 rp->rx_ring[i].rx_status = 0;
949 rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
950 if (rp->rx_skbuff[i]) {
951 pci_unmap_single(rp->pdev,
952 rp->rx_skbuff_dma[i],
953 rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
954 dev_kfree_skb(rp->rx_skbuff[i]);
955 }
956 rp->rx_skbuff[i] = NULL;
957 }
958}
959
960static void alloc_tbufs(struct net_device* dev)
961{
962 struct rhine_private *rp = netdev_priv(dev);
963 dma_addr_t next;
964 int i;
965
966 rp->dirty_tx = rp->cur_tx = 0;
967 next = rp->tx_ring_dma;
968 for (i = 0; i < TX_RING_SIZE; i++) {
969 rp->tx_skbuff[i] = NULL;
970 rp->tx_ring[i].tx_status = 0;
971 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
972 next += sizeof(struct tx_desc);
973 rp->tx_ring[i].next_desc = cpu_to_le32(next);
Roger Luethi4be5de22006-04-04 20:49:16 +0200974 if (rp->quirks & rqRhineI)
975 rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977 rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma);
978
979}
980
981static void free_tbufs(struct net_device* dev)
982{
983 struct rhine_private *rp = netdev_priv(dev);
984 int i;
985
986 for (i = 0; i < TX_RING_SIZE; i++) {
987 rp->tx_ring[i].tx_status = 0;
988 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
989 rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
990 if (rp->tx_skbuff[i]) {
991 if (rp->tx_skbuff_dma[i]) {
992 pci_unmap_single(rp->pdev,
993 rp->tx_skbuff_dma[i],
994 rp->tx_skbuff[i]->len,
995 PCI_DMA_TODEVICE);
996 }
997 dev_kfree_skb(rp->tx_skbuff[i]);
998 }
999 rp->tx_skbuff[i] = NULL;
1000 rp->tx_buf[i] = NULL;
1001 }
1002}
1003
1004static void rhine_check_media(struct net_device *dev, unsigned int init_media)
1005{
1006 struct rhine_private *rp = netdev_priv(dev);
1007 void __iomem *ioaddr = rp->base;
1008
1009 mii_check_media(&rp->mii_if, debug, init_media);
1010
1011 if (rp->mii_if.full_duplex)
1012 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,
1013 ioaddr + ChipCmd1);
1014 else
1015 iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex,
1016 ioaddr + ChipCmd1);
Roger Luethi00b428c2006-03-28 20:53:56 +02001017 if (debug > 1)
1018 printk(KERN_INFO "%s: force_media %d, carrier %d\n", dev->name,
1019 rp->mii_if.force_media, netif_carrier_ok(dev));
1020}
1021
1022/* Called after status of force_media possibly changed */
Adrian Bunk0761be42006-04-10 23:22:21 -07001023static void rhine_set_carrier(struct mii_if_info *mii)
Roger Luethi00b428c2006-03-28 20:53:56 +02001024{
1025 if (mii->force_media) {
1026 /* autoneg is off: Link is always assumed to be up */
1027 if (!netif_carrier_ok(mii->dev))
1028 netif_carrier_on(mii->dev);
1029 }
1030 else /* Let MMI library update carrier status */
1031 rhine_check_media(mii->dev, 0);
1032 if (debug > 1)
1033 printk(KERN_INFO "%s: force_media %d, carrier %d\n",
1034 mii->dev->name, mii->force_media,
1035 netif_carrier_ok(mii->dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036}
1037
1038static void init_registers(struct net_device *dev)
1039{
1040 struct rhine_private *rp = netdev_priv(dev);
1041 void __iomem *ioaddr = rp->base;
1042 int i;
1043
1044 for (i = 0; i < 6; i++)
1045 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i);
1046
1047 /* Initialize other registers. */
1048 iowrite16(0x0006, ioaddr + PCIBusConfig); /* Tune configuration??? */
1049 /* Configure initial FIFO thresholds. */
1050 iowrite8(0x20, ioaddr + TxConfig);
1051 rp->tx_thresh = 0x20;
1052 rp->rx_thresh = 0x60; /* Written in rhine_set_rx_mode(). */
1053
1054 iowrite32(rp->rx_ring_dma, ioaddr + RxRingPtr);
1055 iowrite32(rp->tx_ring_dma, ioaddr + TxRingPtr);
1056
1057 rhine_set_rx_mode(dev);
1058
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001059 napi_enable(&rp->napi);
Stephen Hemmingerab197662006-08-14 23:00:18 -07001060
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 /* Enable interrupts by setting the interrupt mask. */
1062 iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
1063 IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
1064 IntrTxDone | IntrTxError | IntrTxUnderrun |
1065 IntrPCIErr | IntrStatsMax | IntrLinkChange,
1066 ioaddr + IntrEnable);
1067
1068 iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8),
1069 ioaddr + ChipCmd);
1070 rhine_check_media(dev, 1);
1071}
1072
1073/* Enable MII link status auto-polling (required for IntrLinkChange) */
1074static void rhine_enable_linkmon(void __iomem *ioaddr)
1075{
1076 iowrite8(0, ioaddr + MIICmd);
1077 iowrite8(MII_BMSR, ioaddr + MIIRegAddr);
1078 iowrite8(0x80, ioaddr + MIICmd);
1079
1080 RHINE_WAIT_FOR((ioread8(ioaddr + MIIRegAddr) & 0x20));
1081
1082 iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr);
1083}
1084
1085/* Disable MII link status auto-polling (required for MDIO access) */
1086static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
1087{
1088 iowrite8(0, ioaddr + MIICmd);
1089
1090 if (quirks & rqRhineI) {
1091 iowrite8(0x01, ioaddr + MIIRegAddr); // MII_BMSR
1092
John W. Linville38bb6b22006-05-19 10:51:21 -04001093 /* Can be called from ISR. Evil. */
1094 mdelay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
1096 /* 0x80 must be set immediately before turning it off */
1097 iowrite8(0x80, ioaddr + MIICmd);
1098
1099 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x20);
1100
1101 /* Heh. Now clear 0x80 again. */
1102 iowrite8(0, ioaddr + MIICmd);
1103 }
1104 else
1105 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x80);
1106}
1107
1108/* Read and write over the MII Management Data I/O (MDIO) interface. */
1109
1110static int mdio_read(struct net_device *dev, int phy_id, int regnum)
1111{
1112 struct rhine_private *rp = netdev_priv(dev);
1113 void __iomem *ioaddr = rp->base;
1114 int result;
1115
1116 rhine_disable_linkmon(ioaddr, rp->quirks);
1117
1118 /* rhine_disable_linkmon already cleared MIICmd */
1119 iowrite8(phy_id, ioaddr + MIIPhyAddr);
1120 iowrite8(regnum, ioaddr + MIIRegAddr);
1121 iowrite8(0x40, ioaddr + MIICmd); /* Trigger read */
1122 RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x40));
1123 result = ioread16(ioaddr + MIIData);
1124
1125 rhine_enable_linkmon(ioaddr);
1126 return result;
1127}
1128
1129static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value)
1130{
1131 struct rhine_private *rp = netdev_priv(dev);
1132 void __iomem *ioaddr = rp->base;
1133
1134 rhine_disable_linkmon(ioaddr, rp->quirks);
1135
1136 /* rhine_disable_linkmon already cleared MIICmd */
1137 iowrite8(phy_id, ioaddr + MIIPhyAddr);
1138 iowrite8(regnum, ioaddr + MIIRegAddr);
1139 iowrite16(value, ioaddr + MIIData);
1140 iowrite8(0x20, ioaddr + MIICmd); /* Trigger write */
1141 RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x20));
1142
1143 rhine_enable_linkmon(ioaddr);
1144}
1145
1146static int rhine_open(struct net_device *dev)
1147{
1148 struct rhine_private *rp = netdev_priv(dev);
1149 void __iomem *ioaddr = rp->base;
1150 int rc;
1151
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001152 rc = request_irq(rp->pdev->irq, &rhine_interrupt, IRQF_SHARED, dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 dev);
1154 if (rc)
1155 return rc;
1156
1157 if (debug > 1)
1158 printk(KERN_DEBUG "%s: rhine_open() irq %d.\n",
1159 dev->name, rp->pdev->irq);
1160
1161 rc = alloc_ring(dev);
1162 if (rc) {
1163 free_irq(rp->pdev->irq, dev);
1164 return rc;
1165 }
1166 alloc_rbufs(dev);
1167 alloc_tbufs(dev);
1168 rhine_chip_reset(dev);
1169 init_registers(dev);
1170 if (debug > 2)
1171 printk(KERN_DEBUG "%s: Done rhine_open(), status %4.4x "
1172 "MII status: %4.4x.\n",
1173 dev->name, ioread16(ioaddr + ChipCmd),
1174 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1175
1176 netif_start_queue(dev);
1177
1178 return 0;
1179}
1180
1181static void rhine_tx_timeout(struct net_device *dev)
1182{
1183 struct rhine_private *rp = netdev_priv(dev);
1184 void __iomem *ioaddr = rp->base;
1185
1186 printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
1187 "%4.4x, resetting...\n",
1188 dev->name, ioread16(ioaddr + IntrStatus),
1189 mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1190
1191 /* protect against concurrent rx interrupts */
1192 disable_irq(rp->pdev->irq);
1193
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001194 napi_disable(&rp->napi);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001195
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 spin_lock(&rp->lock);
1197
1198 /* clear all descriptors */
1199 free_tbufs(dev);
1200 free_rbufs(dev);
1201 alloc_tbufs(dev);
1202 alloc_rbufs(dev);
1203
1204 /* Reinitialize the hardware. */
1205 rhine_chip_reset(dev);
1206 init_registers(dev);
1207
1208 spin_unlock(&rp->lock);
1209 enable_irq(rp->pdev->irq);
1210
1211 dev->trans_start = jiffies;
Eric Dumazet553e2332009-05-27 10:34:50 +00001212 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 netif_wake_queue(dev);
1214}
1215
1216static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
1217{
1218 struct rhine_private *rp = netdev_priv(dev);
1219 void __iomem *ioaddr = rp->base;
1220 unsigned entry;
1221
1222 /* Caution: the write order is important here, set the field
1223 with the "ownership" bits last. */
1224
1225 /* Calculate the next Tx descriptor entry. */
1226 entry = rp->cur_tx % TX_RING_SIZE;
1227
Herbert Xu5b057c62006-06-23 02:06:41 -07001228 if (skb_padto(skb, ETH_ZLEN))
1229 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231 rp->tx_skbuff[entry] = skb;
1232
1233 if ((rp->quirks & rqRhineI) &&
Patrick McHardy84fa7932006-08-29 16:44:56 -07001234 (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_PARTIAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 /* Must use alignment buffer. */
1236 if (skb->len > PKT_BUF_SZ) {
1237 /* packet too long, drop it */
1238 dev_kfree_skb(skb);
1239 rp->tx_skbuff[entry] = NULL;
Eric Dumazet553e2332009-05-27 10:34:50 +00001240 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 return 0;
1242 }
Craig Brind3e0d1672006-04-27 02:30:46 -07001243
1244 /* Padding is not copied and so must be redone. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
Craig Brind3e0d1672006-04-27 02:30:46 -07001246 if (skb->len < ETH_ZLEN)
1247 memset(rp->tx_buf[entry] + skb->len, 0,
1248 ETH_ZLEN - skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 rp->tx_skbuff_dma[entry] = 0;
1250 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
1251 (rp->tx_buf[entry] -
1252 rp->tx_bufs));
1253 } else {
1254 rp->tx_skbuff_dma[entry] =
1255 pci_map_single(rp->pdev, skb->data, skb->len,
1256 PCI_DMA_TODEVICE);
1257 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]);
1258 }
1259
1260 rp->tx_ring[entry].desc_length =
1261 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1262
1263 /* lock eth irq */
1264 spin_lock_irq(&rp->lock);
1265 wmb();
1266 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1267 wmb();
1268
1269 rp->cur_tx++;
1270
1271 /* Non-x86 Todo: explicitly flush cache lines here. */
1272
1273 /* Wake the potentially-idle transmit channel */
1274 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1275 ioaddr + ChipCmd1);
1276 IOSYNC;
1277
1278 if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
1279 netif_stop_queue(dev);
1280
1281 dev->trans_start = jiffies;
1282
1283 spin_unlock_irq(&rp->lock);
1284
1285 if (debug > 4) {
1286 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1287 dev->name, rp->cur_tx-1, entry);
1288 }
1289 return 0;
1290}
1291
1292/* The interrupt handler does all of the Rx thread work and cleans up
1293 after the Tx thread. */
David Howells7d12e782006-10-05 14:55:46 +01001294static irqreturn_t rhine_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295{
1296 struct net_device *dev = dev_instance;
1297 struct rhine_private *rp = netdev_priv(dev);
1298 void __iomem *ioaddr = rp->base;
1299 u32 intr_status;
1300 int boguscnt = max_interrupt_work;
1301 int handled = 0;
1302
1303 while ((intr_status = get_intr_status(dev))) {
1304 handled = 1;
1305
1306 /* Acknowledge all of the current interrupt sources ASAP. */
1307 if (intr_status & IntrTxDescRace)
1308 iowrite8(0x08, ioaddr + IntrStatus2);
1309 iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
1310 IOSYNC;
1311
1312 if (debug > 4)
1313 printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n",
1314 dev->name, intr_status);
1315
1316 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
Roger Luethi633949a2006-08-14 23:00:17 -07001317 IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) {
Roger Luethi633949a2006-08-14 23:00:17 -07001318 iowrite16(IntrTxAborted |
1319 IntrTxDone | IntrTxError | IntrTxUnderrun |
1320 IntrPCIErr | IntrStatsMax | IntrLinkChange,
1321 ioaddr + IntrEnable);
1322
Ben Hutchings288379f2009-01-19 16:43:59 -08001323 napi_schedule(&rp->napi);
Roger Luethi633949a2006-08-14 23:00:17 -07001324 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
1326 if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
1327 if (intr_status & IntrTxErrSummary) {
1328 /* Avoid scavenging before Tx engine turned off */
1329 RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
1330 if (debug > 2 &&
1331 ioread8(ioaddr+ChipCmd) & CmdTxOn)
1332 printk(KERN_WARNING "%s: "
Joe Perches24500222007-11-19 17:48:28 -08001333 "rhine_interrupt() Tx engine "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 "still on.\n", dev->name);
1335 }
1336 rhine_tx(dev);
1337 }
1338
1339 /* Abnormal error summary/uncommon events handlers. */
1340 if (intr_status & (IntrPCIErr | IntrLinkChange |
1341 IntrStatsMax | IntrTxError | IntrTxAborted |
1342 IntrTxUnderrun | IntrTxDescRace))
1343 rhine_error(dev, intr_status);
1344
1345 if (--boguscnt < 0) {
1346 printk(KERN_WARNING "%s: Too much work at interrupt, "
1347 "status=%#8.8x.\n",
1348 dev->name, intr_status);
1349 break;
1350 }
1351 }
1352
1353 if (debug > 3)
1354 printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n",
1355 dev->name, ioread16(ioaddr + IntrStatus));
1356 return IRQ_RETVAL(handled);
1357}
1358
1359/* This routine is logically part of the interrupt handler, but isolated
1360 for clarity. */
1361static void rhine_tx(struct net_device *dev)
1362{
1363 struct rhine_private *rp = netdev_priv(dev);
1364 int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
1365
1366 spin_lock(&rp->lock);
1367
1368 /* find and cleanup dirty tx descriptors */
1369 while (rp->dirty_tx != rp->cur_tx) {
1370 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
1371 if (debug > 6)
Denis Vlasenkoed4030d2005-06-17 08:23:17 +03001372 printk(KERN_DEBUG "Tx scavenge %d status %8.8x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 entry, txstatus);
1374 if (txstatus & DescOwn)
1375 break;
1376 if (txstatus & 0x8000) {
1377 if (debug > 1)
1378 printk(KERN_DEBUG "%s: Transmit error, "
1379 "Tx status %8.8x.\n",
1380 dev->name, txstatus);
Eric Dumazet553e2332009-05-27 10:34:50 +00001381 dev->stats.tx_errors++;
1382 if (txstatus & 0x0400)
1383 dev->stats.tx_carrier_errors++;
1384 if (txstatus & 0x0200)
1385 dev->stats.tx_window_errors++;
1386 if (txstatus & 0x0100)
1387 dev->stats.tx_aborted_errors++;
1388 if (txstatus & 0x0080)
1389 dev->stats.tx_heartbeat_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 if (((rp->quirks & rqRhineI) && txstatus & 0x0002) ||
1391 (txstatus & 0x0800) || (txstatus & 0x1000)) {
Eric Dumazet553e2332009-05-27 10:34:50 +00001392 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1394 break; /* Keep the skb - we try again */
1395 }
1396 /* Transmitter restarted in 'abnormal' handler. */
1397 } else {
1398 if (rp->quirks & rqRhineI)
Eric Dumazet553e2332009-05-27 10:34:50 +00001399 dev->stats.collisions += (txstatus >> 3) & 0x0F;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 else
Eric Dumazet553e2332009-05-27 10:34:50 +00001401 dev->stats.collisions += txstatus & 0x0F;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if (debug > 6)
1403 printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
1404 (txstatus >> 3) & 0xF,
1405 txstatus & 0xF);
Eric Dumazet553e2332009-05-27 10:34:50 +00001406 dev->stats.tx_bytes += rp->tx_skbuff[entry]->len;
1407 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 }
1409 /* Free the original skb. */
1410 if (rp->tx_skbuff_dma[entry]) {
1411 pci_unmap_single(rp->pdev,
1412 rp->tx_skbuff_dma[entry],
1413 rp->tx_skbuff[entry]->len,
1414 PCI_DMA_TODEVICE);
1415 }
1416 dev_kfree_skb_irq(rp->tx_skbuff[entry]);
1417 rp->tx_skbuff[entry] = NULL;
1418 entry = (++rp->dirty_tx) % TX_RING_SIZE;
1419 }
1420 if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
1421 netif_wake_queue(dev);
1422
1423 spin_unlock(&rp->lock);
1424}
1425
Roger Luethi633949a2006-08-14 23:00:17 -07001426/* Process up to limit frames from receive ring */
1427static int rhine_rx(struct net_device *dev, int limit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428{
1429 struct rhine_private *rp = netdev_priv(dev);
Roger Luethi633949a2006-08-14 23:00:17 -07001430 int count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 int entry = rp->cur_rx % RX_RING_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
1433 if (debug > 4) {
1434 printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
1435 dev->name, entry,
1436 le32_to_cpu(rp->rx_head_desc->rx_status));
1437 }
1438
1439 /* If EOP is set on the next entry, it's a new packet. Send it up. */
Roger Luethi633949a2006-08-14 23:00:17 -07001440 for (count = 0; count < limit; ++count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 struct rx_desc *desc = rp->rx_head_desc;
1442 u32 desc_status = le32_to_cpu(desc->rx_status);
1443 int data_size = desc_status >> 16;
1444
Roger Luethi633949a2006-08-14 23:00:17 -07001445 if (desc_status & DescOwn)
1446 break;
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (debug > 4)
Denis Vlasenkoed4030d2005-06-17 08:23:17 +03001449 printk(KERN_DEBUG "rhine_rx() status is %8.8x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 desc_status);
Roger Luethi633949a2006-08-14 23:00:17 -07001451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
1453 if ((desc_status & RxWholePkt) != RxWholePkt) {
1454 printk(KERN_WARNING "%s: Oversized Ethernet "
1455 "frame spanned multiple buffers, entry "
1456 "%#x length %d status %8.8x!\n",
1457 dev->name, entry, data_size,
1458 desc_status);
1459 printk(KERN_WARNING "%s: Oversized Ethernet "
1460 "frame %p vs %p.\n", dev->name,
1461 rp->rx_head_desc, &rp->rx_ring[entry]);
Eric Dumazet553e2332009-05-27 10:34:50 +00001462 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 } else if (desc_status & RxErr) {
1464 /* There was a error. */
1465 if (debug > 2)
Denis Vlasenkoed4030d2005-06-17 08:23:17 +03001466 printk(KERN_DEBUG "rhine_rx() Rx "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 "error was %8.8x.\n",
1468 desc_status);
Eric Dumazet553e2332009-05-27 10:34:50 +00001469 dev->stats.rx_errors++;
1470 if (desc_status & 0x0030)
1471 dev->stats.rx_length_errors++;
1472 if (desc_status & 0x0048)
1473 dev->stats.rx_fifo_errors++;
1474 if (desc_status & 0x0004)
1475 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 if (desc_status & 0x0002) {
1477 /* this can also be updated outside the interrupt handler */
1478 spin_lock(&rp->lock);
Eric Dumazet553e2332009-05-27 10:34:50 +00001479 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 spin_unlock(&rp->lock);
1481 }
1482 }
1483 } else {
1484 struct sk_buff *skb;
1485 /* Length should omit the CRC */
1486 int pkt_len = data_size - 4;
1487
1488 /* Check if the packet is long enough to accept without
1489 copying to a minimally-sized skbuff. */
1490 if (pkt_len < rx_copybreak &&
Kevin Lob26b5552008-08-27 11:35:09 +08001491 (skb = netdev_alloc_skb(dev, pkt_len + NET_IP_ALIGN)) != NULL) {
1492 skb_reserve(skb, NET_IP_ALIGN); /* 16 byte align the IP header */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 pci_dma_sync_single_for_cpu(rp->pdev,
1494 rp->rx_skbuff_dma[entry],
1495 rp->rx_buf_sz,
1496 PCI_DMA_FROMDEVICE);
1497
David S. Miller8c7b7fa2007-07-10 22:08:12 -07001498 skb_copy_to_linear_data(skb,
David S. Miller689be432005-06-28 15:25:31 -07001499 rp->rx_skbuff[entry]->data,
David S. Miller8c7b7fa2007-07-10 22:08:12 -07001500 pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 skb_put(skb, pkt_len);
1502 pci_dma_sync_single_for_device(rp->pdev,
1503 rp->rx_skbuff_dma[entry],
1504 rp->rx_buf_sz,
1505 PCI_DMA_FROMDEVICE);
1506 } else {
1507 skb = rp->rx_skbuff[entry];
1508 if (skb == NULL) {
1509 printk(KERN_ERR "%s: Inconsistent Rx "
1510 "descriptor chain.\n",
1511 dev->name);
1512 break;
1513 }
1514 rp->rx_skbuff[entry] = NULL;
1515 skb_put(skb, pkt_len);
1516 pci_unmap_single(rp->pdev,
1517 rp->rx_skbuff_dma[entry],
1518 rp->rx_buf_sz,
1519 PCI_DMA_FROMDEVICE);
1520 }
1521 skb->protocol = eth_type_trans(skb, dev);
Roger Luethi633949a2006-08-14 23:00:17 -07001522 netif_receive_skb(skb);
Eric Dumazet553e2332009-05-27 10:34:50 +00001523 dev->stats.rx_bytes += pkt_len;
1524 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 }
1526 entry = (++rp->cur_rx) % RX_RING_SIZE;
1527 rp->rx_head_desc = &rp->rx_ring[entry];
1528 }
1529
1530 /* Refill the Rx ring buffers. */
1531 for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {
1532 struct sk_buff *skb;
1533 entry = rp->dirty_rx % RX_RING_SIZE;
1534 if (rp->rx_skbuff[entry] == NULL) {
Kevin Lob26b5552008-08-27 11:35:09 +08001535 skb = netdev_alloc_skb(dev, rp->rx_buf_sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 rp->rx_skbuff[entry] = skb;
1537 if (skb == NULL)
1538 break; /* Better luck next round. */
1539 skb->dev = dev; /* Mark as being used by this device. */
1540 rp->rx_skbuff_dma[entry] =
David S. Miller689be432005-06-28 15:25:31 -07001541 pci_map_single(rp->pdev, skb->data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 rp->rx_buf_sz,
1543 PCI_DMA_FROMDEVICE);
1544 rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
1545 }
1546 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
1547 }
Roger Luethi633949a2006-08-14 23:00:17 -07001548
1549 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550}
1551
1552/*
1553 * Clears the "tally counters" for CRC errors and missed frames(?).
1554 * It has been reported that some chips need a write of 0 to clear
1555 * these, for others the counters are set to 1 when written to and
1556 * instead cleared when read. So we clear them both ways ...
1557 */
1558static inline void clear_tally_counters(void __iomem *ioaddr)
1559{
1560 iowrite32(0, ioaddr + RxMissed);
1561 ioread16(ioaddr + RxCRCErrs);
1562 ioread16(ioaddr + RxMissed);
1563}
1564
1565static void rhine_restart_tx(struct net_device *dev) {
1566 struct rhine_private *rp = netdev_priv(dev);
1567 void __iomem *ioaddr = rp->base;
1568 int entry = rp->dirty_tx % TX_RING_SIZE;
1569 u32 intr_status;
1570
1571 /*
1572 * If new errors occured, we need to sort them out before doing Tx.
1573 * In that case the ISR will be back here RSN anyway.
1574 */
1575 intr_status = get_intr_status(dev);
1576
1577 if ((intr_status & IntrTxErrSummary) == 0) {
1578
1579 /* We know better than the chip where it should continue. */
1580 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc),
1581 ioaddr + TxRingPtr);
1582
1583 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn,
1584 ioaddr + ChipCmd);
1585 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1586 ioaddr + ChipCmd1);
1587 IOSYNC;
1588 }
1589 else {
1590 /* This should never happen */
1591 if (debug > 1)
1592 printk(KERN_WARNING "%s: rhine_restart_tx() "
1593 "Another error occured %8.8x.\n",
1594 dev->name, intr_status);
1595 }
1596
1597}
1598
1599static void rhine_error(struct net_device *dev, int intr_status)
1600{
1601 struct rhine_private *rp = netdev_priv(dev);
1602 void __iomem *ioaddr = rp->base;
1603
1604 spin_lock(&rp->lock);
1605
1606 if (intr_status & IntrLinkChange)
John W. Linville38bb6b22006-05-19 10:51:21 -04001607 rhine_check_media(dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 if (intr_status & IntrStatsMax) {
Eric Dumazet553e2332009-05-27 10:34:50 +00001609 dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1610 dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 clear_tally_counters(ioaddr);
1612 }
1613 if (intr_status & IntrTxAborted) {
1614 if (debug > 1)
1615 printk(KERN_INFO "%s: Abort %8.8x, frame dropped.\n",
1616 dev->name, intr_status);
1617 }
1618 if (intr_status & IntrTxUnderrun) {
1619 if (rp->tx_thresh < 0xE0)
1620 iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1621 if (debug > 1)
1622 printk(KERN_INFO "%s: Transmitter underrun, Tx "
1623 "threshold now %2.2x.\n",
1624 dev->name, rp->tx_thresh);
1625 }
1626 if (intr_status & IntrTxDescRace) {
1627 if (debug > 2)
1628 printk(KERN_INFO "%s: Tx descriptor write-back race.\n",
1629 dev->name);
1630 }
1631 if ((intr_status & IntrTxError) &&
1632 (intr_status & (IntrTxAborted |
1633 IntrTxUnderrun | IntrTxDescRace)) == 0) {
1634 if (rp->tx_thresh < 0xE0) {
1635 iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1636 }
1637 if (debug > 1)
1638 printk(KERN_INFO "%s: Unspecified error. Tx "
1639 "threshold now %2.2x.\n",
1640 dev->name, rp->tx_thresh);
1641 }
1642 if (intr_status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
1643 IntrTxError))
1644 rhine_restart_tx(dev);
1645
1646 if (intr_status & ~(IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
1647 IntrTxError | IntrTxAborted | IntrNormalSummary |
1648 IntrTxDescRace)) {
1649 if (debug > 1)
1650 printk(KERN_ERR "%s: Something Wicked happened! "
1651 "%8.8x.\n", dev->name, intr_status);
1652 }
1653
1654 spin_unlock(&rp->lock);
1655}
1656
1657static struct net_device_stats *rhine_get_stats(struct net_device *dev)
1658{
1659 struct rhine_private *rp = netdev_priv(dev);
1660 void __iomem *ioaddr = rp->base;
1661 unsigned long flags;
1662
1663 spin_lock_irqsave(&rp->lock, flags);
Eric Dumazet553e2332009-05-27 10:34:50 +00001664 dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1665 dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 clear_tally_counters(ioaddr);
1667 spin_unlock_irqrestore(&rp->lock, flags);
1668
Eric Dumazet553e2332009-05-27 10:34:50 +00001669 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670}
1671
1672static void rhine_set_rx_mode(struct net_device *dev)
1673{
1674 struct rhine_private *rp = netdev_priv(dev);
1675 void __iomem *ioaddr = rp->base;
1676 u32 mc_filter[2]; /* Multicast hash filter */
1677 u8 rx_mode; /* Note: 0x02=accept runt, 0x01=accept errs */
1678
1679 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 rx_mode = 0x1C;
1681 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1682 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1683 } else if ((dev->mc_count > multicast_filter_limit)
1684 || (dev->flags & IFF_ALLMULTI)) {
1685 /* Too many to match, or accept all multicasts. */
1686 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1687 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1688 rx_mode = 0x0C;
1689 } else {
1690 struct dev_mc_list *mclist;
1691 int i;
1692 memset(mc_filter, 0, sizeof(mc_filter));
1693 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1694 i++, mclist = mclist->next) {
1695 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1696
1697 mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1698 }
1699 iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1700 iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1701 rx_mode = 0x0C;
1702 }
1703 iowrite8(rp->rx_thresh | rx_mode, ioaddr + RxConfig);
1704}
1705
1706static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1707{
1708 struct rhine_private *rp = netdev_priv(dev);
1709
1710 strcpy(info->driver, DRV_NAME);
1711 strcpy(info->version, DRV_VERSION);
1712 strcpy(info->bus_info, pci_name(rp->pdev));
1713}
1714
1715static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1716{
1717 struct rhine_private *rp = netdev_priv(dev);
1718 int rc;
1719
1720 spin_lock_irq(&rp->lock);
1721 rc = mii_ethtool_gset(&rp->mii_if, cmd);
1722 spin_unlock_irq(&rp->lock);
1723
1724 return rc;
1725}
1726
1727static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1728{
1729 struct rhine_private *rp = netdev_priv(dev);
1730 int rc;
1731
1732 spin_lock_irq(&rp->lock);
1733 rc = mii_ethtool_sset(&rp->mii_if, cmd);
1734 spin_unlock_irq(&rp->lock);
Roger Luethi00b428c2006-03-28 20:53:56 +02001735 rhine_set_carrier(&rp->mii_if);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736
1737 return rc;
1738}
1739
1740static int netdev_nway_reset(struct net_device *dev)
1741{
1742 struct rhine_private *rp = netdev_priv(dev);
1743
1744 return mii_nway_restart(&rp->mii_if);
1745}
1746
1747static u32 netdev_get_link(struct net_device *dev)
1748{
1749 struct rhine_private *rp = netdev_priv(dev);
1750
1751 return mii_link_ok(&rp->mii_if);
1752}
1753
1754static u32 netdev_get_msglevel(struct net_device *dev)
1755{
1756 return debug;
1757}
1758
1759static void netdev_set_msglevel(struct net_device *dev, u32 value)
1760{
1761 debug = value;
1762}
1763
1764static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1765{
1766 struct rhine_private *rp = netdev_priv(dev);
1767
1768 if (!(rp->quirks & rqWOL))
1769 return;
1770
1771 spin_lock_irq(&rp->lock);
1772 wol->supported = WAKE_PHY | WAKE_MAGIC |
1773 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */
1774 wol->wolopts = rp->wolopts;
1775 spin_unlock_irq(&rp->lock);
1776}
1777
1778static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1779{
1780 struct rhine_private *rp = netdev_priv(dev);
1781 u32 support = WAKE_PHY | WAKE_MAGIC |
1782 WAKE_UCAST | WAKE_MCAST | WAKE_BCAST; /* Untested */
1783
1784 if (!(rp->quirks & rqWOL))
1785 return -EINVAL;
1786
1787 if (wol->wolopts & ~support)
1788 return -EINVAL;
1789
1790 spin_lock_irq(&rp->lock);
1791 rp->wolopts = wol->wolopts;
1792 spin_unlock_irq(&rp->lock);
1793
1794 return 0;
1795}
1796
Jeff Garzik7282d492006-09-13 14:30:00 -04001797static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 .get_drvinfo = netdev_get_drvinfo,
1799 .get_settings = netdev_get_settings,
1800 .set_settings = netdev_set_settings,
1801 .nway_reset = netdev_nway_reset,
1802 .get_link = netdev_get_link,
1803 .get_msglevel = netdev_get_msglevel,
1804 .set_msglevel = netdev_set_msglevel,
1805 .get_wol = rhine_get_wol,
1806 .set_wol = rhine_set_wol,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807};
1808
1809static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1810{
1811 struct rhine_private *rp = netdev_priv(dev);
1812 int rc;
1813
1814 if (!netif_running(dev))
1815 return -EINVAL;
1816
1817 spin_lock_irq(&rp->lock);
1818 rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
1819 spin_unlock_irq(&rp->lock);
Roger Luethi00b428c2006-03-28 20:53:56 +02001820 rhine_set_carrier(&rp->mii_if);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821
1822 return rc;
1823}
1824
1825static int rhine_close(struct net_device *dev)
1826{
1827 struct rhine_private *rp = netdev_priv(dev);
1828 void __iomem *ioaddr = rp->base;
1829
1830 spin_lock_irq(&rp->lock);
1831
1832 netif_stop_queue(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001833 napi_disable(&rp->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
1835 if (debug > 1)
1836 printk(KERN_DEBUG "%s: Shutting down ethercard, "
1837 "status was %4.4x.\n",
1838 dev->name, ioread16(ioaddr + ChipCmd));
1839
1840 /* Switch to loopback mode to avoid hardware races. */
1841 iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
1842
1843 /* Disable interrupts by clearing the interrupt mask. */
1844 iowrite16(0x0000, ioaddr + IntrEnable);
1845
1846 /* Stop the chip's Tx and Rx processes. */
1847 iowrite16(CmdStop, ioaddr + ChipCmd);
1848
1849 spin_unlock_irq(&rp->lock);
1850
1851 free_irq(rp->pdev->irq, dev);
1852 free_rbufs(dev);
1853 free_tbufs(dev);
1854 free_ring(dev);
1855
1856 return 0;
1857}
1858
1859
1860static void __devexit rhine_remove_one(struct pci_dev *pdev)
1861{
1862 struct net_device *dev = pci_get_drvdata(pdev);
1863 struct rhine_private *rp = netdev_priv(dev);
1864
1865 unregister_netdev(dev);
1866
1867 pci_iounmap(pdev, rp->base);
1868 pci_release_regions(pdev);
1869
1870 free_netdev(dev);
1871 pci_disable_device(pdev);
1872 pci_set_drvdata(pdev, NULL);
1873}
1874
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001875static void rhine_shutdown (struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 struct net_device *dev = pci_get_drvdata(pdev);
1878 struct rhine_private *rp = netdev_priv(dev);
1879 void __iomem *ioaddr = rp->base;
1880
1881 if (!(rp->quirks & rqWOL))
1882 return; /* Nothing to do for non-WOL adapters */
1883
1884 rhine_power_init(dev);
1885
1886 /* Make sure we use pattern 0, 1 and not 4, 5 */
1887 if (rp->quirks & rq6patterns)
Laura Garciaf11cf252008-02-23 18:56:35 +01001888 iowrite8(0x04, ioaddr + WOLcgClr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
1890 if (rp->wolopts & WAKE_MAGIC) {
1891 iowrite8(WOLmagic, ioaddr + WOLcrSet);
1892 /*
1893 * Turn EEPROM-controlled wake-up back on -- some hardware may
1894 * not cooperate otherwise.
1895 */
1896 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);
1897 }
1898
1899 if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST))
1900 iowrite8(WOLbmcast, ioaddr + WOLcgSet);
1901
1902 if (rp->wolopts & WAKE_PHY)
1903 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet);
1904
1905 if (rp->wolopts & WAKE_UCAST)
1906 iowrite8(WOLucast, ioaddr + WOLcrSet);
1907
1908 if (rp->wolopts) {
1909 /* Enable legacy WOL (for old motherboards) */
1910 iowrite8(0x01, ioaddr + PwcfgSet);
1911 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
1912 }
1913
1914 /* Hit power state D3 (sleep) */
Roger Luethib933b4d2006-08-14 23:00:21 -07001915 if (!avoid_D3)
1916 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
1918 /* TODO: Check use of pci_enable_wake() */
1919
1920}
1921
1922#ifdef CONFIG_PM
1923static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
1924{
1925 struct net_device *dev = pci_get_drvdata(pdev);
1926 struct rhine_private *rp = netdev_priv(dev);
1927 unsigned long flags;
1928
1929 if (!netif_running(dev))
1930 return 0;
1931
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001932 napi_disable(&rp->napi);
Francois Romieu32b0f532008-07-11 00:30:14 +02001933
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 netif_device_detach(dev);
1935 pci_save_state(pdev);
1936
1937 spin_lock_irqsave(&rp->lock, flags);
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001938 rhine_shutdown(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 spin_unlock_irqrestore(&rp->lock, flags);
1940
1941 free_irq(dev->irq, dev);
1942 return 0;
1943}
1944
1945static int rhine_resume(struct pci_dev *pdev)
1946{
1947 struct net_device *dev = pci_get_drvdata(pdev);
1948 struct rhine_private *rp = netdev_priv(dev);
1949 unsigned long flags;
1950 int ret;
1951
1952 if (!netif_running(dev))
1953 return 0;
1954
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001955 if (request_irq(dev->irq, rhine_interrupt, IRQF_SHARED, dev->name, dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 printk(KERN_ERR "via-rhine %s: request_irq failed\n", dev->name);
1957
1958 ret = pci_set_power_state(pdev, PCI_D0);
1959 if (debug > 1)
1960 printk(KERN_INFO "%s: Entering power state D0 %s (%d).\n",
1961 dev->name, ret ? "failed" : "succeeded", ret);
1962
1963 pci_restore_state(pdev);
1964
1965 spin_lock_irqsave(&rp->lock, flags);
1966#ifdef USE_MMIO
1967 enable_mmio(rp->pioaddr, rp->quirks);
1968#endif
1969 rhine_power_init(dev);
1970 free_tbufs(dev);
1971 free_rbufs(dev);
1972 alloc_tbufs(dev);
1973 alloc_rbufs(dev);
1974 init_registers(dev);
1975 spin_unlock_irqrestore(&rp->lock, flags);
1976
1977 netif_device_attach(dev);
1978
1979 return 0;
1980}
1981#endif /* CONFIG_PM */
1982
1983static struct pci_driver rhine_driver = {
1984 .name = DRV_NAME,
1985 .id_table = rhine_pci_tbl,
1986 .probe = rhine_init_one,
1987 .remove = __devexit_p(rhine_remove_one),
1988#ifdef CONFIG_PM
1989 .suspend = rhine_suspend,
1990 .resume = rhine_resume,
1991#endif /* CONFIG_PM */
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001992 .shutdown = rhine_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993};
1994
Roger Luethie84df482007-03-06 19:57:37 +01001995static struct dmi_system_id __initdata rhine_dmi_table[] = {
1996 {
1997 .ident = "EPIA-M",
1998 .matches = {
1999 DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."),
2000 DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
2001 },
2002 },
2003 {
2004 .ident = "KV7",
2005 .matches = {
2006 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
2007 DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
2008 },
2009 },
2010 { NULL }
2011};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012
2013static int __init rhine_init(void)
2014{
2015/* when a module, this is printed whether or not devices are found in probe */
2016#ifdef MODULE
2017 printk(version);
2018#endif
Roger Luethie84df482007-03-06 19:57:37 +01002019 if (dmi_check_system(rhine_dmi_table)) {
2020 /* these BIOSes fail at PXE boot if chip is in D3 */
2021 avoid_D3 = 1;
2022 printk(KERN_WARNING "%s: Broken BIOS detected, avoid_D3 "
2023 "enabled.\n",
2024 DRV_NAME);
2025 }
2026 else if (avoid_D3)
2027 printk(KERN_INFO "%s: avoid_D3 set.\n", DRV_NAME);
2028
Jeff Garzik29917622006-08-19 17:48:59 -04002029 return pci_register_driver(&rhine_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030}
2031
2032
2033static void __exit rhine_cleanup(void)
2034{
2035 pci_unregister_driver(&rhine_driver);
2036}
2037
2038
2039module_init(rhine_init);
2040module_exit(rhine_cleanup);