1 /* 3c503.c: A shared-memory NS8390 ethernet driver for linux. */
3 Written 1992-94 by Donald Becker.
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency. This software may be used and
7 distributed according to the terms of the GNU General Public License,
8 incorporated herein by reference.
10 The author may be reached as becker@scyld.com, or C/O
11 Scyld Computing Corporation
12 410 Severn Ave., Suite 210
16 This driver should work with the 3c503 and 3c503/16. It should be used
17 in shared memory mode for best performance, although it may also work
18 in programmed-I/O mode.
21 EtherLink II Technical Reference Manual,
22 EtherLink II/16 Technical Reference Manual Supplement,
23 3Com Corporation, 5400 Bayfront Plaza, Santa Clara CA 95052-8145
25 The Crynwr 3c503 packet driver.
29 Paul Gortmaker : add support for the 2nd 8kB of RAM on 16 bit cards.
30 Paul Gortmaker : multiple card support for module users.
31 rjohnson@analogic.com : Fix up PIO interface for efficient operation.
32 Jeff Garzik : ethtool support
36 #define DRV_NAME "3c503"
37 #define DRV_VERSION "1.10a"
38 #define DRV_RELDATE "11/17/2001"
41 static const char version[] =
42 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n";
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/errno.h>
47 #include <linux/string.h>
48 #include <linux/delay.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/init.h>
52 #include <linux/ethtool.h>
54 #include <asm/uaccess.h>
56 #include <asm/system.h>
57 #include <asm/byteorder.h>
63 static int el2_pio_probe(struct net_device *dev);
64 static int el2_probe1(struct net_device *dev, int ioaddr);
66 /* A zero-terminated list of I/O addresses to be probed in PIO mode. */
67 static unsigned int netcard_portlist[] __initdata =
68 { 0x300,0x310,0x330,0x350,0x250,0x280,0x2a0,0x2e0,0};
70 #define EL2_IO_EXTENT 16
72 static int el2_open(struct net_device *dev);
73 static int el2_close(struct net_device *dev);
74 static void el2_reset_8390(struct net_device *dev);
75 static void el2_init_card(struct net_device *dev);
76 static void el2_block_output(struct net_device *dev, int count,
77 const unsigned char *buf, int start_page);
78 static void el2_block_input(struct net_device *dev, int count, struct sk_buff *skb,
80 static void el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
82 static const struct ethtool_ops netdev_ethtool_ops;
85 /* This routine probes for a memory-mapped 3c503 board by looking for
86 the "location register" at the end of the jumpered boot PROM space.
87 This works even if a PROM isn't there.
89 If the ethercard isn't found there is an optional probe for
90 ethercard jumpered to programmed-I/O mode.
92 static int __init do_el2_probe(struct net_device *dev)
94 int *addr, addrs[] = { 0xddffe, 0xd9ffe, 0xcdffe, 0xc9ffe, 0};
95 int base_addr = dev->base_addr;
98 if (base_addr > 0x1ff) /* Check a single specified location. */
99 return el2_probe1(dev, base_addr);
100 else if (base_addr != 0) /* Don't probe at all. */
103 for (addr = addrs; *addr; addr++) {
104 void __iomem *p = ioremap(*addr, 1);
110 base_bits = readb(p);
112 i = ffs(base_bits) - 1;
113 if (i == -1 || base_bits != (1 << i))
115 if (el2_probe1(dev, netcard_portlist[i]) == 0)
119 #if ! defined(no_probe_nonshared_memory)
120 return el2_pio_probe(dev);
126 /* Try all of the locations that aren't obviously empty. This touches
127 a lot of locations, and is much riskier than the code above. */
129 el2_pio_probe(struct net_device *dev)
132 int base_addr = dev->base_addr;
135 if (base_addr > 0x1ff) /* Check a single specified location. */
136 return el2_probe1(dev, base_addr);
137 else if (base_addr != 0) /* Don't probe at all. */
140 for (i = 0; netcard_portlist[i]; i++) {
141 if (el2_probe1(dev, netcard_portlist[i]) == 0)
150 struct net_device * __init el2_probe(int unit)
152 struct net_device *dev = alloc_ei_netdev();
156 return ERR_PTR(-ENOMEM);
158 sprintf(dev->name, "eth%d", unit);
159 netdev_boot_setup_check(dev);
161 err = do_el2_probe(dev);
171 /* Probe for the Etherlink II card at I/O port base IOADDR,
172 returning non-zero on success. If found, set the station
173 address and memory parameters in DEVICE. */
175 el2_probe1(struct net_device *dev, int ioaddr)
177 int i, iobase_reg, membase_reg, saved_406, wordlength, retval;
178 static unsigned version_printed;
179 unsigned long vendor_id;
181 if (!request_region(ioaddr, EL2_IO_EXTENT, DRV_NAME))
184 if (!request_region(ioaddr + 0x400, 8, DRV_NAME)) {
189 /* Reset and/or avoid any lurking NE2000 */
190 if (inb(ioaddr + 0x408) == 0xff) {
196 /* We verify that it's a 3C503 board by checking the first three octets
197 of its ethernet address. */
198 iobase_reg = inb(ioaddr+0x403);
199 membase_reg = inb(ioaddr+0x404);
200 /* ASIC location registers should be 0 or have only a single bit set. */
201 if ( (iobase_reg & (iobase_reg - 1))
202 || (membase_reg & (membase_reg - 1))) {
206 saved_406 = inb_p(ioaddr + 0x406);
207 outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */
208 outb_p(ECNTRL_THIN, ioaddr + 0x406);
209 /* Map the station addr PROM into the lower I/O ports. We now check
210 for both the old and new 3Com prefix */
211 outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406);
212 vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2);
213 if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) {
214 /* Restore the register we frobbed. */
215 outb(saved_406, ioaddr + 0x406);
220 if (ei_debug && version_printed++ == 0)
223 dev->base_addr = ioaddr;
225 printk("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
227 /* Retrieve and print the ethernet address. */
228 for (i = 0; i < 6; i++)
229 printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
231 /* Map the 8390 back into the window. */
232 outb(ECNTRL_THIN, ioaddr + 0x406);
234 /* Check for EL2/16 as described in tech. man. */
235 outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
236 outb_p(0, ioaddr + EN0_DCFG);
237 outb_p(E8390_PAGE2, ioaddr + E8390_CMD);
238 wordlength = inb_p(ioaddr + EN0_DCFG) & ENDCFG_WTS;
239 outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
241 /* Probe for, turn on and clear the board's shared memory. */
242 if (ei_debug > 2) printk(" memory jumpers %2.2x ", membase_reg);
243 outb(EGACFR_NORM, ioaddr + 0x405); /* Enable RAM */
245 /* This should be probed for (or set via an ioctl()) at run-time.
246 Right now we use a sleazy hack to pass in the interface number
247 at boot-time via the low bits of the mem_end field. That value is
248 unused, and the low bits would be discarded even if it was used. */
249 #if defined(EI8390_THICK) || defined(EL2_AUI)
250 ei_status.interface_num = 1;
252 ei_status.interface_num = dev->mem_end & 0xf;
254 printk(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
256 if ((membase_reg & 0xf0) == 0) {
258 ei_status.name = "3c503-PIO";
259 ei_status.mem = NULL;
261 dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
262 ((membase_reg & 0xA0) ? 0x4000 : 0);
263 #define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256
264 ei_status.mem = ioremap(dev->mem_start, EL2_MEMSIZE);
267 /* This has never found an error, but someone might care.
268 Note that it only tests the 2nd 8kB on 16kB 3c503/16
269 cards between card addr. 0x2000 and 0x3fff. */
270 { /* Check the card's memory. */
271 void __iomem *mem_base = ei_status.mem;
272 unsigned int test_val = 0xbbadf00d;
273 writel(0xba5eba5e, mem_base);
274 for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) {
275 writel(test_val, mem_base + i);
276 if (readl(mem_base) != 0xba5eba5e
277 || readl(mem_base + i) != test_val) {
278 printk("3c503: memory failure or memory address conflict.\n");
280 ei_status.name = "3c503-PIO";
282 ei_status.mem = NULL;
285 test_val += 0x55555555;
286 writel(0, mem_base + i);
289 #endif /* EL2MEMTEST */
292 dev->mem_end = dev->mem_start + EL2_MEMSIZE;
294 if (wordlength) { /* No Tx pages to skip over to get to Rx */
296 ei_status.name = "3c503/16";
298 ei_status.priv = TX_PAGES * 256;
299 ei_status.name = "3c503";
304 Divide up the memory on the card. This is the same regardless of
305 whether shared-mem or PIO is used. For 16 bit cards (16kB RAM),
306 we use the entire 8k of bank1 for an Rx ring. We only use 3k
307 of the bank0 for 2 full size Tx packet slots. For 8 bit cards,
308 (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining
309 5kB for an Rx ring. */
312 ei_status.tx_start_page = EL2_MB0_START_PG;
313 ei_status.rx_start_page = EL2_MB1_START_PG;
315 ei_status.tx_start_page = EL2_MB1_START_PG;
316 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
319 /* Finish setting the board's parameters. */
320 ei_status.stop_page = EL2_MB1_STOP_PG;
321 ei_status.word16 = wordlength;
322 ei_status.reset_8390 = &el2_reset_8390;
323 ei_status.get_8390_hdr = &el2_get_8390_hdr;
324 ei_status.block_input = &el2_block_input;
325 ei_status.block_output = &el2_block_output;
329 else if (dev->irq > 5 && dev->irq != 9) {
330 printk("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
335 ei_status.saved_irq = dev->irq;
337 dev->open = &el2_open;
338 dev->stop = &el2_close;
339 dev->ethtool_ops = &netdev_ethtool_ops;
340 #ifdef CONFIG_NET_POLL_CONTROLLER
341 dev->poll_controller = ei_poll;
344 retval = register_netdev(dev);
349 printk("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
350 dev->name, ei_status.name, (wordlength+1)<<3,
351 dev->mem_start, dev->mem_end-1);
355 ei_status.tx_start_page = EL2_MB1_START_PG;
356 ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
357 printk("\n%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
358 dev->name, ei_status.name, (wordlength+1)<<3);
360 release_region(ioaddr + 0x400, 8);
363 release_region(ioaddr + 0x400, 8);
365 release_region(ioaddr, EL2_IO_EXTENT);
370 el2_open(struct net_device *dev)
372 int retval = -EAGAIN;
375 int irqlist[] = {5, 9, 3, 4, 0};
378 outb(EGACFR_NORM, E33G_GACFR); /* Enable RAM and interrupts. */
380 if (request_irq (*irqp, NULL, 0, "bogus", dev) != -EBUSY) {
381 /* Twinkle the interrupt, and check if it's seen. */
382 unsigned long cookie = probe_irq_on();
383 outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
384 outb_p(0x00, E33G_IDCFR);
385 if (*irqp == probe_irq_off(cookie) /* It's a good IRQ line! */
386 && ((retval = request_irq(dev->irq = *irqp,
387 ei_interrupt, 0, dev->name, dev)) == 0))
392 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
396 if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
407 el2_close(struct net_device *dev)
409 free_irq(dev->irq, dev);
410 dev->irq = ei_status.saved_irq;
411 outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
417 /* This is called whenever we have a unrecoverable failure:
419 Bad ring buffer packet header
422 el2_reset_8390(struct net_device *dev)
425 printk("%s: Resetting the 3c503 board...", dev->name);
426 printk("%#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
427 E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
429 outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
431 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
433 if (ei_debug > 1) printk("done\n");
436 /* Initialize the 3c503 GA registers after a reset. */
438 el2_init_card(struct net_device *dev)
440 /* Unmap the station PROM and select the DIX or BNC connector. */
441 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
443 /* Set ASIC copy of rx's first and last+1 buffer pages */
444 /* These must be the same as in the 8390. */
445 outb(ei_status.rx_start_page, E33G_STARTPG);
446 outb(ei_status.stop_page, E33G_STOPPG);
448 /* Point the vector pointer registers somewhere ?harmless?. */
449 outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */
450 outb(0xff, E33G_VP1);
451 outb(0x00, E33G_VP0);
452 /* Turn off all interrupts until we're opened. */
453 outb_p(0x00, dev->base_addr + EN0_IMR);
454 /* Enable IRQs iff started. */
455 outb(EGACFR_NORM, E33G_GACFR);
457 /* Set the interrupt line. */
458 outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
459 outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */
460 outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */
461 outb_p(0x00, E33G_DMAAL);
462 return; /* We always succeed */
466 * Either use the shared memory (if enabled on the board) or put the packet
467 * out through the ASIC FIFO.
470 el2_block_output(struct net_device *dev, int count,
471 const unsigned char *buf, int start_page)
473 unsigned short int *wrd;
474 int boguscount; /* timeout counter */
475 unsigned short word; /* temporary for better machine code */
476 void __iomem *base = ei_status.mem;
478 if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */
479 outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
481 outb(EGACFR_NORM, E33G_GACFR);
483 if (base) { /* Shared memory transfer */
484 memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8),
486 outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */
491 * No shared memory, put the packet out the other way.
492 * Set up then start the internal memory transfer to Tx Start Page
495 word = (unsigned short)start_page;
496 outb(word&0xFF, E33G_DMAAH);
497 outb(word>>8, E33G_DMAAL);
499 outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
500 | ECNTRL_START, E33G_CNTRL);
503 * Here I am going to write data to the FIFO as quickly as possible.
504 * Note that E33G_FIFOH is defined incorrectly. It is really
505 * E33G_FIFOL, the lowest port address for both the byte and
506 * word write. Variable 'count' is NOT checked. Caller must supply a
507 * valid count. Note that I may write a harmless extra byte to the
508 * 8390 if the byte-count was not even.
510 wrd = (unsigned short int *) buf;
511 count = (count + 1) >> 1;
515 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
519 printk("%s: FIFO blocked in el2_block_output.\n", dev->name);
524 if(count > WRD_COUNT)
526 outsw(E33G_FIFOH, wrd, WRD_COUNT);
532 outsw(E33G_FIFOH, wrd, count);
537 outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
541 /* Read the 4 byte, page aligned 8390 specific header. */
543 el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
546 void __iomem *base = ei_status.mem;
549 if (base) { /* Use the shared memory. */
550 void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8);
551 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
552 hdr->count = le16_to_cpu(hdr->count);
557 * No shared memory, use programmed I/O.
560 word = (unsigned short)ring_page;
561 outb(word&0xFF, E33G_DMAAH);
562 outb(word>>8, E33G_DMAAL);
564 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
565 | ECNTRL_START, E33G_CNTRL);
567 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
571 printk("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
572 memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
577 insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
579 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
584 el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
587 void __iomem *base = ei_status.mem;
588 unsigned short int *buf;
591 /* Maybe enable shared memory just be to be safe... nahh.*/
592 if (base) { /* Use the shared memory. */
593 ring_offset -= (EL2_MB1_START_PG<<8);
594 if (ring_offset + count > EL2_MEMSIZE) {
595 /* We must wrap the input move. */
596 int semi_count = EL2_MEMSIZE - ring_offset;
597 memcpy_fromio(skb->data, base + ring_offset, semi_count);
599 memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count);
601 memcpy_fromio(skb->data, base + ring_offset, count);
607 * No shared memory, use programmed I/O.
609 word = (unsigned short) ring_offset;
610 outb(word>>8, E33G_DMAAH);
611 outb(word&0xFF, E33G_DMAAL);
613 outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
614 | ECNTRL_START, E33G_CNTRL);
617 * Here I also try to get data as fast as possible. I am betting that I
618 * can read one extra byte without clobbering anything in the kernel because
619 * this would only occur on an odd byte-count and allocation of skb->data
620 * is word-aligned. Variable 'count' is NOT checked. Caller must check
622 * [This is currently quite safe.... but if one day the 3c503 explodes
623 * you know where to come looking ;)]
626 buf = (unsigned short int *) skb->data;
627 count = (count + 1) >> 1;
631 while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
635 printk("%s: FIFO blocked in el2_block_input.\n", dev->name);
640 if(count > WRD_COUNT)
642 insw(E33G_FIFOH, buf, WRD_COUNT);
648 insw(E33G_FIFOH, buf, count);
653 outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
658 static void netdev_get_drvinfo(struct net_device *dev,
659 struct ethtool_drvinfo *info)
661 strcpy(info->driver, DRV_NAME);
662 strcpy(info->version, DRV_VERSION);
663 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
666 static const struct ethtool_ops netdev_ethtool_ops = {
667 .get_drvinfo = netdev_get_drvinfo,
671 #define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */
673 static struct net_device *dev_el2[MAX_EL2_CARDS];
674 static int io[MAX_EL2_CARDS];
675 static int irq[MAX_EL2_CARDS];
676 static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */
677 module_param_array(io, int, NULL, 0);
678 module_param_array(irq, int, NULL, 0);
679 module_param_array(xcvr, int, NULL, 0);
680 MODULE_PARM_DESC(io, "I/O base address(es)");
681 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
682 MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
683 MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver");
684 MODULE_LICENSE("GPL");
686 /* This is set up so that only a single autoprobe takes place per call.
687 ISA device autoprobes on a running machine are not recommended. */
691 struct net_device *dev;
692 int this_dev, found = 0;
694 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
695 if (io[this_dev] == 0) {
696 if (this_dev != 0) break; /* only autoprobe 1st one */
697 printk(KERN_NOTICE "3c503.c: Presently autoprobing (not recommended) for a single card.\n");
699 dev = alloc_ei_netdev();
702 dev->irq = irq[this_dev];
703 dev->base_addr = io[this_dev];
704 dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */
705 if (do_el2_probe(dev) == 0) {
706 dev_el2[found++] = dev;
710 printk(KERN_WARNING "3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
718 static void cleanup_card(struct net_device *dev)
720 /* NB: el2_close() handles free_irq */
721 release_region(dev->base_addr, EL2_IO_EXTENT);
723 iounmap(ei_status.mem);
731 for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
732 struct net_device *dev = dev_el2[this_dev];
734 unregister_netdev(dev);