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