blob: b03feae459fcf335db90ca08d7d8506b64c86779 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* wd.c: A WD80x3 ethernet driver for linux. */
2/*
3 Written 1993-94 by Donald Becker.
4
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
7
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
10
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
14 Annapolis MD 21403
15
16 This is a driver for WD8003 and WD8013 "compatible" ethercards.
17
18 Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
19
20 Changelog:
21
22 Paul Gortmaker : multiple card support for module users, support
23 for non-standard memory sizes.
24
25
26*/
27
28static const char version[] =
29 "wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
30
31#include <linux/module.h>
32#include <linux/kernel.h>
33#include <linux/errno.h>
34#include <linux/string.h>
35#include <linux/init.h>
36#include <linux/interrupt.h>
37#include <linux/delay.h>
38#include <linux/netdevice.h>
39#include <linux/etherdevice.h>
40
41#include <asm/io.h>
42#include <asm/system.h>
43
44#include "8390.h"
45
46#define DRV_NAME "wd"
47
48/* A zero-terminated list of I/O addresses to be probed. */
49static unsigned int wd_portlist[] __initdata =
50{0x300, 0x280, 0x380, 0x240, 0};
51
52static int wd_probe1(struct net_device *dev, int ioaddr);
53
54static int wd_open(struct net_device *dev);
55static void wd_reset_8390(struct net_device *dev);
56static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
57 int ring_page);
58static void wd_block_input(struct net_device *dev, int count,
59 struct sk_buff *skb, int ring_offset);
60static void wd_block_output(struct net_device *dev, int count,
61 const unsigned char *buf, int start_page);
62static int wd_close(struct net_device *dev);
63
64
65#define WD_START_PG 0x00 /* First page of TX buffer */
66#define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */
67#define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */
68
69#define WD_CMDREG 0 /* Offset to ASIC command register. */
70#define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */
71#define WD_MEMENB 0x40 /* Enable the shared memory. */
72#define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */
73#define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */
74#define NIC16 0x40 /* Enable 16 bit access from the 8390. */
75#define WD_NIC_OFFSET 16 /* Offset to the 8390 from the base_addr. */
76#define WD_IO_EXTENT 32
77
78
79/* Probe for the WD8003 and WD8013. These cards have the station
80 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
81 following. A Soundblaster can have the same checksum as an WDethercard,
82 so we have an extra exclusionary check for it.
83
84 The wd_probe1() routine initializes the card and fills the
85 station address field. */
86
87static int __init do_wd_probe(struct net_device *dev)
88{
89 int i;
90 struct resource *r;
91 int base_addr = dev->base_addr;
92 int irq = dev->irq;
93 int mem_start = dev->mem_start;
94 int mem_end = dev->mem_end;
95
96 SET_MODULE_OWNER(dev);
97
98 if (base_addr > 0x1ff) { /* Check a user specified location. */
99 r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
100 if ( r == NULL)
101 return -EBUSY;
102 i = wd_probe1(dev, base_addr);
103 if (i != 0)
104 release_region(base_addr, WD_IO_EXTENT);
105 else
106 r->name = dev->name;
107 return i;
108 }
109 else if (base_addr != 0) /* Don't probe at all. */
110 return -ENXIO;
111
112 for (i = 0; wd_portlist[i]; i++) {
113 int ioaddr = wd_portlist[i];
114 r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
115 if (r == NULL)
116 continue;
117 if (wd_probe1(dev, ioaddr) == 0) {
118 r->name = dev->name;
119 return 0;
120 }
121 release_region(ioaddr, WD_IO_EXTENT);
122 dev->irq = irq;
123 dev->mem_start = mem_start;
124 dev->mem_end = mem_end;
125 }
126
127 return -ENODEV;
128}
129
130static void cleanup_card(struct net_device *dev)
131{
132 free_irq(dev->irq, dev);
133 release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
134 iounmap(ei_status.mem);
135}
136
137#ifndef MODULE
138struct net_device * __init wd_probe(int unit)
139{
140 struct net_device *dev = alloc_ei_netdev();
141 int err;
142
143 if (!dev)
144 return ERR_PTR(-ENOMEM);
145
146 sprintf(dev->name, "eth%d", unit);
147 netdev_boot_setup_check(dev);
148
149 err = do_wd_probe(dev);
150 if (err)
151 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153out:
154 free_netdev(dev);
155 return ERR_PTR(err);
156}
157#endif
158
159static int __init wd_probe1(struct net_device *dev, int ioaddr)
160{
161 int i;
b1fc5502005-05-12 20:11:55 -0400162 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 int checksum = 0;
164 int ancient = 0; /* An old card without config registers. */
165 int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
166 const char *model_name;
167 static unsigned version_printed;
168
169 for (i = 0; i < 8; i++)
170 checksum += inb(ioaddr + 8 + i);
171 if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
172 || inb(ioaddr + 9) == 0xff
173 || (checksum & 0xff) != 0xFF)
174 return -ENODEV;
175
176 /* Check for semi-valid mem_start/end values if supplied. */
177 if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
178 printk(KERN_WARNING "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
179 dev->mem_start = 0;
180 dev->mem_end = 0;
181 }
182
183 if (ei_debug && version_printed++ == 0)
184 printk(version);
185
186 printk("%s: WD80x3 at %#3x,", dev->name, ioaddr);
187 for (i = 0; i < 6; i++)
188 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
189
190 /* The following PureData probe code was contributed by
191 Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
192 configuration differently from others so we have to check for them.
193 This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
194 */
195 if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
196 unsigned char reg5 = inb(ioaddr+5);
197
198 switch (inb(ioaddr+2)) {
199 case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
200 case 0x05: word16 = 0; model_name = "PDUC8023"; break;
201 case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
202 /* Either 0x01 (dumb) or they've released a new version. */
203 default: word16 = 0; model_name = "PDI8023"; break;
204 }
205 dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
206 dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
207 } else { /* End of PureData probe */
208 /* This method of checking for a 16-bit board is borrowed from the
209 we.c driver. A simpler method is just to look in ASIC reg. 0x03.
210 I'm comparing the two method in alpha test to make certain they
211 return the same result. */
212 /* Check for the old 8 bit board - it has register 0/8 aliasing.
213 Do NOT check i>=6 here -- it hangs the old 8003 boards! */
214 for (i = 0; i < 6; i++)
215 if (inb(ioaddr+i) != inb(ioaddr+8+i))
216 break;
217 if (i >= 6) {
218 ancient = 1;
219 model_name = "WD8003-old";
220 word16 = 0;
221 } else {
222 int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
223 outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
224 if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
225 && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
226 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
227 /* Magic to set ASIC to word-wide mode. */
228 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
229 outb(tmp, ioaddr+1);
230 model_name = "WD8013";
231 word16 = 1; /* We have a 16bit board here! */
232 } else {
233 model_name = "WD8003";
234 word16 = 0;
235 }
236 outb(tmp, ioaddr+1); /* Restore original reg1 value. */
237 }
238#ifndef final_version
239 if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
240 printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
241 word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8);
242#endif
243 }
244
245#if defined(WD_SHMEM) && WD_SHMEM > 0x80000
246 /* Allow a compile-time override. */
247 dev->mem_start = WD_SHMEM;
248#else
249 if (dev->mem_start == 0) {
250 /* Sanity and old 8003 check */
251 int reg0 = inb(ioaddr);
252 if (reg0 == 0xff || reg0 == 0) {
253 /* Future plan: this could check a few likely locations first. */
254 dev->mem_start = 0xd0000;
255 printk(" assigning address %#lx", dev->mem_start);
256 } else {
257 int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
258 /* Some boards don't have the register 5 -- it returns 0xff. */
259 if (high_addr_bits == 0x1f || word16 == 0)
260 high_addr_bits = 0x01;
261 dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
262 }
263 }
264#endif
265
266 /* The 8390 isn't at the base address -- the ASIC regs are there! */
267 dev->base_addr = ioaddr+WD_NIC_OFFSET;
268
269 if (dev->irq < 2) {
270 int irqmap[] = {9,3,5,7,10,11,15,4};
271 int reg1 = inb(ioaddr+1);
272 int reg4 = inb(ioaddr+4);
273 if (ancient || reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
274 short nic_addr = ioaddr+WD_NIC_OFFSET;
275 unsigned long irq_mask;
276
277 /* We have an old-style ethercard that doesn't report its IRQ
278 line. Do autoirq to find the IRQ line. Note that this IS NOT
279 a reliable way to trigger an interrupt. */
280 outb_p(E8390_NODMA + E8390_STOP, nic_addr);
281 outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
282
283 irq_mask = probe_irq_on();
284 outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
285 outb_p(0x00, nic_addr + EN0_RCNTLO);
286 outb_p(0x00, nic_addr + EN0_RCNTHI);
287 outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
288 mdelay(20);
289 dev->irq = probe_irq_off(irq_mask);
290
291 outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
292
293 if (ei_debug > 2)
294 printk(" autoirq is %d", dev->irq);
295 if (dev->irq < 2)
296 dev->irq = word16 ? 10 : 5;
297 } else
298 dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
299 } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
300 dev->irq = 9;
301
302 /* Snarf the interrupt now. There's no point in waiting since we cannot
303 share and the board will usually be enabled. */
304 i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
305 if (i) {
306 printk (" unable to get IRQ %d.\n", dev->irq);
307 return i;
308 }
309
310 /* OK, were are certain this is going to work. Setup the device. */
311 ei_status.name = model_name;
312 ei_status.word16 = word16;
313 ei_status.tx_start_page = WD_START_PG;
314 ei_status.rx_start_page = WD_START_PG + TX_PAGES;
315
316 /* Don't map in the shared memory until the board is actually opened. */
317
318 /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
319 if (dev->mem_end != 0) {
320 ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
321 ei_status.priv = dev->mem_end - dev->mem_start;
322 } else {
323 ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
324 dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
325 ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
326 }
327
328 ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
329 if (!ei_status.mem) {
330 free_irq(dev->irq, dev);
331 return -ENOMEM;
332 }
333
334 printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
335 model_name, dev->irq, dev->mem_start, dev->mem_end-1);
336
337 ei_status.reset_8390 = &wd_reset_8390;
338 ei_status.block_input = &wd_block_input;
339 ei_status.block_output = &wd_block_output;
340 ei_status.get_8390_hdr = &wd_get_8390_hdr;
341 dev->open = &wd_open;
342 dev->stop = &wd_close;
343#ifdef CONFIG_NET_POLL_CONTROLLER
344 dev->poll_controller = ei_poll;
345#endif
346 NS8390_init(dev, 0);
347
348#if 1
349 /* Enable interrupt generation on softconfig cards -- M.U */
350 /* .. but possibly potentially unsafe - Donald */
351 if (inb(ioaddr+14) & 0x20)
352 outb(inb(ioaddr+4)|0x80, ioaddr+4);
353#endif
354
b1fc5502005-05-12 20:11:55 -0400355 err = register_netdev(dev);
356 if (err)
357 free_irq(dev->irq, dev);
358 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
360
361static int
362wd_open(struct net_device *dev)
363{
364 int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
365
366 /* Map in the shared memory. Always set register 0 last to remain
367 compatible with very old boards. */
368 ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
369 ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
370
371 if (ei_status.word16)
372 outb(ei_status.reg5, ioaddr+WD_CMDREG5);
373 outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
374
375 ei_open(dev);
376 return 0;
377}
378
379static void
380wd_reset_8390(struct net_device *dev)
381{
382 int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
383
384 outb(WD_RESET, wd_cmd_port);
385 if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies);
386 ei_status.txing = 0;
387
388 /* Set up the ASIC registers, just in case something changed them. */
389 outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
390 if (ei_status.word16)
391 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
392
393 if (ei_debug > 1) printk("reset done\n");
394 return;
395}
396
397/* Grab the 8390 specific header. Similar to the block_input routine, but
398 we don't need to be concerned with ring wrap as the header will be at
399 the start of a page, so we optimize accordingly. */
400
401static void
402wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
403{
404
405 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
406 void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
407
408 /* We'll always get a 4 byte header read followed by a packet read, so
409 we enable 16 bit mode before the header, and disable after the body. */
410 if (ei_status.word16)
411 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
412
413#ifdef __BIG_ENDIAN
414 /* Officially this is what we are doing, but the readl() is faster */
415 /* unfortunately it isn't endian aware of the struct */
416 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
417 hdr->count = le16_to_cpu(hdr->count);
418#else
419 ((unsigned int*)hdr)[0] = readl(hdr_start);
420#endif
421}
422
423/* Block input and output are easy on shared memory ethercards, and trivial
424 on the Western digital card where there is no choice of how to do it.
425 The only complications are that the ring buffer wraps, and need to map
426 switch between 8- and 16-bit modes. */
427
428static void
429wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
430{
431 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
432 unsigned long offset = ring_offset - (WD_START_PG<<8);
433 void __iomem *xfer_start = ei_status.mem + offset;
434
435 if (offset + count > ei_status.priv) {
436 /* We must wrap the input move. */
437 int semi_count = ei_status.priv - offset;
438 memcpy_fromio(skb->data, xfer_start, semi_count);
439 count -= semi_count;
440 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
441 } else {
442 /* Packet is in one chunk -- we can copy + cksum. */
443 eth_io_copy_and_sum(skb, xfer_start, count, 0);
444 }
445
446 /* Turn off 16 bit access so that reboot works. ISA brain-damage */
447 if (ei_status.word16)
448 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
449}
450
451static void
452wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
453 int start_page)
454{
455 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
456 void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
457
458
459 if (ei_status.word16) {
460 /* Turn on and off 16 bit access so that reboot works. */
461 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
462 memcpy_toio(shmem, buf, count);
463 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
464 } else
465 memcpy_toio(shmem, buf, count);
466}
467
468
469static int
470wd_close(struct net_device *dev)
471{
472 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
473
474 if (ei_debug > 1)
475 printk("%s: Shutting down ethercard.\n", dev->name);
476 ei_close(dev);
477
478 /* Change from 16-bit to 8-bit shared memory so reboot works. */
479 if (ei_status.word16)
480 outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
481
482 /* And disable the shared memory. */
483 outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
484
485 return 0;
486}
487
488
489#ifdef MODULE
490#define MAX_WD_CARDS 4 /* Max number of wd cards per module */
491static struct net_device *dev_wd[MAX_WD_CARDS];
492static int io[MAX_WD_CARDS];
493static int irq[MAX_WD_CARDS];
494static int mem[MAX_WD_CARDS];
495static int mem_end[MAX_WD_CARDS]; /* for non std. mem size */
496
497module_param_array(io, int, NULL, 0);
498module_param_array(irq, int, NULL, 0);
499module_param_array(mem, int, NULL, 0);
500module_param_array(mem_end, int, NULL, 0);
501MODULE_PARM_DESC(io, "I/O base address(es)");
502MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
503MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
504MODULE_PARM_DESC(mem_end, "memory end address(es)");
505MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
506MODULE_LICENSE("GPL");
507
508/* This is set up so that only a single autoprobe takes place per call.
509ISA device autoprobes on a running machine are not recommended. */
510int
511init_module(void)
512{
513 struct net_device *dev;
514 int this_dev, found = 0;
515
516 for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
517 if (io[this_dev] == 0) {
518 if (this_dev != 0) break; /* only autoprobe 1st one */
519 printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
520 }
521 dev = alloc_ei_netdev();
522 if (!dev)
523 break;
524 dev->irq = irq[this_dev];
525 dev->base_addr = io[this_dev];
526 dev->mem_start = mem[this_dev];
527 dev->mem_end = mem_end[this_dev];
528 if (do_wd_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400529 dev_wd[found++] = dev;
530 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532 free_netdev(dev);
533 printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
534 break;
535 }
536 if (found)
537 return 0;
538 return -ENXIO;
539}
540
541void
542cleanup_module(void)
543{
544 int this_dev;
545
546 for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
547 struct net_device *dev = dev_wd[this_dev];
548 if (dev) {
549 unregister_netdev(dev);
550 cleanup_card(dev);
551 free_netdev(dev);
552 }
553 }
554}
555#endif /* MODULE */