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