![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /* wd.c: A WD80x3 ethernet driver for linux. */
2 /*
3 Written 1993 by Donald Becker.
4 Copyright 1993 United States Government as represented by the
5 Director, National Security Agency. This software may be used and
6 distributed according to the terms of the GNU Public License,
7 incorporated herein by reference.
8
9 This is a driver for WD8003 and WD8013 "compatible" ethercards.
10
11 The Author may be reached as becker@super.org or
12 C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
13
14 Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
15 */
16
17 static char *version =
18 "wd.c:v0.99-14 11/21/93 Donald Becker (becker@super.org)\n";
19
20 #include <linux/config.h>
21 #include <linux/kernel.h>
22 #include <linux/sched.h>
23 #include <linux/errno.h>
24 #include <linux/string.h>
25 #include <asm/io.h>
26 #include <asm/system.h>
27
28 #include "dev.h"
29 #include "8390.h"
30
31 /* Compatibility definitions for earlier kernel versions. */
32 #ifndef HAVE_PORTRESERVE
33 #define check_region(ioaddr, size) 0
34 #define snarf_region(ioaddr, size) do ; while (0)
35 #endif
36
37 int wd_probe(struct device *dev);
38 int wdprobe1(int ioaddr, struct device *dev);
39
40 static int wd_open(struct device *dev);
41 static void wd_reset_8390(struct device *dev);
42 static int wd_block_input(struct device *dev, int count,
43 char *buf, int ring_offset);
44 static void wd_block_output(struct device *dev, int count,
45 const unsigned char *buf, const start_page);
46 static int wd_close_card(struct device *dev);
47
48
49 #define WD_START_PG 0x00 /* First page of TX buffer */
50 #define WD03_STOP_PG 0x20 /* Last page +1 of RX ring */
51 #define WD13_STOP_PG 0x40 /* Last page +1 of RX ring */
52
53 #define WD_CMDREG 0 /* Offset to ASIC command register. */
54 #define WD_RESET 0x80 /* Board reset, in WD_CMDREG. */
55 #define WD_MEMENB 0x40 /* Enable the shared memory. */
56 #define WD_CMDREG5 5 /* Offset to 16-bit-only ASIC register 5. */
57 #define ISA16 0x80 /* Enable 16 bit access from the ISA bus. */
58 #define NIC16 0x40 /* Enable 16 bit access from the 8390. */
59 #define WD_NIC_OFFSET 16 /* Offset to the 8390 NIC from the base_addr. */
60
61 /* Probe for the WD8003 and WD8013. These cards have the station
62 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
63 following. A Soundblaster can have the same checksum as an WDethercard,
64 so we have an extra exclusionary check for it.
65
66 The wdprobe1() routine initializes the card and fills the
67 station address field. */
68
69 int wd_probe(struct device *dev)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
70 {
71 int *port, ports[] = {0x300, 0x280, 0x380, 0x240, 0};
72 short ioaddr = dev->base_addr;
73
74 if (ioaddr < 0)
75 return ENXIO; /* Don't probe at all. */
76 if (ioaddr > 0x100)
77 return ! wdprobe1(ioaddr, dev);
78
79 for (port = &ports[0]; *port; port++) {
80 if (check_region(*port, 32))
81 continue;
82 if (inb(*port + 8) != 0xff
83 && inb(*port + 9) != 0xff /* Extra check to avoid soundcard. */
84 && wdprobe1(*port, dev))
85 return 0;
86 }
87 dev->base_addr = ioaddr;
88 return ENODEV;
89 }
90
91 int wdprobe1(int ioaddr, struct device *dev)
/* ![[previous]](../icons/left.png)
*/
92 {
93 int i;
94 unsigned char *station_addr = dev->dev_addr;
95 int checksum = 0;
96 int ancient = 0; /* An old card without config registers. */
97 int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
98 char *model_name;
99
100 for (i = 0; i < 8; i++)
101 checksum += inb(ioaddr + 8 + i);
102 if ((checksum & 0xff) != 0xFF)
103 return 0;
104
105 printk("%s: WD80x3 at %#3x, ", dev->name, ioaddr);
106 for (i = 0; i < 6; i++)
107 printk(" %2.2X", station_addr[i] = inb(ioaddr + 8 + i));
108
109 /* The following PureData probe code was contributed by
110 Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
111 configuration differently from others so we have to check for them.
112 This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
113 */
114 if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
115 unsigned char reg5 = inb(ioaddr+5);
116
117 switch (inb(ioaddr+2)) {
118 case 0x03: word16 = 0; model_name = "PDI8023-8"; break;
119 case 0x05: word16 = 0; model_name = "PDUC8023"; break;
120 case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
121 /* Either 0x01 (dumb) or they've released a new version. */
122 default: word16 = 0; model_name = "PDI8023"; break;
123 }
124 dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
125 dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
126 } else { /* End of PureData probe */
127 /* This method of checking for a 16-bit board is borrowed from the
128 we.c driver. A simpler method is just to look in ASIC reg. 0x03.
129 I'm comparing the two method in alpha test to make certain they
130 return the same result. */
131 /* Check for the old 8 bit board - it has register 0/8 aliasing.
132 Do NOT check i>=6 here -- it hangs the old 8003 boards! */
133 for (i = 0; i < 6; i++)
134 if (inb(ioaddr+i) != inb(ioaddr+8+i))
135 break;
136 if (i >= 6) {
137 ancient = 1;
138 model_name = "WD8003-old";
139 word16 = 0;
140 } else {
141 int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
142 outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
143 if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
144 && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
145 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
146 /* Magic to set ASIC to word-wide mode. */
147 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
148 outb(tmp, ioaddr+1);
149 model_name = "WD8013";
150 word16 = 1; /* We have a 16bit board here! */
151 } else {
152 model_name = "WD8003";
153 word16 = 0;
154 }
155 outb(tmp, ioaddr+1); /* Restore original reg1 value. */
156 }
157 #ifndef final_version
158 if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
159 printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
160 word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8);
161 #endif
162 }
163
164 #if defined(WD_SHMEM) && WD_SHMEM > 0x80000
165 /* Allow a compile-time override. */
166 dev->mem_start = WD_SHMEM;
167 #else
168 if (dev->mem_start == 0) {
169 /* Sanity and old 8003 check */
170 int reg0 = inb(ioaddr);
171 if (reg0 == 0xff || reg0 == 0) {
172 /* Future plan: this could check a few likely locations first. */
173 dev->mem_start = 0xd0000;
174 printk(" assigning address %#lx", dev->mem_start);
175 } else {
176 int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
177 /* Some boards don't have the register 5 -- it returns 0xff. */
178 if (high_addr_bits == 0x1f || word16 == 0)
179 high_addr_bits = 0x01;
180 dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
181 }
182 }
183 #endif
184
185 /* The 8390 isn't at the base address -- the ASIC regs are there! */
186 dev->base_addr = ioaddr+WD_NIC_OFFSET;
187
188 if (dev->irq < 2) {
189 int irqmap[] = {9,3,5,7,10,11,15,4};
190 int reg1 = inb(ioaddr+1);
191 int reg4 = inb(ioaddr+4);
192 if (ancient || reg1 == 0xff) { /* Ack!! No way to read the IRQ! */
193 short nic_addr = ioaddr+WD_NIC_OFFSET;
194
195 /* We have an old-style ethercard that doesn't report its IRQ
196 line. Do autoirq to find the IRQ line. Note that this IS NOT
197 a reliable way to trigger an interrupt. */
198 outb_p(E8390_NODMA + E8390_STOP, nic_addr);
199 outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
200 autoirq_setup(0);
201 outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
202 outb_p(0x00, nic_addr + EN0_RCNTLO);
203 outb_p(0x00, nic_addr + EN0_RCNTHI);
204 outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
205 dev->irq = autoirq_report(2);
206 outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
207
208 if (ei_debug > 2)
209 printk(" autoirq is %d", dev->irq);
210 if (dev->irq < 2)
211 dev->irq = word16 ? 10 : 5;
212 } else
213 dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
214 } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */
215 dev->irq = 9;
216
217 /* Snarf the interrupt now. There's no point in waiting since we cannot
218 share and the board will usually be enabled. */
219 if (irqaction (dev->irq, &ei_sigaction)) {
220 printk (" unable to get IRQ %d.\n", dev->irq);
221 return 0;
222 }
223
224 /* OK, were are certain this is going to work. Setup the device. */
225 snarf_region(ioaddr, 32);
226 ethdev_init(dev);
227
228 ei_status.name = model_name;
229 ei_status.word16 = word16;
230 ei_status.tx_start_page = WD_START_PG;
231 ei_status.rx_start_page = WD_START_PG + TX_PAGES;
232 ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
233
234 /* Don't map in the shared memory until the board is actually opened. */
235 dev->rmem_start = dev->mem_start + TX_PAGES*256;
236 dev->mem_end = dev->rmem_end
237 = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
238
239 printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
240 model_name, dev->irq, dev->mem_start, dev->mem_end-1);
241 if (ei_debug > 0)
242 printk(version);
243
244 ei_status.reset_8390 = &wd_reset_8390;
245 ei_status.block_input = &wd_block_input;
246 ei_status.block_output = &wd_block_output;
247 dev->open = &wd_open;
248 dev->stop = &wd_close_card;
249 NS8390_init(dev, 0);
250
251 return dev->base_addr;
252 }
253
254 static int
255 wd_open(struct device *dev)
/* */
256 {
257 int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
258
259 /* Map in the shared memory. Always set register 0 last to remain
260 compatible with very old boards. */
261 ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
262 ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
263
264 if (ei_status.word16)
265 outb(ei_status.reg5, ioaddr+WD_CMDREG5);
266 outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
267
268 return ei_open(dev);
269 }
270
271 static void
272 wd_reset_8390(struct device *dev)
/* */
273 {
274 int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
275
276 outb(WD_RESET, wd_cmd_port);
277 if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies);
278 ei_status.txing = 0;
279
280 /* Set up the ASIC registers, just in case something changed them. */
281 outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
282 if (ei_status.word16)
283 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
284
285 if (ei_debug > 1) printk("reset done\n");
286 return;
287 }
288
289 /* Block input and output are easy on shared memory ethercards, and trivial
290 on the Western digital card where there is no choice of how to do it.
291 The only complications are that the ring buffer wraps, and need to map
292 switch between 8- and 16-bit modes. */
293
294 static int
295 wd_block_input(struct device *dev, int count, char *buf, int ring_offset)
/* */
296 {
297 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
298 long xfer_start = dev->mem_start + ring_offset - (WD_START_PG<<8);
299
300 /* We'll always get a 4 byte header read followed by a packet read, so
301 we enable 16 bit mode before the header, and disable after the body. */
302 if (count == 4) {
303 if (ei_status.word16)
304 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
305 ((int*)buf)[0] = ((int*)xfer_start)[0];
306 return 0;
307 }
308
309 if (xfer_start + count > dev->rmem_end) {
310 /* We must wrap the input move. */
311 int semi_count = dev->rmem_end - xfer_start;
312 memcpy(buf, (char *)xfer_start, semi_count);
313 count -= semi_count;
314 memcpy(buf + semi_count, (char *)dev->rmem_start, count);
315 } else
316 memcpy(buf, (char *)xfer_start, count);
317
318 /* Turn off 16 bit access so that reboot works. ISA brain-damage */
319 if (ei_status.word16)
320 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
321
322 return 0;
323 }
324
325 static void
326 wd_block_output(struct device *dev, int count, const unsigned char *buf,
/* */
327 int start_page)
328 {
329 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
330 long shmem = dev->mem_start + ((start_page - WD_START_PG)<<8);
331
332
333 if (ei_status.word16) {
334 /* Turn on and off 16 bit access so that reboot works. */
335 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
336 memcpy((char *)shmem, buf, count);
337 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
338 } else
339 memcpy((char *)shmem, buf, count);
340 }
341
342
343 static int
344 wd_close_card(struct device *dev)
/* ![[last]](../icons/n_last.png)
*/
345 {
346 int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
347
348 if (ei_debug > 1)
349 printk("%s: Shutting down ethercard.\n", dev->name);
350 NS8390_init(dev, 0);
351
352 /* Change from 16-bit to 8-bit shared memory so reboot works. */
353 outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
354
355 /* And disable the shared memory. */
356 outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
357
358 return 0;
359 }
360
361
362 /*
363 * Local variables:
364 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c wd.c"
365 * version-control: t
366 * tab-width: 4
367 * kept-new-versions: 5
368 * End:
369 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/