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