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
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.
58 v1.20 04Feb2008 Ondrej Zary <linux@rainbow-software.org>
59 - convert to isa_driver and pnp_driver and some cleanups
62 #define DRV_NAME "3c509"
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)
69 #include <linux/module.h>
70 #include <linux/isa.h>
71 #include <linux/pnp.h>
72 #include <linux/string.h>
73 #include <linux/interrupt.h>
74 #include <linux/errno.h>
76 #include <linux/ioport.h>
77 #include <linux/init.h>
78 #include <linux/netdevice.h>
79 #include <linux/etherdevice.h>
81 #include <linux/skbuff.h>
82 #include <linux/delay.h> /* for udelay() */
83 #include <linux/spinlock.h>
84 #include <linux/ethtool.h>
85 #include <linux/device.h>
86 #include <linux/eisa.h>
87 #include <linux/bitops.h>
89 #include <linux/uaccess.h>
94 static int el3_debug = EL3_DEBUG;
96 static int el3_debug = 2;
99 /* Used to do a global count of all the cards in the system. Must be
100 * a global variable so that the eisa probe routines can increment
102 static int el3_cards = 0;
103 #define EL3_MAX_CARDS 8
105 /* To minimize the size of the driver source I only define operating
106 constants if they are used several times. You'll need the manual
107 anyway if you want to understand driver details. */
108 /* Offsets from base I/O address. */
109 #define EL3_DATA 0x00
111 #define EL3_STATUS 0x0e
112 #define EEPROM_READ 0x80
114 #define EL3_IO_EXTENT 16
116 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
119 /* The top five bits written to EL3_CMD are a command, the lower
120 11 bits are the parameter, if applicable. */
122 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
123 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
124 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
125 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
126 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
127 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
128 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
129 PowerDown = 28<<11, PowerAuto = 29<<11};
132 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
133 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
134 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
136 /* The SetRxFilter command accepts the following classes: */
138 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
140 /* Register window 1 offsets, the window used in normal operation. */
143 #define RX_STATUS 0x08
144 #define TX_STATUS 0x0B
145 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
147 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
148 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
149 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
150 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
151 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
152 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
153 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
156 * Must be a power of two (we use a binary and in the
159 #define SKB_QUEUE_SIZE 64
161 enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA };
167 struct sk_buff *queue[SKB_QUEUE_SIZE];
168 enum el3_cardtype type;
171 static int current_tag;
172 static struct net_device *el3_devs[EL3_MAX_CARDS];
174 /* Parameters that may be passed into the module. */
175 static int debug = -1;
176 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
177 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
178 static int max_interrupt_work = 10;
183 static int el3_common_init(struct net_device *dev);
184 static void el3_common_remove(struct net_device *dev);
185 static ushort id_read_eeprom(int index);
186 static ushort read_eeprom(int ioaddr, int index);
187 static int el3_open(struct net_device *dev);
188 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
189 static irqreturn_t el3_interrupt(int irq, void *dev_id);
190 static void update_stats(struct net_device *dev);
191 static struct net_device_stats *el3_get_stats(struct net_device *dev);
192 static int el3_rx(struct net_device *dev);
193 static int el3_close(struct net_device *dev);
194 static void set_multicast_list(struct net_device *dev);
195 static void el3_tx_timeout (struct net_device *dev, unsigned int txqueue);
196 static void el3_down(struct net_device *dev);
197 static void el3_up(struct net_device *dev);
198 static const struct ethtool_ops ethtool_ops;
200 static int el3_suspend(struct device *, pm_message_t);
201 static int el3_resume(struct device *);
203 #define el3_suspend NULL
204 #define el3_resume NULL
208 /* generic device remove for all device types */
209 static int el3_device_remove (struct device *device);
210 #ifdef CONFIG_NET_POLL_CONTROLLER
211 static void el3_poll_controller(struct net_device *dev);
214 /* Return 0 on success, 1 on error, 2 when found already detected PnP card */
215 static int el3_isa_id_sequence(__be16 *phys_addr)
217 short lrs_state = 0xff;
220 /* ISA boards are detected by sending the ID sequence to the
221 ID_PORT. We find cards past the first by setting the 'current_tag'
222 on cards as they are found. Cards with their tag set will not
223 respond to subsequent ID sequences. */
227 for (i = 0; i < 255; i++) {
228 outb(lrs_state, id_port);
230 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
232 /* For the first probe, clear all board's tag registers. */
233 if (current_tag == 0)
235 else /* Otherwise kill off already-found boards. */
237 if (id_read_eeprom(7) != 0x6d50)
239 /* Read in EEPROM data, which does contention-select.
240 Only the lowest address board will stay "on-line".
241 3Com got the byte order backwards. */
242 for (i = 0; i < 3; i++)
243 phys_addr[i] = htons(id_read_eeprom(i));
246 /* The ISA PnP 3c509 cards respond to the ID sequence too.
247 This check is needed in order not to register them twice. */
248 for (i = 0; i < el3_cards; i++) {
249 struct el3_private *lp = netdev_priv(el3_devs[i]);
250 if (lp->type == EL3_PNP &&
251 ether_addr_equal((u8 *)phys_addr, el3_devs[i]->dev_addr)) {
253 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
254 phys_addr[0] & 0xff, phys_addr[0] >> 8,
255 phys_addr[1] & 0xff, phys_addr[1] >> 8,
256 phys_addr[2] & 0xff, phys_addr[2] >> 8);
257 /* Set the adaptor tag so that the next card can be found. */
258 outb(0xd0 + ++current_tag, id_port);
263 #endif /* CONFIG_PNP */
268 static void el3_dev_fill(struct net_device *dev, __be16 *phys_addr, int ioaddr,
269 int irq, int if_port, enum el3_cardtype type)
271 struct el3_private *lp = netdev_priv(dev);
273 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
274 dev->base_addr = ioaddr;
276 dev->if_port = if_port;
280 static int el3_isa_match(struct device *pdev, unsigned int ndev)
282 struct net_device *dev;
283 int ioaddr, isa_irq, if_port, err;
287 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
288 ; /* Skip to next card when PnP card found */
292 iobase = id_read_eeprom(8);
293 if_port = iobase >> 14;
294 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
295 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
296 isa_irq = irq[el3_cards];
298 isa_irq = id_read_eeprom(9) >> 12;
300 dev = alloc_etherdev(sizeof(struct el3_private));
304 SET_NETDEV_DEV(dev, pdev);
305 netdev_boot_setup_check(dev);
307 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
312 /* Set the adaptor tag so that the next card can be found. */
313 outb(0xd0 + ++current_tag, id_port);
315 /* Activate the adaptor at the EEPROM location. */
316 outb((ioaddr >> 4) | 0xe0, id_port);
319 if (inw(ioaddr) != 0x6d50) {
324 /* Free the interrupt so that some other card can use it. */
325 outw(0x0f00, ioaddr + WN0_IRQ);
327 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
328 dev_set_drvdata(pdev, dev);
329 if (el3_common_init(dev)) {
334 el3_devs[el3_cards++] = dev;
338 static int el3_isa_remove(struct device *pdev,
341 el3_device_remove(pdev);
342 dev_set_drvdata(pdev, NULL);
347 static int el3_isa_suspend(struct device *dev, unsigned int n,
351 return el3_suspend(dev, state);
354 static int el3_isa_resume(struct device *dev, unsigned int n)
356 struct net_device *ndev = dev_get_drvdata(dev);
357 int ioaddr = ndev->base_addr, err;
360 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
361 ; /* Skip to next card when PnP card found */
364 /* Set the adaptor tag so that the next card can be found. */
365 outb(0xd0 + ++current_tag, id_port);
366 /* Enable the card */
367 outb((ioaddr >> 4) | 0xe0, id_port);
369 if (inw(ioaddr) != 0x6d50)
371 /* Free the interrupt so that some other card can use it. */
372 outw(0x0f00, ioaddr + WN0_IRQ);
373 return el3_resume(dev);
377 static struct isa_driver el3_isa_driver = {
378 .match = el3_isa_match,
379 .remove = el3_isa_remove,
381 .suspend = el3_isa_suspend,
382 .resume = el3_isa_resume,
388 static int isa_registered;
391 static const struct pnp_device_id el3_pnp_ids[] = {
392 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
393 { .id = "TCM5091" }, /* 3Com Etherlink III */
394 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
395 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
396 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
397 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
398 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
401 MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
403 static int el3_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
406 int ioaddr, irq, if_port;
408 struct net_device *dev = NULL;
411 ioaddr = pnp_port_start(pdev, 0);
412 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
414 irq = pnp_irq(pdev, 0);
416 for (i = 0; i < 3; i++)
417 phys_addr[i] = htons(read_eeprom(ioaddr, i));
418 if_port = read_eeprom(ioaddr, 8) >> 14;
419 dev = alloc_etherdev(sizeof(struct el3_private));
421 release_region(ioaddr, EL3_IO_EXTENT);
424 SET_NETDEV_DEV(dev, &pdev->dev);
425 netdev_boot_setup_check(dev);
427 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
428 pnp_set_drvdata(pdev, dev);
429 err = el3_common_init(dev);
432 pnp_set_drvdata(pdev, NULL);
437 el3_devs[el3_cards++] = dev;
441 static void el3_pnp_remove(struct pnp_dev *pdev)
443 el3_common_remove(pnp_get_drvdata(pdev));
444 pnp_set_drvdata(pdev, NULL);
448 static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
450 return el3_suspend(&pdev->dev, state);
453 static int el3_pnp_resume(struct pnp_dev *pdev)
455 return el3_resume(&pdev->dev);
459 static struct pnp_driver el3_pnp_driver = {
461 .id_table = el3_pnp_ids,
462 .probe = el3_pnp_probe,
463 .remove = el3_pnp_remove,
465 .suspend = el3_pnp_suspend,
466 .resume = el3_pnp_resume,
469 static int pnp_registered;
470 #endif /* CONFIG_PNP */
473 static const struct eisa_device_id el3_eisa_ids[] = {
483 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
485 static int el3_eisa_probe (struct device *device);
487 static struct eisa_driver el3_eisa_driver = {
488 .id_table = el3_eisa_ids,
491 .probe = el3_eisa_probe,
492 .remove = el3_device_remove,
493 .suspend = el3_suspend,
494 .resume = el3_resume,
497 static int eisa_registered;
500 static const struct net_device_ops netdev_ops = {
501 .ndo_open = el3_open,
502 .ndo_stop = el3_close,
503 .ndo_start_xmit = el3_start_xmit,
504 .ndo_get_stats = el3_get_stats,
505 .ndo_set_rx_mode = set_multicast_list,
506 .ndo_tx_timeout = el3_tx_timeout,
507 .ndo_set_mac_address = eth_mac_addr,
508 .ndo_validate_addr = eth_validate_addr,
509 #ifdef CONFIG_NET_POLL_CONTROLLER
510 .ndo_poll_controller = el3_poll_controller,
514 static int el3_common_init(struct net_device *dev)
516 struct el3_private *lp = netdev_priv(dev);
518 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
520 spin_lock_init(&lp->lock);
522 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
523 dev->if_port = (dev->mem_start & 0x0f);
524 } else { /* xcvr codes 0/8 */
525 /* use eeprom value, but save user's full-duplex selection */
526 dev->if_port |= (dev->mem_start & 0x08);
529 /* The EL3-specific entries in the device structure. */
530 dev->netdev_ops = &netdev_ops;
531 dev->watchdog_timeo = TX_TIMEOUT;
532 dev->ethtool_ops = ðtool_ops;
534 err = register_netdev(dev);
536 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
537 dev->base_addr, dev->irq);
538 release_region(dev->base_addr, EL3_IO_EXTENT);
542 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
543 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
544 dev->dev_addr, dev->irq);
550 static void el3_common_remove (struct net_device *dev)
552 unregister_netdev (dev);
553 release_region(dev->base_addr, EL3_IO_EXTENT);
558 static int el3_eisa_probe(struct device *device)
561 int ioaddr, irq, if_port;
563 struct net_device *dev = NULL;
564 struct eisa_device *edev;
567 /* Yeepee, The driver framework is calling us ! */
568 edev = to_eisa_device (device);
569 ioaddr = edev->base_addr;
571 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
574 /* Change the register set to the configuration window 0. */
575 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
577 irq = inw(ioaddr + WN0_IRQ) >> 12;
578 if_port = inw(ioaddr + 6)>>14;
579 for (i = 0; i < 3; i++)
580 phys_addr[i] = htons(read_eeprom(ioaddr, i));
582 /* Restore the "Product ID" to the EEPROM read register. */
583 read_eeprom(ioaddr, 3);
585 dev = alloc_etherdev(sizeof (struct el3_private));
587 release_region(ioaddr, EL3_IO_EXTENT);
591 SET_NETDEV_DEV(dev, device);
592 netdev_boot_setup_check(dev);
594 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
595 eisa_set_drvdata (edev, dev);
596 err = el3_common_init(dev);
599 eisa_set_drvdata (edev, NULL);
604 el3_devs[el3_cards++] = dev;
609 /* This remove works for all device types.
611 * The net dev must be stored in the driver data field */
612 static int el3_device_remove(struct device *device)
614 struct net_device *dev;
616 dev = dev_get_drvdata(device);
618 el3_common_remove (dev);
622 /* Read a word from the EEPROM using the regular EEPROM access register.
623 Assume that we are in register window zero.
625 static ushort read_eeprom(int ioaddr, int index)
627 outw(EEPROM_READ + index, ioaddr + 10);
628 /* Pause for at least 162 us. for the read to take place.
629 Some chips seem to require much longer */
631 return inw(ioaddr + 12);
634 /* Read a word from the EEPROM when in the ISA ID probe state. */
635 static ushort id_read_eeprom(int index)
639 /* Issue read command, and pause for at least 162 us. for it to complete.
640 Assume extra-fast 16Mhz bus. */
641 outb(EEPROM_READ + index, id_port);
643 /* Pause for at least 162 us. for the read to take place. */
644 /* Some chips seem to require much longer */
647 for (bit = 15; bit >= 0; bit--)
648 word = (word << 1) + (inb(id_port) & 0x01);
651 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
658 el3_open(struct net_device *dev)
660 int ioaddr = dev->base_addr;
663 outw(TxReset, ioaddr + EL3_CMD);
664 outw(RxReset, ioaddr + EL3_CMD);
665 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
667 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
673 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
674 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
679 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
680 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
686 el3_tx_timeout (struct net_device *dev, unsigned int txqueue)
688 int ioaddr = dev->base_addr;
690 /* Transmitter timeout, serious problems. */
691 pr_warn("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d\n",
692 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
693 inw(ioaddr + TX_FREE));
694 dev->stats.tx_errors++;
695 netif_trans_update(dev); /* prevent tx timeout */
696 /* Issue TX_RESET and TX_START commands. */
697 outw(TxReset, ioaddr + EL3_CMD);
698 outw(TxEnable, ioaddr + EL3_CMD);
699 netif_wake_queue(dev);
704 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
706 struct el3_private *lp = netdev_priv(dev);
707 int ioaddr = dev->base_addr;
710 netif_stop_queue (dev);
712 dev->stats.tx_bytes += skb->len;
715 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
716 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
719 * We lock the driver against other processors. Note
720 * we don't need to lock versus the IRQ as we suspended
721 * that. This means that we lose the ability to take
722 * an RX during a TX upload. That sucks a bit with SMP
723 * on an original 3c509 (2K buffer)
725 * Using disable_irq stops us crapping on other
726 * time sensitive devices.
729 spin_lock_irqsave(&lp->lock, flags);
731 /* Put out the doubleword header... */
732 outw(skb->len, ioaddr + TX_FIFO);
733 outw(0x00, ioaddr + TX_FIFO);
734 /* ... and the packet rounded to a doubleword. */
735 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
737 if (inw(ioaddr + TX_FREE) > 1536)
738 netif_start_queue(dev);
740 /* Interrupt us when the FIFO has room for max-sized packet. */
741 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
743 spin_unlock_irqrestore(&lp->lock, flags);
745 dev_consume_skb_any (skb);
747 /* Clear the Tx status stack. */
752 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
753 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
754 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
755 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
756 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
762 /* The EL3 interrupt handler. */
764 el3_interrupt(int irq, void *dev_id)
766 struct net_device *dev = dev_id;
767 struct el3_private *lp;
769 int i = max_interrupt_work;
771 lp = netdev_priv(dev);
772 spin_lock(&lp->lock);
774 ioaddr = dev->base_addr;
777 status = inw(ioaddr + EL3_STATUS);
778 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
781 while ((status = inw(ioaddr + EL3_STATUS)) &
782 (IntLatch | RxComplete | StatsFull)) {
784 if (status & RxComplete)
787 if (status & TxAvailable) {
789 pr_debug(" TX room bit was handled.\n");
790 /* There's room in the FIFO for a full-sized packet. */
791 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
792 netif_wake_queue (dev);
794 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
795 /* Handle all uncommon interrupts. */
796 if (status & StatsFull) /* Empty statistics. */
798 if (status & RxEarly) { /* Rx early is unused. */
800 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
802 if (status & TxComplete) { /* Really Tx error. */
806 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
807 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
808 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
809 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
810 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
813 if (status & AdapterFailure) {
814 /* Adapter failure requires Rx reset and reinit. */
815 outw(RxReset, ioaddr + EL3_CMD);
816 /* Set the Rx filter to the current state. */
817 outw(SetRxFilter | RxStation | RxBroadcast
818 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
819 | (dev->flags & IFF_PROMISC ? RxProm : 0),
821 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
822 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
827 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
829 /* Clear all interrupts. */
830 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
833 /* Acknowledge the IRQ. */
834 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
838 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
839 inw(ioaddr + EL3_STATUS));
841 spin_unlock(&lp->lock);
846 #ifdef CONFIG_NET_POLL_CONTROLLER
848 * Polling receive - used by netconsole and other diagnostic tools
849 * to allow network i/o with interrupts disabled.
851 static void el3_poll_controller(struct net_device *dev)
853 disable_irq(dev->irq);
854 el3_interrupt(dev->irq, dev);
855 enable_irq(dev->irq);
859 static struct net_device_stats *
860 el3_get_stats(struct net_device *dev)
862 struct el3_private *lp = netdev_priv(dev);
866 * This is fast enough not to bother with disable IRQ
870 spin_lock_irqsave(&lp->lock, flags);
872 spin_unlock_irqrestore(&lp->lock, flags);
876 /* Update statistics. We change to register window 6, so this should be run
877 single-threaded if the device is active. This is expected to be a rare
878 operation, and it's simpler for the rest of the driver to assume that
879 window 1 is always valid rather than use a special window-state variable.
881 static void update_stats(struct net_device *dev)
883 int ioaddr = dev->base_addr;
886 pr_debug(" Updating the statistics.\n");
887 /* Turn off statistics updates while reading. */
888 outw(StatsDisable, ioaddr + EL3_CMD);
889 /* Switch to the stats window, and read everything. */
891 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
892 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
893 /* Multiple collisions. */ inb(ioaddr + 2);
894 dev->stats.collisions += inb(ioaddr + 3);
895 dev->stats.tx_window_errors += inb(ioaddr + 4);
896 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
897 dev->stats.tx_packets += inb(ioaddr + 6);
898 /* Rx packets */ inb(ioaddr + 7);
899 /* Tx deferrals */ inb(ioaddr + 8);
900 inw(ioaddr + 10); /* Total Rx and Tx octets. */
903 /* Back to window 1, and turn statistics back on. */
905 outw(StatsEnable, ioaddr + EL3_CMD);
909 el3_rx(struct net_device *dev)
911 int ioaddr = dev->base_addr;
915 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
916 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
917 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
918 if (rx_status & 0x4000) { /* Error, update stats. */
919 short error = rx_status & 0x3800;
921 outw(RxDiscard, ioaddr + EL3_CMD);
922 dev->stats.rx_errors++;
924 case 0x0000: dev->stats.rx_over_errors++; break;
925 case 0x0800: dev->stats.rx_length_errors++; break;
926 case 0x1000: dev->stats.rx_frame_errors++; break;
927 case 0x1800: dev->stats.rx_length_errors++; break;
928 case 0x2000: dev->stats.rx_frame_errors++; break;
929 case 0x2800: dev->stats.rx_crc_errors++; break;
932 short pkt_len = rx_status & 0x7ff;
935 skb = netdev_alloc_skb(dev, pkt_len + 5);
937 pr_debug("Receiving packet size %d status %4.4x.\n",
940 skb_reserve(skb, 2); /* Align IP on 16 byte */
942 /* 'skb->data' points to the start of sk_buff data area. */
943 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
946 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
947 skb->protocol = eth_type_trans(skb,dev);
949 dev->stats.rx_bytes += pkt_len;
950 dev->stats.rx_packets++;
953 outw(RxDiscard, ioaddr + EL3_CMD);
954 dev->stats.rx_dropped++;
956 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
959 inw(ioaddr + EL3_STATUS); /* Delay. */
960 while (inw(ioaddr + EL3_STATUS) & 0x1000)
961 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
962 inw(ioaddr + EL3_STATUS) );
969 * Set or clear the multicast filter for this adaptor.
972 set_multicast_list(struct net_device *dev)
975 struct el3_private *lp = netdev_priv(dev);
976 int ioaddr = dev->base_addr;
977 int mc_count = netdev_mc_count(dev);
981 if (old != mc_count) {
983 pr_debug("%s: Setting Rx mode to %d addresses.\n",
984 dev->name, mc_count);
987 spin_lock_irqsave(&lp->lock, flags);
988 if (dev->flags&IFF_PROMISC) {
989 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
992 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
993 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
996 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
997 spin_unlock_irqrestore(&lp->lock, flags);
1001 el3_close(struct net_device *dev)
1003 int ioaddr = dev->base_addr;
1004 struct el3_private *lp = netdev_priv(dev);
1007 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1011 free_irq(dev->irq, dev);
1012 /* Switching back to window 0 disables the IRQ. */
1014 if (lp->type != EL3_EISA) {
1015 /* But we explicitly zero the IRQ line select anyway. Don't do
1016 * it on EISA cards, it prevents the module from getting an
1017 * IRQ after unload+reload... */
1018 outw(0x0f00, ioaddr + WN0_IRQ);
1025 el3_link_ok(struct net_device *dev)
1027 int ioaddr = dev->base_addr;
1031 tmp = inw(ioaddr + WN4_MEDIA);
1033 return tmp & (1<<11);
1037 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_link_ksettings *cmd)
1040 int ioaddr = dev->base_addr;
1044 /* obtain current transceiver via WN4_MEDIA? */
1045 tmp = inw(ioaddr + WN0_ADDR_CONF);
1046 switch (tmp >> 14) {
1048 cmd->base.port = PORT_TP;
1051 cmd->base.port = PORT_AUI;
1054 cmd->base.port = PORT_BNC;
1059 cmd->base.duplex = DUPLEX_HALF;
1061 tmp = inw(ioaddr + WN0_CONF_CTRL);
1063 supported |= SUPPORTED_AUI;
1065 supported |= SUPPORTED_BNC;
1067 supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1068 SUPPORTED_10baseT_Full; /* hmm... */
1070 tmp = inw(ioaddr + WN4_NETDIAG);
1071 if (tmp & FD_ENABLE)
1072 cmd->base.duplex = DUPLEX_FULL;
1075 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1077 cmd->base.speed = SPEED_10;
1082 el3_netdev_set_ecmd(struct net_device *dev,
1083 const struct ethtool_link_ksettings *cmd)
1086 int ioaddr = dev->base_addr;
1088 if (cmd->base.speed != SPEED_10)
1090 if ((cmd->base.duplex != DUPLEX_HALF) &&
1091 (cmd->base.duplex != DUPLEX_FULL))
1094 /* change XCVR type */
1096 tmp = inw(ioaddr + WN0_ADDR_CONF);
1097 switch (cmd->base.port) {
1114 outw(tmp, ioaddr + WN0_ADDR_CONF);
1115 if (dev->if_port == 3) {
1116 /* fire up the DC-DC convertor if BNC gets enabled */
1117 tmp = inw(ioaddr + WN0_ADDR_CONF);
1118 if (tmp & (3 << 14)) {
1119 outw(StartCoax, ioaddr + EL3_CMD);
1126 tmp = inw(ioaddr + WN4_NETDIAG);
1127 if (cmd->base.duplex == DUPLEX_FULL)
1131 outw(tmp, ioaddr + WN4_NETDIAG);
1137 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1139 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1142 static int el3_get_link_ksettings(struct net_device *dev,
1143 struct ethtool_link_ksettings *cmd)
1145 struct el3_private *lp = netdev_priv(dev);
1147 spin_lock_irq(&lp->lock);
1148 el3_netdev_get_ecmd(dev, cmd);
1149 spin_unlock_irq(&lp->lock);
1153 static int el3_set_link_ksettings(struct net_device *dev,
1154 const struct ethtool_link_ksettings *cmd)
1156 struct el3_private *lp = netdev_priv(dev);
1159 spin_lock_irq(&lp->lock);
1160 ret = el3_netdev_set_ecmd(dev, cmd);
1161 spin_unlock_irq(&lp->lock);
1165 static u32 el3_get_link(struct net_device *dev)
1167 struct el3_private *lp = netdev_priv(dev);
1170 spin_lock_irq(&lp->lock);
1171 ret = el3_link_ok(dev);
1172 spin_unlock_irq(&lp->lock);
1176 static u32 el3_get_msglevel(struct net_device *dev)
1181 static void el3_set_msglevel(struct net_device *dev, u32 v)
1186 static const struct ethtool_ops ethtool_ops = {
1187 .get_drvinfo = el3_get_drvinfo,
1188 .get_link = el3_get_link,
1189 .get_msglevel = el3_get_msglevel,
1190 .set_msglevel = el3_set_msglevel,
1191 .get_link_ksettings = el3_get_link_ksettings,
1192 .set_link_ksettings = el3_set_link_ksettings,
1196 el3_down(struct net_device *dev)
1198 int ioaddr = dev->base_addr;
1200 netif_stop_queue(dev);
1202 /* Turn off statistics ASAP. We update lp->stats below. */
1203 outw(StatsDisable, ioaddr + EL3_CMD);
1205 /* Disable the receiver and transmitter. */
1206 outw(RxDisable, ioaddr + EL3_CMD);
1207 outw(TxDisable, ioaddr + EL3_CMD);
1209 if (dev->if_port == 3)
1210 /* Turn off thinnet power. Green! */
1211 outw(StopCoax, ioaddr + EL3_CMD);
1212 else if (dev->if_port == 0) {
1213 /* Disable link beat and jabber, if_port may change here next open(). */
1215 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1218 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1224 el3_up(struct net_device *dev)
1226 int i, sw_info, net_diag;
1227 int ioaddr = dev->base_addr;
1229 /* Activating the board required and does no harm otherwise */
1230 outw(0x0001, ioaddr + 4);
1232 /* Set the IRQ line. */
1233 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1235 /* Set the station address in window 2 each time opened. */
1238 for (i = 0; i < 6; i++)
1239 outb(dev->dev_addr[i], ioaddr + i);
1241 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1242 /* Start the thinnet transceiver. We should really wait 50ms...*/
1243 outw(StartCoax, ioaddr + EL3_CMD);
1244 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1245 /* Combine secondary sw_info word (the adapter level) and primary
1246 sw_info word (duplex setting plus other useless bits) */
1248 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1249 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1252 net_diag = inw(ioaddr + WN4_NETDIAG);
1253 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1254 pr_info("%s: ", dev->name);
1255 switch (dev->if_port & 0x0c) {
1257 /* force full-duplex mode if 3c5x9b */
1258 if (sw_info & 0x000f) {
1259 pr_cont("Forcing 3c5x9b full-duplex mode");
1264 /* set full-duplex mode based on eeprom config setting */
1265 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1266 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1271 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1272 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1273 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1276 outw(net_diag, ioaddr + WN4_NETDIAG);
1277 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1279 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1280 /* Enable link beat and jabber check. */
1281 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1284 /* Switch to the stats window, and clear all stats by reading. */
1285 outw(StatsDisable, ioaddr + EL3_CMD);
1287 for (i = 0; i < 9; i++)
1292 /* Switch to register set 1 for normal use. */
1295 /* Accept b-case and phys addr only. */
1296 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1297 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1299 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1300 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1301 /* Allow status bits to be seen. */
1302 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1303 /* Ack all pending events, and set active indicator mask. */
1304 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1306 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1309 netif_start_queue(dev);
1312 /* Power Management support functions */
1316 el3_suspend(struct device *pdev, pm_message_t state)
1318 unsigned long flags;
1319 struct net_device *dev;
1320 struct el3_private *lp;
1323 dev = dev_get_drvdata(pdev);
1324 lp = netdev_priv(dev);
1325 ioaddr = dev->base_addr;
1327 spin_lock_irqsave(&lp->lock, flags);
1329 if (netif_running(dev))
1330 netif_device_detach(dev);
1333 outw(PowerDown, ioaddr + EL3_CMD);
1335 spin_unlock_irqrestore(&lp->lock, flags);
1340 el3_resume(struct device *pdev)
1342 unsigned long flags;
1343 struct net_device *dev;
1344 struct el3_private *lp;
1347 dev = dev_get_drvdata(pdev);
1348 lp = netdev_priv(dev);
1349 ioaddr = dev->base_addr;
1351 spin_lock_irqsave(&lp->lock, flags);
1353 outw(PowerUp, ioaddr + EL3_CMD);
1357 if (netif_running(dev))
1358 netif_device_attach(dev);
1360 spin_unlock_irqrestore(&lp->lock, flags);
1364 #endif /* CONFIG_PM */
1366 module_param(debug,int, 0);
1367 module_param_hw_array(irq, int, irq, NULL, 0);
1368 module_param(max_interrupt_work, int, 0);
1369 MODULE_PARM_DESC(debug, "debug level (0-6)");
1370 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1371 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1373 module_param(nopnp, int, 0);
1374 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1375 #endif /* CONFIG_PNP */
1376 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1377 MODULE_LICENSE("GPL");
1379 static int __init el3_init_module(void)
1388 ret = pnp_register_driver(&el3_pnp_driver);
1393 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1394 /* Start with 0x110 to avoid some sound cards.*/
1395 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1396 if (!request_region(id_port, 1, "3c509-control"))
1398 outb(0x00, id_port);
1399 outb(0xff, id_port);
1400 if (inb(id_port) & 0x01)
1403 release_region(id_port, 1);
1405 if (id_port >= 0x200) {
1407 pr_err("No I/O port available for 3c509 activation.\n");
1409 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1414 ret = eisa_driver_register(&el3_eisa_driver);
1416 eisa_registered = 1;
1426 if (eisa_registered)
1432 static void __exit el3_cleanup_module(void)
1436 pnp_unregister_driver(&el3_pnp_driver);
1439 isa_unregister_driver(&el3_isa_driver);
1441 release_region(id_port, 1);
1443 if (eisa_registered)
1444 eisa_driver_unregister(&el3_eisa_driver);
1448 module_init (el3_init_module);
1449 module_exit (el3_cleanup_module);