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/mca.h>
73 #include <linux/isa.h>
74 #include <linux/pnp.h>
75 #include <linux/string.h>
76 #include <linux/interrupt.h>
77 #include <linux/errno.h>
79 #include <linux/ioport.h>
80 #include <linux/init.h>
81 #include <linux/netdevice.h>
82 #include <linux/etherdevice.h>
84 #include <linux/skbuff.h>
85 #include <linux/delay.h> /* for udelay() */
86 #include <linux/spinlock.h>
87 #include <linux/ethtool.h>
88 #include <linux/device.h>
89 #include <linux/eisa.h>
90 #include <linux/bitops.h>
92 #include <asm/uaccess.h>
96 static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
99 static int el3_debug = EL3_DEBUG;
101 static int el3_debug = 2;
104 /* Used to do a global count of all the cards in the system. Must be
105 * a global variable so that the mca/eisa probe routines can increment
107 static int el3_cards = 0;
108 #define EL3_MAX_CARDS 8
110 /* To minimize the size of the driver source I only define operating
111 constants if they are used several times. You'll need the manual
112 anyway if you want to understand driver details. */
113 /* Offsets from base I/O address. */
114 #define EL3_DATA 0x00
116 #define EL3_STATUS 0x0e
117 #define EEPROM_READ 0x80
119 #define EL3_IO_EXTENT 16
121 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
124 /* The top five bits written to EL3_CMD are a command, the lower
125 11 bits are the parameter, if applicable. */
127 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
128 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
129 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
130 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
131 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
132 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
133 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
134 PowerDown = 28<<11, PowerAuto = 29<<11};
137 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
138 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
139 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
141 /* The SetRxFilter command accepts the following classes: */
143 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
145 /* Register window 1 offsets, the window used in normal operation. */
148 #define RX_STATUS 0x08
149 #define TX_STATUS 0x0B
150 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
152 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
153 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
154 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
155 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
156 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
157 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
158 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
161 * Must be a power of two (we use a binary and in the
164 #define SKB_QUEUE_SIZE 64
166 enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_MCA, EL3_EISA };
172 struct sk_buff *queue[SKB_QUEUE_SIZE];
173 enum el3_cardtype type;
176 static int current_tag;
177 static struct net_device *el3_devs[EL3_MAX_CARDS];
179 /* Parameters that may be passed into the module. */
180 static int debug = -1;
181 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
182 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
183 static int max_interrupt_work = 10;
188 static int __devinit el3_common_init(struct net_device *dev);
189 static void el3_common_remove(struct net_device *dev);
190 static ushort id_read_eeprom(int index);
191 static ushort read_eeprom(int ioaddr, int index);
192 static int el3_open(struct net_device *dev);
193 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
194 static irqreturn_t el3_interrupt(int irq, void *dev_id);
195 static void update_stats(struct net_device *dev);
196 static struct net_device_stats *el3_get_stats(struct net_device *dev);
197 static int el3_rx(struct net_device *dev);
198 static int el3_close(struct net_device *dev);
199 static void set_multicast_list(struct net_device *dev);
200 static void el3_tx_timeout (struct net_device *dev);
201 static void el3_down(struct net_device *dev);
202 static void el3_up(struct net_device *dev);
203 static const struct ethtool_ops ethtool_ops;
205 static int el3_suspend(struct device *, pm_message_t);
206 static int el3_resume(struct device *);
208 #define el3_suspend NULL
209 #define el3_resume NULL
213 /* generic device remove for all device types */
214 static int el3_device_remove (struct device *device);
215 #ifdef CONFIG_NET_POLL_CONTROLLER
216 static void el3_poll_controller(struct net_device *dev);
219 /* Return 0 on success, 1 on error, 2 when found already detected PnP card */
220 static int el3_isa_id_sequence(__be16 *phys_addr)
222 short lrs_state = 0xff;
225 /* ISA boards are detected by sending the ID sequence to the
226 ID_PORT. We find cards past the first by setting the 'current_tag'
227 on cards as they are found. Cards with their tag set will not
228 respond to subsequent ID sequences. */
232 for (i = 0; i < 255; i++) {
233 outb(lrs_state, id_port);
235 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
237 /* For the first probe, clear all board's tag registers. */
238 if (current_tag == 0)
240 else /* Otherwise kill off already-found boards. */
242 if (id_read_eeprom(7) != 0x6d50)
244 /* Read in EEPROM data, which does contention-select.
245 Only the lowest address board will stay "on-line".
246 3Com got the byte order backwards. */
247 for (i = 0; i < 3; i++)
248 phys_addr[i] = htons(id_read_eeprom(i));
251 /* The ISA PnP 3c509 cards respond to the ID sequence too.
252 This check is needed in order not to register them twice. */
253 for (i = 0; i < el3_cards; i++) {
254 struct el3_private *lp = netdev_priv(el3_devs[i]);
255 if (lp->type == EL3_PNP &&
256 !memcmp(phys_addr, el3_devs[i]->dev_addr,
259 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
260 phys_addr[0] & 0xff, phys_addr[0] >> 8,
261 phys_addr[1] & 0xff, phys_addr[1] >> 8,
262 phys_addr[2] & 0xff, phys_addr[2] >> 8);
263 /* Set the adaptor tag so that the next card can be found. */
264 outb(0xd0 + ++current_tag, id_port);
269 #endif /* CONFIG_PNP */
274 static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
275 int ioaddr, int irq, int if_port,
276 enum el3_cardtype type)
278 struct el3_private *lp = netdev_priv(dev);
280 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
281 dev->base_addr = ioaddr;
283 dev->if_port = if_port;
287 static int __devinit el3_isa_match(struct device *pdev,
290 struct net_device *dev;
291 int ioaddr, isa_irq, if_port, err;
295 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
296 ; /* Skip to next card when PnP card found */
300 iobase = id_read_eeprom(8);
301 if_port = iobase >> 14;
302 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
303 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
304 isa_irq = irq[el3_cards];
306 isa_irq = id_read_eeprom(9) >> 12;
308 dev = alloc_etherdev(sizeof(struct el3_private));
312 netdev_boot_setup_check(dev);
314 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
319 /* Set the adaptor tag so that the next card can be found. */
320 outb(0xd0 + ++current_tag, id_port);
322 /* Activate the adaptor at the EEPROM location. */
323 outb((ioaddr >> 4) | 0xe0, id_port);
326 if (inw(ioaddr) != 0x6d50) {
331 /* Free the interrupt so that some other card can use it. */
332 outw(0x0f00, ioaddr + WN0_IRQ);
334 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
335 dev_set_drvdata(pdev, dev);
336 if (el3_common_init(dev)) {
341 el3_devs[el3_cards++] = dev;
345 static int __devexit el3_isa_remove(struct device *pdev,
348 el3_device_remove(pdev);
349 dev_set_drvdata(pdev, NULL);
354 static int el3_isa_suspend(struct device *dev, unsigned int n,
358 return el3_suspend(dev, state);
361 static int el3_isa_resume(struct device *dev, unsigned int n)
363 struct net_device *ndev = dev_get_drvdata(dev);
364 int ioaddr = ndev->base_addr, err;
367 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
368 ; /* Skip to next card when PnP card found */
371 /* Set the adaptor tag so that the next card can be found. */
372 outb(0xd0 + ++current_tag, id_port);
373 /* Enable the card */
374 outb((ioaddr >> 4) | 0xe0, id_port);
376 if (inw(ioaddr) != 0x6d50)
378 /* Free the interrupt so that some other card can use it. */
379 outw(0x0f00, ioaddr + WN0_IRQ);
380 return el3_resume(dev);
384 static struct isa_driver el3_isa_driver = {
385 .match = el3_isa_match,
386 .remove = __devexit_p(el3_isa_remove),
388 .suspend = el3_isa_suspend,
389 .resume = el3_isa_resume,
395 static int isa_registered;
398 static struct pnp_device_id el3_pnp_ids[] = {
399 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
400 { .id = "TCM5091" }, /* 3Com Etherlink III */
401 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
402 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
403 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
404 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
405 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
408 MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
410 static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
411 const struct pnp_device_id *id)
414 int ioaddr, irq, if_port;
416 struct net_device *dev = NULL;
419 ioaddr = pnp_port_start(pdev, 0);
420 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
422 irq = pnp_irq(pdev, 0);
424 for (i = 0; i < 3; i++)
425 phys_addr[i] = htons(read_eeprom(ioaddr, i));
426 if_port = read_eeprom(ioaddr, 8) >> 14;
427 dev = alloc_etherdev(sizeof(struct el3_private));
429 release_region(ioaddr, EL3_IO_EXTENT);
432 SET_NETDEV_DEV(dev, &pdev->dev);
433 netdev_boot_setup_check(dev);
435 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
436 pnp_set_drvdata(pdev, dev);
437 err = el3_common_init(dev);
440 pnp_set_drvdata(pdev, NULL);
445 el3_devs[el3_cards++] = dev;
449 static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
451 el3_common_remove(pnp_get_drvdata(pdev));
452 pnp_set_drvdata(pdev, NULL);
456 static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
458 return el3_suspend(&pdev->dev, state);
461 static int el3_pnp_resume(struct pnp_dev *pdev)
463 return el3_resume(&pdev->dev);
467 static struct pnp_driver el3_pnp_driver = {
469 .id_table = el3_pnp_ids,
470 .probe = el3_pnp_probe,
471 .remove = __devexit_p(el3_pnp_remove),
473 .suspend = el3_pnp_suspend,
474 .resume = el3_pnp_resume,
477 static int pnp_registered;
478 #endif /* CONFIG_PNP */
481 static struct eisa_device_id el3_eisa_ids[] = {
491 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
493 static int el3_eisa_probe (struct device *device);
495 static struct eisa_driver el3_eisa_driver = {
496 .id_table = el3_eisa_ids,
499 .probe = el3_eisa_probe,
500 .remove = __devexit_p (el3_device_remove),
501 .suspend = el3_suspend,
502 .resume = el3_resume,
505 static int eisa_registered;
509 static int el3_mca_probe(struct device *dev);
511 static short el3_mca_adapter_ids[] __initdata = {
520 static char *el3_mca_adapter_names[] __initdata = {
521 "3Com 3c529 EtherLink III (10base2)",
522 "3Com 3c529 EtherLink III (10baseT)",
523 "3Com 3c529 EtherLink III (test mode)",
524 "3Com 3c529 EtherLink III (TP or coax)",
525 "3Com 3c529 EtherLink III (TP)",
529 static struct mca_driver el3_mca_driver = {
530 .id_table = el3_mca_adapter_ids,
533 .bus = &mca_bus_type,
534 .probe = el3_mca_probe,
535 .remove = __devexit_p(el3_device_remove),
536 .suspend = el3_suspend,
537 .resume = el3_resume,
540 static int mca_registered;
541 #endif /* CONFIG_MCA */
543 static const struct net_device_ops netdev_ops = {
544 .ndo_open = el3_open,
545 .ndo_stop = el3_close,
546 .ndo_start_xmit = el3_start_xmit,
547 .ndo_get_stats = el3_get_stats,
548 .ndo_set_multicast_list = set_multicast_list,
549 .ndo_tx_timeout = el3_tx_timeout,
550 .ndo_change_mtu = eth_change_mtu,
551 .ndo_set_mac_address = eth_mac_addr,
552 .ndo_validate_addr = eth_validate_addr,
553 #ifdef CONFIG_NET_POLL_CONTROLLER
554 .ndo_poll_controller = el3_poll_controller,
558 static int __devinit el3_common_init(struct net_device *dev)
560 struct el3_private *lp = netdev_priv(dev);
562 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
564 spin_lock_init(&lp->lock);
566 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
567 dev->if_port = (dev->mem_start & 0x0f);
568 } else { /* xcvr codes 0/8 */
569 /* use eeprom value, but save user's full-duplex selection */
570 dev->if_port |= (dev->mem_start & 0x08);
573 /* The EL3-specific entries in the device structure. */
574 dev->netdev_ops = &netdev_ops;
575 dev->watchdog_timeo = TX_TIMEOUT;
576 SET_ETHTOOL_OPS(dev, ðtool_ops);
578 err = register_netdev(dev);
580 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
581 dev->base_addr, dev->irq);
582 release_region(dev->base_addr, EL3_IO_EXTENT);
586 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
587 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
588 dev->dev_addr, dev->irq);
591 pr_info("%s", version);
596 static void el3_common_remove (struct net_device *dev)
598 unregister_netdev (dev);
599 release_region(dev->base_addr, EL3_IO_EXTENT);
604 static int __init el3_mca_probe(struct device *device)
606 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
607 * heavily modified by Chris Beauregard
608 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
611 * redone for multi-card detection by ZP Gu (zpg@castle.net)
612 * now works as a module */
615 int ioaddr, irq, if_port;
617 struct net_device *dev = NULL;
619 struct mca_device *mdev = to_mca_device(device);
620 int slot = mdev->slot;
623 pos4 = mca_device_read_stored_pos(mdev, 4);
624 pos5 = mca_device_read_stored_pos(mdev, 5);
626 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
630 pr_info("3c529: found %s at slot %d\n",
631 el3_mca_adapter_names[mdev->index], slot + 1);
634 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
636 mca_device_set_claim(mdev, 1);
638 if_port = pos4 & 0x03;
640 irq = mca_device_transform_irq(mdev, irq);
641 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
643 pr_debug("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
646 for (i = 0; i < 3; i++)
647 phys_addr[i] = htons(read_eeprom(ioaddr, i));
649 dev = alloc_etherdev(sizeof (struct el3_private));
651 release_region(ioaddr, EL3_IO_EXTENT);
655 netdev_boot_setup_check(dev);
657 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
658 dev_set_drvdata(device, dev);
659 err = el3_common_init(dev);
662 dev_set_drvdata(device, NULL);
667 el3_devs[el3_cards++] = dev;
671 #endif /* CONFIG_MCA */
674 static int __init el3_eisa_probe (struct device *device)
677 int ioaddr, irq, if_port;
679 struct net_device *dev = NULL;
680 struct eisa_device *edev;
683 /* Yeepee, The driver framework is calling us ! */
684 edev = to_eisa_device (device);
685 ioaddr = edev->base_addr;
687 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
690 /* Change the register set to the configuration window 0. */
691 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
693 irq = inw(ioaddr + WN0_IRQ) >> 12;
694 if_port = inw(ioaddr + 6)>>14;
695 for (i = 0; i < 3; i++)
696 phys_addr[i] = htons(read_eeprom(ioaddr, i));
698 /* Restore the "Product ID" to the EEPROM read register. */
699 read_eeprom(ioaddr, 3);
701 dev = alloc_etherdev(sizeof (struct el3_private));
703 release_region(ioaddr, EL3_IO_EXTENT);
707 netdev_boot_setup_check(dev);
709 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
710 eisa_set_drvdata (edev, dev);
711 err = el3_common_init(dev);
714 eisa_set_drvdata (edev, NULL);
719 el3_devs[el3_cards++] = dev;
724 /* This remove works for all device types.
726 * The net dev must be stored in the driver data field */
727 static int __devexit el3_device_remove (struct device *device)
729 struct net_device *dev;
731 dev = dev_get_drvdata(device);
733 el3_common_remove (dev);
737 /* Read a word from the EEPROM using the regular EEPROM access register.
738 Assume that we are in register window zero.
740 static ushort read_eeprom(int ioaddr, int index)
742 outw(EEPROM_READ + index, ioaddr + 10);
743 /* Pause for at least 162 us. for the read to take place.
744 Some chips seem to require much longer */
746 return inw(ioaddr + 12);
749 /* Read a word from the EEPROM when in the ISA ID probe state. */
750 static ushort id_read_eeprom(int index)
754 /* Issue read command, and pause for at least 162 us. for it to complete.
755 Assume extra-fast 16Mhz bus. */
756 outb(EEPROM_READ + index, id_port);
758 /* Pause for at least 162 us. for the read to take place. */
759 /* Some chips seem to require much longer */
762 for (bit = 15; bit >= 0; bit--)
763 word = (word << 1) + (inb(id_port) & 0x01);
766 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
773 el3_open(struct net_device *dev)
775 int ioaddr = dev->base_addr;
778 outw(TxReset, ioaddr + EL3_CMD);
779 outw(RxReset, ioaddr + EL3_CMD);
780 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
782 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
788 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
789 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
794 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
795 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
801 el3_tx_timeout (struct net_device *dev)
803 int ioaddr = dev->base_addr;
805 /* Transmitter timeout, serious problems. */
806 pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
807 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
808 inw(ioaddr + TX_FREE));
809 dev->stats.tx_errors++;
810 dev->trans_start = jiffies; /* prevent tx timeout */
811 /* Issue TX_RESET and TX_START commands. */
812 outw(TxReset, ioaddr + EL3_CMD);
813 outw(TxEnable, ioaddr + EL3_CMD);
814 netif_wake_queue(dev);
819 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
821 struct el3_private *lp = netdev_priv(dev);
822 int ioaddr = dev->base_addr;
825 netif_stop_queue (dev);
827 dev->stats.tx_bytes += skb->len;
830 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
831 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
834 #ifndef final_version
835 { /* Error-checking code, delete someday. */
836 ushort status = inw(ioaddr + EL3_STATUS);
837 if (status & 0x0001 && /* IRQ line active, missed one. */
838 inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
839 pr_debug("%s: Missed interrupt, status then %04x now %04x"
840 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
841 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
842 inw(ioaddr + RX_STATUS));
843 /* Fake interrupt trigger by masking, acknowledge interrupts. */
844 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
845 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
847 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
853 * We lock the driver against other processors. Note
854 * we don't need to lock versus the IRQ as we suspended
855 * that. This means that we lose the ability to take
856 * an RX during a TX upload. That sucks a bit with SMP
857 * on an original 3c509 (2K buffer)
859 * Using disable_irq stops us crapping on other
860 * time sensitive devices.
863 spin_lock_irqsave(&lp->lock, flags);
865 /* Put out the doubleword header... */
866 outw(skb->len, ioaddr + TX_FIFO);
867 outw(0x00, ioaddr + TX_FIFO);
868 /* ... and the packet rounded to a doubleword. */
869 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
871 if (inw(ioaddr + TX_FREE) > 1536)
872 netif_start_queue(dev);
874 /* Interrupt us when the FIFO has room for max-sized packet. */
875 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
877 spin_unlock_irqrestore(&lp->lock, flags);
881 /* Clear the Tx status stack. */
886 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
887 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
888 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
889 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
890 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
896 /* The EL3 interrupt handler. */
898 el3_interrupt(int irq, void *dev_id)
900 struct net_device *dev = dev_id;
901 struct el3_private *lp;
903 int i = max_interrupt_work;
905 lp = netdev_priv(dev);
906 spin_lock(&lp->lock);
908 ioaddr = dev->base_addr;
911 status = inw(ioaddr + EL3_STATUS);
912 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
915 while ((status = inw(ioaddr + EL3_STATUS)) &
916 (IntLatch | RxComplete | StatsFull)) {
918 if (status & RxComplete)
921 if (status & TxAvailable) {
923 pr_debug(" TX room bit was handled.\n");
924 /* There's room in the FIFO for a full-sized packet. */
925 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
926 netif_wake_queue (dev);
928 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
929 /* Handle all uncommon interrupts. */
930 if (status & StatsFull) /* Empty statistics. */
932 if (status & RxEarly) { /* Rx early is unused. */
934 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
936 if (status & TxComplete) { /* Really Tx error. */
940 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
941 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
942 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
943 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
944 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
947 if (status & AdapterFailure) {
948 /* Adapter failure requires Rx reset and reinit. */
949 outw(RxReset, ioaddr + EL3_CMD);
950 /* Set the Rx filter to the current state. */
951 outw(SetRxFilter | RxStation | RxBroadcast
952 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
953 | (dev->flags & IFF_PROMISC ? RxProm : 0),
955 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
956 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
961 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
963 /* Clear all interrupts. */
964 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
967 /* Acknowledge the IRQ. */
968 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
972 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
973 inw(ioaddr + EL3_STATUS));
975 spin_unlock(&lp->lock);
980 #ifdef CONFIG_NET_POLL_CONTROLLER
982 * Polling receive - used by netconsole and other diagnostic tools
983 * to allow network i/o with interrupts disabled.
985 static void el3_poll_controller(struct net_device *dev)
987 disable_irq(dev->irq);
988 el3_interrupt(dev->irq, dev);
989 enable_irq(dev->irq);
993 static struct net_device_stats *
994 el3_get_stats(struct net_device *dev)
996 struct el3_private *lp = netdev_priv(dev);
1000 * This is fast enough not to bother with disable IRQ
1004 spin_lock_irqsave(&lp->lock, flags);
1006 spin_unlock_irqrestore(&lp->lock, flags);
1010 /* Update statistics. We change to register window 6, so this should be run
1011 single-threaded if the device is active. This is expected to be a rare
1012 operation, and it's simpler for the rest of the driver to assume that
1013 window 1 is always valid rather than use a special window-state variable.
1015 static void update_stats(struct net_device *dev)
1017 int ioaddr = dev->base_addr;
1020 pr_debug(" Updating the statistics.\n");
1021 /* Turn off statistics updates while reading. */
1022 outw(StatsDisable, ioaddr + EL3_CMD);
1023 /* Switch to the stats window, and read everything. */
1025 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1026 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1027 /* Multiple collisions. */ inb(ioaddr + 2);
1028 dev->stats.collisions += inb(ioaddr + 3);
1029 dev->stats.tx_window_errors += inb(ioaddr + 4);
1030 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1031 dev->stats.tx_packets += inb(ioaddr + 6);
1032 /* Rx packets */ inb(ioaddr + 7);
1033 /* Tx deferrals */ inb(ioaddr + 8);
1034 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1037 /* Back to window 1, and turn statistics back on. */
1039 outw(StatsEnable, ioaddr + EL3_CMD);
1044 el3_rx(struct net_device *dev)
1046 int ioaddr = dev->base_addr;
1050 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1051 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1052 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1053 if (rx_status & 0x4000) { /* Error, update stats. */
1054 short error = rx_status & 0x3800;
1056 outw(RxDiscard, ioaddr + EL3_CMD);
1057 dev->stats.rx_errors++;
1059 case 0x0000: dev->stats.rx_over_errors++; break;
1060 case 0x0800: dev->stats.rx_length_errors++; break;
1061 case 0x1000: dev->stats.rx_frame_errors++; break;
1062 case 0x1800: dev->stats.rx_length_errors++; break;
1063 case 0x2000: dev->stats.rx_frame_errors++; break;
1064 case 0x2800: dev->stats.rx_crc_errors++; break;
1067 short pkt_len = rx_status & 0x7ff;
1068 struct sk_buff *skb;
1070 skb = dev_alloc_skb(pkt_len+5);
1072 pr_debug("Receiving packet size %d status %4.4x.\n",
1073 pkt_len, rx_status);
1075 skb_reserve(skb, 2); /* Align IP on 16 byte */
1077 /* 'skb->data' points to the start of sk_buff data area. */
1078 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1079 (pkt_len + 3) >> 2);
1081 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1082 skb->protocol = eth_type_trans(skb,dev);
1084 dev->stats.rx_bytes += pkt_len;
1085 dev->stats.rx_packets++;
1088 outw(RxDiscard, ioaddr + EL3_CMD);
1089 dev->stats.rx_dropped++;
1091 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
1092 dev->name, pkt_len);
1094 inw(ioaddr + EL3_STATUS); /* Delay. */
1095 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1096 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
1097 inw(ioaddr + EL3_STATUS) );
1104 * Set or clear the multicast filter for this adaptor.
1107 set_multicast_list(struct net_device *dev)
1109 unsigned long flags;
1110 struct el3_private *lp = netdev_priv(dev);
1111 int ioaddr = dev->base_addr;
1112 int mc_count = netdev_mc_count(dev);
1114 if (el3_debug > 1) {
1116 if (old != mc_count) {
1118 pr_debug("%s: Setting Rx mode to %d addresses.\n",
1119 dev->name, mc_count);
1122 spin_lock_irqsave(&lp->lock, flags);
1123 if (dev->flags&IFF_PROMISC) {
1124 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1127 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1128 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1131 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1132 spin_unlock_irqrestore(&lp->lock, flags);
1136 el3_close(struct net_device *dev)
1138 int ioaddr = dev->base_addr;
1139 struct el3_private *lp = netdev_priv(dev);
1142 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1146 free_irq(dev->irq, dev);
1147 /* Switching back to window 0 disables the IRQ. */
1149 if (lp->type != EL3_EISA) {
1150 /* But we explicitly zero the IRQ line select anyway. Don't do
1151 * it on EISA cards, it prevents the module from getting an
1152 * IRQ after unload+reload... */
1153 outw(0x0f00, ioaddr + WN0_IRQ);
1160 el3_link_ok(struct net_device *dev)
1162 int ioaddr = dev->base_addr;
1166 tmp = inw(ioaddr + WN4_MEDIA);
1168 return tmp & (1<<11);
1172 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1175 int ioaddr = dev->base_addr;
1178 /* obtain current transceiver via WN4_MEDIA? */
1179 tmp = inw(ioaddr + WN0_ADDR_CONF);
1180 ecmd->transceiver = XCVR_INTERNAL;
1181 switch (tmp >> 14) {
1183 ecmd->port = PORT_TP;
1186 ecmd->port = PORT_AUI;
1187 ecmd->transceiver = XCVR_EXTERNAL;
1190 ecmd->port = PORT_BNC;
1195 ecmd->duplex = DUPLEX_HALF;
1196 ecmd->supported = 0;
1197 tmp = inw(ioaddr + WN0_CONF_CTRL);
1199 ecmd->supported |= SUPPORTED_AUI;
1201 ecmd->supported |= SUPPORTED_BNC;
1203 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1204 SUPPORTED_10baseT_Full; /* hmm... */
1206 tmp = inw(ioaddr + WN4_NETDIAG);
1207 if (tmp & FD_ENABLE)
1208 ecmd->duplex = DUPLEX_FULL;
1211 ecmd->speed = SPEED_10;
1217 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1220 int ioaddr = dev->base_addr;
1222 if (ecmd->speed != SPEED_10)
1224 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1226 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1229 /* change XCVR type */
1231 tmp = inw(ioaddr + WN0_ADDR_CONF);
1232 switch (ecmd->port) {
1249 outw(tmp, ioaddr + WN0_ADDR_CONF);
1250 if (dev->if_port == 3) {
1251 /* fire up the DC-DC convertor if BNC gets enabled */
1252 tmp = inw(ioaddr + WN0_ADDR_CONF);
1253 if (tmp & (3 << 14)) {
1254 outw(StartCoax, ioaddr + EL3_CMD);
1261 tmp = inw(ioaddr + WN4_NETDIAG);
1262 if (ecmd->duplex == DUPLEX_FULL)
1266 outw(tmp, ioaddr + WN4_NETDIAG);
1272 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1274 strcpy(info->driver, DRV_NAME);
1275 strcpy(info->version, DRV_VERSION);
1278 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1280 struct el3_private *lp = netdev_priv(dev);
1283 spin_lock_irq(&lp->lock);
1284 ret = el3_netdev_get_ecmd(dev, ecmd);
1285 spin_unlock_irq(&lp->lock);
1289 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1291 struct el3_private *lp = netdev_priv(dev);
1294 spin_lock_irq(&lp->lock);
1295 ret = el3_netdev_set_ecmd(dev, ecmd);
1296 spin_unlock_irq(&lp->lock);
1300 static u32 el3_get_link(struct net_device *dev)
1302 struct el3_private *lp = netdev_priv(dev);
1305 spin_lock_irq(&lp->lock);
1306 ret = el3_link_ok(dev);
1307 spin_unlock_irq(&lp->lock);
1311 static u32 el3_get_msglevel(struct net_device *dev)
1316 static void el3_set_msglevel(struct net_device *dev, u32 v)
1321 static const struct ethtool_ops ethtool_ops = {
1322 .get_drvinfo = el3_get_drvinfo,
1323 .get_settings = el3_get_settings,
1324 .set_settings = el3_set_settings,
1325 .get_link = el3_get_link,
1326 .get_msglevel = el3_get_msglevel,
1327 .set_msglevel = el3_set_msglevel,
1331 el3_down(struct net_device *dev)
1333 int ioaddr = dev->base_addr;
1335 netif_stop_queue(dev);
1337 /* Turn off statistics ASAP. We update lp->stats below. */
1338 outw(StatsDisable, ioaddr + EL3_CMD);
1340 /* Disable the receiver and transmitter. */
1341 outw(RxDisable, ioaddr + EL3_CMD);
1342 outw(TxDisable, ioaddr + EL3_CMD);
1344 if (dev->if_port == 3)
1345 /* Turn off thinnet power. Green! */
1346 outw(StopCoax, ioaddr + EL3_CMD);
1347 else if (dev->if_port == 0) {
1348 /* Disable link beat and jabber, if_port may change here next open(). */
1350 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1353 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1359 el3_up(struct net_device *dev)
1361 int i, sw_info, net_diag;
1362 int ioaddr = dev->base_addr;
1364 /* Activating the board required and does no harm otherwise */
1365 outw(0x0001, ioaddr + 4);
1367 /* Set the IRQ line. */
1368 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1370 /* Set the station address in window 2 each time opened. */
1373 for (i = 0; i < 6; i++)
1374 outb(dev->dev_addr[i], ioaddr + i);
1376 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1377 /* Start the thinnet transceiver. We should really wait 50ms...*/
1378 outw(StartCoax, ioaddr + EL3_CMD);
1379 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1380 /* Combine secondary sw_info word (the adapter level) and primary
1381 sw_info word (duplex setting plus other useless bits) */
1383 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1384 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1387 net_diag = inw(ioaddr + WN4_NETDIAG);
1388 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1389 pr_info("%s: ", dev->name);
1390 switch (dev->if_port & 0x0c) {
1392 /* force full-duplex mode if 3c5x9b */
1393 if (sw_info & 0x000f) {
1394 pr_cont("Forcing 3c5x9b full-duplex mode");
1398 /* set full-duplex mode based on eeprom config setting */
1399 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1400 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1404 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1405 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1406 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1409 outw(net_diag, ioaddr + WN4_NETDIAG);
1410 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1412 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1413 /* Enable link beat and jabber check. */
1414 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1417 /* Switch to the stats window, and clear all stats by reading. */
1418 outw(StatsDisable, ioaddr + EL3_CMD);
1420 for (i = 0; i < 9; i++)
1425 /* Switch to register set 1 for normal use. */
1428 /* Accept b-case and phys addr only. */
1429 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1430 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1432 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1433 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1434 /* Allow status bits to be seen. */
1435 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1436 /* Ack all pending events, and set active indicator mask. */
1437 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1439 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1442 netif_start_queue(dev);
1445 /* Power Management support functions */
1449 el3_suspend(struct device *pdev, pm_message_t state)
1451 unsigned long flags;
1452 struct net_device *dev;
1453 struct el3_private *lp;
1456 dev = dev_get_drvdata(pdev);
1457 lp = netdev_priv(dev);
1458 ioaddr = dev->base_addr;
1460 spin_lock_irqsave(&lp->lock, flags);
1462 if (netif_running(dev))
1463 netif_device_detach(dev);
1466 outw(PowerDown, ioaddr + EL3_CMD);
1468 spin_unlock_irqrestore(&lp->lock, flags);
1473 el3_resume(struct device *pdev)
1475 unsigned long flags;
1476 struct net_device *dev;
1477 struct el3_private *lp;
1480 dev = dev_get_drvdata(pdev);
1481 lp = netdev_priv(dev);
1482 ioaddr = dev->base_addr;
1484 spin_lock_irqsave(&lp->lock, flags);
1486 outw(PowerUp, ioaddr + EL3_CMD);
1490 if (netif_running(dev))
1491 netif_device_attach(dev);
1493 spin_unlock_irqrestore(&lp->lock, flags);
1497 #endif /* CONFIG_PM */
1499 module_param(debug,int, 0);
1500 module_param_array(irq, int, NULL, 0);
1501 module_param(max_interrupt_work, int, 0);
1502 MODULE_PARM_DESC(debug, "debug level (0-6)");
1503 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1504 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1506 module_param(nopnp, int, 0);
1507 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1508 #endif /* CONFIG_PNP */
1509 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1510 MODULE_LICENSE("GPL");
1512 static int __init el3_init_module(void)
1521 ret = pnp_register_driver(&el3_pnp_driver);
1526 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1527 /* Start with 0x110 to avoid some sound cards.*/
1528 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1529 if (!request_region(id_port, 1, "3c509-control"))
1531 outb(0x00, id_port);
1532 outb(0xff, id_port);
1533 if (inb(id_port) & 0x01)
1536 release_region(id_port, 1);
1538 if (id_port >= 0x200) {
1540 pr_err("No I/O port available for 3c509 activation.\n");
1542 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1547 ret = eisa_driver_register(&el3_eisa_driver);
1549 eisa_registered = 1;
1552 ret = mca_register_driver(&el3_mca_driver);
1564 if (eisa_registered)
1574 static void __exit el3_cleanup_module(void)
1578 pnp_unregister_driver(&el3_pnp_driver);
1581 isa_unregister_driver(&el3_isa_driver);
1583 release_region(id_port, 1);
1585 if (eisa_registered)
1586 eisa_driver_unregister(&el3_eisa_driver);
1590 mca_unregister_driver(&el3_mca_driver);
1594 module_init (el3_init_module);
1595 module_exit (el3_cleanup_module);