ACPI: fix memory leak in acpi_thermal_add() error path
[linux-2.6] / drivers / net / smc-ultra.c
1 /* 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
57 static 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>
71 #include <asm/irq.h>
72 #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. */
79 static unsigned int ultra_portlist[] __initdata =
80 {0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
81
82 static int ultra_probe1(struct net_device *dev, int ioaddr);
83
84 #ifdef __ISAPNP__
85 static int ultra_probe_isapnp(struct net_device *dev);
86 #endif
87
88 static int ultra_open(struct net_device *dev);
89 static void ultra_reset_8390(struct net_device *dev);
90 static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
91                                                 int ring_page);
92 static void ultra_block_input(struct net_device *dev, int count,
93                                                   struct sk_buff *skb, int ring_offset);
94 static void ultra_block_output(struct net_device *dev, int count,
95                                                         const unsigned char *buf, const int start_page);
96 static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
97                                                 int ring_page);
98 static void ultra_pio_input(struct net_device *dev, int count,
99                                                   struct sk_buff *skb, int ring_offset);
100 static void ultra_pio_output(struct net_device *dev, int count,
101                                                          const unsigned char *buf, const int start_page);
102 static int ultra_close_card(struct net_device *dev);
103
104 #ifdef __ISAPNP__
105 static 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
112 MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
113 #endif
114
115 \f
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 \f
127 #ifdef CONFIG_NET_POLL_CONTROLLER
128 static 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
140 static 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
171 #ifndef MODULE
172 struct 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;
186         return dev;
187 out:
188         free_netdev(dev);
189         return ERR_PTR(err);
190 }
191 #endif
192
193 static 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
312         retval = register_netdev(dev);
313         if (retval)
314                 goto out;
315         return 0;
316 out:
317         release_region(ioaddr, ULTRA_IO_EXTENT);
318         return retval;
319 }
320
321 #ifdef __ISAPNP__
322 static 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
367 static int
368 ultra_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
399 static void
400 ultra_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
423 static void
424 ultra_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
443 static void
444 ultra_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
465 static void
466 ultra_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. */
487 static 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
496 static 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
509 static 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
519 static int
520 ultra_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 \f
541 #ifdef MODULE
542 #define MAX_ULTRA_CARDS 4       /* Max number of Ultra cards per module */
543 static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
544 static int io[MAX_ULTRA_CARDS];
545 static int irq[MAX_ULTRA_CARDS];
546
547 module_param_array(io, int, NULL, 0);
548 module_param_array(irq, int, NULL, 0);
549 MODULE_PARM_DESC(io, "I/O base address(es)");
550 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
551 MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
552 MODULE_LICENSE("GPL");
553
554 /* This is set up so that only a single autoprobe takes place per call.
555 ISA device autoprobes on a running machine are not recommended. */
556 int
557 init_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) {
573                         dev_ultra[found++] = dev;
574                         continue;
575                 }
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
585 static 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
597 void
598 cleanup_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 */