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"
63 #define DRV_VERSION "1.20"
64 #define DRV_RELDATE "04Feb2008"
66 /* A few values that may be tweaked. */
68 /* Time in jiffies before concluding the transmitter is hung. */
69 #define TX_TIMEOUT (400*HZ/1000)
71 #include <linux/module.h>
72 #include <linux/isa.h>
73 #include <linux/pnp.h>
74 #include <linux/string.h>
75 #include <linux/interrupt.h>
76 #include <linux/errno.h>
78 #include <linux/ioport.h>
79 #include <linux/init.h>
80 #include <linux/netdevice.h>
81 #include <linux/etherdevice.h>
83 #include <linux/skbuff.h>
84 #include <linux/delay.h> /* for udelay() */
85 #include <linux/spinlock.h>
86 #include <linux/ethtool.h>
87 #include <linux/device.h>
88 #include <linux/eisa.h>
89 #include <linux/bitops.h>
91 #include <asm/uaccess.h>
95 static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
98 static int el3_debug = EL3_DEBUG;
100 static int el3_debug = 2;
103 /* Used to do a global count of all the cards in the system. Must be
104 * a global variable so that the eisa probe routines can increment
106 static int el3_cards = 0;
107 #define EL3_MAX_CARDS 8
109 /* To minimize the size of the driver source I only define operating
110 constants if they are used several times. You'll need the manual
111 anyway if you want to understand driver details. */
112 /* Offsets from base I/O address. */
113 #define EL3_DATA 0x00
115 #define EL3_STATUS 0x0e
116 #define EEPROM_READ 0x80
118 #define EL3_IO_EXTENT 16
120 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
123 /* The top five bits written to EL3_CMD are a command, the lower
124 11 bits are the parameter, if applicable. */
126 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
127 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
128 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
129 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
130 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
131 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
132 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
133 PowerDown = 28<<11, PowerAuto = 29<<11};
136 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
137 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
138 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
140 /* The SetRxFilter command accepts the following classes: */
142 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
144 /* Register window 1 offsets, the window used in normal operation. */
147 #define RX_STATUS 0x08
148 #define TX_STATUS 0x0B
149 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
151 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
152 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
153 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
154 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
155 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
156 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
157 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
160 * Must be a power of two (we use a binary and in the
163 #define SKB_QUEUE_SIZE 64
165 enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA };
171 struct sk_buff *queue[SKB_QUEUE_SIZE];
172 enum el3_cardtype type;
175 static int current_tag;
176 static struct net_device *el3_devs[EL3_MAX_CARDS];
178 /* Parameters that may be passed into the module. */
179 static int debug = -1;
180 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
181 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
182 static int max_interrupt_work = 10;
187 static int __devinit el3_common_init(struct net_device *dev);
188 static void el3_common_remove(struct net_device *dev);
189 static ushort id_read_eeprom(int index);
190 static ushort read_eeprom(int ioaddr, int index);
191 static int el3_open(struct net_device *dev);
192 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
193 static irqreturn_t el3_interrupt(int irq, void *dev_id);
194 static void update_stats(struct net_device *dev);
195 static struct net_device_stats *el3_get_stats(struct net_device *dev);
196 static int el3_rx(struct net_device *dev);
197 static int el3_close(struct net_device *dev);
198 static void set_multicast_list(struct net_device *dev);
199 static void el3_tx_timeout (struct net_device *dev);
200 static void el3_down(struct net_device *dev);
201 static void el3_up(struct net_device *dev);
202 static const struct ethtool_ops ethtool_ops;
204 static int el3_suspend(struct device *, pm_message_t);
205 static int el3_resume(struct device *);
207 #define el3_suspend NULL
208 #define el3_resume NULL
212 /* generic device remove for all device types */
213 static int el3_device_remove (struct device *device);
214 #ifdef CONFIG_NET_POLL_CONTROLLER
215 static void el3_poll_controller(struct net_device *dev);
218 /* Return 0 on success, 1 on error, 2 when found already detected PnP card */
219 static int el3_isa_id_sequence(__be16 *phys_addr)
221 short lrs_state = 0xff;
224 /* ISA boards are detected by sending the ID sequence to the
225 ID_PORT. We find cards past the first by setting the 'current_tag'
226 on cards as they are found. Cards with their tag set will not
227 respond to subsequent ID sequences. */
231 for (i = 0; i < 255; i++) {
232 outb(lrs_state, id_port);
234 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
236 /* For the first probe, clear all board's tag registers. */
237 if (current_tag == 0)
239 else /* Otherwise kill off already-found boards. */
241 if (id_read_eeprom(7) != 0x6d50)
243 /* Read in EEPROM data, which does contention-select.
244 Only the lowest address board will stay "on-line".
245 3Com got the byte order backwards. */
246 for (i = 0; i < 3; i++)
247 phys_addr[i] = htons(id_read_eeprom(i));
250 /* The ISA PnP 3c509 cards respond to the ID sequence too.
251 This check is needed in order not to register them twice. */
252 for (i = 0; i < el3_cards; i++) {
253 struct el3_private *lp = netdev_priv(el3_devs[i]);
254 if (lp->type == EL3_PNP &&
255 !memcmp(phys_addr, el3_devs[i]->dev_addr,
258 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
259 phys_addr[0] & 0xff, phys_addr[0] >> 8,
260 phys_addr[1] & 0xff, phys_addr[1] >> 8,
261 phys_addr[2] & 0xff, phys_addr[2] >> 8);
262 /* Set the adaptor tag so that the next card can be found. */
263 outb(0xd0 + ++current_tag, id_port);
268 #endif /* CONFIG_PNP */
273 static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
274 int ioaddr, int irq, int if_port,
275 enum el3_cardtype type)
277 struct el3_private *lp = netdev_priv(dev);
279 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
280 dev->base_addr = ioaddr;
282 dev->if_port = if_port;
286 static int __devinit el3_isa_match(struct device *pdev,
289 struct net_device *dev;
290 int ioaddr, isa_irq, if_port, err;
294 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
295 ; /* Skip to next card when PnP card found */
299 iobase = id_read_eeprom(8);
300 if_port = iobase >> 14;
301 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
302 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
303 isa_irq = irq[el3_cards];
305 isa_irq = id_read_eeprom(9) >> 12;
307 dev = alloc_etherdev(sizeof(struct el3_private));
311 netdev_boot_setup_check(dev);
313 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
318 /* Set the adaptor tag so that the next card can be found. */
319 outb(0xd0 + ++current_tag, id_port);
321 /* Activate the adaptor at the EEPROM location. */
322 outb((ioaddr >> 4) | 0xe0, id_port);
325 if (inw(ioaddr) != 0x6d50) {
330 /* Free the interrupt so that some other card can use it. */
331 outw(0x0f00, ioaddr + WN0_IRQ);
333 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
334 dev_set_drvdata(pdev, dev);
335 if (el3_common_init(dev)) {
340 el3_devs[el3_cards++] = dev;
344 static int __devexit el3_isa_remove(struct device *pdev,
347 el3_device_remove(pdev);
348 dev_set_drvdata(pdev, NULL);
353 static int el3_isa_suspend(struct device *dev, unsigned int n,
357 return el3_suspend(dev, state);
360 static int el3_isa_resume(struct device *dev, unsigned int n)
362 struct net_device *ndev = dev_get_drvdata(dev);
363 int ioaddr = ndev->base_addr, err;
366 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
367 ; /* Skip to next card when PnP card found */
370 /* Set the adaptor tag so that the next card can be found. */
371 outb(0xd0 + ++current_tag, id_port);
372 /* Enable the card */
373 outb((ioaddr >> 4) | 0xe0, id_port);
375 if (inw(ioaddr) != 0x6d50)
377 /* Free the interrupt so that some other card can use it. */
378 outw(0x0f00, ioaddr + WN0_IRQ);
379 return el3_resume(dev);
383 static struct isa_driver el3_isa_driver = {
384 .match = el3_isa_match,
385 .remove = __devexit_p(el3_isa_remove),
387 .suspend = el3_isa_suspend,
388 .resume = el3_isa_resume,
394 static int isa_registered;
397 static struct pnp_device_id el3_pnp_ids[] = {
398 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
399 { .id = "TCM5091" }, /* 3Com Etherlink III */
400 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
401 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
402 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
403 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
404 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
407 MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
409 static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
410 const struct pnp_device_id *id)
413 int ioaddr, irq, if_port;
415 struct net_device *dev = NULL;
418 ioaddr = pnp_port_start(pdev, 0);
419 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
421 irq = pnp_irq(pdev, 0);
423 for (i = 0; i < 3; i++)
424 phys_addr[i] = htons(read_eeprom(ioaddr, i));
425 if_port = read_eeprom(ioaddr, 8) >> 14;
426 dev = alloc_etherdev(sizeof(struct el3_private));
428 release_region(ioaddr, EL3_IO_EXTENT);
431 SET_NETDEV_DEV(dev, &pdev->dev);
432 netdev_boot_setup_check(dev);
434 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
435 pnp_set_drvdata(pdev, dev);
436 err = el3_common_init(dev);
439 pnp_set_drvdata(pdev, NULL);
444 el3_devs[el3_cards++] = dev;
448 static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
450 el3_common_remove(pnp_get_drvdata(pdev));
451 pnp_set_drvdata(pdev, NULL);
455 static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
457 return el3_suspend(&pdev->dev, state);
460 static int el3_pnp_resume(struct pnp_dev *pdev)
462 return el3_resume(&pdev->dev);
466 static struct pnp_driver el3_pnp_driver = {
468 .id_table = el3_pnp_ids,
469 .probe = el3_pnp_probe,
470 .remove = __devexit_p(el3_pnp_remove),
472 .suspend = el3_pnp_suspend,
473 .resume = el3_pnp_resume,
476 static int pnp_registered;
477 #endif /* CONFIG_PNP */
480 static struct eisa_device_id el3_eisa_ids[] = {
490 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
492 static int el3_eisa_probe (struct device *device);
494 static struct eisa_driver el3_eisa_driver = {
495 .id_table = el3_eisa_ids,
498 .probe = el3_eisa_probe,
499 .remove = __devexit_p (el3_device_remove),
500 .suspend = el3_suspend,
501 .resume = el3_resume,
504 static int eisa_registered;
507 static const struct net_device_ops netdev_ops = {
508 .ndo_open = el3_open,
509 .ndo_stop = el3_close,
510 .ndo_start_xmit = el3_start_xmit,
511 .ndo_get_stats = el3_get_stats,
512 .ndo_set_rx_mode = set_multicast_list,
513 .ndo_tx_timeout = el3_tx_timeout,
514 .ndo_change_mtu = eth_change_mtu,
515 .ndo_set_mac_address = eth_mac_addr,
516 .ndo_validate_addr = eth_validate_addr,
517 #ifdef CONFIG_NET_POLL_CONTROLLER
518 .ndo_poll_controller = el3_poll_controller,
522 static int __devinit el3_common_init(struct net_device *dev)
524 struct el3_private *lp = netdev_priv(dev);
526 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
528 spin_lock_init(&lp->lock);
530 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
531 dev->if_port = (dev->mem_start & 0x0f);
532 } else { /* xcvr codes 0/8 */
533 /* use eeprom value, but save user's full-duplex selection */
534 dev->if_port |= (dev->mem_start & 0x08);
537 /* The EL3-specific entries in the device structure. */
538 dev->netdev_ops = &netdev_ops;
539 dev->watchdog_timeo = TX_TIMEOUT;
540 SET_ETHTOOL_OPS(dev, ðtool_ops);
542 err = register_netdev(dev);
544 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
545 dev->base_addr, dev->irq);
546 release_region(dev->base_addr, EL3_IO_EXTENT);
550 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
551 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
552 dev->dev_addr, dev->irq);
555 pr_info("%s", version);
560 static void el3_common_remove (struct net_device *dev)
562 unregister_netdev (dev);
563 release_region(dev->base_addr, EL3_IO_EXTENT);
568 static int __init el3_eisa_probe (struct device *device)
571 int ioaddr, irq, if_port;
573 struct net_device *dev = NULL;
574 struct eisa_device *edev;
577 /* Yeepee, The driver framework is calling us ! */
578 edev = to_eisa_device (device);
579 ioaddr = edev->base_addr;
581 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
584 /* Change the register set to the configuration window 0. */
585 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
587 irq = inw(ioaddr + WN0_IRQ) >> 12;
588 if_port = inw(ioaddr + 6)>>14;
589 for (i = 0; i < 3; i++)
590 phys_addr[i] = htons(read_eeprom(ioaddr, i));
592 /* Restore the "Product ID" to the EEPROM read register. */
593 read_eeprom(ioaddr, 3);
595 dev = alloc_etherdev(sizeof (struct el3_private));
597 release_region(ioaddr, EL3_IO_EXTENT);
601 netdev_boot_setup_check(dev);
603 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
604 eisa_set_drvdata (edev, dev);
605 err = el3_common_init(dev);
608 eisa_set_drvdata (edev, NULL);
613 el3_devs[el3_cards++] = dev;
618 /* This remove works for all device types.
620 * The net dev must be stored in the driver data field */
621 static int __devexit el3_device_remove (struct device *device)
623 struct net_device *dev;
625 dev = dev_get_drvdata(device);
627 el3_common_remove (dev);
631 /* Read a word from the EEPROM using the regular EEPROM access register.
632 Assume that we are in register window zero.
634 static ushort read_eeprom(int ioaddr, int index)
636 outw(EEPROM_READ + index, ioaddr + 10);
637 /* Pause for at least 162 us. for the read to take place.
638 Some chips seem to require much longer */
640 return inw(ioaddr + 12);
643 /* Read a word from the EEPROM when in the ISA ID probe state. */
644 static ushort id_read_eeprom(int index)
648 /* Issue read command, and pause for at least 162 us. for it to complete.
649 Assume extra-fast 16Mhz bus. */
650 outb(EEPROM_READ + index, id_port);
652 /* Pause for at least 162 us. for the read to take place. */
653 /* Some chips seem to require much longer */
656 for (bit = 15; bit >= 0; bit--)
657 word = (word << 1) + (inb(id_port) & 0x01);
660 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
667 el3_open(struct net_device *dev)
669 int ioaddr = dev->base_addr;
672 outw(TxReset, ioaddr + EL3_CMD);
673 outw(RxReset, ioaddr + EL3_CMD);
674 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
676 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
682 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
683 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
688 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
689 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
695 el3_tx_timeout (struct net_device *dev)
697 int ioaddr = dev->base_addr;
699 /* Transmitter timeout, serious problems. */
700 pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
701 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
702 inw(ioaddr + TX_FREE));
703 dev->stats.tx_errors++;
704 dev->trans_start = jiffies; /* prevent tx timeout */
705 /* Issue TX_RESET and TX_START commands. */
706 outw(TxReset, ioaddr + EL3_CMD);
707 outw(TxEnable, ioaddr + EL3_CMD);
708 netif_wake_queue(dev);
713 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
715 struct el3_private *lp = netdev_priv(dev);
716 int ioaddr = dev->base_addr;
719 netif_stop_queue (dev);
721 dev->stats.tx_bytes += skb->len;
724 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
725 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
728 #ifndef final_version
729 { /* Error-checking code, delete someday. */
730 ushort status = inw(ioaddr + EL3_STATUS);
731 if (status & 0x0001 && /* IRQ line active, missed one. */
732 inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
733 pr_debug("%s: Missed interrupt, status then %04x now %04x"
734 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
735 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
736 inw(ioaddr + RX_STATUS));
737 /* Fake interrupt trigger by masking, acknowledge interrupts. */
738 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
739 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
741 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
747 * We lock the driver against other processors. Note
748 * we don't need to lock versus the IRQ as we suspended
749 * that. This means that we lose the ability to take
750 * an RX during a TX upload. That sucks a bit with SMP
751 * on an original 3c509 (2K buffer)
753 * Using disable_irq stops us crapping on other
754 * time sensitive devices.
757 spin_lock_irqsave(&lp->lock, flags);
759 /* Put out the doubleword header... */
760 outw(skb->len, ioaddr + TX_FIFO);
761 outw(0x00, ioaddr + TX_FIFO);
762 /* ... and the packet rounded to a doubleword. */
763 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
765 if (inw(ioaddr + TX_FREE) > 1536)
766 netif_start_queue(dev);
768 /* Interrupt us when the FIFO has room for max-sized packet. */
769 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
771 spin_unlock_irqrestore(&lp->lock, flags);
775 /* Clear the Tx status stack. */
780 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
781 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
782 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
783 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
784 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
790 /* The EL3 interrupt handler. */
792 el3_interrupt(int irq, void *dev_id)
794 struct net_device *dev = dev_id;
795 struct el3_private *lp;
797 int i = max_interrupt_work;
799 lp = netdev_priv(dev);
800 spin_lock(&lp->lock);
802 ioaddr = dev->base_addr;
805 status = inw(ioaddr + EL3_STATUS);
806 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
809 while ((status = inw(ioaddr + EL3_STATUS)) &
810 (IntLatch | RxComplete | StatsFull)) {
812 if (status & RxComplete)
815 if (status & TxAvailable) {
817 pr_debug(" TX room bit was handled.\n");
818 /* There's room in the FIFO for a full-sized packet. */
819 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
820 netif_wake_queue (dev);
822 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
823 /* Handle all uncommon interrupts. */
824 if (status & StatsFull) /* Empty statistics. */
826 if (status & RxEarly) { /* Rx early is unused. */
828 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
830 if (status & TxComplete) { /* Really Tx error. */
834 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
835 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
836 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
837 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
838 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
841 if (status & AdapterFailure) {
842 /* Adapter failure requires Rx reset and reinit. */
843 outw(RxReset, ioaddr + EL3_CMD);
844 /* Set the Rx filter to the current state. */
845 outw(SetRxFilter | RxStation | RxBroadcast
846 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
847 | (dev->flags & IFF_PROMISC ? RxProm : 0),
849 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
850 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
855 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
857 /* Clear all interrupts. */
858 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
861 /* Acknowledge the IRQ. */
862 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
866 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
867 inw(ioaddr + EL3_STATUS));
869 spin_unlock(&lp->lock);
874 #ifdef CONFIG_NET_POLL_CONTROLLER
876 * Polling receive - used by netconsole and other diagnostic tools
877 * to allow network i/o with interrupts disabled.
879 static void el3_poll_controller(struct net_device *dev)
881 disable_irq(dev->irq);
882 el3_interrupt(dev->irq, dev);
883 enable_irq(dev->irq);
887 static struct net_device_stats *
888 el3_get_stats(struct net_device *dev)
890 struct el3_private *lp = netdev_priv(dev);
894 * This is fast enough not to bother with disable IRQ
898 spin_lock_irqsave(&lp->lock, flags);
900 spin_unlock_irqrestore(&lp->lock, flags);
904 /* Update statistics. We change to register window 6, so this should be run
905 single-threaded if the device is active. This is expected to be a rare
906 operation, and it's simpler for the rest of the driver to assume that
907 window 1 is always valid rather than use a special window-state variable.
909 static void update_stats(struct net_device *dev)
911 int ioaddr = dev->base_addr;
914 pr_debug(" Updating the statistics.\n");
915 /* Turn off statistics updates while reading. */
916 outw(StatsDisable, ioaddr + EL3_CMD);
917 /* Switch to the stats window, and read everything. */
919 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
920 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
921 /* Multiple collisions. */ inb(ioaddr + 2);
922 dev->stats.collisions += inb(ioaddr + 3);
923 dev->stats.tx_window_errors += inb(ioaddr + 4);
924 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
925 dev->stats.tx_packets += inb(ioaddr + 6);
926 /* Rx packets */ inb(ioaddr + 7);
927 /* Tx deferrals */ inb(ioaddr + 8);
928 inw(ioaddr + 10); /* Total Rx and Tx octets. */
931 /* Back to window 1, and turn statistics back on. */
933 outw(StatsEnable, ioaddr + EL3_CMD);
937 el3_rx(struct net_device *dev)
939 int ioaddr = dev->base_addr;
943 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
944 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
945 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
946 if (rx_status & 0x4000) { /* Error, update stats. */
947 short error = rx_status & 0x3800;
949 outw(RxDiscard, ioaddr + EL3_CMD);
950 dev->stats.rx_errors++;
952 case 0x0000: dev->stats.rx_over_errors++; break;
953 case 0x0800: dev->stats.rx_length_errors++; break;
954 case 0x1000: dev->stats.rx_frame_errors++; break;
955 case 0x1800: dev->stats.rx_length_errors++; break;
956 case 0x2000: dev->stats.rx_frame_errors++; break;
957 case 0x2800: dev->stats.rx_crc_errors++; break;
960 short pkt_len = rx_status & 0x7ff;
963 skb = netdev_alloc_skb(dev, pkt_len + 5);
965 pr_debug("Receiving packet size %d status %4.4x.\n",
968 skb_reserve(skb, 2); /* Align IP on 16 byte */
970 /* 'skb->data' points to the start of sk_buff data area. */
971 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
974 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
975 skb->protocol = eth_type_trans(skb,dev);
977 dev->stats.rx_bytes += pkt_len;
978 dev->stats.rx_packets++;
981 outw(RxDiscard, ioaddr + EL3_CMD);
982 dev->stats.rx_dropped++;
984 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
987 inw(ioaddr + EL3_STATUS); /* Delay. */
988 while (inw(ioaddr + EL3_STATUS) & 0x1000)
989 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
990 inw(ioaddr + EL3_STATUS) );
997 * Set or clear the multicast filter for this adaptor.
1000 set_multicast_list(struct net_device *dev)
1002 unsigned long flags;
1003 struct el3_private *lp = netdev_priv(dev);
1004 int ioaddr = dev->base_addr;
1005 int mc_count = netdev_mc_count(dev);
1007 if (el3_debug > 1) {
1009 if (old != mc_count) {
1011 pr_debug("%s: Setting Rx mode to %d addresses.\n",
1012 dev->name, mc_count);
1015 spin_lock_irqsave(&lp->lock, flags);
1016 if (dev->flags&IFF_PROMISC) {
1017 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1020 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1021 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1024 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1025 spin_unlock_irqrestore(&lp->lock, flags);
1029 el3_close(struct net_device *dev)
1031 int ioaddr = dev->base_addr;
1032 struct el3_private *lp = netdev_priv(dev);
1035 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1039 free_irq(dev->irq, dev);
1040 /* Switching back to window 0 disables the IRQ. */
1042 if (lp->type != EL3_EISA) {
1043 /* But we explicitly zero the IRQ line select anyway. Don't do
1044 * it on EISA cards, it prevents the module from getting an
1045 * IRQ after unload+reload... */
1046 outw(0x0f00, ioaddr + WN0_IRQ);
1053 el3_link_ok(struct net_device *dev)
1055 int ioaddr = dev->base_addr;
1059 tmp = inw(ioaddr + WN4_MEDIA);
1061 return tmp & (1<<11);
1065 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1068 int ioaddr = dev->base_addr;
1071 /* obtain current transceiver via WN4_MEDIA? */
1072 tmp = inw(ioaddr + WN0_ADDR_CONF);
1073 ecmd->transceiver = XCVR_INTERNAL;
1074 switch (tmp >> 14) {
1076 ecmd->port = PORT_TP;
1079 ecmd->port = PORT_AUI;
1080 ecmd->transceiver = XCVR_EXTERNAL;
1083 ecmd->port = PORT_BNC;
1088 ecmd->duplex = DUPLEX_HALF;
1089 ecmd->supported = 0;
1090 tmp = inw(ioaddr + WN0_CONF_CTRL);
1092 ecmd->supported |= SUPPORTED_AUI;
1094 ecmd->supported |= SUPPORTED_BNC;
1096 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1097 SUPPORTED_10baseT_Full; /* hmm... */
1099 tmp = inw(ioaddr + WN4_NETDIAG);
1100 if (tmp & FD_ENABLE)
1101 ecmd->duplex = DUPLEX_FULL;
1104 ethtool_cmd_speed_set(ecmd, SPEED_10);
1110 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1113 int ioaddr = dev->base_addr;
1115 if (ecmd->speed != SPEED_10)
1117 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1119 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1122 /* change XCVR type */
1124 tmp = inw(ioaddr + WN0_ADDR_CONF);
1125 switch (ecmd->port) {
1142 outw(tmp, ioaddr + WN0_ADDR_CONF);
1143 if (dev->if_port == 3) {
1144 /* fire up the DC-DC convertor if BNC gets enabled */
1145 tmp = inw(ioaddr + WN0_ADDR_CONF);
1146 if (tmp & (3 << 14)) {
1147 outw(StartCoax, ioaddr + EL3_CMD);
1154 tmp = inw(ioaddr + WN4_NETDIAG);
1155 if (ecmd->duplex == DUPLEX_FULL)
1159 outw(tmp, ioaddr + WN4_NETDIAG);
1165 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1167 strcpy(info->driver, DRV_NAME);
1168 strcpy(info->version, DRV_VERSION);
1171 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1173 struct el3_private *lp = netdev_priv(dev);
1176 spin_lock_irq(&lp->lock);
1177 ret = el3_netdev_get_ecmd(dev, ecmd);
1178 spin_unlock_irq(&lp->lock);
1182 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1184 struct el3_private *lp = netdev_priv(dev);
1187 spin_lock_irq(&lp->lock);
1188 ret = el3_netdev_set_ecmd(dev, ecmd);
1189 spin_unlock_irq(&lp->lock);
1193 static u32 el3_get_link(struct net_device *dev)
1195 struct el3_private *lp = netdev_priv(dev);
1198 spin_lock_irq(&lp->lock);
1199 ret = el3_link_ok(dev);
1200 spin_unlock_irq(&lp->lock);
1204 static u32 el3_get_msglevel(struct net_device *dev)
1209 static void el3_set_msglevel(struct net_device *dev, u32 v)
1214 static const struct ethtool_ops ethtool_ops = {
1215 .get_drvinfo = el3_get_drvinfo,
1216 .get_settings = el3_get_settings,
1217 .set_settings = el3_set_settings,
1218 .get_link = el3_get_link,
1219 .get_msglevel = el3_get_msglevel,
1220 .set_msglevel = el3_set_msglevel,
1224 el3_down(struct net_device *dev)
1226 int ioaddr = dev->base_addr;
1228 netif_stop_queue(dev);
1230 /* Turn off statistics ASAP. We update lp->stats below. */
1231 outw(StatsDisable, ioaddr + EL3_CMD);
1233 /* Disable the receiver and transmitter. */
1234 outw(RxDisable, ioaddr + EL3_CMD);
1235 outw(TxDisable, ioaddr + EL3_CMD);
1237 if (dev->if_port == 3)
1238 /* Turn off thinnet power. Green! */
1239 outw(StopCoax, ioaddr + EL3_CMD);
1240 else if (dev->if_port == 0) {
1241 /* Disable link beat and jabber, if_port may change here next open(). */
1243 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1246 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1252 el3_up(struct net_device *dev)
1254 int i, sw_info, net_diag;
1255 int ioaddr = dev->base_addr;
1257 /* Activating the board required and does no harm otherwise */
1258 outw(0x0001, ioaddr + 4);
1260 /* Set the IRQ line. */
1261 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1263 /* Set the station address in window 2 each time opened. */
1266 for (i = 0; i < 6; i++)
1267 outb(dev->dev_addr[i], ioaddr + i);
1269 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1270 /* Start the thinnet transceiver. We should really wait 50ms...*/
1271 outw(StartCoax, ioaddr + EL3_CMD);
1272 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1273 /* Combine secondary sw_info word (the adapter level) and primary
1274 sw_info word (duplex setting plus other useless bits) */
1276 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1277 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1280 net_diag = inw(ioaddr + WN4_NETDIAG);
1281 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1282 pr_info("%s: ", dev->name);
1283 switch (dev->if_port & 0x0c) {
1285 /* force full-duplex mode if 3c5x9b */
1286 if (sw_info & 0x000f) {
1287 pr_cont("Forcing 3c5x9b full-duplex mode");
1291 /* set full-duplex mode based on eeprom config setting */
1292 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1293 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1297 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1298 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1299 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1302 outw(net_diag, ioaddr + WN4_NETDIAG);
1303 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1305 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1306 /* Enable link beat and jabber check. */
1307 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1310 /* Switch to the stats window, and clear all stats by reading. */
1311 outw(StatsDisable, ioaddr + EL3_CMD);
1313 for (i = 0; i < 9; i++)
1318 /* Switch to register set 1 for normal use. */
1321 /* Accept b-case and phys addr only. */
1322 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1323 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1325 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1326 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1327 /* Allow status bits to be seen. */
1328 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1329 /* Ack all pending events, and set active indicator mask. */
1330 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1332 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1335 netif_start_queue(dev);
1338 /* Power Management support functions */
1342 el3_suspend(struct device *pdev, pm_message_t state)
1344 unsigned long flags;
1345 struct net_device *dev;
1346 struct el3_private *lp;
1349 dev = dev_get_drvdata(pdev);
1350 lp = netdev_priv(dev);
1351 ioaddr = dev->base_addr;
1353 spin_lock_irqsave(&lp->lock, flags);
1355 if (netif_running(dev))
1356 netif_device_detach(dev);
1359 outw(PowerDown, ioaddr + EL3_CMD);
1361 spin_unlock_irqrestore(&lp->lock, flags);
1366 el3_resume(struct device *pdev)
1368 unsigned long flags;
1369 struct net_device *dev;
1370 struct el3_private *lp;
1373 dev = dev_get_drvdata(pdev);
1374 lp = netdev_priv(dev);
1375 ioaddr = dev->base_addr;
1377 spin_lock_irqsave(&lp->lock, flags);
1379 outw(PowerUp, ioaddr + EL3_CMD);
1383 if (netif_running(dev))
1384 netif_device_attach(dev);
1386 spin_unlock_irqrestore(&lp->lock, flags);
1390 #endif /* CONFIG_PM */
1392 module_param(debug,int, 0);
1393 module_param_array(irq, int, NULL, 0);
1394 module_param(max_interrupt_work, int, 0);
1395 MODULE_PARM_DESC(debug, "debug level (0-6)");
1396 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1397 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1399 module_param(nopnp, int, 0);
1400 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1401 #endif /* CONFIG_PNP */
1402 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1403 MODULE_LICENSE("GPL");
1405 static int __init el3_init_module(void)
1414 ret = pnp_register_driver(&el3_pnp_driver);
1419 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1420 /* Start with 0x110 to avoid some sound cards.*/
1421 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1422 if (!request_region(id_port, 1, "3c509-control"))
1424 outb(0x00, id_port);
1425 outb(0xff, id_port);
1426 if (inb(id_port) & 0x01)
1429 release_region(id_port, 1);
1431 if (id_port >= 0x200) {
1433 pr_err("No I/O port available for 3c509 activation.\n");
1435 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1440 ret = eisa_driver_register(&el3_eisa_driver);
1442 eisa_registered = 1;
1452 if (eisa_registered)
1458 static void __exit el3_cleanup_module(void)
1462 pnp_unregister_driver(&el3_pnp_driver);
1465 isa_unregister_driver(&el3_isa_driver);
1467 release_region(id_port, 1);
1469 if (eisa_registered)
1470 eisa_driver_unregister(&el3_eisa_driver);
1474 module_init (el3_init_module);
1475 module_exit (el3_cleanup_module);