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.
61 Shu Iwanaga: 3c569B(PC-9801 C-bus) support
64 #define DRV_NAME "3c509"
65 #define DRV_VERSION "1.19b"
66 #define DRV_RELDATE "08Nov2002"
68 /* A few values that may be tweaked. */
70 /* Time in jiffies before concluding the transmitter is hung. */
71 #define TX_TIMEOUT (400*HZ/1000)
72 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
73 static int max_interrupt_work = 10;
75 #include <linux/config.h>
76 #include <linux/module.h>
78 #include <linux/mca.h>
80 #include <linux/isapnp.h>
81 #include <linux/string.h>
82 #include <linux/interrupt.h>
83 #include <linux/errno.h>
85 #include <linux/slab.h>
86 #include <linux/ioport.h>
87 #include <linux/init.h>
88 #include <linux/netdevice.h>
89 #include <linux/etherdevice.h>
91 #include <linux/skbuff.h>
92 #include <linux/delay.h> /* for udelay() */
93 #include <linux/spinlock.h>
94 #include <linux/ethtool.h>
95 #include <linux/device.h>
96 #include <linux/eisa.h>
98 #include <asm/uaccess.h>
99 #include <asm/bitops.h>
103 static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
104 static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
107 static int el3_debug = EL3_DEBUG;
109 static int el3_debug = 2;
112 /* Used to do a global count of all the cards in the system. Must be
113 * a global variable so that the mca/eisa probe routines can increment
115 static int el3_cards = 0;
117 /* To minimize the size of the driver source I only define operating
118 constants if they are used several times. You'll need the manual
119 anyway if you want to understand driver details. */
120 /* Offsets from base I/O address. */
121 #define EL3_DATA 0x00
123 #define EL3_STATUS 0x0e
124 #define EEPROM_READ 0x80
126 #define EL3_IO_EXTENT 16
128 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
131 /* The top five bits written to EL3_CMD are a command, the lower
132 11 bits are the parameter, if applicable. */
134 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
135 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
136 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
137 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
138 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
139 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
140 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
141 PowerDown = 28<<11, PowerAuto = 29<<11};
144 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
145 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
146 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
148 /* The SetRxFilter command accepts the following classes: */
150 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
152 /* Register window 1 offsets, the window used in normal operation. */
155 #define RX_STATUS 0x08
156 #define TX_STATUS 0x0B
157 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
159 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
160 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
161 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
162 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
163 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
164 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
165 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
168 * Must be a power of two (we use a binary and in the
171 #define SKB_QUEUE_SIZE 64
174 struct net_device_stats stats;
175 struct net_device *next_dev;
179 struct sk_buff *queue[SKB_QUEUE_SIZE];
181 struct pm_dev *pmdev;
187 } type; /* type of device */
190 static int id_port __initdata = 0x110; /* Start with 0x110 to avoid new sound cards.*/
191 static struct net_device *el3_root_dev;
193 static ushort id_read_eeprom(int index);
194 static ushort read_eeprom(int ioaddr, int index);
195 static int el3_open(struct net_device *dev);
196 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
197 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
198 static void update_stats(struct net_device *dev);
199 static struct net_device_stats *el3_get_stats(struct net_device *dev);
200 static int el3_rx(struct net_device *dev);
201 static int el3_close(struct net_device *dev);
202 static void set_multicast_list(struct net_device *dev);
203 static void el3_tx_timeout (struct net_device *dev);
204 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
205 static void el3_down(struct net_device *dev);
206 static void el3_up(struct net_device *dev);
208 static int el3_suspend(struct pm_dev *pdev);
209 static int el3_resume(struct pm_dev *pdev);
210 static int el3_pm_callback(struct pm_dev *pdev, pm_request_t rqst, void *data);
212 /* generic device remove for all device types */
213 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
214 static int el3_device_remove (struct device *device);
218 struct eisa_device_id el3_eisa_ids[] = {
224 static int el3_eisa_probe (struct device *device);
226 struct eisa_driver el3_eisa_driver = {
227 .id_table = el3_eisa_ids,
230 .probe = el3_eisa_probe,
231 .remove = __devexit_p (el3_device_remove)
237 static int el3_mca_probe(struct device *dev);
239 static short el3_mca_adapter_ids[] __initdata = {
248 static char *el3_mca_adapter_names[] __initdata = {
249 "3Com 3c529 EtherLink III (10base2)",
250 "3Com 3c529 EtherLink III (10baseT)",
251 "3Com 3c529 EtherLink III (test mode)",
252 "3Com 3c529 EtherLink III (TP or coax)",
253 "3Com 3c529 EtherLink III (TP)",
257 static struct mca_driver el3_mca_driver = {
258 .id_table = el3_mca_adapter_ids,
261 .bus = &mca_bus_type,
262 .probe = el3_mca_probe,
263 .remove = __devexit_p(el3_device_remove),
266 #endif /* CONFIG_MCA */
268 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
269 static struct isapnp_device_id el3_isapnp_adapters[] __initdata = {
270 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
271 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090),
272 (long) "3Com Etherlink III (TP)" },
273 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
274 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091),
275 (long) "3Com Etherlink III" },
276 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
277 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094),
278 (long) "3Com Etherlink III (combo)" },
279 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
280 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095),
281 (long) "3Com Etherlink III (TPO)" },
282 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
283 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098),
284 (long) "3Com Etherlink III (TPC)" },
285 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
286 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f7),
287 (long) "3Com Etherlink III compatible" },
288 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
289 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8),
290 (long) "3Com Etherlink III compatible" },
291 { } /* terminate list */
294 static u16 el3_isapnp_phys_addr[8][3];
296 #endif /* __ISAPNP__ */
298 /* With the driver model introduction for EISA devices, both init
299 * and cleanup have been split :
300 * - EISA devices probe/remove starts in el3_eisa_probe/el3_device_remove
301 * - MCA/ISA still use el3_probe
303 * Both call el3_common_init/el3_common_remove. */
305 static int __init el3_common_init(struct net_device *dev)
307 struct el3_private *lp = netdev_priv(dev);
311 spin_lock_init(&lp->lock);
313 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
314 dev->if_port = (dev->mem_start & 0x0f);
315 } else { /* xcvr codes 0/8 */
316 /* use eeprom value, but save user's full-duplex selection */
317 dev->if_port |= (dev->mem_start & 0x08);
320 /* The EL3-specific entries in the device structure. */
321 dev->open = &el3_open;
322 dev->hard_start_xmit = &el3_start_xmit;
323 dev->stop = &el3_close;
324 dev->get_stats = &el3_get_stats;
325 dev->set_multicast_list = &set_multicast_list;
326 dev->tx_timeout = el3_tx_timeout;
327 dev->watchdog_timeo = TX_TIMEOUT;
328 dev->do_ioctl = netdev_ioctl;
330 err = register_netdev(dev);
332 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
333 dev->base_addr, dev->irq);
334 release_region(dev->base_addr, EL3_IO_EXTENT);
339 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
340 printk("%s: 3c5x9 found at %#3.3lx, %s port, address ",
341 dev->name, dev->base_addr,
342 if_names[(dev->if_port & 0x03)]);
345 /* Read in the station address. */
346 for (i = 0; i < 6; i++)
347 printk(" %2.2x", dev->dev_addr[i]);
348 printk(", IRQ %d.\n", dev->irq);
351 printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
356 static void el3_common_remove (struct net_device *dev)
358 struct el3_private *lp = netdev_priv(dev);
360 (void) lp; /* Keep gcc quiet... */
363 pm_unregister(lp->pmdev);
365 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
366 if (lp->type == EL3_PNP)
367 pnp_device_detach(to_pnp_dev(lp->dev));
370 unregister_netdev (dev);
371 release_region(dev->base_addr, EL3_IO_EXTENT);
375 static int __init el3_probe(int card_idx)
377 struct net_device *dev;
378 struct el3_private *lp;
379 short lrs_state = 0xff, i;
380 int ioaddr, irq, if_port;
382 static int current_tag;
384 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
385 static int pnp_cards;
386 struct pnp_dev *idev = NULL;
391 for (i=0; el3_isapnp_adapters[i].vendor != 0; i++) {
393 while ((idev = pnp_find_dev(NULL,
394 el3_isapnp_adapters[i].vendor,
395 el3_isapnp_adapters[i].function,
397 if (pnp_device_attach(idev) < 0)
399 if (pnp_activate_dev(idev) < 0) {
401 pnp_device_detach(idev);
404 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
406 ioaddr = pnp_port_start(idev, 0);
407 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509 PnP")) {
408 pnp_device_detach(idev);
411 irq = pnp_irq(idev, 0);
413 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
414 (char*) el3_isapnp_adapters[i].driver_data, ioaddr, irq);
416 for (j = 0; j < 3; j++)
417 el3_isapnp_phys_addr[pnp_cards][j] =
419 htons(read_eeprom(ioaddr, j));
420 if_port = read_eeprom(ioaddr, 8) >> 14;
421 dev = alloc_etherdev(sizeof (struct el3_private));
423 release_region(ioaddr, EL3_IO_EXTENT);
424 pnp_device_detach(idev);
428 SET_MODULE_OWNER(dev);
429 SET_NETDEV_DEV(dev, &idev->dev);
432 netdev_boot_setup_check(dev);
437 #endif /* __ISAPNP__ */
439 #ifdef CONFIG_X86_PC9800
442 /* Select an open I/O location at 0x1*0 to do contention select. */
443 for ( ; id_port < 0x200; id_port += 0x10) {
444 if (!request_region(id_port, 1, "3c509"))
448 if (inb(id_port) & 0x01){
449 release_region(id_port, 1);
452 release_region(id_port, 1);
454 if (id_port >= 0x200) {
455 /* Rare -- do we really need a warning? */
456 printk(" WARNING: No I/O port available for 3c509 activation.\n");
459 #endif /* CONFIG_X86_PC9800 */
460 /* Next check for all ISA bus boards by sending the ID sequence to the
461 ID_PORT. We find cards past the first by setting the 'current_tag'
462 on cards as they are found. Cards with their tag set will not
463 respond to subsequent ID sequences. */
467 for(i = 0; i < 255; i++) {
468 outb(lrs_state, id_port);
470 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
473 /* For the first probe, clear all board's tag registers. */
474 if (current_tag == 0)
476 else /* Otherwise kill off already-found boards. */
479 if (id_read_eeprom(7) != 0x6d50) {
483 /* Read in EEPROM data, which does contention-select.
484 Only the lowest address board will stay "on-line".
485 3Com got the byte order backwards. */
486 for (i = 0; i < 3; i++) {
487 phys_addr[i] = htons(id_read_eeprom(i));
490 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
492 /* The ISA PnP 3c509 cards respond to the ID sequence.
493 This check is needed in order not to register them twice. */
494 for (i = 0; i < pnp_cards; i++) {
495 if (phys_addr[0] == el3_isapnp_phys_addr[i][0] &&
496 phys_addr[1] == el3_isapnp_phys_addr[i][1] &&
497 phys_addr[2] == el3_isapnp_phys_addr[i][2])
500 printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
501 phys_addr[0] & 0xff, phys_addr[0] >> 8,
502 phys_addr[1] & 0xff, phys_addr[1] >> 8,
503 phys_addr[2] & 0xff, phys_addr[2] >> 8);
504 /* Set the adaptor tag so that the next card can be found. */
505 outb(0xd0 + ++current_tag, id_port);
510 #endif /* __ISAPNP__ */
513 unsigned int iobase = id_read_eeprom(8);
514 if_port = iobase >> 14;
515 #ifdef CONFIG_X86_PC9800
516 ioaddr = 0x40d0 + ((iobase & 0x1f) << 8);
518 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
521 irq = id_read_eeprom(9) >> 12;
522 #ifdef CONFIG_X86_PC9800
529 dev = alloc_etherdev(sizeof (struct el3_private));
533 SET_MODULE_OWNER(dev);
535 netdev_boot_setup_check(dev);
537 /* Set passed-in IRQ or I/O Addr. */
538 if (dev->irq > 1 && dev->irq < 16)
541 if (dev->base_addr) {
542 if (dev->mem_end == 0x3c509 /* Magic key */
543 && dev->base_addr >= 0x200 && dev->base_addr <= 0x3e0)
544 ioaddr = dev->base_addr & 0x3f0;
545 else if (dev->base_addr != ioaddr)
549 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509")) {
554 /* Set the adaptor tag so that the next card can be found. */
555 outb(0xd0 + ++current_tag, id_port);
557 /* Activate the adaptor at the EEPROM location. */
558 #ifdef CONFIG_X86_PC9800
559 outb((ioaddr >> 8) | 0xe0, id_port);
561 outb((ioaddr >> 4) | 0xe0, id_port);
565 if (inw(ioaddr) != 0x6d50)
568 /* Free the interrupt so that some other card can use it. */
569 outw(0x0f00, ioaddr + WN0_IRQ);
571 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
572 found: /* PNP jumps here... */
573 #endif /* __ISAPNP__ */
575 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
576 dev->base_addr = ioaddr;
578 dev->if_port = if_port;
579 lp = netdev_priv(dev);
580 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
581 lp->dev = &idev->dev;
583 err = el3_common_init(dev);
589 /* register power management */
590 lp->pmdev = pm_register(PM_ISA_DEV, card_idx, el3_pm_callback);
594 p->data = (struct net_device *)dev;
599 lp->next_dev = el3_root_dev;
604 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
606 pnp_device_detach(idev);
614 static int __init el3_mca_probe(struct device *device)
616 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
617 * heavily modified by Chris Beauregard
618 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
621 * redone for multi-card detection by ZP Gu (zpg@castle.net)
622 * now works as a module */
624 struct el3_private *lp;
626 int ioaddr, irq, if_port;
628 struct net_device *dev = NULL;
630 struct mca_device *mdev = to_mca_device(device);
631 int slot = mdev->slot;
634 pos4 = mca_device_read_stored_pos(mdev, 4);
635 pos5 = mca_device_read_stored_pos(mdev, 5);
637 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
641 printk("3c529: found %s at slot %d\n",
642 el3_mca_adapter_names[mdev->index], slot + 1);
645 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
647 mca_device_set_claim(mdev, 1);
649 if_port = pos4 & 0x03;
651 irq = mca_device_transform_irq(mdev, irq);
652 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
654 printk("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
657 for (i = 0; i < 3; i++) {
658 phys_addr[i] = htons(read_eeprom(ioaddr, i));
661 dev = alloc_etherdev(sizeof (struct el3_private));
663 release_region(ioaddr, EL3_IO_EXTENT);
667 SET_MODULE_OWNER(dev);
668 netdev_boot_setup_check(dev);
670 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
671 dev->base_addr = ioaddr;
673 dev->if_port = if_port;
674 lp = netdev_priv(dev);
677 device->driver_data = dev;
678 err = el3_common_init(dev);
681 device->driver_data = NULL;
690 #endif /* CONFIG_MCA */
693 static int __init el3_eisa_probe (struct device *device)
695 struct el3_private *lp;
697 int ioaddr, irq, if_port;
699 struct net_device *dev = NULL;
700 struct eisa_device *edev;
703 /* Yeepee, The driver framework is calling us ! */
704 edev = to_eisa_device (device);
705 ioaddr = edev->base_addr;
707 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509"))
710 /* Change the register set to the configuration window 0. */
711 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
713 irq = inw(ioaddr + WN0_IRQ) >> 12;
714 if_port = inw(ioaddr + 6)>>14;
715 for (i = 0; i < 3; i++)
716 phys_addr[i] = htons(read_eeprom(ioaddr, i));
718 /* Restore the "Product ID" to the EEPROM read register. */
719 read_eeprom(ioaddr, 3);
721 dev = alloc_etherdev(sizeof (struct el3_private));
723 release_region(ioaddr, EL3_IO_EXTENT);
727 SET_MODULE_OWNER(dev);
729 netdev_boot_setup_check(dev);
731 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
732 dev->base_addr = ioaddr;
734 dev->if_port = if_port;
735 lp = netdev_priv(dev);
738 eisa_set_drvdata (edev, dev);
739 err = el3_common_init(dev);
742 eisa_set_drvdata (edev, NULL);
752 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
753 /* This remove works for all device types.
755 * The net dev must be stored in the driver_data field */
756 static int __devexit el3_device_remove (struct device *device)
758 struct net_device *dev;
760 dev = device->driver_data;
762 el3_common_remove (dev);
767 /* Read a word from the EEPROM using the regular EEPROM access register.
768 Assume that we are in register window zero.
770 static ushort read_eeprom(int ioaddr, int index)
772 outw(EEPROM_READ + index, ioaddr + 10);
773 /* Pause for at least 162 us. for the read to take place.
774 Some chips seem to require much longer */
776 return inw(ioaddr + 12);
779 /* Read a word from the EEPROM when in the ISA ID probe state. */
780 static ushort __init id_read_eeprom(int index)
784 /* Issue read command, and pause for at least 162 us. for it to complete.
785 Assume extra-fast 16Mhz bus. */
786 outb(EEPROM_READ + index, id_port);
788 /* Pause for at least 162 us. for the read to take place. */
789 /* Some chips seem to require much longer */
792 for (bit = 15; bit >= 0; bit--)
793 word = (word << 1) + (inb(id_port) & 0x01);
796 printk(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
803 el3_open(struct net_device *dev)
805 int ioaddr = dev->base_addr;
808 outw(TxReset, ioaddr + EL3_CMD);
809 outw(RxReset, ioaddr + EL3_CMD);
810 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
812 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
818 printk("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
819 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
824 printk("%s: Opened 3c509 IRQ %d status %4.4x.\n",
825 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
831 el3_tx_timeout (struct net_device *dev)
833 struct el3_private *lp = netdev_priv(dev);
834 int ioaddr = dev->base_addr;
836 /* Transmitter timeout, serious problems. */
837 printk("%s: transmit timed out, Tx_status %2.2x status %4.4x "
838 "Tx FIFO room %d.\n",
839 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
840 inw(ioaddr + TX_FREE));
841 lp->stats.tx_errors++;
842 dev->trans_start = jiffies;
843 /* Issue TX_RESET and TX_START commands. */
844 outw(TxReset, ioaddr + EL3_CMD);
845 outw(TxEnable, ioaddr + EL3_CMD);
846 netif_wake_queue(dev);
851 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
853 struct el3_private *lp = netdev_priv(dev);
854 int ioaddr = dev->base_addr;
857 netif_stop_queue (dev);
859 lp->stats.tx_bytes += skb->len;
862 printk("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
863 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
866 #ifndef final_version
867 { /* Error-checking code, delete someday. */
868 ushort status = inw(ioaddr + EL3_STATUS);
869 if (status & 0x0001 /* IRQ line active, missed one. */
870 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
871 printk("%s: Missed interrupt, status then %04x now %04x"
872 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
873 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
874 inw(ioaddr + RX_STATUS));
875 /* Fake interrupt trigger by masking, acknowledge interrupts. */
876 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
877 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
879 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
885 * We lock the driver against other processors. Note
886 * we don't need to lock versus the IRQ as we suspended
887 * that. This means that we lose the ability to take
888 * an RX during a TX upload. That sucks a bit with SMP
889 * on an original 3c509 (2K buffer)
891 * Using disable_irq stops us crapping on other
892 * time sensitive devices.
895 spin_lock_irqsave(&lp->lock, flags);
897 /* Put out the doubleword header... */
898 outw(skb->len, ioaddr + TX_FIFO);
899 outw(0x00, ioaddr + TX_FIFO);
900 /* ... and the packet rounded to a doubleword. */
902 outsl_ns(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
904 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
907 dev->trans_start = jiffies;
908 if (inw(ioaddr + TX_FREE) > 1536)
909 netif_start_queue(dev);
911 /* Interrupt us when the FIFO has room for max-sized packet. */
912 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
914 spin_unlock_irqrestore(&lp->lock, flags);
918 /* Clear the Tx status stack. */
923 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
924 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
925 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
926 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
927 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
933 /* The EL3 interrupt handler. */
935 el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
937 struct net_device *dev = (struct net_device *)dev_id;
938 struct el3_private *lp;
940 int i = max_interrupt_work;
943 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
947 lp = netdev_priv(dev);
948 spin_lock(&lp->lock);
950 ioaddr = dev->base_addr;
953 status = inw(ioaddr + EL3_STATUS);
954 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
957 while ((status = inw(ioaddr + EL3_STATUS)) &
958 (IntLatch | RxComplete | StatsFull)) {
960 if (status & RxComplete)
963 if (status & TxAvailable) {
965 printk(" TX room bit was handled.\n");
966 /* There's room in the FIFO for a full-sized packet. */
967 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
968 netif_wake_queue (dev);
970 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
971 /* Handle all uncommon interrupts. */
972 if (status & StatsFull) /* Empty statistics. */
974 if (status & RxEarly) { /* Rx early is unused. */
976 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
978 if (status & TxComplete) { /* Really Tx error. */
979 struct el3_private *lp = netdev_priv(dev);
983 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
984 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
985 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
986 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
987 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
990 if (status & AdapterFailure) {
991 /* Adapter failure requires Rx reset and reinit. */
992 outw(RxReset, ioaddr + EL3_CMD);
993 /* Set the Rx filter to the current state. */
994 outw(SetRxFilter | RxStation | RxBroadcast
995 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
996 | (dev->flags & IFF_PROMISC ? RxProm : 0),
998 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
999 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
1004 printk("%s: Infinite loop in interrupt, status %4.4x.\n",
1006 /* Clear all interrupts. */
1007 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
1010 /* Acknowledge the IRQ. */
1011 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
1014 if (el3_debug > 4) {
1015 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
1016 inw(ioaddr + EL3_STATUS));
1018 spin_unlock(&lp->lock);
1023 static struct net_device_stats *
1024 el3_get_stats(struct net_device *dev)
1026 struct el3_private *lp = netdev_priv(dev);
1027 unsigned long flags;
1030 * This is fast enough not to bother with disable IRQ
1034 spin_lock_irqsave(&lp->lock, flags);
1036 spin_unlock_irqrestore(&lp->lock, flags);
1040 /* Update statistics. We change to register window 6, so this should be run
1041 single-threaded if the device is active. This is expected to be a rare
1042 operation, and it's simpler for the rest of the driver to assume that
1043 window 1 is always valid rather than use a special window-state variable.
1045 static void update_stats(struct net_device *dev)
1047 struct el3_private *lp = netdev_priv(dev);
1048 int ioaddr = dev->base_addr;
1051 printk(" Updating the statistics.\n");
1052 /* Turn off statistics updates while reading. */
1053 outw(StatsDisable, ioaddr + EL3_CMD);
1054 /* Switch to the stats window, and read everything. */
1056 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1057 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1058 /* Multiple collisions. */ inb(ioaddr + 2);
1059 lp->stats.collisions += inb(ioaddr + 3);
1060 lp->stats.tx_window_errors += inb(ioaddr + 4);
1061 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1062 lp->stats.tx_packets += inb(ioaddr + 6);
1063 /* Rx packets */ inb(ioaddr + 7);
1064 /* Tx deferrals */ inb(ioaddr + 8);
1065 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1068 /* Back to window 1, and turn statistics back on. */
1070 outw(StatsEnable, ioaddr + EL3_CMD);
1075 el3_rx(struct net_device *dev)
1077 struct el3_private *lp = netdev_priv(dev);
1078 int ioaddr = dev->base_addr;
1082 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1083 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1084 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1085 if (rx_status & 0x4000) { /* Error, update stats. */
1086 short error = rx_status & 0x3800;
1088 outw(RxDiscard, ioaddr + EL3_CMD);
1089 lp->stats.rx_errors++;
1091 case 0x0000: lp->stats.rx_over_errors++; break;
1092 case 0x0800: lp->stats.rx_length_errors++; break;
1093 case 0x1000: lp->stats.rx_frame_errors++; break;
1094 case 0x1800: lp->stats.rx_length_errors++; break;
1095 case 0x2000: lp->stats.rx_frame_errors++; break;
1096 case 0x2800: lp->stats.rx_crc_errors++; break;
1099 short pkt_len = rx_status & 0x7ff;
1100 struct sk_buff *skb;
1102 skb = dev_alloc_skb(pkt_len+5);
1103 lp->stats.rx_bytes += pkt_len;
1105 printk("Receiving packet size %d status %4.4x.\n",
1106 pkt_len, rx_status);
1109 skb_reserve(skb, 2); /* Align IP on 16 byte */
1111 /* 'skb->data' points to the start of sk_buff data area. */
1113 insl_ns(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
1114 (pkt_len + 3) >> 2);
1116 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1117 (pkt_len + 3) >> 2);
1120 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1121 skb->protocol = eth_type_trans(skb,dev);
1123 dev->last_rx = jiffies;
1124 lp->stats.rx_packets++;
1127 outw(RxDiscard, ioaddr + EL3_CMD);
1128 lp->stats.rx_dropped++;
1130 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1131 dev->name, pkt_len);
1133 inw(ioaddr + EL3_STATUS); /* Delay. */
1134 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1135 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1136 inw(ioaddr + EL3_STATUS) );
1143 * Set or clear the multicast filter for this adaptor.
1146 set_multicast_list(struct net_device *dev)
1148 unsigned long flags;
1149 struct el3_private *lp = netdev_priv(dev);
1150 int ioaddr = dev->base_addr;
1152 if (el3_debug > 1) {
1154 if (old != dev->mc_count) {
1155 old = dev->mc_count;
1156 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1159 spin_lock_irqsave(&lp->lock, flags);
1160 if (dev->flags&IFF_PROMISC) {
1161 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1164 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1165 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1168 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1169 spin_unlock_irqrestore(&lp->lock, flags);
1173 el3_close(struct net_device *dev)
1175 int ioaddr = dev->base_addr;
1176 struct el3_private *lp = netdev_priv(dev);
1179 printk("%s: Shutting down ethercard.\n", dev->name);
1183 free_irq(dev->irq, dev);
1184 /* Switching back to window 0 disables the IRQ. */
1186 if (lp->type != EL3_EISA) {
1187 /* But we explicitly zero the IRQ line select anyway. Don't do
1188 * it on EISA cards, it prevents the module from getting an
1189 * IRQ after unload+reload... */
1190 outw(0x0f00, ioaddr + WN0_IRQ);
1197 el3_link_ok(struct net_device *dev)
1199 int ioaddr = dev->base_addr;
1203 tmp = inw(ioaddr + WN4_MEDIA);
1205 return tmp & (1<<11);
1209 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1212 int ioaddr = dev->base_addr;
1215 /* obtain current transceiver via WN4_MEDIA? */
1216 tmp = inw(ioaddr + WN0_ADDR_CONF);
1217 ecmd->transceiver = XCVR_INTERNAL;
1218 switch (tmp >> 14) {
1220 ecmd->port = PORT_TP;
1223 ecmd->port = PORT_AUI;
1224 ecmd->transceiver = XCVR_EXTERNAL;
1227 ecmd->port = PORT_BNC;
1232 ecmd->duplex = DUPLEX_HALF;
1233 ecmd->supported = 0;
1234 tmp = inw(ioaddr + WN0_CONF_CTRL);
1236 ecmd->supported |= SUPPORTED_AUI;
1238 ecmd->supported |= SUPPORTED_BNC;
1240 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1241 SUPPORTED_10baseT_Full; /* hmm... */
1243 tmp = inw(ioaddr + WN4_NETDIAG);
1244 if (tmp & FD_ENABLE)
1245 ecmd->duplex = DUPLEX_FULL;
1248 ecmd->speed = SPEED_10;
1254 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1257 int ioaddr = dev->base_addr;
1259 if (ecmd->speed != SPEED_10)
1261 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1263 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1266 /* change XCVR type */
1268 tmp = inw(ioaddr + WN0_ADDR_CONF);
1269 switch (ecmd->port) {
1286 outw(tmp, ioaddr + WN0_ADDR_CONF);
1287 if (dev->if_port == 3) {
1288 /* fire up the DC-DC convertor if BNC gets enabled */
1289 tmp = inw(ioaddr + WN0_ADDR_CONF);
1290 if (tmp & (3 << 14)) {
1291 outw(StartCoax, ioaddr + EL3_CMD);
1298 tmp = inw(ioaddr + WN4_NETDIAG);
1299 if (ecmd->duplex == DUPLEX_FULL)
1303 outw(tmp, ioaddr + WN4_NETDIAG);
1310 * netdev_ethtool_ioctl: Handle network interface SIOCETHTOOL ioctls
1311 * @dev: network interface on which out-of-band action is to be performed
1312 * @useraddr: userspace address to which data is to be read and returned
1314 * Process the various commands of the SIOCETHTOOL interface.
1318 netdev_ethtool_ioctl (struct net_device *dev, void __user *useraddr)
1321 struct el3_private *lp = netdev_priv(dev);
1323 /* dev_ioctl() in ../../net/core/dev.c has already checked
1324 capable(CAP_NET_ADMIN), so don't bother with that here. */
1326 if (get_user(ethcmd, (u32 __user *)useraddr))
1331 case ETHTOOL_GDRVINFO: {
1332 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
1333 strcpy (info.driver, DRV_NAME);
1334 strcpy (info.version, DRV_VERSION);
1335 if (copy_to_user (useraddr, &info, sizeof (info)))
1341 case ETHTOOL_GSET: {
1343 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
1344 spin_lock_irq(&lp->lock);
1345 ret = el3_netdev_get_ecmd(dev, &ecmd);
1346 spin_unlock_irq(&lp->lock);
1347 if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1353 case ETHTOOL_SSET: {
1355 struct ethtool_cmd ecmd;
1356 if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
1358 spin_lock_irq(&lp->lock);
1359 ret = el3_netdev_set_ecmd(dev, &ecmd);
1360 spin_unlock_irq(&lp->lock);
1364 /* get link status */
1365 case ETHTOOL_GLINK: {
1366 struct ethtool_value edata = { ETHTOOL_GLINK };
1367 spin_lock_irq(&lp->lock);
1368 edata.data = el3_link_ok(dev);
1369 spin_unlock_irq(&lp->lock);
1370 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1375 /* get message-level */
1376 case ETHTOOL_GMSGLVL: {
1377 struct ethtool_value edata = {ETHTOOL_GMSGLVL};
1378 edata.data = el3_debug;
1379 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1383 /* set message-level */
1384 case ETHTOOL_SMSGLVL: {
1385 struct ethtool_value edata;
1386 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1388 el3_debug = edata.data;
1400 * netdev_ioctl: Handle network interface ioctls
1401 * @dev: network interface on which out-of-band action is to be performed
1402 * @rq: user request data
1403 * @cmd: command issued by user
1405 * Process the various out-of-band ioctls passed to this driver.
1409 netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1415 rc = netdev_ethtool_ioctl(dev, rq->ifr_data);
1427 el3_down(struct net_device *dev)
1429 int ioaddr = dev->base_addr;
1431 netif_stop_queue(dev);
1433 /* Turn off statistics ASAP. We update lp->stats below. */
1434 outw(StatsDisable, ioaddr + EL3_CMD);
1436 /* Disable the receiver and transmitter. */
1437 outw(RxDisable, ioaddr + EL3_CMD);
1438 outw(TxDisable, ioaddr + EL3_CMD);
1440 if (dev->if_port == 3)
1441 /* Turn off thinnet power. Green! */
1442 outw(StopCoax, ioaddr + EL3_CMD);
1443 else if (dev->if_port == 0) {
1444 /* Disable link beat and jabber, if_port may change here next open(). */
1446 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1449 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1455 el3_up(struct net_device *dev)
1457 int i, sw_info, net_diag;
1458 int ioaddr = dev->base_addr;
1460 /* Activating the board required and does no harm otherwise */
1461 outw(0x0001, ioaddr + 4);
1463 /* Set the IRQ line. */
1464 #ifdef CONFIG_X86_PC9800
1467 else if (dev->irq == 13)
1470 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1472 /* Set the station address in window 2 each time opened. */
1475 for (i = 0; i < 6; i++)
1476 outb(dev->dev_addr[i], ioaddr + i);
1478 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1479 /* Start the thinnet transceiver. We should really wait 50ms...*/
1480 outw(StartCoax, ioaddr + EL3_CMD);
1481 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1482 /* Combine secondary sw_info word (the adapter level) and primary
1483 sw_info word (duplex setting plus other useless bits) */
1485 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1486 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1489 net_diag = inw(ioaddr + WN4_NETDIAG);
1490 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1491 printk("%s: ", dev->name);
1492 switch (dev->if_port & 0x0c) {
1494 /* force full-duplex mode if 3c5x9b */
1495 if (sw_info & 0x000f) {
1496 printk("Forcing 3c5x9b full-duplex mode");
1500 /* set full-duplex mode based on eeprom config setting */
1501 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1502 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1506 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1507 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1508 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1511 outw(net_diag, ioaddr + WN4_NETDIAG);
1512 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1514 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1515 /* Enable link beat and jabber check. */
1516 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1519 /* Switch to the stats window, and clear all stats by reading. */
1520 outw(StatsDisable, ioaddr + EL3_CMD);
1522 for (i = 0; i < 9; i++)
1527 /* Switch to register set 1 for normal use. */
1530 /* Accept b-case and phys addr only. */
1531 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1532 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1534 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1535 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1536 /* Allow status bits to be seen. */
1537 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1538 /* Ack all pending events, and set active indicator mask. */
1539 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1541 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1544 netif_start_queue(dev);
1547 /* Power Management support functions */
1551 el3_suspend(struct pm_dev *pdev)
1553 unsigned long flags;
1554 struct net_device *dev;
1555 struct el3_private *lp;
1558 if (!pdev && !pdev->data)
1561 dev = (struct net_device *)pdev->data;
1562 lp = netdev_priv(dev);
1563 ioaddr = dev->base_addr;
1565 spin_lock_irqsave(&lp->lock, flags);
1567 if (netif_running(dev))
1568 netif_device_detach(dev);
1571 outw(PowerDown, ioaddr + EL3_CMD);
1573 spin_unlock_irqrestore(&lp->lock, flags);
1578 el3_resume(struct pm_dev *pdev)
1580 unsigned long flags;
1581 struct net_device *dev;
1582 struct el3_private *lp;
1585 if (!pdev && !pdev->data)
1588 dev = (struct net_device *)pdev->data;
1589 lp = netdev_priv(dev);
1590 ioaddr = dev->base_addr;
1592 spin_lock_irqsave(&lp->lock, flags);
1594 outw(PowerUp, ioaddr + EL3_CMD);
1597 if (netif_running(dev))
1598 netif_device_attach(dev);
1600 spin_unlock_irqrestore(&lp->lock, flags);
1605 el3_pm_callback(struct pm_dev *pdev, pm_request_t rqst, void *data)
1609 return el3_suspend(pdev);
1612 return el3_resume(pdev);
1617 #endif /* CONFIG_PM */
1619 /* Parameters that may be passed into the module. */
1620 static int debug = -1;
1621 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1622 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1624 MODULE_PARM(debug,"i");
1625 MODULE_PARM(irq,"1-8i");
1626 MODULE_PARM(xcvr,"1-12i");
1627 MODULE_PARM(max_interrupt_work, "i");
1628 MODULE_PARM_DESC(debug, "debug level (0-6)");
1629 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1630 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1631 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1632 #if defined(__ISAPNP__) && !defined(CONFIG_X86_PC9800)
1633 MODULE_PARM(nopnp, "i");
1634 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1635 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1636 #endif /* __ISAPNP__ */
1637 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1638 MODULE_LICENSE("GPL");
1640 static int __init el3_init_module(void)
1647 el3_root_dev = NULL;
1648 while (el3_probe(el3_cards) == 0) {
1649 if (irq[el3_cards] > 1)
1650 el3_root_dev->irq = irq[el3_cards];
1651 if (xcvr[el3_cards] >= 0)
1652 el3_root_dev->if_port = xcvr[el3_cards];
1657 if (eisa_driver_register (&el3_eisa_driver) < 0) {
1658 eisa_driver_unregister (&el3_eisa_driver);
1662 mca_register_driver(&el3_mca_driver);
1667 static void __exit el3_cleanup_module(void)
1669 struct net_device *next_dev;
1671 while (el3_root_dev) {
1672 struct el3_private *lp = netdev_priv(el3_root_dev);
1674 next_dev = lp->next_dev;
1675 el3_common_remove (el3_root_dev);
1676 el3_root_dev = next_dev;
1680 eisa_driver_unregister (&el3_eisa_driver);
1683 mca_unregister_driver(&el3_mca_driver);
1687 module_init (el3_init_module);
1688 module_exit (el3_cleanup_module);