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