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
do_wd_probe(struct net_device * dev)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, 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
wd_probe(int unit)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(-ENOMEM);
135
136 sprintf(dev->name, "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(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
wd_probe1(struct net_device * dev,int ioaddr)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(ioaddr + 8 + i);
177 if (inb(ioaddr + 8) == 0xff /* Extra check to avoid soundcard. */
178 || inb(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 "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, version);
192
193 for (i = 0; i < 6; i++)
194 addr[i] = inb(ioaddr + 8 + i);
195 eth_hw_addr_set(dev, addr);
196
197 netdev_info(dev, "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(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
205 unsigned char reg5 = inb(ioaddr+5);
206
207 switch (inb(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(ioaddr+i) != inb(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(ioaddr+1); /* fiddle with 16bit bit */
232 outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
233 if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
234 && (tmp & 0x01) == 0x01 ) { /* In a 16 slot. */
235 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
236 /* Magic to set ASIC to word-wide mode. */
237 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
238 outb(tmp, 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(tmp, ioaddr+1); /* Restore original reg1 value. */
246 }
247 #ifndef final_version
248 if ( !ancient && (inb(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(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(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(ioaddr+1);
282 int reg4 = inb(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, nic_addr);
291 outb(0x00, nic_addr+EN0_IMR); /* Disable all intrs. */
292
293 irq_mask = probe_irq_on();
294 outb_p(0xff, nic_addr + EN0_IMR); /* Enable all interrupts. */
295 outb_p(0x00, nic_addr + EN0_RCNTLO);
296 outb_p(0x00, nic_addr + EN0_RCNTHI);
297 outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
298 mdelay(20);
299 dev->irq = probe_irq_off(irq_mask);
300
301 outb_p(0x00, 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(dev->irq, ei_interrupt, 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(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, 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(ioaddr+14) & 0x20)
360 outb(inb(ioaddr+4)|0x80, 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
wd_open(struct net_device * dev)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, ioaddr+WD_CMDREG5);
383 outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
384
385 return ei_open(dev);
386 }
387
388 static void
wd_reset_8390(struct net_device * dev)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, 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((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
401 if (ei_status.word16)
402 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), 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
wd_get_8390_hdr(struct net_device * dev,struct e8390_pkt_hdr * hdr,int ring_page)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, 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(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
wd_block_input(struct net_device * dev,int count,struct sk_buff * skb,int ring_offset)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, wd_cmdreg+WD_CMDREG5);
459 }
460
461 static void
wd_block_output(struct net_device * dev,int count,const unsigned char * buf,int start_page)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, wd_cmdreg+WD_CMDREG5);
472 memcpy_toio(shmem, buf, count);
473 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
474 } else
475 memcpy_toio(shmem, buf, count);
476 }
477
478
479 static int
wd_close(struct net_device * dev)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, wd_cmdreg + WD_CMDREG5 );
491
492 /* And disable the shared memory. */
493 outb(ei_status.reg0 & ~WD_MEMENB, 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
wd_init_module(void)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
cleanup_card(struct net_device * dev)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
wd_cleanup_module(void)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