1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
3 Written 1993-2000 by Donald Becker.
5 Copyright 1994-2000 by Donald Becker.
6 Copyright 1993 United States Government as represented by the
7 Director, National Security Agency. This software may be used and
8 distributed according to the terms of the GNU General Public License,
9 incorporated herein by reference.
11 This driver is for the 3Com EtherLinkIII series.
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
19 Because of the way 3c509 ISA detection works it's difficult to predict
20 a priori which of several ISA-mode cards will be detected first.
22 This driver does not use predictive interrupt mode, resulting in higher
23 packet latency but lower overhead. If interrupts are disabled for an
24 unusually long time it could also result in missed packets, but in
25 practice this rarely happens.
29 Alan Cox: Removed the 'Unexpected interrupt' bug.
30 Michael Meskes: Upgraded to Donald Becker's version 1.07.
31 Alan Cox: Increased the eeprom delay. Regardless of
32 what the docs say some people definitely
33 get problems with lower (but in card spec)
35 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
37 Andrea Arcangeli: Upgraded to Donald Becker's version 1.12.
38 Rick Payne: Fixed SMP race condition
39 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
40 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
41 v1.15 1/31/98 Faster recovery for Tx errors. -djb
42 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
43 v1.18 12Mar2001 Andrew Morton <andrewm@uow.edu.au>
44 - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
45 - Reviewed against 1.18 from scyld.com
46 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
48 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
49 - Power Management support
50 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
52 v1.19 16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
53 - Additional ethtool features
54 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
55 - Increase *read_eeprom udelay to workaround oops with 2 cards.
56 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
57 - Introduce driver model for EISA cards.
60 #define DRV_NAME "3c509"
61 #define DRV_VERSION "1.19b"
62 #define DRV_RELDATE "08Nov2002"
64 /* A few values that may be tweaked. */
66 /* Time in jiffies before concluding the transmitter is hung. */
67 #define TX_TIMEOUT (400*HZ/1000)
68 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
69 static int max_interrupt_work = 10;
71 #include <linux/module.h>
73 #include <linux/mca.h>
75 #include <linux/isapnp.h>
76 #include <linux/string.h>
77 #include <linux/interrupt.h>
78 #include <linux/errno.h>
80 #include <linux/slab.h>
81 #include <linux/ioport.h>
82 #include <linux/init.h>
83 #include <linux/netdevice.h>
84 #include <linux/etherdevice.h>
86 #include <linux/skbuff.h>
87 #include <linux/delay.h> /* for udelay() */
88 #include <linux/spinlock.h>
89 #include <linux/ethtool.h>
90 #include <linux/device.h>
91 #include <linux/eisa.h>
92 #include <linux/bitops.h>
94 #include <asm/uaccess.h>
98 static char version[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
100 #if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
105 static int el3_debug = EL3_DEBUG;
107 static int el3_debug = 2;
110 /* Used to do a global count of all the cards in the system. Must be
111 * a global variable so that the mca/eisa probe routines can increment
113 static int el3_cards = 0;
115 /* To minimize the size of the driver source I only define operating
116 constants if they are used several times. You'll need the manual
117 anyway if you want to understand driver details. */
118 /* Offsets from base I/O address. */
119 #define EL3_DATA 0x00
121 #define EL3_STATUS 0x0e
122 #define EEPROM_READ 0x80
124 #define EL3_IO_EXTENT 16
126 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
129 /* The top five bits written to EL3_CMD are a command, the lower
130 11 bits are the parameter, if applicable. */
132 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
133 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
134 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
135 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
136 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
137 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
138 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
139 PowerDown = 28<<11, PowerAuto = 29<<11};
142 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
143 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
144 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
146 /* The SetRxFilter command accepts the following classes: */
148 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
150 /* Register window 1 offsets, the window used in normal operation. */
153 #define RX_STATUS 0x08
154 #define TX_STATUS 0x0B
155 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
157 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
158 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
159 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
160 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
161 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
162 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
163 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
166 * Must be a power of two (we use a binary and in the
169 #define SKB_QUEUE_SIZE 64
172 struct net_device_stats stats;
173 struct net_device *next_dev;
177 struct sk_buff *queue[SKB_QUEUE_SIZE];
182 } type; /* type of device */
185 static int id_port __initdata = 0x110; /* Start with 0x110 to avoid new sound cards.*/
186 static struct net_device *el3_root_dev;
188 static ushort id_read_eeprom(int index);
189 static ushort read_eeprom(int ioaddr, int index);
190 static int el3_open(struct net_device *dev);
191 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
192 static irqreturn_t el3_interrupt(int irq, void *dev_id);
193 static void update_stats(struct net_device *dev);
194 static struct net_device_stats *el3_get_stats(struct net_device *dev);
195 static int el3_rx(struct net_device *dev);
196 static int el3_close(struct net_device *dev);
197 static void set_multicast_list(struct net_device *dev);
198 static void el3_tx_timeout (struct net_device *dev);
199 static void el3_down(struct net_device *dev);
200 static void el3_up(struct net_device *dev);
201 static const struct ethtool_ops ethtool_ops;
203 static int el3_suspend(struct device *, pm_message_t);
204 static int el3_resume(struct device *);
206 #define el3_suspend NULL
207 #define el3_resume NULL
211 /* generic device remove for all device types */
212 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
213 static int el3_device_remove (struct device *device);
215 #ifdef CONFIG_NET_POLL_CONTROLLER
216 static void el3_poll_controller(struct net_device *dev);
220 static struct eisa_device_id el3_eisa_ids[] = {
226 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
228 static int el3_eisa_probe (struct device *device);
230 static struct eisa_driver el3_eisa_driver = {
231 .id_table = el3_eisa_ids,
234 .probe = el3_eisa_probe,
235 .remove = __devexit_p (el3_device_remove),
236 .suspend = el3_suspend,
237 .resume = el3_resume,
243 static int el3_mca_probe(struct device *dev);
245 static short el3_mca_adapter_ids[] __initdata = {
254 static char *el3_mca_adapter_names[] __initdata = {
255 "3Com 3c529 EtherLink III (10base2)",
256 "3Com 3c529 EtherLink III (10baseT)",
257 "3Com 3c529 EtherLink III (test mode)",
258 "3Com 3c529 EtherLink III (TP or coax)",
259 "3Com 3c529 EtherLink III (TP)",
263 static struct mca_driver el3_mca_driver = {
264 .id_table = el3_mca_adapter_ids,
267 .bus = &mca_bus_type,
268 .probe = el3_mca_probe,
269 .remove = __devexit_p(el3_device_remove),
270 .suspend = el3_suspend,
271 .resume = el3_resume,
274 #endif /* CONFIG_MCA */
276 #if defined(__ISAPNP__)
277 static struct isapnp_device_id el3_isapnp_adapters[] __initdata = {
278 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
279 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090),
280 (long) "3Com Etherlink III (TP)" },
281 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
282 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091),
283 (long) "3Com Etherlink III" },
284 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
285 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094),
286 (long) "3Com Etherlink III (combo)" },
287 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
288 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095),
289 (long) "3Com Etherlink III (TPO)" },
290 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
291 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098),
292 (long) "3Com Etherlink III (TPC)" },
293 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
294 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f7),
295 (long) "3Com Etherlink III compatible" },
296 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
297 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8),
298 (long) "3Com Etherlink III compatible" },
299 { } /* terminate list */
302 static u16 el3_isapnp_phys_addr[8][3];
304 #endif /* __ISAPNP__ */
306 /* With the driver model introduction for EISA devices, both init
307 * and cleanup have been split :
308 * - EISA devices probe/remove starts in el3_eisa_probe/el3_device_remove
309 * - MCA/ISA still use el3_probe
311 * Both call el3_common_init/el3_common_remove. */
313 static int __init el3_common_init(struct net_device *dev)
315 struct el3_private *lp = netdev_priv(dev);
319 spin_lock_init(&lp->lock);
321 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
322 dev->if_port = (dev->mem_start & 0x0f);
323 } else { /* xcvr codes 0/8 */
324 /* use eeprom value, but save user's full-duplex selection */
325 dev->if_port |= (dev->mem_start & 0x08);
328 /* The EL3-specific entries in the device structure. */
329 dev->open = &el3_open;
330 dev->hard_start_xmit = &el3_start_xmit;
331 dev->stop = &el3_close;
332 dev->get_stats = &el3_get_stats;
333 dev->set_multicast_list = &set_multicast_list;
334 dev->tx_timeout = el3_tx_timeout;
335 dev->watchdog_timeo = TX_TIMEOUT;
336 #ifdef CONFIG_NET_POLL_CONTROLLER
337 dev->poll_controller = el3_poll_controller;
339 SET_ETHTOOL_OPS(dev, ðtool_ops);
341 err = register_netdev(dev);
343 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
344 dev->base_addr, dev->irq);
345 release_region(dev->base_addr, EL3_IO_EXTENT);
350 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
351 printk("%s: 3c5x9 found at %#3.3lx, %s port, address ",
352 dev->name, dev->base_addr,
353 if_names[(dev->if_port & 0x03)]);
356 /* Read in the station address. */
357 for (i = 0; i < 6; i++)
358 printk(" %2.2x", dev->dev_addr[i]);
359 printk(", IRQ %d.\n", dev->irq);
362 printk(KERN_INFO "%s", version);
367 static void el3_common_remove (struct net_device *dev)
369 struct el3_private *lp = netdev_priv(dev);
371 (void) lp; /* Keep gcc quiet... */
372 #if defined(__ISAPNP__)
373 if (lp->type == EL3_PNP)
374 pnp_device_detach(to_pnp_dev(lp->dev));
377 unregister_netdev (dev);
378 release_region(dev->base_addr, EL3_IO_EXTENT);
382 static int __init el3_probe(int card_idx)
384 struct net_device *dev;
385 struct el3_private *lp;
386 short lrs_state = 0xff, i;
387 int ioaddr, irq, if_port;
389 static int current_tag;
391 #if defined(__ISAPNP__)
392 static int pnp_cards;
393 struct pnp_dev *idev = NULL;
398 for (i=0; el3_isapnp_adapters[i].vendor != 0; i++) {
400 while ((idev = pnp_find_dev(NULL,
401 el3_isapnp_adapters[i].vendor,
402 el3_isapnp_adapters[i].function,
404 if (pnp_device_attach(idev) < 0)
406 if (pnp_activate_dev(idev) < 0) {
408 pnp_device_detach(idev);
411 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
413 ioaddr = pnp_port_start(idev, 0);
414 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509 PnP")) {
415 pnp_device_detach(idev);
418 irq = pnp_irq(idev, 0);
420 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
421 (char*) el3_isapnp_adapters[i].driver_data, ioaddr, irq);
423 for (j = 0; j < 3; j++)
424 el3_isapnp_phys_addr[pnp_cards][j] =
426 htons(read_eeprom(ioaddr, j));
427 if_port = read_eeprom(ioaddr, 8) >> 14;
428 dev = alloc_etherdev(sizeof (struct el3_private));
430 release_region(ioaddr, EL3_IO_EXTENT);
431 pnp_device_detach(idev);
435 SET_NETDEV_DEV(dev, &idev->dev);
438 netdev_boot_setup_check(dev);
443 #endif /* __ISAPNP__ */
445 /* Select an open I/O location at 0x1*0 to do contention select. */
446 for ( ; id_port < 0x200; id_port += 0x10) {
447 if (!request_region(id_port, 1, "3c509"))
451 if (inb(id_port) & 0x01){
452 release_region(id_port, 1);
455 release_region(id_port, 1);
457 if (id_port >= 0x200) {
458 /* Rare -- do we really need a warning? */
459 printk(" WARNING: No I/O port available for 3c509 activation.\n");
463 /* Next check for all ISA bus boards by sending the ID sequence to the
464 ID_PORT. We find cards past the first by setting the 'current_tag'
465 on cards as they are found. Cards with their tag set will not
466 respond to subsequent ID sequences. */
470 for(i = 0; i < 255; i++) {
471 outb(lrs_state, id_port);
473 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
476 /* For the first probe, clear all board's tag registers. */
477 if (current_tag == 0)
479 else /* Otherwise kill off already-found boards. */
482 if (id_read_eeprom(7) != 0x6d50) {
486 /* Read in EEPROM data, which does contention-select.
487 Only the lowest address board will stay "on-line".
488 3Com got the byte order backwards. */
489 for (i = 0; i < 3; i++) {
490 phys_addr[i] = htons(id_read_eeprom(i));
493 #if defined(__ISAPNP__)
495 /* The ISA PnP 3c509 cards respond to the ID sequence.
496 This check is needed in order not to register them twice. */
497 for (i = 0; i < pnp_cards; i++) {
498 if (phys_addr[0] == el3_isapnp_phys_addr[i][0] &&
499 phys_addr[1] == el3_isapnp_phys_addr[i][1] &&
500 phys_addr[2] == el3_isapnp_phys_addr[i][2])
503 printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
504 phys_addr[0] & 0xff, phys_addr[0] >> 8,
505 phys_addr[1] & 0xff, phys_addr[1] >> 8,
506 phys_addr[2] & 0xff, phys_addr[2] >> 8);
507 /* Set the adaptor tag so that the next card can be found. */
508 outb(0xd0 + ++current_tag, id_port);
513 #endif /* __ISAPNP__ */
516 unsigned int iobase = id_read_eeprom(8);
517 if_port = iobase >> 14;
518 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
520 irq = id_read_eeprom(9) >> 12;
522 dev = alloc_etherdev(sizeof (struct el3_private));
526 netdev_boot_setup_check(dev);
528 /* Set passed-in IRQ or I/O Addr. */
529 if (dev->irq > 1 && dev->irq < 16)
532 if (dev->base_addr) {
533 if (dev->mem_end == 0x3c509 /* Magic key */
534 && dev->base_addr >= 0x200 && dev->base_addr <= 0x3e0)
535 ioaddr = dev->base_addr & 0x3f0;
536 else if (dev->base_addr != ioaddr)
540 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509")) {
545 /* Set the adaptor tag so that the next card can be found. */
546 outb(0xd0 + ++current_tag, id_port);
548 /* Activate the adaptor at the EEPROM location. */
549 outb((ioaddr >> 4) | 0xe0, id_port);
552 if (inw(ioaddr) != 0x6d50)
555 /* Free the interrupt so that some other card can use it. */
556 outw(0x0f00, ioaddr + WN0_IRQ);
558 #if defined(__ISAPNP__)
559 found: /* PNP jumps here... */
560 #endif /* __ISAPNP__ */
562 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
563 dev->base_addr = ioaddr;
565 dev->if_port = if_port;
566 lp = netdev_priv(dev);
567 #if defined(__ISAPNP__)
568 lp->dev = &idev->dev;
570 err = el3_common_init(dev);
576 lp->next_dev = el3_root_dev;
581 #if defined(__ISAPNP__)
583 pnp_device_detach(idev);
591 static int __init el3_mca_probe(struct device *device)
593 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
594 * heavily modified by Chris Beauregard
595 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
598 * redone for multi-card detection by ZP Gu (zpg@castle.net)
599 * now works as a module */
601 struct el3_private *lp;
603 int ioaddr, irq, if_port;
605 struct net_device *dev = NULL;
607 struct mca_device *mdev = to_mca_device(device);
608 int slot = mdev->slot;
611 pos4 = mca_device_read_stored_pos(mdev, 4);
612 pos5 = mca_device_read_stored_pos(mdev, 5);
614 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
618 printk("3c529: found %s at slot %d\n",
619 el3_mca_adapter_names[mdev->index], slot + 1);
622 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
624 mca_device_set_claim(mdev, 1);
626 if_port = pos4 & 0x03;
628 irq = mca_device_transform_irq(mdev, irq);
629 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
631 printk("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
634 for (i = 0; i < 3; i++) {
635 phys_addr[i] = htons(read_eeprom(ioaddr, i));
638 dev = alloc_etherdev(sizeof (struct el3_private));
640 release_region(ioaddr, EL3_IO_EXTENT);
644 netdev_boot_setup_check(dev);
646 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
647 dev->base_addr = ioaddr;
649 dev->if_port = if_port;
650 lp = netdev_priv(dev);
653 device->driver_data = dev;
654 err = el3_common_init(dev);
657 device->driver_data = NULL;
666 #endif /* CONFIG_MCA */
669 static int __init el3_eisa_probe (struct device *device)
671 struct el3_private *lp;
673 int ioaddr, irq, if_port;
675 struct net_device *dev = NULL;
676 struct eisa_device *edev;
679 /* Yeepee, The driver framework is calling us ! */
680 edev = to_eisa_device (device);
681 ioaddr = edev->base_addr;
683 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509"))
686 /* Change the register set to the configuration window 0. */
687 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
689 irq = inw(ioaddr + WN0_IRQ) >> 12;
690 if_port = inw(ioaddr + 6)>>14;
691 for (i = 0; i < 3; i++)
692 phys_addr[i] = htons(read_eeprom(ioaddr, i));
694 /* Restore the "Product ID" to the EEPROM read register. */
695 read_eeprom(ioaddr, 3);
697 dev = alloc_etherdev(sizeof (struct el3_private));
699 release_region(ioaddr, EL3_IO_EXTENT);
703 netdev_boot_setup_check(dev);
705 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
706 dev->base_addr = ioaddr;
708 dev->if_port = if_port;
709 lp = netdev_priv(dev);
712 eisa_set_drvdata (edev, dev);
713 err = el3_common_init(dev);
716 eisa_set_drvdata (edev, NULL);
726 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
727 /* This remove works for all device types.
729 * The net dev must be stored in the driver_data field */
730 static int __devexit el3_device_remove (struct device *device)
732 struct net_device *dev;
734 dev = device->driver_data;
736 el3_common_remove (dev);
741 /* Read a word from the EEPROM using the regular EEPROM access register.
742 Assume that we are in register window zero.
744 static ushort read_eeprom(int ioaddr, int index)
746 outw(EEPROM_READ + index, ioaddr + 10);
747 /* Pause for at least 162 us. for the read to take place.
748 Some chips seem to require much longer */
750 return inw(ioaddr + 12);
753 /* Read a word from the EEPROM when in the ISA ID probe state. */
754 static ushort __init id_read_eeprom(int index)
758 /* Issue read command, and pause for at least 162 us. for it to complete.
759 Assume extra-fast 16Mhz bus. */
760 outb(EEPROM_READ + index, id_port);
762 /* Pause for at least 162 us. for the read to take place. */
763 /* Some chips seem to require much longer */
766 for (bit = 15; bit >= 0; bit--)
767 word = (word << 1) + (inb(id_port) & 0x01);
770 printk(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
777 el3_open(struct net_device *dev)
779 int ioaddr = dev->base_addr;
782 outw(TxReset, ioaddr + EL3_CMD);
783 outw(RxReset, ioaddr + EL3_CMD);
784 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
786 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
792 printk("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
793 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
798 printk("%s: Opened 3c509 IRQ %d status %4.4x.\n",
799 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
805 el3_tx_timeout (struct net_device *dev)
807 struct el3_private *lp = netdev_priv(dev);
808 int ioaddr = dev->base_addr;
810 /* Transmitter timeout, serious problems. */
811 printk("%s: transmit timed out, Tx_status %2.2x status %4.4x "
812 "Tx FIFO room %d.\n",
813 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
814 inw(ioaddr + TX_FREE));
815 lp->stats.tx_errors++;
816 dev->trans_start = jiffies;
817 /* Issue TX_RESET and TX_START commands. */
818 outw(TxReset, ioaddr + EL3_CMD);
819 outw(TxEnable, ioaddr + EL3_CMD);
820 netif_wake_queue(dev);
825 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
827 struct el3_private *lp = netdev_priv(dev);
828 int ioaddr = dev->base_addr;
831 netif_stop_queue (dev);
833 lp->stats.tx_bytes += skb->len;
836 printk("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
837 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
840 #ifndef final_version
841 { /* Error-checking code, delete someday. */
842 ushort status = inw(ioaddr + EL3_STATUS);
843 if (status & 0x0001 /* IRQ line active, missed one. */
844 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
845 printk("%s: Missed interrupt, status then %04x now %04x"
846 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
847 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
848 inw(ioaddr + RX_STATUS));
849 /* Fake interrupt trigger by masking, acknowledge interrupts. */
850 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
851 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
853 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
859 * We lock the driver against other processors. Note
860 * we don't need to lock versus the IRQ as we suspended
861 * that. This means that we lose the ability to take
862 * an RX during a TX upload. That sucks a bit with SMP
863 * on an original 3c509 (2K buffer)
865 * Using disable_irq stops us crapping on other
866 * time sensitive devices.
869 spin_lock_irqsave(&lp->lock, flags);
871 /* Put out the doubleword header... */
872 outw(skb->len, ioaddr + TX_FIFO);
873 outw(0x00, ioaddr + TX_FIFO);
874 /* ... and the packet rounded to a doubleword. */
875 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
877 dev->trans_start = jiffies;
878 if (inw(ioaddr + TX_FREE) > 1536)
879 netif_start_queue(dev);
881 /* Interrupt us when the FIFO has room for max-sized packet. */
882 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
884 spin_unlock_irqrestore(&lp->lock, flags);
888 /* Clear the Tx status stack. */
893 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
894 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
895 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
896 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
897 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
903 /* The EL3 interrupt handler. */
905 el3_interrupt(int irq, void *dev_id)
907 struct net_device *dev = dev_id;
908 struct el3_private *lp;
910 int i = max_interrupt_work;
912 lp = netdev_priv(dev);
913 spin_lock(&lp->lock);
915 ioaddr = dev->base_addr;
918 status = inw(ioaddr + EL3_STATUS);
919 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
922 while ((status = inw(ioaddr + EL3_STATUS)) &
923 (IntLatch | RxComplete | StatsFull)) {
925 if (status & RxComplete)
928 if (status & TxAvailable) {
930 printk(" TX room bit was handled.\n");
931 /* There's room in the FIFO for a full-sized packet. */
932 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
933 netif_wake_queue (dev);
935 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
936 /* Handle all uncommon interrupts. */
937 if (status & StatsFull) /* Empty statistics. */
939 if (status & RxEarly) { /* Rx early is unused. */
941 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
943 if (status & TxComplete) { /* Really Tx error. */
944 struct el3_private *lp = netdev_priv(dev);
948 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
949 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
950 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
951 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
952 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
955 if (status & AdapterFailure) {
956 /* Adapter failure requires Rx reset and reinit. */
957 outw(RxReset, ioaddr + EL3_CMD);
958 /* Set the Rx filter to the current state. */
959 outw(SetRxFilter | RxStation | RxBroadcast
960 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
961 | (dev->flags & IFF_PROMISC ? RxProm : 0),
963 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
964 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
969 printk("%s: Infinite loop in interrupt, status %4.4x.\n",
971 /* Clear all interrupts. */
972 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
975 /* Acknowledge the IRQ. */
976 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
980 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
981 inw(ioaddr + EL3_STATUS));
983 spin_unlock(&lp->lock);
988 #ifdef CONFIG_NET_POLL_CONTROLLER
990 * Polling receive - used by netconsole and other diagnostic tools
991 * to allow network i/o with interrupts disabled.
993 static void el3_poll_controller(struct net_device *dev)
995 disable_irq(dev->irq);
996 el3_interrupt(dev->irq, dev);
997 enable_irq(dev->irq);
1001 static struct net_device_stats *
1002 el3_get_stats(struct net_device *dev)
1004 struct el3_private *lp = netdev_priv(dev);
1005 unsigned long flags;
1008 * This is fast enough not to bother with disable IRQ
1012 spin_lock_irqsave(&lp->lock, flags);
1014 spin_unlock_irqrestore(&lp->lock, flags);
1018 /* Update statistics. We change to register window 6, so this should be run
1019 single-threaded if the device is active. This is expected to be a rare
1020 operation, and it's simpler for the rest of the driver to assume that
1021 window 1 is always valid rather than use a special window-state variable.
1023 static void update_stats(struct net_device *dev)
1025 struct el3_private *lp = netdev_priv(dev);
1026 int ioaddr = dev->base_addr;
1029 printk(" Updating the statistics.\n");
1030 /* Turn off statistics updates while reading. */
1031 outw(StatsDisable, ioaddr + EL3_CMD);
1032 /* Switch to the stats window, and read everything. */
1034 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1035 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1036 /* Multiple collisions. */ inb(ioaddr + 2);
1037 lp->stats.collisions += inb(ioaddr + 3);
1038 lp->stats.tx_window_errors += inb(ioaddr + 4);
1039 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1040 lp->stats.tx_packets += inb(ioaddr + 6);
1041 /* Rx packets */ inb(ioaddr + 7);
1042 /* Tx deferrals */ inb(ioaddr + 8);
1043 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1046 /* Back to window 1, and turn statistics back on. */
1048 outw(StatsEnable, ioaddr + EL3_CMD);
1053 el3_rx(struct net_device *dev)
1055 struct el3_private *lp = netdev_priv(dev);
1056 int ioaddr = dev->base_addr;
1060 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1061 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1062 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1063 if (rx_status & 0x4000) { /* Error, update stats. */
1064 short error = rx_status & 0x3800;
1066 outw(RxDiscard, ioaddr + EL3_CMD);
1067 lp->stats.rx_errors++;
1069 case 0x0000: lp->stats.rx_over_errors++; break;
1070 case 0x0800: lp->stats.rx_length_errors++; break;
1071 case 0x1000: lp->stats.rx_frame_errors++; break;
1072 case 0x1800: lp->stats.rx_length_errors++; break;
1073 case 0x2000: lp->stats.rx_frame_errors++; break;
1074 case 0x2800: lp->stats.rx_crc_errors++; break;
1077 short pkt_len = rx_status & 0x7ff;
1078 struct sk_buff *skb;
1080 skb = dev_alloc_skb(pkt_len+5);
1081 lp->stats.rx_bytes += pkt_len;
1083 printk("Receiving packet size %d status %4.4x.\n",
1084 pkt_len, rx_status);
1086 skb_reserve(skb, 2); /* Align IP on 16 byte */
1088 /* 'skb->data' points to the start of sk_buff data area. */
1089 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1090 (pkt_len + 3) >> 2);
1092 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1093 skb->protocol = eth_type_trans(skb,dev);
1095 dev->last_rx = jiffies;
1096 lp->stats.rx_packets++;
1099 outw(RxDiscard, ioaddr + EL3_CMD);
1100 lp->stats.rx_dropped++;
1102 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1103 dev->name, pkt_len);
1105 inw(ioaddr + EL3_STATUS); /* Delay. */
1106 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1107 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1108 inw(ioaddr + EL3_STATUS) );
1115 * Set or clear the multicast filter for this adaptor.
1118 set_multicast_list(struct net_device *dev)
1120 unsigned long flags;
1121 struct el3_private *lp = netdev_priv(dev);
1122 int ioaddr = dev->base_addr;
1124 if (el3_debug > 1) {
1126 if (old != dev->mc_count) {
1127 old = dev->mc_count;
1128 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1131 spin_lock_irqsave(&lp->lock, flags);
1132 if (dev->flags&IFF_PROMISC) {
1133 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1136 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1137 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1140 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1141 spin_unlock_irqrestore(&lp->lock, flags);
1145 el3_close(struct net_device *dev)
1147 int ioaddr = dev->base_addr;
1148 struct el3_private *lp = netdev_priv(dev);
1151 printk("%s: Shutting down ethercard.\n", dev->name);
1155 free_irq(dev->irq, dev);
1156 /* Switching back to window 0 disables the IRQ. */
1158 if (lp->type != EL3_EISA) {
1159 /* But we explicitly zero the IRQ line select anyway. Don't do
1160 * it on EISA cards, it prevents the module from getting an
1161 * IRQ after unload+reload... */
1162 outw(0x0f00, ioaddr + WN0_IRQ);
1169 el3_link_ok(struct net_device *dev)
1171 int ioaddr = dev->base_addr;
1175 tmp = inw(ioaddr + WN4_MEDIA);
1177 return tmp & (1<<11);
1181 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1184 int ioaddr = dev->base_addr;
1187 /* obtain current transceiver via WN4_MEDIA? */
1188 tmp = inw(ioaddr + WN0_ADDR_CONF);
1189 ecmd->transceiver = XCVR_INTERNAL;
1190 switch (tmp >> 14) {
1192 ecmd->port = PORT_TP;
1195 ecmd->port = PORT_AUI;
1196 ecmd->transceiver = XCVR_EXTERNAL;
1199 ecmd->port = PORT_BNC;
1204 ecmd->duplex = DUPLEX_HALF;
1205 ecmd->supported = 0;
1206 tmp = inw(ioaddr + WN0_CONF_CTRL);
1208 ecmd->supported |= SUPPORTED_AUI;
1210 ecmd->supported |= SUPPORTED_BNC;
1212 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1213 SUPPORTED_10baseT_Full; /* hmm... */
1215 tmp = inw(ioaddr + WN4_NETDIAG);
1216 if (tmp & FD_ENABLE)
1217 ecmd->duplex = DUPLEX_FULL;
1220 ecmd->speed = SPEED_10;
1226 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1229 int ioaddr = dev->base_addr;
1231 if (ecmd->speed != SPEED_10)
1233 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1235 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1238 /* change XCVR type */
1240 tmp = inw(ioaddr + WN0_ADDR_CONF);
1241 switch (ecmd->port) {
1258 outw(tmp, ioaddr + WN0_ADDR_CONF);
1259 if (dev->if_port == 3) {
1260 /* fire up the DC-DC convertor if BNC gets enabled */
1261 tmp = inw(ioaddr + WN0_ADDR_CONF);
1262 if (tmp & (3 << 14)) {
1263 outw(StartCoax, ioaddr + EL3_CMD);
1270 tmp = inw(ioaddr + WN4_NETDIAG);
1271 if (ecmd->duplex == DUPLEX_FULL)
1275 outw(tmp, ioaddr + WN4_NETDIAG);
1281 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1283 strcpy(info->driver, DRV_NAME);
1284 strcpy(info->version, DRV_VERSION);
1287 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1289 struct el3_private *lp = netdev_priv(dev);
1292 spin_lock_irq(&lp->lock);
1293 ret = el3_netdev_get_ecmd(dev, ecmd);
1294 spin_unlock_irq(&lp->lock);
1298 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1300 struct el3_private *lp = netdev_priv(dev);
1303 spin_lock_irq(&lp->lock);
1304 ret = el3_netdev_set_ecmd(dev, ecmd);
1305 spin_unlock_irq(&lp->lock);
1309 static u32 el3_get_link(struct net_device *dev)
1311 struct el3_private *lp = netdev_priv(dev);
1314 spin_lock_irq(&lp->lock);
1315 ret = el3_link_ok(dev);
1316 spin_unlock_irq(&lp->lock);
1320 static u32 el3_get_msglevel(struct net_device *dev)
1325 static void el3_set_msglevel(struct net_device *dev, u32 v)
1330 static const struct ethtool_ops ethtool_ops = {
1331 .get_drvinfo = el3_get_drvinfo,
1332 .get_settings = el3_get_settings,
1333 .set_settings = el3_set_settings,
1334 .get_link = el3_get_link,
1335 .get_msglevel = el3_get_msglevel,
1336 .set_msglevel = el3_set_msglevel,
1340 el3_down(struct net_device *dev)
1342 int ioaddr = dev->base_addr;
1344 netif_stop_queue(dev);
1346 /* Turn off statistics ASAP. We update lp->stats below. */
1347 outw(StatsDisable, ioaddr + EL3_CMD);
1349 /* Disable the receiver and transmitter. */
1350 outw(RxDisable, ioaddr + EL3_CMD);
1351 outw(TxDisable, ioaddr + EL3_CMD);
1353 if (dev->if_port == 3)
1354 /* Turn off thinnet power. Green! */
1355 outw(StopCoax, ioaddr + EL3_CMD);
1356 else if (dev->if_port == 0) {
1357 /* Disable link beat and jabber, if_port may change here next open(). */
1359 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1362 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1368 el3_up(struct net_device *dev)
1370 int i, sw_info, net_diag;
1371 int ioaddr = dev->base_addr;
1373 /* Activating the board required and does no harm otherwise */
1374 outw(0x0001, ioaddr + 4);
1376 /* Set the IRQ line. */
1377 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1379 /* Set the station address in window 2 each time opened. */
1382 for (i = 0; i < 6; i++)
1383 outb(dev->dev_addr[i], ioaddr + i);
1385 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1386 /* Start the thinnet transceiver. We should really wait 50ms...*/
1387 outw(StartCoax, ioaddr + EL3_CMD);
1388 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1389 /* Combine secondary sw_info word (the adapter level) and primary
1390 sw_info word (duplex setting plus other useless bits) */
1392 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1393 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1396 net_diag = inw(ioaddr + WN4_NETDIAG);
1397 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1398 printk("%s: ", dev->name);
1399 switch (dev->if_port & 0x0c) {
1401 /* force full-duplex mode if 3c5x9b */
1402 if (sw_info & 0x000f) {
1403 printk("Forcing 3c5x9b full-duplex mode");
1407 /* set full-duplex mode based on eeprom config setting */
1408 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1409 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1413 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1414 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1415 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1418 outw(net_diag, ioaddr + WN4_NETDIAG);
1419 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1421 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1422 /* Enable link beat and jabber check. */
1423 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1426 /* Switch to the stats window, and clear all stats by reading. */
1427 outw(StatsDisable, ioaddr + EL3_CMD);
1429 for (i = 0; i < 9; i++)
1434 /* Switch to register set 1 for normal use. */
1437 /* Accept b-case and phys addr only. */
1438 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1439 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1441 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1442 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1443 /* Allow status bits to be seen. */
1444 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1445 /* Ack all pending events, and set active indicator mask. */
1446 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1448 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1451 netif_start_queue(dev);
1454 /* Power Management support functions */
1458 el3_suspend(struct device *pdev, pm_message_t state)
1460 unsigned long flags;
1461 struct net_device *dev;
1462 struct el3_private *lp;
1465 dev = pdev->driver_data;
1466 lp = netdev_priv(dev);
1467 ioaddr = dev->base_addr;
1469 spin_lock_irqsave(&lp->lock, flags);
1471 if (netif_running(dev))
1472 netif_device_detach(dev);
1475 outw(PowerDown, ioaddr + EL3_CMD);
1477 spin_unlock_irqrestore(&lp->lock, flags);
1482 el3_resume(struct device *pdev)
1484 unsigned long flags;
1485 struct net_device *dev;
1486 struct el3_private *lp;
1489 dev = pdev->driver_data;
1490 lp = netdev_priv(dev);
1491 ioaddr = dev->base_addr;
1493 spin_lock_irqsave(&lp->lock, flags);
1495 outw(PowerUp, ioaddr + EL3_CMD);
1498 if (netif_running(dev))
1499 netif_device_attach(dev);
1501 spin_unlock_irqrestore(&lp->lock, flags);
1505 #endif /* EL3_SUSPEND */
1507 /* Parameters that may be passed into the module. */
1508 static int debug = -1;
1509 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1510 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1512 module_param(debug,int, 0);
1513 module_param_array(irq, int, NULL, 0);
1514 module_param_array(xcvr, int, NULL, 0);
1515 module_param(max_interrupt_work, int, 0);
1516 MODULE_PARM_DESC(debug, "debug level (0-6)");
1517 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1518 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1519 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1520 #if defined(__ISAPNP__)
1521 module_param(nopnp, int, 0);
1522 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1523 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1524 #endif /* __ISAPNP__ */
1525 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1526 MODULE_LICENSE("GPL");
1528 static int __init el3_init_module(void)
1536 el3_root_dev = NULL;
1537 while (el3_probe(el3_cards) == 0) {
1538 if (irq[el3_cards] > 1)
1539 el3_root_dev->irq = irq[el3_cards];
1540 if (xcvr[el3_cards] >= 0)
1541 el3_root_dev->if_port = xcvr[el3_cards];
1546 ret = eisa_driver_register(&el3_eisa_driver);
1550 int err = mca_register_driver(&el3_mca_driver);
1558 static void __exit el3_cleanup_module(void)
1560 struct net_device *next_dev;
1562 while (el3_root_dev) {
1563 struct el3_private *lp = netdev_priv(el3_root_dev);
1565 next_dev = lp->next_dev;
1566 el3_common_remove (el3_root_dev);
1567 el3_root_dev = next_dev;
1571 eisa_driver_unregister (&el3_eisa_driver);
1574 mca_unregister_driver(&el3_mca_driver);
1578 module_init (el3_init_module);
1579 module_exit (el3_cleanup_module);