blob: b564c677c6d25542a75a06a21e4d13f9adc0851f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* smc-ultra.c: A SMC Ultra ethernet driver for linux. */
2/*
3 This is a driver for the SMC Ultra and SMC EtherEZ ISA ethercards.
4
5 Written 1993-1998 by Donald Becker.
6
7 Copyright 1993 United States Government as represented by the
8 Director, National Security Agency.
9
10 This software may be used and distributed according to the terms
11 of the GNU General Public License, incorporated herein by reference.
12
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
16 Annapolis MD 21403
17
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
21
22 ultra_probe() Detecting and initializing the card.
23 ultra_probe1()
24 ultra_probe_isapnp()
25
26 ultra_open() The card-specific details of starting, stopping
27 ultra_reset_8390() and resetting the 8390 NIC core.
28 ultra_close()
29
30 ultra_block_input() Routines for reading and writing blocks of
31 ultra_block_output() packet buffer memory.
32 ultra_pio_input()
33 ultra_pio_output()
34
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.
38
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.
42
43 Changelog:
44
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
49
50 Note about the ISA PnP support:
51
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.
55*/
56
57static const char version[] =
58 "smc-ultra.c:v2.02 2/3/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
59
60#include <linux/config.h>
61#include <linux/module.h>
62#include <linux/kernel.h>
63#include <linux/errno.h>
64#include <linux/string.h>
65#include <linux/init.h>
66#include <linux/isapnp.h>
67#include <linux/netdevice.h>
68#include <linux/etherdevice.h>
69
70#include <asm/io.h>
71#include <asm/system.h>
72
73#include "8390.h"
74
75#define DRV_NAME "smc-ultra"
76
77/* A zero-terminated list of I/O addresses to be probed. */
78static unsigned int ultra_portlist[] __initdata =
79{0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
80
81static int ultra_probe1(struct net_device *dev, int ioaddr);
82
83#ifdef __ISAPNP__
84static int ultra_probe_isapnp(struct net_device *dev);
85#endif
86
87static int ultra_open(struct net_device *dev);
88static void ultra_reset_8390(struct net_device *dev);
89static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
90 int ring_page);
91static void ultra_block_input(struct net_device *dev, int count,
92 struct sk_buff *skb, int ring_offset);
93static void ultra_block_output(struct net_device *dev, int count,
94 const unsigned char *buf, const int start_page);
95static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
96 int ring_page);
97static void ultra_pio_input(struct net_device *dev, int count,
98 struct sk_buff *skb, int ring_offset);
99static void ultra_pio_output(struct net_device *dev, int count,
100 const unsigned char *buf, const int start_page);
101static int ultra_close_card(struct net_device *dev);
102
103#ifdef __ISAPNP__
104static 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 */
109};
110
111MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
112#endif
113
114
115#define START_PG 0x00 /* First page of TX buffer */
116
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. */
125
126#ifdef CONFIG_NET_POLL_CONTROLLER
127static void ultra_poll(struct net_device *dev)
128{
129 disable_irq(dev->irq);
130 ei_interrupt(dev->irq, dev, NULL);
131 enable_irq(dev->irq);
132}
133#endif
134/* Probe for the Ultra. This looks like a 8013 with the station
135 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
136 following.
137*/
138
139static int __init do_ultra_probe(struct net_device *dev)
140{
141 int i;
142 int base_addr = dev->base_addr;
143 int irq = dev->irq;
144
145 SET_MODULE_OWNER(dev);
146
147#ifdef CONFIG_NET_POLL_CONTROLLER
148 dev->poll_controller = &ultra_poll;
149#endif
150 if (base_addr > 0x1ff) /* Check a single specified location. */
151 return ultra_probe1(dev, base_addr);
152 else if (base_addr != 0) /* Don't probe at all. */
153 return -ENXIO;
154
155#ifdef __ISAPNP__
156 /* Look for any installed ISAPnP cards */
157 if (isapnp_present() && (ultra_probe_isapnp(dev) == 0))
158 return 0;
159#endif
160
161 for (i = 0; ultra_portlist[i]; i++) {
162 dev->irq = irq;
163 if (ultra_probe1(dev, ultra_portlist[i]) == 0)
164 return 0;
165 }
166
167 return -ENODEV;
168}
169
170static void cleanup_card(struct net_device *dev)
171{
172 /* NB: ultra_close_card() does free_irq */
173#ifdef __ISAPNP__
174 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
175 if (idev)
176 pnp_device_detach(idev);
177#endif
178 release_region(dev->base_addr - ULTRA_NIC_OFFSET, ULTRA_IO_EXTENT);
179 iounmap(ei_status.mem);
180}
181
182#ifndef MODULE
183struct net_device * __init ultra_probe(int unit)
184{
185 struct net_device *dev = alloc_ei_netdev();
186 int err;
187
188 if (!dev)
189 return ERR_PTR(-ENOMEM);
190
191 sprintf(dev->name, "eth%d", unit);
192 netdev_boot_setup_check(dev);
193
194 err = do_ultra_probe(dev);
195 if (err)
196 goto out;
197 err = register_netdev(dev);
198 if (err)
199 goto out1;
200 return dev;
201out1:
202 cleanup_card(dev);
203out:
204 free_netdev(dev);
205 return ERR_PTR(err);
206}
207#endif
208
209static int __init ultra_probe1(struct net_device *dev, int ioaddr)
210{
211 int i, retval;
212 int checksum = 0;
213 const char *model_name;
214 unsigned char eeprom_irq = 0;
215 static unsigned version_printed;
216 /* Values from various config regs. */
217 unsigned char num_pages, irqreg, addr, piomode;
218 unsigned char idreg = inb(ioaddr + 7);
219 unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
220
221 if (!request_region(ioaddr, ULTRA_IO_EXTENT, DRV_NAME))
222 return -EBUSY;
223
224 /* Check the ID nibble. */
225 if ((idreg & 0xF0) != 0x20 /* SMC Ultra */
226 && (idreg & 0xF0) != 0x40) { /* SMC EtherEZ */
227 retval = -ENODEV;
228 goto out;
229 }
230
231 /* Select the station address register set. */
232 outb(reg4, ioaddr + 4);
233
234 for (i = 0; i < 8; i++)
235 checksum += inb(ioaddr + 8 + i);
236 if ((checksum & 0xff) != 0xFF) {
237 retval = -ENODEV;
238 goto out;
239 }
240
241 if (ei_debug && version_printed++ == 0)
242 printk(version);
243
244 model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
245
246 printk("%s: %s at %#3x,", dev->name, model_name, ioaddr);
247
248 for (i = 0; i < 6; i++)
249 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
250
251 /* Switch from the station address to the alternate register set and
252 read the useful registers there. */
253 outb(0x80 | reg4, ioaddr + 4);
254
255 /* Enabled FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
256 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
257 piomode = inb(ioaddr + 0x8);
258 addr = inb(ioaddr + 0xb);
259 irqreg = inb(ioaddr + 0xd);
260
261 /* Switch back to the station address register set so that the MS-DOS driver
262 can find the card after a warm boot. */
263 outb(reg4, ioaddr + 4);
264
265 if (dev->irq < 2) {
266 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
267 int irq;
268
269 /* The IRQ bits are split. */
270 irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
271
272 if (irq == 0) {
273 printk(", failed to detect IRQ line.\n");
274 retval = -EAGAIN;
275 goto out;
276 }
277 dev->irq = irq;
278 eeprom_irq = 1;
279 }
280
281 /* The 8390 isn't at the base address, so fake the offset */
282 dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
283
284 {
285 int addr_tbl[4] = {0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000};
286 short num_pages_tbl[4] = {0x20, 0x40, 0x80, 0xff};
287
288 dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
289 num_pages = num_pages_tbl[(addr >> 4) & 3];
290 }
291
292 ei_status.name = model_name;
293 ei_status.word16 = 1;
294 ei_status.tx_start_page = START_PG;
295 ei_status.rx_start_page = START_PG + TX_PAGES;
296 ei_status.stop_page = num_pages;
297
298 ei_status.mem = ioremap(dev->mem_start, (ei_status.stop_page - START_PG)*256);
299 if (!ei_status.mem) {
300 printk(", failed to ioremap.\n");
301 retval = -ENOMEM;
302 goto out;
303 }
304
305 dev->mem_end = dev->mem_start + (ei_status.stop_page - START_PG)*256;
306
307 if (piomode) {
308 printk(",%s IRQ %d programmed-I/O mode.\n",
309 eeprom_irq ? "EEPROM" : "assigned ", dev->irq);
310 ei_status.block_input = &ultra_pio_input;
311 ei_status.block_output = &ultra_pio_output;
312 ei_status.get_8390_hdr = &ultra_pio_get_hdr;
313 } else {
314 printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
315 dev->irq, dev->mem_start, dev->mem_end-1);
316 ei_status.block_input = &ultra_block_input;
317 ei_status.block_output = &ultra_block_output;
318 ei_status.get_8390_hdr = &ultra_get_8390_hdr;
319 }
320 ei_status.reset_8390 = &ultra_reset_8390;
321 dev->open = &ultra_open;
322 dev->stop = &ultra_close_card;
323#ifdef CONFIG_NET_POLL_CONTROLLER
324 dev->poll_controller = ei_poll;
325#endif
326 NS8390_init(dev, 0);
327
328 return 0;
329out:
330 release_region(ioaddr, ULTRA_IO_EXTENT);
331 return retval;
332}
333
334#ifdef __ISAPNP__
335static int __init ultra_probe_isapnp(struct net_device *dev)
336{
337 int i;
338
339 for (i = 0; ultra_device_ids[i].vendor != 0; i++) {
340 struct pnp_dev *idev = NULL;
341
342 while ((idev = pnp_find_dev(NULL,
343 ultra_device_ids[i].vendor,
344 ultra_device_ids[i].function,
345 idev))) {
346 /* Avoid already found cards from previous calls */
347 if (pnp_device_attach(idev) < 0)
348 continue;
349 if (pnp_activate_dev(idev) < 0) {
350 __again:
351 pnp_device_detach(idev);
352 continue;
353 }
354 /* if no io and irq, search for next */
355 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
356 goto __again;
357 /* found it */
358 dev->base_addr = pnp_port_start(idev, 0);
359 dev->irq = pnp_irq(idev, 0);
360 printk(KERN_INFO "smc-ultra.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
361 (char *) ultra_device_ids[i].driver_data,
362 dev->base_addr, dev->irq);
363 if (ultra_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
364 printk(KERN_ERR "smc-ultra.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
365 pnp_device_detach(idev);
366 return -ENXIO;
367 }
368 ei_status.priv = (unsigned long)idev;
369 break;
370 }
371 if (!idev)
372 continue;
373 return 0;
374 }
375
376 return -ENODEV;
377}
378#endif
379
380static int
381ultra_open(struct net_device *dev)
382{
383 int retval;
384 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
385 unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
386 0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
387
388 retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
389 if (retval)
390 return retval;
391
392 outb(0x00, ioaddr); /* Disable shared memory for safety. */
393 outb(0x80, ioaddr + 5);
394 /* Set the IRQ line. */
395 outb(inb(ioaddr + 4) | 0x80, ioaddr + 4);
396 outb((inb(ioaddr + 13) & ~0x4C) | irq2reg[dev->irq], ioaddr + 13);
397 outb(inb(ioaddr + 4) & 0x7f, ioaddr + 4);
398
399 if (ei_status.block_input == &ultra_pio_input) {
400 outb(0x11, ioaddr + 6); /* Enable interrupts and PIO. */
401 outb(0x01, ioaddr + 0x19); /* Enable ring read auto-wrap. */
402 } else
403 outb(0x01, ioaddr + 6); /* Enable interrupts and memory. */
404 /* Set the early receive warning level in window 0 high enough not
405 to receive ERW interrupts. */
406 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
407 outb(0xff, dev->base_addr + EN0_ERWCNT);
408 ei_open(dev);
409 return 0;
410}
411
412static void
413ultra_reset_8390(struct net_device *dev)
414{
415 int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC base addr */
416
417 outb(ULTRA_RESET, cmd_port);
418 if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
419 ei_status.txing = 0;
420
421 outb(0x00, cmd_port); /* Disable shared memory for safety. */
422 outb(0x80, cmd_port + 5);
423 if (ei_status.block_input == &ultra_pio_input)
424 outb(0x11, cmd_port + 6); /* Enable interrupts and PIO. */
425 else
426 outb(0x01, cmd_port + 6); /* Enable interrupts and memory. */
427
428 if (ei_debug > 1) printk("reset done\n");
429 return;
430}
431
432/* Grab the 8390 specific header. Similar to the block_input routine, but
433 we don't need to be concerned with ring wrap as the header will be at
434 the start of a page, so we optimize accordingly. */
435
436static void
437ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
438{
439 void __iomem *hdr_start = ei_status.mem + ((ring_page - START_PG)<<8);
440
441 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem on */
442#ifdef __BIG_ENDIAN
443 /* Officially this is what we are doing, but the readl() is faster */
444 /* unfortunately it isn't endian aware of the struct */
445 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
446 hdr->count = le16_to_cpu(hdr->count);
447#else
448 ((unsigned int*)hdr)[0] = readl(hdr_start);
449#endif
450 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
451}
452
453/* Block input and output are easy on shared memory ethercards, the only
454 complication is when the ring buffer wraps. */
455
456static void
457ultra_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
458{
459 void __iomem *xfer_start = ei_status.mem + ring_offset - (START_PG<<8);
460
461 /* Enable shared memory. */
462 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
463
464 if (ring_offset + count > ei_status.stop_page*256) {
465 /* We must wrap the input move. */
466 int semi_count = ei_status.stop_page*256 - ring_offset;
467 memcpy_fromio(skb->data, xfer_start, semi_count);
468 count -= semi_count;
469 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
470 } else {
471 /* Packet is in one chunk -- we can copy + cksum. */
472 eth_io_copy_and_sum(skb, xfer_start, count, 0);
473 }
474
475 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
476}
477
478static void
479ultra_block_output(struct net_device *dev, int count, const unsigned char *buf,
480 int start_page)
481{
482 void __iomem *shmem = ei_status.mem + ((start_page - START_PG)<<8);
483
484 /* Enable shared memory. */
485 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
486
487 memcpy_toio(shmem, buf, count);
488
489 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
490}
491
492/* The identical operations for programmed I/O cards.
493 The PIO model is trivial to use: the 16 bit start address is written
494 byte-sequentially to IOPA, with no intervening I/O operations, and the
495 data is read or written to the IOPD data port.
496 The only potential complication is that the address register is shared
497 and must be always be rewritten between each read/write direction change.
498 This is no problem for us, as the 8390 code ensures that we are single
499 threaded. */
500static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
501 int ring_page)
502{
503 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
504 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
505 outb(ring_page, ioaddr + IOPA);
506 insw(ioaddr + IOPD, hdr, sizeof(struct e8390_pkt_hdr)>>1);
507}
508
509static void ultra_pio_input(struct net_device *dev, int count,
510 struct sk_buff *skb, int ring_offset)
511{
512 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
513 char *buf = skb->data;
514
515 /* For now set the address again, although it should already be correct. */
516 outb(ring_offset, ioaddr + IOPA); /* Set the address, LSB first. */
517 outb(ring_offset >> 8, ioaddr + IOPA);
518 /* We know skbuffs are padded to at least word alignment. */
519 insw(ioaddr + IOPD, buf, (count+1)>>1);
520}
521
522static void ultra_pio_output(struct net_device *dev, int count,
523 const unsigned char *buf, const int start_page)
524{
525 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
526 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
527 outb(start_page, ioaddr + IOPA);
528 /* An extra odd byte is OK here as well. */
529 outsw(ioaddr + IOPD, buf, (count+1)>>1);
530}
531
532static int
533ultra_close_card(struct net_device *dev)
534{
535 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
536
537 netif_stop_queue(dev);
538
539 if (ei_debug > 1)
540 printk("%s: Shutting down ethercard.\n", dev->name);
541
542 outb(0x00, ioaddr + 6); /* Disable interrupts. */
543 free_irq(dev->irq, dev);
544
545 NS8390_init(dev, 0);
546
547 /* We should someday disable shared memory and change to 8-bit mode
548 "just in case"... */
549
550 return 0;
551}
552
553
554#ifdef MODULE
555#define MAX_ULTRA_CARDS 4 /* Max number of Ultra cards per module */
556static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
557static int io[MAX_ULTRA_CARDS];
558static int irq[MAX_ULTRA_CARDS];
559
560module_param_array(io, int, NULL, 0);
561module_param_array(irq, int, NULL, 0);
562MODULE_PARM_DESC(io, "I/O base address(es)");
563MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
564MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
565MODULE_LICENSE("GPL");
566
567/* This is set up so that only a single autoprobe takes place per call.
568ISA device autoprobes on a running machine are not recommended. */
569int
570init_module(void)
571{
572 struct net_device *dev;
573 int this_dev, found = 0;
574
575 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
576 if (io[this_dev] == 0) {
577 if (this_dev != 0) break; /* only autoprobe 1st one */
578 printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
579 }
580 dev = alloc_ei_netdev();
581 if (!dev)
582 break;
583 dev->irq = irq[this_dev];
584 dev->base_addr = io[this_dev];
585 if (do_ultra_probe(dev) == 0) {
586 if (register_netdev(dev) == 0) {
587 dev_ultra[found++] = dev;
588 continue;
589 }
590 cleanup_card(dev);
591 }
592 free_netdev(dev);
593 printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
594 break;
595 }
596 if (found)
597 return 0;
598 return -ENXIO;
599}
600
601void
602cleanup_module(void)
603{
604 int this_dev;
605
606 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
607 struct net_device *dev = dev_ultra[this_dev];
608 if (dev) {
609 unregister_netdev(dev);
610 cleanup_card(dev);
611 free_netdev(dev);
612 }
613 }
614}
615#endif /* MODULE */