1 /* smc-ultra.c: A SMC Ultra ethernet driver for linux. */
3 This is a driver for the SMC Ultra and SMC EtherEZ ISA ethercards.
5 Written 1993-1998 by Donald Becker.
7 Copyright 1993 United States Government as represented by the
8 Director, National Security Agency.
10 This software may be used and distributed according to the terms
11 of the GNU General Public License, incorporated herein by reference.
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
18 This driver uses the cards in the 8390-compatible mode.
19 Most of the run-time complexity is handled by the generic code in
20 8390.c. The code in this file is responsible for
22 ultra_probe() Detecting and initializing the card.
26 ultra_open() The card-specific details of starting, stopping
27 ultra_reset_8390() and resetting the 8390 NIC core.
30 ultra_block_input() Routines for reading and writing blocks of
31 ultra_block_output() packet buffer memory.
35 This driver enables the shared memory only when doing the actual data
36 transfers to avoid a bug in early version of the card that corrupted
37 data transferred by a AHA1542.
39 This driver now supports the programmed-I/O (PIO) data transfer mode of
40 the EtherEZ. It does not use the non-8390-compatible "Altego" mode.
41 That support (if available) is in smc-ez.c.
45 Paul Gortmaker : multiple card support for module users.
46 Donald Becker : 4/17/96 PIO support, minor potential problems avoided.
47 Donald Becker : 6/6/96 correctly set auto-wrap bit.
48 Alexander Sotirov : 1/20/01 Added support for ISAPnP cards
50 Note about the ISA PnP support:
52 This driver can not autoprobe for more than one SMC EtherEZ PnP card.
53 You have to configure the second card manually through the /proc/isapnp
54 interface and then load the module with an explicit io=0x___ option.
57 static const char version[] =
58 "smc-ultra.c:v2.02 2/3/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
60 #include <linux/config.h>
61 #include <linux/module.h>
63 #include <linux/kernel.h>
64 #include <linux/sched.h>
65 #include <linux/errno.h>
66 #include <linux/string.h>
67 #include <linux/init.h>
68 #include <linux/isapnp.h>
70 #include <asm/system.h>
72 #include <linux/netdevice.h>
73 #include <linux/etherdevice.h>
76 /* A zero-terminated list of I/O addresses to be probed. */
77 static unsigned int ultra_portlist[] __initdata =
78 {0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
80 int ultra_probe(struct net_device *dev);
81 static int ultra_probe1(struct net_device *dev, int ioaddr);
83 #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
84 static int ultra_probe_isapnp(struct net_device *dev);
87 static int ultra_open(struct net_device *dev);
88 static void ultra_reset_8390(struct net_device *dev);
89 static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
91 static void ultra_block_input(struct net_device *dev, int count,
92 struct sk_buff *skb, int ring_offset);
93 static void ultra_block_output(struct net_device *dev, int count,
94 const unsigned char *buf, const int start_page);
95 static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
97 static void ultra_pio_input(struct net_device *dev, int count,
98 struct sk_buff *skb, int ring_offset);
99 static void ultra_pio_output(struct net_device *dev, int count,
100 const unsigned char *buf, const int start_page);
101 static int ultra_close_card(struct net_device *dev);
103 #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
104 static struct isapnp_device_id ultra_device_ids[] __initdata = {
105 { ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
106 ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
107 (long) "SMC EtherEZ (8416)" },
108 { } /* terminate list */
111 MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
115 #define START_PG 0x00 /* First page of TX buffer */
117 #define ULTRA_CMDREG 0 /* Offset to ASIC command register. */
118 #define ULTRA_RESET 0x80 /* Board reset, in ULTRA_CMDREG. */
119 #define ULTRA_MEMENB 0x40 /* Enable the shared memory. */
120 #define IOPD 0x02 /* I/O Pipe Data (16 bits), PIO operation. */
121 #define IOPA 0x07 /* I/O Pipe Address for PIO operation. */
122 #define ULTRA_NIC_OFFSET 16 /* NIC register offset from the base_addr. */
123 #define ULTRA_IO_EXTENT 32
124 #define EN0_ERWCNT 0x08 /* Early receive warning count. */
126 /* Probe for the Ultra. This looks like a 8013 with the station
127 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
131 int __init ultra_probe(struct net_device *dev)
134 int base_addr = dev->base_addr;
136 SET_MODULE_OWNER(dev);
138 if (base_addr > 0x1ff) /* Check a single specified location. */
139 return ultra_probe1(dev, base_addr);
140 else if (base_addr != 0) /* Don't probe at all. */
143 #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
144 /* Look for any installed ISAPnP cards */
145 if (isapnp_present() && (ultra_probe_isapnp(dev) == 0))
148 printk(KERN_NOTICE "smc-ultra.c: No ISAPnP cards found, trying standard ones...\n");
151 for (i = 0; ultra_portlist[i]; i++)
152 if (ultra_probe1(dev, ultra_portlist[i]) == 0)
158 static int __init ultra_probe1(struct net_device *dev, int ioaddr)
162 const char *model_name;
163 unsigned char eeprom_irq = 0;
164 static unsigned version_printed;
165 /* Values from various config regs. */
166 unsigned char num_pages, irqreg, addr, piomode;
167 unsigned char idreg = inb(ioaddr + 7);
168 unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
170 if (!request_region(ioaddr, ULTRA_IO_EXTENT, dev->name))
173 /* Check the ID nibble. */
174 if ((idreg & 0xF0) != 0x20 /* SMC Ultra */
175 && (idreg & 0xF0) != 0x40) { /* SMC EtherEZ */
180 /* Select the station address register set. */
181 outb(reg4, ioaddr + 4);
183 for (i = 0; i < 8; i++)
184 checksum += inb(ioaddr + 8 + i);
185 if ((checksum & 0xff) != 0xFF) {
190 if (ei_debug && version_printed++ == 0)
193 model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
195 printk("%s: %s at %#3x,", dev->name, model_name, ioaddr);
197 for (i = 0; i < 6; i++)
198 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
200 /* Switch from the station address to the alternate register set and
201 read the useful registers there. */
202 outb(0x80 | reg4, ioaddr + 4);
204 /* Enabled FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
205 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
206 piomode = inb(ioaddr + 0x8);
207 addr = inb(ioaddr + 0xb);
208 irqreg = inb(ioaddr + 0xd);
210 /* Switch back to the station address register set so that the MS-DOS driver
211 can find the card after a warm boot. */
212 outb(reg4, ioaddr + 4);
215 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
218 /* The IRQ bits are split. */
219 irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
222 printk(", failed to detect IRQ line.\n");
230 /* Allocate dev->priv and fill in 8390 specific dev fields. */
231 if (ethdev_init(dev)) {
232 printk (", no memory for dev->priv.\n");
237 /* The 8390 isn't at the base address, so fake the offset */
238 dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
241 int addr_tbl[4] = {0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000};
242 short num_pages_tbl[4] = {0x20, 0x40, 0x80, 0xff};
244 dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
245 num_pages = num_pages_tbl[(addr >> 4) & 3];
248 ei_status.name = model_name;
249 ei_status.word16 = 1;
250 ei_status.tx_start_page = START_PG;
251 ei_status.rx_start_page = START_PG + TX_PAGES;
252 ei_status.stop_page = num_pages;
254 dev->rmem_start = dev->mem_start + TX_PAGES*256;
255 dev->mem_end = dev->rmem_end
256 = dev->mem_start + (ei_status.stop_page - START_PG)*256;
259 printk(",%s IRQ %d programmed-I/O mode.\n",
260 eeprom_irq ? "EEPROM" : "assigned ", dev->irq);
261 ei_status.block_input = &ultra_pio_input;
262 ei_status.block_output = &ultra_pio_output;
263 ei_status.get_8390_hdr = &ultra_pio_get_hdr;
265 printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
266 dev->irq, dev->mem_start, dev->mem_end-1);
267 ei_status.block_input = &ultra_block_input;
268 ei_status.block_output = &ultra_block_output;
269 ei_status.get_8390_hdr = &ultra_get_8390_hdr;
271 ei_status.reset_8390 = &ultra_reset_8390;
272 dev->open = &ultra_open;
273 dev->stop = &ultra_close_card;
278 release_region(ioaddr, ULTRA_IO_EXTENT);
282 #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
283 static int __init ultra_probe_isapnp(struct net_device *dev)
287 for (i = 0; ultra_device_ids[i].vendor != 0; i++) {
288 struct pci_dev *idev = NULL;
290 while ((idev = isapnp_find_dev(NULL,
291 ultra_device_ids[i].vendor,
292 ultra_device_ids[i].function,
294 /* Avoid already found cards from previous calls */
295 if (idev->prepare(idev))
297 if (idev->activate(idev))
299 /* if no irq, search for next */
300 if (idev->irq_resource[0].start == 0)
303 dev->base_addr = idev->resource[0].start;
304 dev->irq = idev->irq_resource[0].start;
305 printk(KERN_INFO "smc-ultra.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
306 (char *) ultra_device_ids[i].driver_data,
308 dev->base_addr, dev->irq);
309 if (ultra_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
310 printk(KERN_ERR "smc-ultra.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr); return -ENXIO;
312 ei_status.priv = (unsigned long)idev;
325 ultra_open(struct net_device *dev)
328 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
329 unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
330 0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
332 retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
336 outb(0x00, ioaddr); /* Disable shared memory for safety. */
337 outb(0x80, ioaddr + 5);
338 /* Set the IRQ line. */
339 outb(inb(ioaddr + 4) | 0x80, ioaddr + 4);
340 outb((inb(ioaddr + 13) & ~0x4C) | irq2reg[dev->irq], ioaddr + 13);
341 outb(inb(ioaddr + 4) & 0x7f, ioaddr + 4);
343 if (ei_status.block_input == &ultra_pio_input) {
344 outb(0x11, ioaddr + 6); /* Enable interrupts and PIO. */
345 outb(0x01, ioaddr + 0x19); /* Enable ring read auto-wrap. */
347 outb(0x01, ioaddr + 6); /* Enable interrupts and memory. */
348 /* Set the early receive warning level in window 0 high enough not
349 to receive ERW interrupts. */
350 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
351 outb(0xff, dev->base_addr + EN0_ERWCNT);
357 ultra_reset_8390(struct net_device *dev)
359 int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC base addr */
361 outb(ULTRA_RESET, cmd_port);
362 if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
365 outb(0x00, cmd_port); /* Disable shared memory for safety. */
366 outb(0x80, cmd_port + 5);
367 if (ei_status.block_input == &ultra_pio_input)
368 outb(0x11, cmd_port + 6); /* Enable interrupts and PIO. */
370 outb(0x01, cmd_port + 6); /* Enable interrupts and memory. */
372 if (ei_debug > 1) printk("reset done\n");
376 /* Grab the 8390 specific header. Similar to the block_input routine, but
377 we don't need to be concerned with ring wrap as the header will be at
378 the start of a page, so we optimize accordingly. */
381 ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
383 unsigned long hdr_start = dev->mem_start + ((ring_page - START_PG)<<8);
385 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem on */
387 /* Officially this is what we are doing, but the readl() is faster */
388 /* unfortunately it isn't endian aware of the struct */
389 isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
390 hdr->count = le16_to_cpu(hdr->count);
392 ((unsigned int*)hdr)[0] = isa_readl(hdr_start);
394 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
397 /* Block input and output are easy on shared memory ethercards, the only
398 complication is when the ring buffer wraps. */
401 ultra_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
403 unsigned long xfer_start = dev->mem_start + ring_offset - (START_PG<<8);
405 /* Enable shared memory. */
406 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
408 if (xfer_start + count > dev->rmem_end) {
409 /* We must wrap the input move. */
410 int semi_count = dev->rmem_end - xfer_start;
411 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
413 isa_memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
415 /* Packet is in one chunk -- we can copy + cksum. */
416 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
419 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
423 ultra_block_output(struct net_device *dev, int count, const unsigned char *buf,
426 unsigned long shmem = dev->mem_start + ((start_page - START_PG)<<8);
428 /* Enable shared memory. */
429 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
431 isa_memcpy_toio(shmem, buf, count);
433 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
436 /* The identical operations for programmed I/O cards.
437 The PIO model is trivial to use: the 16 bit start address is written
438 byte-sequentially to IOPA, with no intervening I/O operations, and the
439 data is read or written to the IOPD data port.
440 The only potential complication is that the address register is shared
441 and must be always be rewritten between each read/write direction change.
442 This is no problem for us, as the 8390 code ensures that we are single
444 static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
447 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
448 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
449 outb(ring_page, ioaddr + IOPA);
450 insw(ioaddr + IOPD, hdr, sizeof(struct e8390_pkt_hdr)>>1);
453 static void ultra_pio_input(struct net_device *dev, int count,
454 struct sk_buff *skb, int ring_offset)
456 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
457 char *buf = skb->data;
459 /* For now set the address again, although it should already be correct. */
460 outb(ring_offset, ioaddr + IOPA); /* Set the address, LSB first. */
461 outb(ring_offset >> 8, ioaddr + IOPA);
462 /* We know skbuffs are padded to at least word alignment. */
463 insw(ioaddr + IOPD, buf, (count+1)>>1);
466 static void ultra_pio_output(struct net_device *dev, int count,
467 const unsigned char *buf, const int start_page)
469 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
470 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
471 outb(start_page, ioaddr + IOPA);
472 /* An extra odd byte is OK here as well. */
473 outsw(ioaddr + IOPD, buf, (count+1)>>1);
477 ultra_close_card(struct net_device *dev)
479 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
481 netif_stop_queue(dev);
484 printk("%s: Shutting down ethercard.\n", dev->name);
486 outb(0x00, ioaddr + 6); /* Disable interrupts. */
487 free_irq(dev->irq, dev);
491 /* We should someday disable shared memory and change to 8-bit mode
499 #define MAX_ULTRA_CARDS 4 /* Max number of Ultra cards per module */
500 static struct net_device dev_ultra[MAX_ULTRA_CARDS];
501 static int io[MAX_ULTRA_CARDS];
502 static int irq[MAX_ULTRA_CARDS];
504 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_ULTRA_CARDS) "i");
505 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_ULTRA_CARDS) "i");
506 MODULE_PARM_DESC(io, "I/O base address(es)");
507 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
508 MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
509 MODULE_LICENSE("GPL");
513 /* This is set up so that only a single autoprobe takes place per call.
514 ISA device autoprobes on a running machine are not recommended. */
518 int this_dev, found = 0;
520 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
521 struct net_device *dev = &dev_ultra[this_dev];
522 dev->irq = irq[this_dev];
523 dev->base_addr = io[this_dev];
524 dev->init = ultra_probe;
525 if (io[this_dev] == 0) {
526 if (this_dev != 0) break; /* only autoprobe 1st one */
527 printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
529 if (register_netdev(dev) != 0) {
530 printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
531 if (found != 0) return 0; /* Got at least one. */
545 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
546 struct net_device *dev = &dev_ultra[this_dev];
547 if (dev->priv != NULL) {
548 /* NB: ultra_close_card() does free_irq */
549 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
551 #if defined CONFIG_ISAPNP || defined CONFIG_ISAPNP_MODULE
552 struct pci_dev *idev = (struct pci_dev *)ei_status.priv;
554 idev->deactivate(idev);
557 unregister_netdev(dev);
558 release_region(ioaddr, ULTRA_IO_EXTENT);
569 * compile-command: "gcc -D__KERNEL__ -Wall -O6 -I/usr/src/linux/net/inet -c smc-ultra.c"
571 * kept-new-versions: 5