blob: 3db30cd0625e5fd7151f18af72b414bebe47e054 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* smc-ultra.c: A SMC Ultra ethernet driver for linux. */
2/*
3 This is a driver for the SMC Ultra and SMC EtherEZ ISA ethercards.
4
5 Written 1993-1998 by Donald Becker.
6
7 Copyright 1993 United States Government as represented by the
8 Director, National Security Agency.
9
10 This software may be used and distributed according to the terms
11 of the GNU General Public License, incorporated herein by reference.
12
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
16 Annapolis MD 21403
17
18 This driver uses the cards in the 8390-compatible mode.
19 Most of the run-time complexity is handled by the generic code in
20 8390.c. The code in this file is responsible for
21
22 ultra_probe() Detecting and initializing the card.
23 ultra_probe1()
24 ultra_probe_isapnp()
25
26 ultra_open() The card-specific details of starting, stopping
27 ultra_reset_8390() and resetting the 8390 NIC core.
28 ultra_close()
29
30 ultra_block_input() Routines for reading and writing blocks of
31 ultra_block_output() packet buffer memory.
32 ultra_pio_input()
33 ultra_pio_output()
34
35 This driver enables the shared memory only when doing the actual data
36 transfers to avoid a bug in early version of the card that corrupted
37 data transferred by a AHA1542.
38
39 This driver now supports the programmed-I/O (PIO) data transfer mode of
40 the EtherEZ. It does not use the non-8390-compatible "Altego" mode.
41 That support (if available) is in smc-ez.c.
42
43 Changelog:
44
45 Paul Gortmaker : multiple card support for module users.
46 Donald Becker : 4/17/96 PIO support, minor potential problems avoided.
47 Donald Becker : 6/6/96 correctly set auto-wrap bit.
48 Alexander Sotirov : 1/20/01 Added support for ISAPnP cards
49
50 Note about the ISA PnP support:
51
52 This driver can not autoprobe for more than one SMC EtherEZ PnP card.
53 You have to configure the second card manually through the /proc/isapnp
54 interface and then load the module with an explicit io=0x___ option.
55*/
56
57static const char version[] =
58 "smc-ultra.c:v2.02 2/3/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
59
60#include <linux/config.h>
61#include <linux/module.h>
62#include <linux/kernel.h>
63#include <linux/errno.h>
64#include <linux/string.h>
65#include <linux/init.h>
66#include <linux/isapnp.h>
67#include <linux/netdevice.h>
68#include <linux/etherdevice.h>
69
70#include <asm/io.h>
Al Virobf4e70e2005-08-28 03:52:22 +010071#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <asm/system.h>
73
74#include "8390.h"
75
76#define DRV_NAME "smc-ultra"
77
78/* A zero-terminated list of I/O addresses to be probed. */
79static unsigned int ultra_portlist[] __initdata =
80{0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
81
82static int ultra_probe1(struct net_device *dev, int ioaddr);
83
84#ifdef __ISAPNP__
85static int ultra_probe_isapnp(struct net_device *dev);
86#endif
87
88static int ultra_open(struct net_device *dev);
89static void ultra_reset_8390(struct net_device *dev);
90static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
91 int ring_page);
92static void ultra_block_input(struct net_device *dev, int count,
93 struct sk_buff *skb, int ring_offset);
94static void ultra_block_output(struct net_device *dev, int count,
95 const unsigned char *buf, const int start_page);
96static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
97 int ring_page);
98static void ultra_pio_input(struct net_device *dev, int count,
99 struct sk_buff *skb, int ring_offset);
100static void ultra_pio_output(struct net_device *dev, int count,
101 const unsigned char *buf, const int start_page);
102static int ultra_close_card(struct net_device *dev);
103
104#ifdef __ISAPNP__
105static struct isapnp_device_id ultra_device_ids[] __initdata = {
106 { ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
107 ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
108 (long) "SMC EtherEZ (8416)" },
109 { } /* terminate list */
110};
111
112MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
113#endif
114
115
116#define START_PG 0x00 /* First page of TX buffer */
117
118#define ULTRA_CMDREG 0 /* Offset to ASIC command register. */
119#define ULTRA_RESET 0x80 /* Board reset, in ULTRA_CMDREG. */
120#define ULTRA_MEMENB 0x40 /* Enable the shared memory. */
121#define IOPD 0x02 /* I/O Pipe Data (16 bits), PIO operation. */
122#define IOPA 0x07 /* I/O Pipe Address for PIO operation. */
123#define ULTRA_NIC_OFFSET 16 /* NIC register offset from the base_addr. */
124#define ULTRA_IO_EXTENT 32
125#define EN0_ERWCNT 0x08 /* Early receive warning count. */
126
127#ifdef CONFIG_NET_POLL_CONTROLLER
128static void ultra_poll(struct net_device *dev)
129{
130 disable_irq(dev->irq);
131 ei_interrupt(dev->irq, dev, NULL);
132 enable_irq(dev->irq);
133}
134#endif
135/* Probe for the Ultra. This looks like a 8013 with the station
136 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
137 following.
138*/
139
140static int __init do_ultra_probe(struct net_device *dev)
141{
142 int i;
143 int base_addr = dev->base_addr;
144 int irq = dev->irq;
145
146 SET_MODULE_OWNER(dev);
147
148#ifdef CONFIG_NET_POLL_CONTROLLER
149 dev->poll_controller = &ultra_poll;
150#endif
151 if (base_addr > 0x1ff) /* Check a single specified location. */
152 return ultra_probe1(dev, base_addr);
153 else if (base_addr != 0) /* Don't probe at all. */
154 return -ENXIO;
155
156#ifdef __ISAPNP__
157 /* Look for any installed ISAPnP cards */
158 if (isapnp_present() && (ultra_probe_isapnp(dev) == 0))
159 return 0;
160#endif
161
162 for (i = 0; ultra_portlist[i]; i++) {
163 dev->irq = irq;
164 if (ultra_probe1(dev, ultra_portlist[i]) == 0)
165 return 0;
166 }
167
168 return -ENODEV;
169}
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171#ifndef MODULE
172struct net_device * __init ultra_probe(int unit)
173{
174 struct net_device *dev = alloc_ei_netdev();
175 int err;
176
177 if (!dev)
178 return ERR_PTR(-ENOMEM);
179
180 sprintf(dev->name, "eth%d", unit);
181 netdev_boot_setup_check(dev);
182
183 err = do_ultra_probe(dev);
184 if (err)
185 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187out:
188 free_netdev(dev);
189 return ERR_PTR(err);
190}
191#endif
192
193static int __init ultra_probe1(struct net_device *dev, int ioaddr)
194{
195 int i, retval;
196 int checksum = 0;
197 const char *model_name;
198 unsigned char eeprom_irq = 0;
199 static unsigned version_printed;
200 /* Values from various config regs. */
201 unsigned char num_pages, irqreg, addr, piomode;
202 unsigned char idreg = inb(ioaddr + 7);
203 unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
204
205 if (!request_region(ioaddr, ULTRA_IO_EXTENT, DRV_NAME))
206 return -EBUSY;
207
208 /* Check the ID nibble. */
209 if ((idreg & 0xF0) != 0x20 /* SMC Ultra */
210 && (idreg & 0xF0) != 0x40) { /* SMC EtherEZ */
211 retval = -ENODEV;
212 goto out;
213 }
214
215 /* Select the station address register set. */
216 outb(reg4, ioaddr + 4);
217
218 for (i = 0; i < 8; i++)
219 checksum += inb(ioaddr + 8 + i);
220 if ((checksum & 0xff) != 0xFF) {
221 retval = -ENODEV;
222 goto out;
223 }
224
225 if (ei_debug && version_printed++ == 0)
226 printk(version);
227
228 model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
229
230 printk("%s: %s at %#3x,", dev->name, model_name, ioaddr);
231
232 for (i = 0; i < 6; i++)
233 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
234
235 /* Switch from the station address to the alternate register set and
236 read the useful registers there. */
237 outb(0x80 | reg4, ioaddr + 4);
238
239 /* Enabled FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
240 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
241 piomode = inb(ioaddr + 0x8);
242 addr = inb(ioaddr + 0xb);
243 irqreg = inb(ioaddr + 0xd);
244
245 /* Switch back to the station address register set so that the MS-DOS driver
246 can find the card after a warm boot. */
247 outb(reg4, ioaddr + 4);
248
249 if (dev->irq < 2) {
250 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
251 int irq;
252
253 /* The IRQ bits are split. */
254 irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
255
256 if (irq == 0) {
257 printk(", failed to detect IRQ line.\n");
258 retval = -EAGAIN;
259 goto out;
260 }
261 dev->irq = irq;
262 eeprom_irq = 1;
263 }
264
265 /* The 8390 isn't at the base address, so fake the offset */
266 dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
267
268 {
269 int addr_tbl[4] = {0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000};
270 short num_pages_tbl[4] = {0x20, 0x40, 0x80, 0xff};
271
272 dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
273 num_pages = num_pages_tbl[(addr >> 4) & 3];
274 }
275
276 ei_status.name = model_name;
277 ei_status.word16 = 1;
278 ei_status.tx_start_page = START_PG;
279 ei_status.rx_start_page = START_PG + TX_PAGES;
280 ei_status.stop_page = num_pages;
281
282 ei_status.mem = ioremap(dev->mem_start, (ei_status.stop_page - START_PG)*256);
283 if (!ei_status.mem) {
284 printk(", failed to ioremap.\n");
285 retval = -ENOMEM;
286 goto out;
287 }
288
289 dev->mem_end = dev->mem_start + (ei_status.stop_page - START_PG)*256;
290
291 if (piomode) {
292 printk(",%s IRQ %d programmed-I/O mode.\n",
293 eeprom_irq ? "EEPROM" : "assigned ", dev->irq);
294 ei_status.block_input = &ultra_pio_input;
295 ei_status.block_output = &ultra_pio_output;
296 ei_status.get_8390_hdr = &ultra_pio_get_hdr;
297 } else {
298 printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
299 dev->irq, dev->mem_start, dev->mem_end-1);
300 ei_status.block_input = &ultra_block_input;
301 ei_status.block_output = &ultra_block_output;
302 ei_status.get_8390_hdr = &ultra_get_8390_hdr;
303 }
304 ei_status.reset_8390 = &ultra_reset_8390;
305 dev->open = &ultra_open;
306 dev->stop = &ultra_close_card;
307#ifdef CONFIG_NET_POLL_CONTROLLER
308 dev->poll_controller = ei_poll;
309#endif
310 NS8390_init(dev, 0);
311
b1fc5502005-05-12 20:11:55 -0400312 retval = register_netdev(dev);
313 if (retval)
314 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 return 0;
316out:
317 release_region(ioaddr, ULTRA_IO_EXTENT);
318 return retval;
319}
320
321#ifdef __ISAPNP__
322static int __init ultra_probe_isapnp(struct net_device *dev)
323{
324 int i;
325
326 for (i = 0; ultra_device_ids[i].vendor != 0; i++) {
327 struct pnp_dev *idev = NULL;
328
329 while ((idev = pnp_find_dev(NULL,
330 ultra_device_ids[i].vendor,
331 ultra_device_ids[i].function,
332 idev))) {
333 /* Avoid already found cards from previous calls */
334 if (pnp_device_attach(idev) < 0)
335 continue;
336 if (pnp_activate_dev(idev) < 0) {
337 __again:
338 pnp_device_detach(idev);
339 continue;
340 }
341 /* if no io and irq, search for next */
342 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
343 goto __again;
344 /* found it */
345 dev->base_addr = pnp_port_start(idev, 0);
346 dev->irq = pnp_irq(idev, 0);
347 printk(KERN_INFO "smc-ultra.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
348 (char *) ultra_device_ids[i].driver_data,
349 dev->base_addr, dev->irq);
350 if (ultra_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
351 printk(KERN_ERR "smc-ultra.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
352 pnp_device_detach(idev);
353 return -ENXIO;
354 }
355 ei_status.priv = (unsigned long)idev;
356 break;
357 }
358 if (!idev)
359 continue;
360 return 0;
361 }
362
363 return -ENODEV;
364}
365#endif
366
367static int
368ultra_open(struct net_device *dev)
369{
370 int retval;
371 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
372 unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
373 0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
374
375 retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
376 if (retval)
377 return retval;
378
379 outb(0x00, ioaddr); /* Disable shared memory for safety. */
380 outb(0x80, ioaddr + 5);
381 /* Set the IRQ line. */
382 outb(inb(ioaddr + 4) | 0x80, ioaddr + 4);
383 outb((inb(ioaddr + 13) & ~0x4C) | irq2reg[dev->irq], ioaddr + 13);
384 outb(inb(ioaddr + 4) & 0x7f, ioaddr + 4);
385
386 if (ei_status.block_input == &ultra_pio_input) {
387 outb(0x11, ioaddr + 6); /* Enable interrupts and PIO. */
388 outb(0x01, ioaddr + 0x19); /* Enable ring read auto-wrap. */
389 } else
390 outb(0x01, ioaddr + 6); /* Enable interrupts and memory. */
391 /* Set the early receive warning level in window 0 high enough not
392 to receive ERW interrupts. */
393 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
394 outb(0xff, dev->base_addr + EN0_ERWCNT);
395 ei_open(dev);
396 return 0;
397}
398
399static void
400ultra_reset_8390(struct net_device *dev)
401{
402 int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC base addr */
403
404 outb(ULTRA_RESET, cmd_port);
405 if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
406 ei_status.txing = 0;
407
408 outb(0x00, cmd_port); /* Disable shared memory for safety. */
409 outb(0x80, cmd_port + 5);
410 if (ei_status.block_input == &ultra_pio_input)
411 outb(0x11, cmd_port + 6); /* Enable interrupts and PIO. */
412 else
413 outb(0x01, cmd_port + 6); /* Enable interrupts and memory. */
414
415 if (ei_debug > 1) printk("reset done\n");
416 return;
417}
418
419/* Grab the 8390 specific header. Similar to the block_input routine, but
420 we don't need to be concerned with ring wrap as the header will be at
421 the start of a page, so we optimize accordingly. */
422
423static void
424ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
425{
426 void __iomem *hdr_start = ei_status.mem + ((ring_page - START_PG)<<8);
427
428 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem on */
429#ifdef __BIG_ENDIAN
430 /* Officially this is what we are doing, but the readl() is faster */
431 /* unfortunately it isn't endian aware of the struct */
432 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
433 hdr->count = le16_to_cpu(hdr->count);
434#else
435 ((unsigned int*)hdr)[0] = readl(hdr_start);
436#endif
437 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
438}
439
440/* Block input and output are easy on shared memory ethercards, the only
441 complication is when the ring buffer wraps. */
442
443static void
444ultra_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
445{
446 void __iomem *xfer_start = ei_status.mem + ring_offset - (START_PG<<8);
447
448 /* Enable shared memory. */
449 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
450
451 if (ring_offset + count > ei_status.stop_page*256) {
452 /* We must wrap the input move. */
453 int semi_count = ei_status.stop_page*256 - ring_offset;
454 memcpy_fromio(skb->data, xfer_start, semi_count);
455 count -= semi_count;
456 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
457 } else {
458 /* Packet is in one chunk -- we can copy + cksum. */
459 eth_io_copy_and_sum(skb, xfer_start, count, 0);
460 }
461
462 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
463}
464
465static void
466ultra_block_output(struct net_device *dev, int count, const unsigned char *buf,
467 int start_page)
468{
469 void __iomem *shmem = ei_status.mem + ((start_page - START_PG)<<8);
470
471 /* Enable shared memory. */
472 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
473
474 memcpy_toio(shmem, buf, count);
475
476 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
477}
478
479/* The identical operations for programmed I/O cards.
480 The PIO model is trivial to use: the 16 bit start address is written
481 byte-sequentially to IOPA, with no intervening I/O operations, and the
482 data is read or written to the IOPD data port.
483 The only potential complication is that the address register is shared
484 and must be always be rewritten between each read/write direction change.
485 This is no problem for us, as the 8390 code ensures that we are single
486 threaded. */
487static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
488 int ring_page)
489{
490 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
491 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
492 outb(ring_page, ioaddr + IOPA);
493 insw(ioaddr + IOPD, hdr, sizeof(struct e8390_pkt_hdr)>>1);
494}
495
496static void ultra_pio_input(struct net_device *dev, int count,
497 struct sk_buff *skb, int ring_offset)
498{
499 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
500 char *buf = skb->data;
501
502 /* For now set the address again, although it should already be correct. */
503 outb(ring_offset, ioaddr + IOPA); /* Set the address, LSB first. */
504 outb(ring_offset >> 8, ioaddr + IOPA);
505 /* We know skbuffs are padded to at least word alignment. */
506 insw(ioaddr + IOPD, buf, (count+1)>>1);
507}
508
509static void ultra_pio_output(struct net_device *dev, int count,
510 const unsigned char *buf, const int start_page)
511{
512 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
513 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
514 outb(start_page, ioaddr + IOPA);
515 /* An extra odd byte is OK here as well. */
516 outsw(ioaddr + IOPD, buf, (count+1)>>1);
517}
518
519static int
520ultra_close_card(struct net_device *dev)
521{
522 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
523
524 netif_stop_queue(dev);
525
526 if (ei_debug > 1)
527 printk("%s: Shutting down ethercard.\n", dev->name);
528
529 outb(0x00, ioaddr + 6); /* Disable interrupts. */
530 free_irq(dev->irq, dev);
531
532 NS8390_init(dev, 0);
533
534 /* We should someday disable shared memory and change to 8-bit mode
535 "just in case"... */
536
537 return 0;
538}
539
540
541#ifdef MODULE
542#define MAX_ULTRA_CARDS 4 /* Max number of Ultra cards per module */
543static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
544static int io[MAX_ULTRA_CARDS];
545static int irq[MAX_ULTRA_CARDS];
546
547module_param_array(io, int, NULL, 0);
548module_param_array(irq, int, NULL, 0);
549MODULE_PARM_DESC(io, "I/O base address(es)");
550MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
551MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
552MODULE_LICENSE("GPL");
553
554/* This is set up so that only a single autoprobe takes place per call.
555ISA device autoprobes on a running machine are not recommended. */
556int
557init_module(void)
558{
559 struct net_device *dev;
560 int this_dev, found = 0;
561
562 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
563 if (io[this_dev] == 0) {
564 if (this_dev != 0) break; /* only autoprobe 1st one */
565 printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
566 }
567 dev = alloc_ei_netdev();
568 if (!dev)
569 break;
570 dev->irq = irq[this_dev];
571 dev->base_addr = io[this_dev];
572 if (do_ultra_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -0400573 dev_ultra[found++] = dev;
574 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 }
576 free_netdev(dev);
577 printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
578 break;
579 }
580 if (found)
581 return 0;
582 return -ENXIO;
583}
584
Denis Vlasenko64916f12006-01-05 22:45:47 -0800585static void cleanup_card(struct net_device *dev)
586{
587 /* NB: ultra_close_card() does free_irq */
588#ifdef __ISAPNP__
589 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
590 if (idev)
591 pnp_device_detach(idev);
592#endif
593 release_region(dev->base_addr - ULTRA_NIC_OFFSET, ULTRA_IO_EXTENT);
594 iounmap(ei_status.mem);
595}
596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597void
598cleanup_module(void)
599{
600 int this_dev;
601
602 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
603 struct net_device *dev = dev_ultra[this_dev];
604 if (dev) {
605 unregister_netdev(dev);
606 cleanup_card(dev);
607 free_netdev(dev);
608 }
609 }
610}
611#endif /* MODULE */