Merge http://gkernel.bkbits.net/linus-2.5
[opensuse:kernel.git] / drivers / net / via-rhine.c
1 /* via-rhine.c: A Linux Ethernet device driver for VIA Rhine family chips. */
2 /*
3         Written 1998-2001 by Donald Becker.
4
5         This software may be used and distributed according to the terms of
6         the GNU General Public License (GPL), incorporated herein by reference.
7         Drivers based on or derived from this code fall under the GPL and must
8         retain the authorship, copyright and license notice.  This file is not
9         a complete program and may only be used when the entire operating
10         system is licensed under the GPL.
11
12         This driver is designed for the VIA VT86c100A Rhine-II PCI Fast Ethernet
13         controller.  It also works with the older 3043 Rhine-I chip.
14
15         The author may be reached as becker@scyld.com, or C/O
16         Scyld Computing Corporation
17         410 Severn Ave., Suite 210
18         Annapolis MD 21403
19
20
21         This driver contains some changes from the original Donald Becker
22         version. He may or may not be interested in bug reports on this
23         code. You can find his versions at:
24         http://www.scyld.com/network/via-rhine.html
25
26
27         Linux kernel version history:
28         
29         LK1.1.0:
30         - Jeff Garzik: softnet 'n stuff
31         
32         LK1.1.1:
33         - Justin Guyett: softnet and locking fixes
34         - Jeff Garzik: use PCI interface
35
36         LK1.1.2:
37         - Urban Widmark: minor cleanups, merges from Becker 1.03a/1.04 versions
38
39         LK1.1.3:
40         - Urban Widmark: use PCI DMA interface (with thanks to the eepro100.c
41                          code) update "Theory of Operation" with
42                          softnet/locking changes
43         - Dave Miller: PCI DMA and endian fixups
44         - Jeff Garzik: MOD_xxx race fixes, updated PCI resource allocation
45
46         LK1.1.4:
47         - Urban Widmark: fix gcc 2.95.2 problem and
48                          remove writel's to fixed address 0x7c
49
50         LK1.1.5:
51         - Urban Widmark: mdio locking, bounce buffer changes
52                          merges from Beckers 1.05 version
53                          added netif_running_on/off support
54
55         LK1.1.6:
56         - Urban Widmark: merges from Beckers 1.08b version (VT6102 + mdio)
57                          set netif_running_on/off on startup, del_timer_sync
58         
59         LK1.1.7:
60         - Manfred Spraul: added reset into tx_timeout
61
62         LK1.1.9:
63         - Urban Widmark: merges from Beckers 1.10 version
64                          (media selection + eeprom reload)
65         - David Vrabel:  merges from D-Link "1.11" version
66                          (disable WOL and PME on startup)
67
68         LK1.1.10:
69         - Manfred Spraul: use "singlecopy" for unaligned buffers
70                           don't allocate bounce buffers for !ReqTxAlign cards
71
72         LK1.1.11:
73         - David Woodhouse: Set dev->base_addr before the first time we call
74                                            wait_for_reset(). It's a lot happier that way.
75                                            Free np->tx_bufs only if we actually allocated it.
76
77         LK1.1.12:
78         - Martin Eriksson: Allow Memory-Mapped IO to be enabled.
79
80         LK1.1.13 (jgarzik):
81         - Add ethtool support
82         - Replace some MII-related magic numbers with constants
83         
84         LK1.1.14 (jgarzik):
85         - Merge new PCI id from 'linuxfet' driver.
86
87 */
88
89 #define DRV_NAME        "via-rhine"
90 #define DRV_VERSION     "1.1.14"
91 #define DRV_RELDATE     "Feb-12-2002"
92
93
94 /* A few user-configurable values.
95    These may be modified when a driver module is loaded. */
96
97 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
98 static int max_interrupt_work = 20;
99
100 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
101    Setting to > 1518 effectively disables this feature. */
102 static int rx_copybreak;
103
104 /* Used to pass the media type, etc.
105    Both 'options[]' and 'full_duplex[]' should exist for driver
106    interoperability.
107    The media type is usually passed in 'options[]'.
108    The default is autonegotation for speed and duplex.
109      This should rarely be overridden.
110    Use option values 0x10/0x20 for 10Mbps, 0x100,0x200 for 100Mbps.
111    Use option values 0x10 and 0x100 for forcing half duplex fixed speed.
112    Use option values 0x20 and 0x200 for forcing full duplex operation.
113 */
114 #define MAX_UNITS 8             /* More are supported, limit only on options */
115 static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
116 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
117
118 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
119    The Rhine has a 64 element 8390-like hash table.  */
120 static const int multicast_filter_limit = 32;
121
122
123 /* Operational parameters that are set at compile time. */
124
125 /* Keep the ring sizes a power of two for compile efficiency.
126    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
127    Making the Tx ring too large decreases the effectiveness of channel
128    bonding and packet priority.
129    There are no ill effects from too-large receive rings. */
130 #define TX_RING_SIZE    16
131 #define TX_QUEUE_LEN    10              /* Limit ring entries actually used.  */
132 #define RX_RING_SIZE    16
133
134
135 /* Operational parameters that usually are not changed. */
136
137 /* Time in jiffies before concluding the transmitter is hung. */
138 #define TX_TIMEOUT  (2*HZ)
139
140 #define PKT_BUF_SZ              1536                    /* Size of each temporary Rx buffer.*/
141
142 /* max time out delay time */
143 #define W_MAX_TIMEOUT   0x0FFFU
144
145 #if !defined(__OPTIMIZE__)  ||  !defined(__KERNEL__)
146 #warning  You must compile this file with the correct options!
147 #warning  See the last lines of the source file.
148 #error  You must compile this driver with "-O".
149 #endif
150
151 #include <linux/module.h>
152 #include <linux/kernel.h>
153 #include <linux/string.h>
154 #include <linux/timer.h>
155 #include <linux/errno.h>
156 #include <linux/ioport.h>
157 #include <linux/slab.h>
158 #include <linux/interrupt.h>
159 #include <linux/pci.h>
160 #include <linux/netdevice.h>
161 #include <linux/etherdevice.h>
162 #include <linux/skbuff.h>
163 #include <linux/init.h>
164 #include <linux/delay.h>
165 #include <linux/mii.h>
166 #include <linux/ethtool.h>
167 #include <linux/crc32.h>
168 #include <asm/processor.h>              /* Processor type for cache alignment. */
169 #include <asm/bitops.h>
170 #include <asm/io.h>
171 #include <asm/irq.h>
172 #include <asm/uaccess.h>
173
174 /* These identify the driver base version and may not be removed. */
175 static char version[] __devinitdata =
176 KERN_INFO DRV_NAME ".c:v1.10-LK" DRV_VERSION "  " DRV_RELDATE "  Written by Donald Becker\n"
177 KERN_INFO "  http://www.scyld.com/network/via-rhine.html\n";
178
179 static char shortname[] __devinitdata = DRV_NAME;
180
181
182 /* This driver was written to use PCI memory space, however most versions
183    of the Rhine only work correctly with I/O space accesses. */
184 #ifdef CONFIG_VIA_RHINE_MMIO
185 #define USE_MEM
186 #else
187 #define USE_IO
188 #undef readb
189 #undef readw
190 #undef readl
191 #undef writeb
192 #undef writew
193 #undef writel
194 #define readb inb
195 #define readw inw
196 #define readl inl
197 #define writeb outb
198 #define writew outw
199 #define writel outl
200 #endif
201
202 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
203 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");
204 MODULE_LICENSE("GPL");
205
206 MODULE_PARM(max_interrupt_work, "i");
207 MODULE_PARM(debug, "i");
208 MODULE_PARM(rx_copybreak, "i");
209 MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
210 MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
211 MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");
212 MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");
213 MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames");
214 MODULE_PARM_DESC(options, "VIA Rhine: Bits 0-3: media type, bit 17: full duplex");
215 MODULE_PARM_DESC(full_duplex, "VIA Rhine full duplex setting(s) (1)");
216
217 /*
218                                 Theory of Operation
219
220 I. Board Compatibility
221
222 This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet
223 controller.
224
225 II. Board-specific settings
226
227 Boards with this chip are functional only in a bus-master PCI slot.
228
229 Many operational settings are loaded from the EEPROM to the Config word at
230 offset 0x78.  This driver assumes that they are correct.
231 If this driver is compiled to use PCI memory space operations the EEPROM
232 must be configured to enable memory ops.
233
234 III. Driver operation
235
236 IIIa. Ring buffers
237
238 This driver uses two statically allocated fixed-size descriptor lists
239 formed into rings by a branch from the final descriptor to the beginning of
240 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
241
242 IIIb/c. Transmit/Receive Structure
243
244 This driver attempts to use a zero-copy receive and transmit scheme.
245
246 Alas, all data buffers are required to start on a 32 bit boundary, so
247 the driver must often copy transmit packets into bounce buffers.
248
249 The driver allocates full frame size skbuffs for the Rx ring buffers at
250 open() time and passes the skb->data field to the chip as receive data
251 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
252 a fresh skbuff is allocated and the frame is copied to the new skbuff.
253 When the incoming frame is larger, the skbuff is passed directly up the
254 protocol stack.  Buffers consumed this way are replaced by newly allocated
255 skbuffs in the last phase of via_rhine_rx().
256
257 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
258 using a full-sized skbuff for small frames vs. the copying costs of larger
259 frames.  New boards are typically used in generously configured machines
260 and the underfilled buffers have negligible impact compared to the benefit of
261 a single allocation size, so the default value of zero results in never
262 copying packets.  When copying is done, the cost is usually mitigated by using
263 a combined copy/checksum routine.  Copying also preloads the cache, which is
264 most useful with small frames.
265
266 Since the VIA chips are only able to transfer data to buffers on 32 bit
267 boundaries, the IP header at offset 14 in an ethernet frame isn't
268 longword aligned for further processing.  Copying these unaligned buffers
269 has the beneficial effect of 16-byte aligning the IP header.
270
271 IIId. Synchronization
272
273 The driver runs as two independent, single-threaded flows of control.  One
274 is the send-packet routine, which enforces single-threaded use by the
275 dev->priv->lock spinlock. The other thread is the interrupt handler, which 
276 is single threaded by the hardware and interrupt handling software.
277
278 The send packet thread has partial control over the Tx ring. It locks the 
279 dev->priv->lock whenever it's queuing a Tx packet. If the next slot in the ring
280 is not available it stops the transmit queue by calling netif_stop_queue.
281
282 The interrupt handler has exclusive control over the Rx ring and records stats
283 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
284 empty by incrementing the dirty_tx mark. If at least half of the entries in
285 the Rx ring are available the transmit queue is woken up if it was stopped.
286
287 IV. Notes
288
289 IVb. References
290
291 Preliminary VT86C100A manual from http://www.via.com.tw/
292 http://www.scyld.com/expert/100mbps.html
293 http://www.scyld.com/expert/NWay.html
294 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf
295 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF
296
297
298 IVc. Errata
299
300 The VT86C100A manual is not reliable information.
301 The 3043 chip does not handle unaligned transmit or receive buffers, resulting
302 in significant performance degradation for bounce buffer copies on transmit
303 and unaligned IP headers on receive.
304 The chip does not pad to minimum transmit length.
305
306 */
307
308
309 /* This table drives the PCI probe routines.  It's mostly boilerplate in all
310    of the drivers, and will likely be provided by some future kernel.
311    Note the matching code -- the first table entry matchs all 56** cards but
312    second only the 1234 card.
313 */
314
315 enum pci_flags_bit {
316         PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
317         PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3,
318 };
319
320 enum via_rhine_chips {
321         VT86C100A = 0,
322         VT6102,
323         VT3043,
324 };
325
326 struct via_rhine_chip_info {
327         const char *name;
328         u16 pci_flags;
329         int io_size;
330         int drv_flags;
331 };
332
333
334 enum chip_capability_flags {
335         CanHaveMII=1, HasESIPhy=2, HasDavicomPhy=4,
336         ReqTxAlign=0x10, HasWOL=0x20, };
337
338 #ifdef USE_MEM
339 #define RHINE_IOTYPE (PCI_USES_MEM | PCI_USES_MASTER | PCI_ADDR1)
340 #else
341 #define RHINE_IOTYPE (PCI_USES_IO  | PCI_USES_MASTER | PCI_ADDR0)
342 #endif
343
344 /* directly indexed by enum via_rhine_chips, above */
345 static struct via_rhine_chip_info via_rhine_chip_info[] __devinitdata =
346 {
347         { "VIA VT86C100A Rhine", RHINE_IOTYPE, 128,
348           CanHaveMII | ReqTxAlign },
349         { "VIA VT6102 Rhine-II", RHINE_IOTYPE, 256,
350           CanHaveMII | HasWOL },
351         { "VIA VT3043 Rhine",    RHINE_IOTYPE, 128,
352           CanHaveMII | ReqTxAlign }
353         { "VIA VT6105 Rhine-III", RHINE_IOTYPE, 256,
354           CanHaveMII | HasWOL },
355 };
356
357 static struct pci_device_id via_rhine_pci_tbl[] __devinitdata =
358 {
359         {0x1106, 0x6100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT86C100A},
360         {0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT6102},
361         {0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT3043},
362         {0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT6105},
363         {0,}                    /* terminate list */
364 };
365 MODULE_DEVICE_TABLE(pci, via_rhine_pci_tbl);
366
367
368 /* Offsets to the device registers. */
369 enum register_offsets {
370         StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08,
371         IntrStatus=0x0C, IntrEnable=0x0E,
372         MulticastFilter0=0x10, MulticastFilter1=0x14,
373         RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54,
374         MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E,
375         MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74,
376         ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B,
377         RxMissed=0x7C, RxCRCErrs=0x7E,
378         StickyHW=0x83, WOLcrClr=0xA4, WOLcgClr=0xA7, PwrcsrClr=0xAC,
379 };
380
381 #ifdef USE_MEM
382 /* Registers we check that mmio and reg are the same. */
383 int mmio_verify_registers[] = {
384         RxConfig, TxConfig, IntrEnable, ConfigA, ConfigB, ConfigC, ConfigD,
385         0
386 };
387 #endif
388
389 /* Bits in the interrupt status/mask registers. */
390 enum intr_status_bits {
391         IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,
392         IntrTxDone=0x0002, IntrTxAbort=0x0008, IntrTxUnderrun=0x0010,
393         IntrPCIErr=0x0040,
394         IntrStatsMax=0x0080, IntrRxEarly=0x0100, IntrMIIChange=0x0200,
395         IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,
396         IntrTxAborted=0x2000, IntrLinkChange=0x4000,
397         IntrRxWakeUp=0x8000,
398         IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,
399 };
400
401 /* MII interface, status flags.
402    Not to be confused with the MIIStatus register ... */
403 enum mii_status_bits {
404         MIICap100T4                     = 0x8000,
405         MIICap10100HdFd         = 0x7800,
406         MIIPreambleSupr         = 0x0040,
407         MIIAutoNegCompleted     = 0x0020,
408         MIIRemoteFault          = 0x0010,
409         MIICapAutoNeg           = 0x0008,
410         MIILink                         = 0x0004,
411         MIIJabber                       = 0x0002,
412         MIIExtended                     = 0x0001
413 };
414
415 /* The Rx and Tx buffer descriptors. */
416 struct rx_desc {
417         s32 rx_status;
418         u32 desc_length;
419         u32 addr;
420         u32 next_desc;
421 };
422 struct tx_desc {
423         s32 tx_status;
424         u32 desc_length;
425         u32 addr;
426         u32 next_desc;
427 };
428
429 /* Bits in *_desc.status */
430 enum rx_status_bits {
431         RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F
432 };
433
434 enum desc_status_bits {
435         DescOwn=0x80000000, DescEndPacket=0x4000, DescIntr=0x1000,
436 };
437
438 /* Bits in ChipCmd. */
439 enum chip_cmd_bits {
440         CmdInit=0x0001, CmdStart=0x0002, CmdStop=0x0004, CmdRxOn=0x0008,
441         CmdTxOn=0x0010, CmdTxDemand=0x0020, CmdRxDemand=0x0040,
442         CmdEarlyRx=0x0100, CmdEarlyTx=0x0200, CmdFDuplex=0x0400,
443         CmdNoTxPoll=0x0800, CmdReset=0x8000,
444 };
445
446 #define MAX_MII_CNT     4
447 struct netdev_private {
448         /* Descriptor rings */
449         struct rx_desc *rx_ring;
450         struct tx_desc *tx_ring;
451         dma_addr_t rx_ring_dma;
452         dma_addr_t tx_ring_dma;
453
454         /* The addresses of receive-in-place skbuffs. */
455         struct sk_buff *rx_skbuff[RX_RING_SIZE];
456         dma_addr_t rx_skbuff_dma[RX_RING_SIZE];
457
458         /* The saved address of a sent-in-place packet/buffer, for later free(). */
459         struct sk_buff *tx_skbuff[TX_RING_SIZE];
460         dma_addr_t tx_skbuff_dma[TX_RING_SIZE];
461
462         /* Tx bounce buffers */
463         unsigned char *tx_buf[TX_RING_SIZE];
464         unsigned char *tx_bufs;
465         dma_addr_t tx_bufs_dma;
466
467         struct pci_dev *pdev;
468         struct net_device_stats stats;
469         struct timer_list timer;        /* Media monitoring timer. */
470         spinlock_t lock;
471
472         /* Frequently used values: keep some adjacent for cache effect. */
473         int chip_id, drv_flags;
474         struct rx_desc *rx_head_desc;
475         unsigned int cur_rx, dirty_rx;          /* Producer/consumer ring indices */
476         unsigned int cur_tx, dirty_tx;
477         unsigned int rx_buf_sz;                         /* Based on MTU+slack. */
478         u16 chip_cmd;                                           /* Current setting for ChipCmd */
479
480         /* These values are keep track of the transceiver/media in use. */
481         unsigned int full_duplex:1;                     /* Full-duplex operation requested. */
482         unsigned int duplex_lock:1;
483         unsigned int default_port:4;            /* Last dev->if_port value. */
484         u8 tx_thresh, rx_thresh;
485
486         /* MII transceiver section. */
487         u16 advertising;                                        /* NWay media advertisement */
488         unsigned char phys[MAX_MII_CNT];                        /* MII device addresses. */
489         unsigned int mii_cnt;                   /* number of MIIs found, but only the first one is used */
490         u16 mii_status;                                         /* last read MII status */
491         struct mii_if_info mii_if;
492 };
493
494 static int  mdio_read(struct net_device *dev, int phy_id, int location);
495 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
496 static int  via_rhine_open(struct net_device *dev);
497 static void via_rhine_check_duplex(struct net_device *dev);
498 static void via_rhine_timer(unsigned long data);
499 static void via_rhine_tx_timeout(struct net_device *dev);
500 static int  via_rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
501 static void via_rhine_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
502 static void via_rhine_tx(struct net_device *dev);
503 static void via_rhine_rx(struct net_device *dev);
504 static void via_rhine_error(struct net_device *dev, int intr_status);
505 static void via_rhine_set_rx_mode(struct net_device *dev);
506 static struct net_device_stats *via_rhine_get_stats(struct net_device *dev);
507 static int via_rhine_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
508 static int  via_rhine_close(struct net_device *dev);
509 static inline void clear_tally_counters(long ioaddr);
510
511 static void wait_for_reset(struct net_device *dev, char *name)
512 {
513         struct netdev_private *np = dev->priv;
514         long ioaddr = dev->base_addr;
515         int chip_id = np->chip_id;
516         int i;
517
518         /* 3043 may need long delay after reset (dlink) */
519         if (chip_id == VT3043 || chip_id == VT86C100A)
520                 udelay(100);
521
522         i = 0;
523         do {
524                 udelay(5);
525                 i++;
526                 if(i > 2000) {
527                         printk(KERN_ERR "%s: reset did not complete in 10 ms.\n", name);
528                         break;
529                 }
530         } while(readw(ioaddr + ChipCmd) & CmdReset);
531         if (debug > 1)
532                 printk(KERN_INFO "%s: reset finished after %d microseconds.\n",
533                            name, 5*i);
534 }
535
536 #ifdef USE_MEM
537 static void __devinit enable_mmio(long ioaddr, int chip_id)
538 {
539         int n;
540         if (chip_id == VT3043 || chip_id == VT86C100A) {
541                 /* More recent docs say that this bit is reserved ... */
542                 n = inb(ioaddr + ConfigA) | 0x20;
543                 outb(n, ioaddr + ConfigA);
544         } else if (chip_id == VT6102) {
545                 n = inb(ioaddr + ConfigD) | 0x80;
546                 outb(n, ioaddr + ConfigD);
547         }
548 }
549 #endif
550
551 static void __devinit reload_eeprom(long ioaddr)
552 {
553         int i;
554         outb(0x20, ioaddr + MACRegEEcsr);
555         /* Typically 2 cycles to reload. */
556         for (i = 0; i < 150; i++)
557                 if (! (inb(ioaddr + MACRegEEcsr) & 0x20))
558                         break;
559 }
560
561 static int __devinit via_rhine_init_one (struct pci_dev *pdev,
562                                          const struct pci_device_id *ent)
563 {
564         struct net_device *dev;
565         struct netdev_private *np;
566         int i, option;
567         int chip_id = (int) ent->driver_data;
568         static int card_idx = -1;
569         long ioaddr;
570         long memaddr;
571         int io_size;
572         int pci_flags;
573 #ifdef USE_MEM
574         long ioaddr0;
575 #endif
576         
577 /* when built into the kernel, we only print version if device is found */
578 #ifndef MODULE
579         static int printed_version;
580         if (!printed_version++)
581                 printk(version);
582 #endif
583
584         card_idx++;
585         option = card_idx < MAX_UNITS ? options[card_idx] : 0;
586         io_size = via_rhine_chip_info[chip_id].io_size;
587         pci_flags = via_rhine_chip_info[chip_id].pci_flags;
588
589         if (pci_enable_device (pdev))
590                 goto err_out;
591
592         /* this should always be supported */
593         if (pci_set_dma_mask(pdev, 0xffffffff)) {
594                 printk(KERN_ERR "32-bit PCI DMA addresses not supported by the card!?\n");
595                 goto err_out;
596         }
597         
598         /* sanity check */
599         if ((pci_resource_len (pdev, 0) < io_size) ||
600             (pci_resource_len (pdev, 1) < io_size)) {
601                 printk (KERN_ERR "Insufficient PCI resources, aborting\n");
602                 goto err_out;
603         }
604
605         ioaddr = pci_resource_start (pdev, 0);
606         memaddr = pci_resource_start (pdev, 1);
607
608         if (pci_flags & PCI_USES_MASTER)
609                 pci_set_master (pdev);
610
611         dev = alloc_etherdev(sizeof(*np));
612         if (dev == NULL) {
613                 printk (KERN_ERR "init_ethernet failed for card #%d\n", card_idx);
614                 goto err_out;
615         }
616         SET_MODULE_OWNER(dev);
617         
618         if (pci_request_regions(pdev, shortname))
619                 goto err_out_free_netdev;
620
621 #ifdef USE_MEM
622         ioaddr0 = ioaddr;
623         enable_mmio(ioaddr0, chip_id);
624
625         ioaddr = (long) ioremap (memaddr, io_size);
626         if (!ioaddr) {
627                 printk (KERN_ERR "ioremap failed for device %s, region 0x%X @ 0x%lX\n",
628                                 pdev->slot_name, io_size, memaddr);
629                 goto err_out_free_res;
630         }
631
632         /* Check that selected MMIO registers match the PIO ones */
633         i = 0;
634         while (mmio_verify_registers[i]) {
635                 int reg = mmio_verify_registers[i++];
636                 unsigned char a = inb(ioaddr0+reg);
637                 unsigned char b = readb(ioaddr+reg);
638                 if (a != b) {
639                         printk (KERN_ERR "MMIO do not match PIO [%02x] (%02x != %02x)\n",
640                                         reg, a, b);
641                         goto err_out_unmap;
642                 }
643         }
644 #endif
645
646         /* D-Link provided reset code (with comment additions) */
647         if (via_rhine_chip_info[chip_id].drv_flags & HasWOL) {
648                 unsigned char byOrgValue;
649
650                 /* clear sticky bit before reset & read ethernet address */
651                 byOrgValue = readb(ioaddr + StickyHW);
652                 byOrgValue = byOrgValue & 0xFC;
653                 writeb(byOrgValue, ioaddr + StickyHW);
654
655                 /* (bits written are cleared?) */
656                 /* disable force PME-enable */
657                 writeb(0x80, ioaddr + WOLcgClr);
658                 /* disable power-event config bit */
659                 writeb(0xFF, ioaddr + WOLcrClr);
660                 /* clear power status (undocumented in vt6102 docs?) */
661                 writeb(0xFF, ioaddr + PwrcsrClr);
662         }
663
664         /* Reset the chip to erase previous misconfiguration. */
665         writew(CmdReset, ioaddr + ChipCmd);
666
667         dev->base_addr = ioaddr;
668         wait_for_reset(dev, shortname);
669
670         /* Reload the station address from the EEPROM. */
671 #ifdef USE_IO
672         reload_eeprom(ioaddr);
673 #else
674         reload_eeprom(ioaddr0);
675         /* Reloading from eeprom overwrites cfgA-D, so we must re-enable MMIO.
676            If reload_eeprom() was done first this could be avoided, but it is
677            not known if that still works with the "win98-reboot" problem. */
678         enable_mmio(ioaddr0, chip_id);
679 #endif
680
681         for (i = 0; i < 6; i++)
682                 dev->dev_addr[i] = readb(ioaddr + StationAddr + i);
683
684         if (!is_valid_ether_addr(dev->dev_addr)) {
685                 printk(KERN_ERR "Invalid MAC address for card #%d\n", card_idx);
686                 goto err_out_unmap;
687         }
688
689         if (chip_id == VT6102) {
690                 /*
691                  * for 3065D, EEPROM reloaded will cause bit 0 in MAC_REG_CFGA
692                  * turned on.  it makes MAC receive magic packet
693                  * automatically. So, we turn it off. (D-Link)
694                  */
695                 writeb(readb(ioaddr + ConfigA) & 0xFE, ioaddr + ConfigA);
696         }
697
698         dev->irq = pdev->irq;
699
700         np = dev->priv;
701         spin_lock_init (&np->lock);
702         np->chip_id = chip_id;
703         np->drv_flags = via_rhine_chip_info[chip_id].drv_flags;
704         np->pdev = pdev;
705         np->mii_if.dev = dev;
706         np->mii_if.mdio_read = mdio_read;
707         np->mii_if.mdio_write = mdio_write;
708
709         if (dev->mem_start)
710                 option = dev->mem_start;
711
712         /* The lower four bits are the media type. */
713         if (option > 0) {
714                 if (option & 0x200)
715                         np->mii_if.full_duplex = 1;
716                 np->default_port = option & 15;
717         }
718         if (card_idx < MAX_UNITS  &&  full_duplex[card_idx] > 0)
719                 np->mii_if.full_duplex = 1;
720
721         if (np->mii_if.full_duplex) {
722                 printk(KERN_INFO "%s: Set to forced full duplex, autonegotiation"
723                            " disabled.\n", dev->name);
724                 np->mii_if.duplex_lock = 1;
725         }
726
727         /* The chip-specific entries in the device structure. */
728         dev->open = via_rhine_open;
729         dev->hard_start_xmit = via_rhine_start_tx;
730         dev->stop = via_rhine_close;
731         dev->get_stats = via_rhine_get_stats;
732         dev->set_multicast_list = via_rhine_set_rx_mode;
733         dev->do_ioctl = via_rhine_ioctl;
734         dev->tx_timeout = via_rhine_tx_timeout;
735         dev->watchdog_timeo = TX_TIMEOUT;
736         if (np->drv_flags & ReqTxAlign)
737                 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
738         
739         i = register_netdev(dev);
740         if (i)
741                 goto err_out_unmap;
742
743         printk(KERN_INFO "%s: %s at 0x%lx, ",
744                    dev->name, via_rhine_chip_info[chip_id].name,
745                    (pci_flags & PCI_USES_IO) ? ioaddr : memaddr);
746
747         for (i = 0; i < 5; i++)
748                         printk("%2.2x:", dev->dev_addr[i]);
749         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], pdev->irq);
750
751         pci_set_drvdata(pdev, dev);
752
753         if (np->drv_flags & CanHaveMII) {
754                 int phy, phy_idx = 0;
755                 np->phys[0] = 1;                /* Standard for this chip. */
756                 for (phy = 1; phy < 32 && phy_idx < MAX_MII_CNT; phy++) {
757                         int mii_status = mdio_read(dev, phy, 1);
758                         if (mii_status != 0xffff  &&  mii_status != 0x0000) {
759                                 np->phys[phy_idx++] = phy;
760                                 np->mii_if.advertising = mdio_read(dev, phy, 4);
761                                 printk(KERN_INFO "%s: MII PHY found at address %d, status "
762                                            "0x%4.4x advertising %4.4x Link %4.4x.\n",
763                                            dev->name, phy, mii_status, np->mii_if.advertising,
764                                            mdio_read(dev, phy, 5));
765
766                                 /* set IFF_RUNNING */
767                                 if (mii_status & MIILink)
768                                         netif_carrier_on(dev);
769                                 else
770                                         netif_carrier_off(dev);
771                         }
772                 }
773                 np->mii_cnt = phy_idx;
774                 np->mii_if.phy_id = np->phys[0];
775         }
776
777         /* Allow forcing the media type. */
778         if (option > 0) {
779                 if (option & 0x220)
780                         np->mii_if.full_duplex = 1;
781                 np->default_port = option & 0x3ff;
782                 if (np->default_port & 0x330) {
783                         /* FIXME: shouldn't someone check this variable? */
784                         /* np->medialock = 1; */
785                         printk(KERN_INFO "  Forcing %dMbs %s-duplex operation.\n",
786                                    (option & 0x300 ? 100 : 10),
787                                    (option & 0x220 ? "full" : "half"));
788                         if (np->mii_cnt)
789                                 mdio_write(dev, np->phys[0], 0,
790                                                    ((option & 0x300) ? 0x2000 : 0) |  /* 100mbps? */
791                                                    ((option & 0x220) ? 0x0100 : 0));  /* Full duplex? */
792                 }
793         }
794
795         return 0;
796
797 err_out_unmap:
798 #ifdef USE_MEM
799         iounmap((void *)ioaddr);
800 err_out_free_res:
801 #endif
802         pci_release_regions(pdev);
803 err_out_free_netdev:
804         kfree (dev);
805 err_out:
806         return -ENODEV;
807 }
808
809 static int alloc_ring(struct net_device* dev)
810 {
811         struct netdev_private *np = dev->priv;
812         void *ring;
813         dma_addr_t ring_dma;
814
815         ring = pci_alloc_consistent(np->pdev, 
816                                     RX_RING_SIZE * sizeof(struct rx_desc) +
817                                     TX_RING_SIZE * sizeof(struct tx_desc),
818                                     &ring_dma);
819         if (!ring) {
820                 printk(KERN_ERR "Could not allocate DMA memory.\n");
821                 return -ENOMEM;
822         }
823         if (np->drv_flags & ReqTxAlign) {
824                 np->tx_bufs = pci_alloc_consistent(np->pdev, PKT_BUF_SZ * TX_RING_SIZE,
825                                                                    &np->tx_bufs_dma);
826                 if (np->tx_bufs == NULL) {
827                         pci_free_consistent(np->pdev, 
828                                     RX_RING_SIZE * sizeof(struct rx_desc) +
829                                     TX_RING_SIZE * sizeof(struct tx_desc),
830                                     ring, ring_dma);
831                         return -ENOMEM;
832                 }
833         }
834
835         np->rx_ring = ring;
836         np->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
837         np->rx_ring_dma = ring_dma;
838         np->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
839
840         return 0;
841 }
842
843 void free_ring(struct net_device* dev)
844 {
845         struct netdev_private *np = dev->priv;
846
847         pci_free_consistent(np->pdev, 
848                             RX_RING_SIZE * sizeof(struct rx_desc) +
849                             TX_RING_SIZE * sizeof(struct tx_desc),
850                             np->rx_ring, np->rx_ring_dma);
851         np->tx_ring = NULL;
852
853         if (np->tx_bufs)
854                 pci_free_consistent(np->pdev, PKT_BUF_SZ * TX_RING_SIZE,
855                                                         np->tx_bufs, np->tx_bufs_dma);
856
857         np->tx_bufs = NULL;
858
859 }
860
861 static void alloc_rbufs(struct net_device *dev)
862 {
863         struct netdev_private *np = dev->priv;
864         dma_addr_t next;
865         int i;
866
867         np->dirty_rx = np->cur_rx = 0;
868
869         np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
870         np->rx_head_desc = &np->rx_ring[0];
871         next = np->rx_ring_dma;
872         
873         /* Init the ring entries */
874         for (i = 0; i < RX_RING_SIZE; i++) {
875                 np->rx_ring[i].rx_status = 0;
876                 np->rx_ring[i].desc_length = cpu_to_le32(np->rx_buf_sz);
877                 next += sizeof(struct rx_desc);
878                 np->rx_ring[i].next_desc = cpu_to_le32(next);
879                 np->rx_skbuff[i] = 0;
880         }
881         /* Mark the last entry as wrapping the ring. */
882         np->rx_ring[i-1].next_desc = cpu_to_le32(np->rx_ring_dma);
883
884         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
885         for (i = 0; i < RX_RING_SIZE; i++) {
886                 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
887                 np->rx_skbuff[i] = skb;
888                 if (skb == NULL)
889                         break;
890                 skb->dev = dev;                 /* Mark as being used by this device. */
891
892                 np->rx_skbuff_dma[i] =
893                         pci_map_single(np->pdev, skb->tail, np->rx_buf_sz,
894                                                    PCI_DMA_FROMDEVICE);
895
896                 np->rx_ring[i].addr = cpu_to_le32(np->rx_skbuff_dma[i]);
897                 np->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
898         }
899         np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
900 }
901
902 static void free_rbufs(struct net_device* dev)
903 {
904         struct netdev_private *np = dev->priv;
905         int i;
906
907         /* Free all the skbuffs in the Rx queue. */
908         for (i = 0; i < RX_RING_SIZE; i++) {
909                 np->rx_ring[i].rx_status = 0;
910                 np->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
911                 if (np->rx_skbuff[i]) {
912                         pci_unmap_single(np->pdev,
913                                                          np->rx_skbuff_dma[i],
914                                                          np->rx_buf_sz, PCI_DMA_FROMDEVICE);
915                         dev_kfree_skb(np->rx_skbuff[i]);
916                 }
917                 np->rx_skbuff[i] = 0;
918         }
919 }
920
921 static void alloc_tbufs(struct net_device* dev)
922 {
923         struct netdev_private *np = dev->priv;
924         dma_addr_t next;
925         int i;
926
927         np->dirty_tx = np->cur_tx = 0;
928         next = np->tx_ring_dma;
929         for (i = 0; i < TX_RING_SIZE; i++) {
930                 np->tx_skbuff[i] = 0;
931                 np->tx_ring[i].tx_status = 0;
932                 np->tx_ring[i].desc_length = cpu_to_le32(0x00e08000);
933                 next += sizeof(struct tx_desc);
934                 np->tx_ring[i].next_desc = cpu_to_le32(next);
935                 np->tx_buf[i] = &np->tx_bufs[i * PKT_BUF_SZ];
936         }
937         np->tx_ring[i-1].next_desc = cpu_to_le32(np->tx_ring_dma);
938
939 }
940
941 static void free_tbufs(struct net_device* dev)
942 {
943         struct netdev_private *np = dev->priv;
944         int i;
945
946         for (i = 0; i < TX_RING_SIZE; i++) {
947                 np->tx_ring[i].tx_status = 0;
948                 np->tx_ring[i].desc_length = cpu_to_le32(0x00e08000);
949                 np->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
950                 if (np->tx_skbuff[i]) {
951                         if (np->tx_skbuff_dma[i]) {
952                                 pci_unmap_single(np->pdev,
953                                                                  np->tx_skbuff_dma[i],
954                                                                  np->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
955                         }
956                         dev_kfree_skb(np->tx_skbuff[i]);
957                 }
958                 np->tx_skbuff[i] = 0;
959                 np->tx_buf[i] = 0;
960         }
961 }
962
963 static void init_registers(struct net_device *dev)
964 {
965         struct netdev_private *np = dev->priv;
966         long ioaddr = dev->base_addr;
967         int i;
968
969         for (i = 0; i < 6; i++)
970                 writeb(dev->dev_addr[i], ioaddr + StationAddr + i);
971
972         /* Initialize other registers. */
973         writew(0x0006, ioaddr + PCIBusConfig);  /* Tune configuration??? */
974         /* Configure the FIFO thresholds. */
975         writeb(0x20, ioaddr + TxConfig);        /* Initial threshold 32 bytes */
976         np->tx_thresh = 0x20;
977         np->rx_thresh = 0x60;                   /* Written in via_rhine_set_rx_mode(). */
978
979         if (dev->if_port == 0)
980                 dev->if_port = np->default_port;
981
982         writel(np->rx_ring_dma, ioaddr + RxRingPtr);
983         writel(np->tx_ring_dma, ioaddr + TxRingPtr);
984
985         via_rhine_set_rx_mode(dev);
986
987         /* Enable interrupts by setting the interrupt mask. */
988         writew(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow| IntrRxDropped|
989                    IntrTxDone | IntrTxAbort | IntrTxUnderrun |
990                    IntrPCIErr | IntrStatsMax | IntrLinkChange | IntrMIIChange,
991                    ioaddr + IntrEnable);
992
993         np->chip_cmd = CmdStart|CmdTxOn|CmdRxOn|CmdNoTxPoll;
994         if (np->mii_if.duplex_lock)
995                 np->chip_cmd |= CmdFDuplex;
996         writew(np->chip_cmd, ioaddr + ChipCmd);
997
998         via_rhine_check_duplex(dev);
999
1000         /* The LED outputs of various MII xcvrs should be configured.  */
1001         /* For NS or Mison phys, turn on bit 1 in register 0x17 */
1002         /* For ESI phys, turn on bit 7 in register 0x17. */
1003         mdio_write(dev, np->phys[0], 0x17, mdio_read(dev, np->phys[0], 0x17) |
1004                            (np->drv_flags & HasESIPhy) ? 0x0080 : 0x0001);
1005 }
1006 /* Read and write over the MII Management Data I/O (MDIO) interface. */
1007
1008 static int mdio_read(struct net_device *dev, int phy_id, int regnum)
1009 {
1010         long ioaddr = dev->base_addr;
1011         int boguscnt = 1024;
1012
1013         /* Wait for a previous command to complete. */
1014         while ((readb(ioaddr + MIICmd) & 0x60) && --boguscnt > 0)
1015                 ;
1016         writeb(0x00, ioaddr + MIICmd);
1017         writeb(phy_id, ioaddr + MIIPhyAddr);
1018         writeb(regnum, ioaddr + MIIRegAddr);
1019         writeb(0x40, ioaddr + MIICmd);                  /* Trigger read */
1020         boguscnt = 1024;
1021         while ((readb(ioaddr + MIICmd) & 0x40) && --boguscnt > 0)
1022                 ;
1023         return readw(ioaddr + MIIData);
1024 }
1025
1026 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value)
1027 {
1028         struct netdev_private *np = dev->priv;
1029         long ioaddr = dev->base_addr;
1030         int boguscnt = 1024;
1031
1032         if (phy_id == np->phys[0]) {
1033                 switch (regnum) {
1034                 case 0:                                                 /* Is user forcing speed/duplex? */
1035                         if (value & 0x9000)                     /* Autonegotiation. */
1036                                 np->mii_if.duplex_lock = 0;
1037                         else
1038                                 np->mii_if.full_duplex = (value & 0x0100) ? 1 : 0;
1039                         break;
1040                 case 4:
1041                         np->mii_if.advertising = value;
1042                         break;
1043                 }
1044         }
1045
1046         /* Wait for a previous command to complete. */
1047         while ((readb(ioaddr + MIICmd) & 0x60) && --boguscnt > 0)
1048                 ;
1049         writeb(0x00, ioaddr + MIICmd);
1050         writeb(phy_id, ioaddr + MIIPhyAddr);
1051         writeb(regnum, ioaddr + MIIRegAddr);
1052         writew(value, ioaddr + MIIData);
1053         writeb(0x20, ioaddr + MIICmd);                  /* Trigger write. */
1054 }
1055
1056
1057 static int via_rhine_open(struct net_device *dev)
1058 {
1059         struct netdev_private *np = dev->priv;
1060         long ioaddr = dev->base_addr;
1061         int i;
1062
1063         /* Reset the chip. */
1064         writew(CmdReset, ioaddr + ChipCmd);
1065
1066         i = request_irq(np->pdev->irq, &via_rhine_interrupt, SA_SHIRQ, dev->name, dev);
1067         if (i)
1068                 return i;
1069
1070         if (debug > 1)
1071                 printk(KERN_DEBUG "%s: via_rhine_open() irq %d.\n",
1072                            dev->name, np->pdev->irq);
1073         
1074         i = alloc_ring(dev);
1075         if (i)
1076                 return i;
1077         alloc_rbufs(dev);
1078         alloc_tbufs(dev);
1079         wait_for_reset(dev, dev->name);
1080         init_registers(dev);
1081         if (debug > 2)
1082                 printk(KERN_DEBUG "%s: Done via_rhine_open(), status %4.4x "
1083                            "MII status: %4.4x.\n",
1084                            dev->name, readw(ioaddr + ChipCmd),
1085                            mdio_read(dev, np->phys[0], MII_BMSR));
1086
1087         netif_start_queue(dev);
1088
1089         /* Set the timer to check for link beat. */
1090         init_timer(&np->timer);
1091         np->timer.expires = jiffies + 2;
1092         np->timer.data = (unsigned long)dev;
1093         np->timer.function = &via_rhine_timer;                          /* timer handler */
1094         add_timer(&np->timer);
1095
1096         return 0;
1097 }
1098
1099 static void via_rhine_check_duplex(struct net_device *dev)
1100 {
1101         struct netdev_private *np = dev->priv;
1102         long ioaddr = dev->base_addr;
1103         int mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
1104         int negotiated = mii_lpa & np->mii_if.advertising;
1105         int duplex;
1106
1107         if (np->mii_if.duplex_lock  ||  mii_lpa == 0xffff)
1108                 return;
1109         duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
1110         if (np->mii_if.full_duplex != duplex) {
1111                 np->mii_if.full_duplex = duplex;
1112                 if (debug)
1113                         printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d link"
1114                                    " partner capability of %4.4x.\n", dev->name,
1115                                    duplex ? "full" : "half", np->phys[0], mii_lpa);
1116                 if (duplex)
1117                         np->chip_cmd |= CmdFDuplex;
1118                 else
1119                         np->chip_cmd &= ~CmdFDuplex;
1120                 writew(np->chip_cmd, ioaddr + ChipCmd);
1121         }
1122 }
1123
1124
1125 static void via_rhine_timer(unsigned long data)
1126 {
1127         struct net_device *dev = (struct net_device *)data;
1128         struct netdev_private *np = dev->priv;
1129         long ioaddr = dev->base_addr;
1130         int next_tick = 10*HZ;
1131         int mii_status;
1132
1133         if (debug > 3) {
1134                 printk(KERN_DEBUG "%s: VIA Rhine monitor tick, status %4.4x.\n",
1135                            dev->name, readw(ioaddr + IntrStatus));
1136         }
1137
1138         spin_lock_irq (&np->lock);
1139
1140         via_rhine_check_duplex(dev);
1141
1142         /* make IFF_RUNNING follow the MII status bit "Link established" */
1143         mii_status = mdio_read(dev, np->phys[0], MII_BMSR);
1144         if ( (mii_status & MIILink) != (np->mii_status & MIILink) ) {
1145                 if (mii_status & MIILink)
1146                         netif_carrier_on(dev);
1147                 else
1148                         netif_carrier_off(dev);
1149         }
1150         np->mii_status = mii_status;
1151
1152         spin_unlock_irq (&np->lock);
1153
1154         np->timer.expires = jiffies + next_tick;
1155         add_timer(&np->timer);
1156 }
1157
1158
1159 static void via_rhine_tx_timeout (struct net_device *dev)
1160 {
1161         struct netdev_private *np = dev->priv;
1162         long ioaddr = dev->base_addr;
1163
1164         printk (KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
1165                 "%4.4x, resetting...\n",
1166                 dev->name, readw (ioaddr + IntrStatus),
1167                 mdio_read (dev, np->phys[0], MII_BMSR));
1168
1169         dev->if_port = 0;
1170
1171         /* protect against concurrent rx interrupts */
1172         disable_irq(np->pdev->irq);
1173
1174         spin_lock(&np->lock);
1175
1176         /* Reset the chip. */
1177         writew(CmdReset, ioaddr + ChipCmd);
1178
1179         /* clear all descriptors */
1180         free_tbufs(dev);
1181         free_rbufs(dev);
1182         alloc_tbufs(dev);
1183         alloc_rbufs(dev);
1184
1185         /* Reinitialize the hardware. */
1186         wait_for_reset(dev, dev->name);
1187         init_registers(dev);
1188         
1189         spin_unlock(&np->lock);
1190         enable_irq(np->pdev->irq);
1191
1192         dev->trans_start = jiffies;
1193         np->stats.tx_errors++;
1194         netif_wake_queue(dev);
1195 }
1196
1197 static int via_rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
1198 {
1199         struct netdev_private *np = dev->priv;
1200         unsigned entry;
1201
1202         /* Caution: the write order is important here, set the field
1203            with the "ownership" bits last. */
1204
1205         /* Calculate the next Tx descriptor entry. */
1206         entry = np->cur_tx % TX_RING_SIZE;
1207
1208         np->tx_skbuff[entry] = skb;
1209
1210         if ((np->drv_flags & ReqTxAlign) &&
1211                 (((long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_HW)
1212                 ) {
1213                 /* Must use alignment buffer. */
1214                 if (skb->len > PKT_BUF_SZ) {
1215                         /* packet too long, drop it */
1216                         dev_kfree_skb(skb);
1217                         np->tx_skbuff[entry] = NULL;
1218                         np->stats.tx_dropped++;
1219                         return 0;
1220                 }
1221                 skb_copy_and_csum_dev(skb, np->tx_buf[entry]);
1222                 np->tx_skbuff_dma[entry] = 0;
1223                 np->tx_ring[entry].addr = cpu_to_le32(np->tx_bufs_dma +
1224                                                                                   (np->tx_buf[entry] - np->tx_bufs));
1225         } else {
1226                 np->tx_skbuff_dma[entry] =
1227                         pci_map_single(np->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1228                 np->tx_ring[entry].addr = cpu_to_le32(np->tx_skbuff_dma[entry]);
1229         }
1230
1231         np->tx_ring[entry].desc_length = 
1232                 cpu_to_le32(0x00E08000 | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1233
1234         /* lock eth irq */
1235         spin_lock_irq (&np->lock);
1236         wmb();
1237         np->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1238         wmb();
1239
1240         np->cur_tx++;
1241
1242         /* Non-x86 Todo: explicitly flush cache lines here. */
1243
1244         /* Wake the potentially-idle transmit channel. */
1245         writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd);
1246
1247         if (np->cur_tx == np->dirty_tx + TX_QUEUE_LEN)
1248                 netif_stop_queue(dev);
1249
1250         dev->trans_start = jiffies;
1251
1252         spin_unlock_irq (&np->lock);
1253
1254         if (debug > 4) {
1255                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1256                            dev->name, np->cur_tx, entry);
1257         }
1258         return 0;
1259 }
1260
1261 /* The interrupt handler does all of the Rx thread work and cleans up
1262    after the Tx thread. */
1263 static void via_rhine_interrupt(int irq, void *dev_instance, struct pt_regs *rgs)
1264 {
1265         struct net_device *dev = dev_instance;
1266         long ioaddr;
1267         u32 intr_status;
1268         int boguscnt = max_interrupt_work;
1269
1270         ioaddr = dev->base_addr;
1271         
1272         while ((intr_status = readw(ioaddr + IntrStatus))) {
1273                 /* Acknowledge all of the current interrupt sources ASAP. */
1274                 writew(intr_status & 0xffff, ioaddr + IntrStatus);
1275
1276                 if (debug > 4)
1277                         printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n",
1278                                    dev->name, intr_status);
1279
1280                 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
1281                                                    IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf))
1282                         via_rhine_rx(dev);
1283
1284                 if (intr_status & (IntrTxDone | IntrTxAbort | IntrTxUnderrun |
1285                                                    IntrTxAborted))
1286                         via_rhine_tx(dev);
1287
1288                 /* Abnormal error summary/uncommon events handlers. */
1289                 if (intr_status & (IntrPCIErr | IntrLinkChange | IntrMIIChange |
1290                                                    IntrStatsMax | IntrTxAbort | IntrTxUnderrun))
1291                         via_rhine_error(dev, intr_status);
1292
1293                 if (--boguscnt < 0) {
1294                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1295                                    "status=0x%4.4x.\n",
1296                                    dev->name, intr_status);
1297                         break;
1298                 }
1299         }
1300
1301         if (debug > 3)
1302                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1303                            dev->name, readw(ioaddr + IntrStatus));
1304 }
1305
1306 /* This routine is logically part of the interrupt handler, but isolated
1307    for clarity. */
1308 static void via_rhine_tx(struct net_device *dev)
1309 {
1310         struct netdev_private *np = dev->priv;
1311         int txstatus = 0, entry = np->dirty_tx % TX_RING_SIZE;
1312
1313         spin_lock (&np->lock);
1314
1315         /* find and cleanup dirty tx descriptors */
1316         while (np->dirty_tx != np->cur_tx) {
1317                 txstatus = le32_to_cpu(np->tx_ring[entry].tx_status);
1318                 if (txstatus & DescOwn)
1319                         break;
1320                 if (debug > 6)
1321                         printk(KERN_DEBUG " Tx scavenge %d status %8.8x.\n",
1322                                    entry, txstatus);
1323                 if (txstatus & 0x8000) {
1324                         if (debug > 1)
1325                                 printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
1326                                            dev->name, txstatus);
1327                         np->stats.tx_errors++;
1328                         if (txstatus & 0x0400) np->stats.tx_carrier_errors++;
1329                         if (txstatus & 0x0200) np->stats.tx_window_errors++;
1330                         if (txstatus & 0x0100) np->stats.tx_aborted_errors++;
1331                         if (txstatus & 0x0080) np->stats.tx_heartbeat_errors++;
1332                         if (txstatus & 0x0002) np->stats.tx_fifo_errors++;
1333                         /* Transmitter restarted in 'abnormal' handler. */
1334                 } else {
1335                         np->stats.collisions += (txstatus >> 3) & 15;
1336                         np->stats.tx_bytes += np->tx_skbuff[entry]->len;
1337                         np->stats.tx_packets++;
1338                 }
1339                 /* Free the original skb. */
1340                 if (np->tx_skbuff_dma[entry]) {
1341                         pci_unmap_single(np->pdev,
1342                                                          np->tx_skbuff_dma[entry],
1343                                                          np->tx_skbuff[entry]->len, PCI_DMA_TODEVICE);
1344                 }
1345                 dev_kfree_skb_irq(np->tx_skbuff[entry]);
1346                 np->tx_skbuff[entry] = NULL;
1347                 entry = (++np->dirty_tx) % TX_RING_SIZE;
1348         }
1349         if ((np->cur_tx - np->dirty_tx) < TX_QUEUE_LEN - 4)
1350                 netif_wake_queue (dev);
1351
1352         spin_unlock (&np->lock);
1353 }
1354
1355 /* This routine is logically part of the interrupt handler, but isolated
1356    for clarity and better register allocation. */
1357 static void via_rhine_rx(struct net_device *dev)
1358 {
1359         struct netdev_private *np = dev->priv;
1360         int entry = np->cur_rx % RX_RING_SIZE;
1361         int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
1362
1363         if (debug > 4) {
1364                 printk(KERN_DEBUG " In via_rhine_rx(), entry %d status %8.8x.\n",
1365                            entry, le32_to_cpu(np->rx_head_desc->rx_status));
1366         }
1367
1368         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1369         while ( ! (np->rx_head_desc->rx_status & cpu_to_le32(DescOwn))) {
1370                 struct rx_desc *desc = np->rx_head_desc;
1371                 u32 desc_status = le32_to_cpu(desc->rx_status);
1372                 int data_size = desc_status >> 16;
1373
1374                 if (debug > 4)
1375                         printk(KERN_DEBUG "  via_rhine_rx() status is %8.8x.\n",
1376                                    desc_status);
1377                 if (--boguscnt < 0)
1378                         break;
1379                 if ( (desc_status & (RxWholePkt | RxErr)) !=  RxWholePkt) {
1380                         if ((desc_status & RxWholePkt) !=  RxWholePkt) {
1381                                 printk(KERN_WARNING "%s: Oversized Ethernet frame spanned "
1382                                            "multiple buffers, entry %#x length %d status %8.8x!\n",
1383                                            dev->name, entry, data_size, desc_status);
1384                                 printk(KERN_WARNING "%s: Oversized Ethernet frame %p vs %p.\n",
1385                                            dev->name, np->rx_head_desc, &np->rx_ring[entry]);
1386                                 np->stats.rx_length_errors++;
1387                         } else if (desc_status & RxErr) {
1388                                 /* There was a error. */
1389                                 if (debug > 2)
1390                                         printk(KERN_DEBUG "  via_rhine_rx() Rx error was %8.8x.\n",
1391                                                    desc_status);
1392                                 np->stats.rx_errors++;
1393                                 if (desc_status & 0x0030) np->stats.rx_length_errors++;
1394                                 if (desc_status & 0x0048) np->stats.rx_fifo_errors++;
1395                                 if (desc_status & 0x0004) np->stats.rx_frame_errors++;
1396                                 if (desc_status & 0x0002) {
1397                                         /* this can also be updated outside the interrupt handler */
1398                                         spin_lock (&np->lock);
1399                                         np->stats.rx_crc_errors++;
1400                                         spin_unlock (&np->lock);
1401                                 }
1402                         }
1403                 } else {
1404                         struct sk_buff *skb;
1405                         /* Length should omit the CRC */
1406                         int pkt_len = data_size - 4;
1407
1408                         /* Check if the packet is long enough to accept without copying
1409                            to a minimally-sized skbuff. */
1410                         if (pkt_len < rx_copybreak &&
1411                                 (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1412                                 skb->dev = dev;
1413                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1414                                 pci_dma_sync_single(np->pdev, np->rx_skbuff_dma[entry],
1415                                                     np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1416
1417                                 /* *_IP_COPYSUM isn't defined anywhere and eth_copy_and_sum
1418                                    is memcpy for all archs so this is kind of pointless right
1419                                    now ... or? */
1420 #if HAS_IP_COPYSUM                     /* Call copy + cksum if available. */
1421                                 eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0);
1422                                 skb_put(skb, pkt_len);
1423 #else
1424                                 memcpy(skb_put(skb, pkt_len), np->rx_skbuff[entry]->tail,
1425                                            pkt_len);
1426 #endif
1427                         } else {
1428                                 skb = np->rx_skbuff[entry];
1429                                 if (skb == NULL) {
1430                                         printk(KERN_ERR "%s: Inconsistent Rx descriptor chain.\n",
1431                                                    dev->name);
1432                                         break;
1433                                 }
1434                                 np->rx_skbuff[entry] = NULL;
1435                                 skb_put(skb, pkt_len);
1436                                 pci_unmap_single(np->pdev, np->rx_skbuff_dma[entry],
1437                                                                  np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1438                         }
1439                         skb->protocol = eth_type_trans(skb, dev);
1440                         netif_rx(skb);
1441                         dev->last_rx = jiffies;
1442                         np->stats.rx_bytes += pkt_len;
1443                         np->stats.rx_packets++;
1444                 }
1445                 entry = (++np->cur_rx) % RX_RING_SIZE;
1446                 np->rx_head_desc = &np->rx_ring[entry];
1447         }
1448
1449         /* Refill the Rx ring buffers. */
1450         for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1451                 struct sk_buff *skb;
1452                 entry = np->dirty_rx % RX_RING_SIZE;
1453                 if (np->rx_skbuff[entry] == NULL) {
1454                         skb = dev_alloc_skb(np->rx_buf_sz);
1455                         np->rx_skbuff[entry] = skb;
1456                         if (skb == NULL)
1457                                 break;                  /* Better luck next round. */
1458                         skb->dev = dev;                 /* Mark as being used by this device. */
1459                         np->rx_skbuff_dma[entry] =
1460                                 pci_map_single(np->pdev, skb->tail, np->rx_buf_sz, 
1461                                                            PCI_DMA_FROMDEVICE);
1462                         np->rx_ring[entry].addr = cpu_to_le32(np->rx_skbuff_dma[entry]);
1463                 }
1464                 np->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
1465         }
1466
1467         /* Pre-emptively restart Rx engine. */
1468         writew(CmdRxDemand | np->chip_cmd, dev->base_addr + ChipCmd);
1469 }
1470
1471 static void via_rhine_error(struct net_device *dev, int intr_status)
1472 {
1473         struct netdev_private *np = dev->priv;
1474         long ioaddr = dev->base_addr;
1475
1476         spin_lock (&np->lock);
1477
1478         if (intr_status & (IntrMIIChange | IntrLinkChange)) {
1479                 if (readb(ioaddr + MIIStatus) & 0x02) {
1480                         /* Link failed, restart autonegotiation. */
1481                         if (np->drv_flags & HasDavicomPhy)
1482                                 mdio_write(dev, np->phys[0], MII_BMCR, 0x3300);
1483                 } else
1484                         via_rhine_check_duplex(dev);
1485                 if (debug)
1486                         printk(KERN_ERR "%s: MII status changed: Autonegotiation "
1487                                    "advertising %4.4x  partner %4.4x.\n", dev->name,
1488                            mdio_read(dev, np->phys[0], MII_ADVERTISE),
1489                            mdio_read(dev, np->phys[0], MII_LPA));
1490         }
1491         if (intr_status & IntrStatsMax) {
1492                 np->stats.rx_crc_errors += readw(ioaddr + RxCRCErrs);
1493                 np->stats.rx_missed_errors      += readw(ioaddr + RxMissed);
1494                 clear_tally_counters(ioaddr);
1495         }
1496         if (intr_status & IntrTxAbort) {
1497                 /* Stats counted in Tx-done handler, just restart Tx. */
1498                 writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd);
1499         }
1500         if (intr_status & IntrTxUnderrun) {
1501                 if (np->tx_thresh < 0xE0)
1502                         writeb(np->tx_thresh += 0x20, ioaddr + TxConfig);
1503                 if (debug > 1)
1504                         printk(KERN_INFO "%s: Transmitter underrun, increasing Tx "
1505                                    "threshold setting to %2.2x.\n", dev->name, np->tx_thresh);
1506         }
1507         if ((intr_status & ~( IntrLinkChange | IntrStatsMax |
1508                                                   IntrTxAbort | IntrTxAborted))) {
1509                 if (debug > 1)
1510                         printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1511                            dev->name, intr_status);
1512                 /* Recovery for other fault sources not known. */
1513                 writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd);
1514         }
1515
1516         spin_unlock (&np->lock);
1517 }
1518
1519 static struct net_device_stats *via_rhine_get_stats(struct net_device *dev)
1520 {
1521         struct netdev_private *np = dev->priv;
1522         long ioaddr = dev->base_addr;
1523         unsigned long flags;
1524
1525         spin_lock_irqsave(&np->lock, flags);
1526         np->stats.rx_crc_errors += readw(ioaddr + RxCRCErrs);
1527         np->stats.rx_missed_errors      += readw(ioaddr + RxMissed);
1528         clear_tally_counters(ioaddr);
1529         spin_unlock_irqrestore(&np->lock, flags);
1530
1531         return &np->stats;
1532 }
1533
1534 /* Clears the "tally counters" for CRC errors and missed frames(?).
1535    It has been reported that some chips need a write of 0 to clear
1536    these, for others the counters are set to 1 when written to and
1537    instead cleared when read. So we clear them both ways ... */
1538 static inline void clear_tally_counters(const long ioaddr)
1539 {
1540         writel(0, ioaddr + RxMissed);
1541         readw(ioaddr + RxCRCErrs);
1542         readw(ioaddr + RxMissed);
1543 }
1544
1545 static void via_rhine_set_rx_mode(struct net_device *dev)
1546 {
1547         struct netdev_private *np = dev->priv;
1548         long ioaddr = dev->base_addr;
1549         u32 mc_filter[2];                       /* Multicast hash filter */
1550         u8 rx_mode;                                     /* Note: 0x02=accept runt, 0x01=accept errs */
1551
1552         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1553                 /* Unconditionally log net taps. */
1554                 printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1555                 rx_mode = 0x1C;
1556         } else if ((dev->mc_count > multicast_filter_limit)
1557                            ||  (dev->flags & IFF_ALLMULTI)) {
1558                 /* Too many to match, or accept all multicasts. */
1559                 writel(0xffffffff, ioaddr + MulticastFilter0);
1560                 writel(0xffffffff, ioaddr + MulticastFilter1);
1561                 rx_mode = 0x0C;
1562         } else {
1563                 struct dev_mc_list *mclist;
1564                 int i;
1565                 memset(mc_filter, 0, sizeof(mc_filter));
1566                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1567                          i++, mclist = mclist->next) {
1568                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1569
1570                         mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1571                 }
1572                 writel(mc_filter[0], ioaddr + MulticastFilter0);
1573                 writel(mc_filter[1], ioaddr + MulticastFilter1);
1574                 rx_mode = 0x0C;
1575         }
1576         writeb(np->rx_thresh | rx_mode, ioaddr + RxConfig);
1577 }
1578
1579 static int via_rhine_ethtool_ioctl (struct net_device *dev, void *useraddr)
1580 {
1581         struct netdev_private *np = dev->priv;
1582         u32 ethcmd;
1583
1584         if (get_user(ethcmd, (u32 *)useraddr))
1585                 return -EFAULT;
1586
1587         switch (ethcmd) {
1588         case ETHTOOL_GDRVINFO: {
1589                 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
1590                 strcpy (info.driver, DRV_NAME);
1591                 strcpy (info.version, DRV_VERSION);
1592                 strcpy (info.bus_info, np->pdev->slot_name);
1593                 if (copy_to_user (useraddr, &info, sizeof (info)))
1594                         return -EFAULT;
1595                 return 0;
1596         }
1597
1598         /* get settings */
1599         case ETHTOOL_GSET: {
1600                 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
1601                 if (!(np->drv_flags & CanHaveMII))
1602                         break;
1603                 spin_lock_irq(&np->lock);
1604                 mii_ethtool_gset(&np->mii_if, &ecmd);
1605                 spin_unlock_irq(&np->lock);
1606                 if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1607                         return -EFAULT;
1608                 return 0;
1609         }
1610         /* set settings */
1611         case ETHTOOL_SSET: {
1612                 int r;
1613                 struct ethtool_cmd ecmd;
1614                 if (!(np->drv_flags & CanHaveMII))
1615                         break;
1616                 if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
1617                         return -EFAULT;
1618                 spin_lock_irq(&np->lock);
1619                 r = mii_ethtool_sset(&np->mii_if, &ecmd);
1620                 spin_unlock_irq(&np->lock);
1621                 return r;
1622         }
1623         /* restart autonegotiation */
1624         case ETHTOOL_NWAY_RST: {
1625                 if (!(np->drv_flags & CanHaveMII))
1626                         break;
1627                 return mii_nway_restart(&np->mii_if);
1628         }
1629         /* get link status */
1630         case ETHTOOL_GLINK: {
1631                 struct ethtool_value edata = {ETHTOOL_GLINK};
1632                 if (!(np->drv_flags & CanHaveMII))
1633                         break;
1634                 edata.data = mii_link_ok(&np->mii_if);
1635                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1636                         return -EFAULT;
1637                 return 0;
1638         }
1639
1640         /* get message-level */
1641         case ETHTOOL_GMSGLVL: {
1642                 struct ethtool_value edata = {ETHTOOL_GMSGLVL};
1643                 edata.data = debug;
1644                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1645                         return -EFAULT;
1646                 return 0;
1647         }
1648         /* set message-level */
1649         case ETHTOOL_SMSGLVL: {
1650                 struct ethtool_value edata;
1651                 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1652                         return -EFAULT;
1653                 debug = edata.data;
1654                 return 0;
1655         }
1656         default:
1657                 break;
1658         }
1659
1660         return -EOPNOTSUPP;
1661 }
1662 static int via_rhine_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1663 {
1664         struct netdev_private *np = dev->priv;
1665         struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
1666         unsigned long flags;
1667         int retval;
1668
1669         if (cmd == SIOCETHTOOL)
1670                 return via_rhine_ethtool_ioctl(dev, (void *) rq->ifr_data);
1671
1672         spin_lock_irqsave(&np->lock, flags);
1673         retval = 0;
1674
1675         switch(cmd) {
1676         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
1677                 data->phy_id = np->phys[0] & 0x1f;
1678                 /* Fall Through */
1679
1680         case SIOCGMIIREG:               /* Read MII PHY register. */
1681                 data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1682                 break;
1683
1684         case SIOCSMIIREG:               /* Write MII PHY register. */
1685                 if (!capable(CAP_NET_ADMIN)) {
1686                         retval = -EPERM;
1687                         break;
1688                 }
1689                 mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1690                 break;
1691         default:
1692                 retval = -EOPNOTSUPP;
1693         }
1694
1695         spin_unlock_irqrestore(&np->lock, flags);
1696         return retval;
1697 }
1698
1699 static int via_rhine_close(struct net_device *dev)
1700 {
1701         long ioaddr = dev->base_addr;
1702         struct netdev_private *np = dev->priv;
1703
1704         del_timer_sync(&np->timer);
1705
1706         spin_lock_irq(&np->lock);
1707
1708         netif_stop_queue(dev);
1709
1710         if (debug > 1)
1711                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was %4.4x.\n",
1712                            dev->name, readw(ioaddr + ChipCmd));
1713
1714         /* Switch to loopback mode to avoid hardware races. */
1715         writeb(np->tx_thresh | 0x02, ioaddr + TxConfig);
1716
1717         /* Disable interrupts by clearing the interrupt mask. */
1718         writew(0x0000, ioaddr + IntrEnable);
1719
1720         /* Stop the chip's Tx and Rx processes. */
1721         writew(CmdStop, ioaddr + ChipCmd);
1722
1723         spin_unlock_irq(&np->lock);
1724
1725         free_irq(np->pdev->irq, dev);
1726         free_rbufs(dev);
1727         free_tbufs(dev);
1728         free_ring(dev);
1729
1730         return 0;
1731 }
1732
1733
1734 static void __devexit via_rhine_remove_one (struct pci_dev *pdev)
1735 {
1736         struct net_device *dev = pci_get_drvdata(pdev);
1737         
1738         unregister_netdev(dev);
1739
1740         pci_release_regions(pdev);
1741
1742 #ifdef USE_MEM
1743         iounmap((char *)(dev->base_addr));
1744 #endif
1745
1746         kfree(dev);
1747         pci_disable_device(pdev);
1748         pci_set_drvdata(pdev, NULL);
1749 }
1750
1751
1752 static struct pci_driver via_rhine_driver = {
1753         name:           "via-rhine",
1754         id_table:       via_rhine_pci_tbl,
1755         probe:          via_rhine_init_one,
1756         remove:         __devexit_p(via_rhine_remove_one),
1757 };
1758
1759
1760 static int __init via_rhine_init (void)
1761 {
1762 /* when a module, this is printed whether or not devices are found in probe */
1763 #ifdef MODULE
1764         printk(version);
1765 #endif
1766         return pci_module_init (&via_rhine_driver);
1767 }
1768
1769
1770 static void __exit via_rhine_cleanup (void)
1771 {
1772         pci_unregister_driver (&via_rhine_driver);
1773 }
1774
1775
1776 module_init(via_rhine_init);
1777 module_exit(via_rhine_cleanup);
1778
1779
1780 /*
1781  * Local variables:
1782  *  compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -c via-rhine.c `[ -f /usr/include/linux/modversions.h ] && echo -DMODVERSIONS`"
1783  *  c-indent-level: 4
1784  *  c-basic-offset: 4
1785  *  tab-width: 4
1786  * End:
1787  */