?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add linux-next specific files for 20110831
[linux-2.6/next.git] / drivers / net / ethernet / 8390 / smc-ultra.c
blob1cc306a83ff7d2f6760b4d7073893d343c311926
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/module.h>
61 #include <linux/kernel.h>
62 #include <linux/errno.h>
63 #include <linux/string.h>
64 #include <linux/init.h>
65 #include <linux/interrupt.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
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
128 static void ultra_poll(struct net_device *dev)
129 {
130 disable_irq(dev->irq);
131 ei_interrupt(dev->irq, dev);
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 if (base_addr > 0x1ff) /* Check a single specified location. */
147 return ultra_probe1(dev, base_addr);
148 else if (base_addr != 0) /* Don't probe at all. */
149 return -ENXIO;
150
151 #ifdef __ISAPNP__
152 /* Look for any installed ISAPnP cards */
153 if (isapnp_present() && (ultra_probe_isapnp(dev) == 0))
154 return 0;
155 #endif
156
157 for (i = 0; ultra_portlist[i]; i++) {
158 dev->irq = irq;
159 if (ultra_probe1(dev, ultra_portlist[i]) == 0)
160 return 0;
161 }
162
163 return -ENODEV;
164 }
165
166 #ifndef MODULE
167 struct net_device * __init ultra_probe(int unit)
168 {
169 struct net_device *dev = alloc_ei_netdev();
170 int err;
171
172 if (!dev)
173 return ERR_PTR(-ENOMEM);
174
175 sprintf(dev->name, "eth%d", unit);
176 netdev_boot_setup_check(dev);
177
178 err = do_ultra_probe(dev);
179 if (err)
180 goto out;
181 return dev;
182 out:
183 free_netdev(dev);
184 return ERR_PTR(err);
185 }
186 #endif
187
188 static const struct net_device_ops ultra_netdev_ops = {
189 .ndo_open = ultra_open,
190 .ndo_stop = ultra_close_card,
191
192 .ndo_start_xmit = ei_start_xmit,
193 .ndo_tx_timeout = ei_tx_timeout,
194 .ndo_get_stats = ei_get_stats,
195 .ndo_set_rx_mode = ei_set_multicast_list,
196 .ndo_validate_addr = eth_validate_addr,
197 .ndo_set_mac_address = eth_mac_addr,
198 .ndo_change_mtu = eth_change_mtu,
199 #ifdef CONFIG_NET_POLL_CONTROLLER
200 .ndo_poll_controller = ultra_poll,
201 #endif
202 };
203
204 static int __init ultra_probe1(struct net_device *dev, int ioaddr)
205 {
206 int i, retval;
207 int checksum = 0;
208 const char *model_name;
209 unsigned char eeprom_irq = 0;
210 static unsigned version_printed;
211 /* Values from various config regs. */
212 unsigned char num_pages, irqreg, addr, piomode;
213 unsigned char idreg = inb(ioaddr + 7);
214 unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
215
216 if (!request_region(ioaddr, ULTRA_IO_EXTENT, DRV_NAME))
217 return -EBUSY;
218
219 /* Check the ID nibble. */
220 if ((idreg & 0xF0) != 0x20 /* SMC Ultra */
221 && (idreg & 0xF0) != 0x40) { /* SMC EtherEZ */
222 retval = -ENODEV;
223 goto out;
224 }
225
226 /* Select the station address register set. */
227 outb(reg4, ioaddr + 4);
228
229 for (i = 0; i < 8; i++)
230 checksum += inb(ioaddr + 8 + i);
231 if ((checksum & 0xff) != 0xFF) {
232 retval = -ENODEV;
233 goto out;
234 }
235
236 if (ei_debug && version_printed++ == 0)
237 printk(version);
238
239 model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
240
241 for (i = 0; i < 6; i++)
242 dev->dev_addr[i] = inb(ioaddr + 8 + i);
243
244 printk("%s: %s at %#3x, %pM", dev->name, model_name,
245 ioaddr, dev->dev_addr);
246
247 /* Switch from the station address to the alternate register set and
248 read the useful registers there. */
249 outb(0x80 | reg4, ioaddr + 4);
250
251 /* Enabled FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
252 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
253 piomode = inb(ioaddr + 0x8);
254 addr = inb(ioaddr + 0xb);
255 irqreg = inb(ioaddr + 0xd);
256
257 /* Switch back to the station address register set so that the MS-DOS driver
258 can find the card after a warm boot. */
259 outb(reg4, ioaddr + 4);
260
261 if (dev->irq < 2) {
262 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
263 int irq;
264
265 /* The IRQ bits are split. */
266 irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
267
268 if (irq == 0) {
269 printk(", failed to detect IRQ line.\n");
270 retval = -EAGAIN;
271 goto out;
272 }
273 dev->irq = irq;
274 eeprom_irq = 1;
275 }
276
277 /* The 8390 isn't at the base address, so fake the offset */
278 dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
279
280 {
281 static const int addr_tbl[4] = {
282 0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000
283 };
284 static const short num_pages_tbl[4] = {
285 0x20, 0x40, 0x80, 0xff
286 };
287
288 dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
289 num_pages = num_pages_tbl[(addr >> 4) & 3];
290 }
291
292 ei_status.name = model_name;
293 ei_status.word16 = 1;
294 ei_status.tx_start_page = START_PG;
295 ei_status.rx_start_page = START_PG + TX_PAGES;
296 ei_status.stop_page = num_pages;
297
298 ei_status.mem = ioremap(dev->mem_start, (ei_status.stop_page - START_PG)*256);
299 if (!ei_status.mem) {
300 printk(", failed to ioremap.\n");
301 retval = -ENOMEM;
302 goto out;
303 }
304
305 dev->mem_end = dev->mem_start + (ei_status.stop_page - START_PG)*256;
306
307 if (piomode) {
308 printk(",%s IRQ %d programmed-I/O mode.\n",
309 eeprom_irq ? "EEPROM" : "assigned ", dev->irq);
310 ei_status.block_input = &ultra_pio_input;
311 ei_status.block_output = &ultra_pio_output;
312 ei_status.get_8390_hdr = &ultra_pio_get_hdr;
313 } else {
314 printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
315 dev->irq, dev->mem_start, dev->mem_end-1);
316 ei_status.block_input = &ultra_block_input;
317 ei_status.block_output = &ultra_block_output;
318 ei_status.get_8390_hdr = &ultra_get_8390_hdr;
319 }
320 ei_status.reset_8390 = &ultra_reset_8390;
321
322 dev->netdev_ops = &ultra_netdev_ops;
323 NS8390_init(dev, 0);
324
325 retval = register_netdev(dev);
326 if (retval)
327 goto out;
328 return 0;
329 out:
330 release_region(ioaddr, ULTRA_IO_EXTENT);
331 return retval;
332 }
333
334 #ifdef __ISAPNP__
335 static int __init ultra_probe_isapnp(struct net_device *dev)
336 {
337 int i;
338
339 for (i = 0; ultra_device_ids[i].vendor != 0; i++) {
340 struct pnp_dev *idev = NULL;
341
342 while ((idev = pnp_find_dev(NULL,
343 ultra_device_ids[i].vendor,
344 ultra_device_ids[i].function,
345 idev))) {
346 /* Avoid already found cards from previous calls */
347 if (pnp_device_attach(idev) < 0)
348 continue;
349 if (pnp_activate_dev(idev) < 0) {
350 __again:
351 pnp_device_detach(idev);
352 continue;
353 }
354 /* if no io and irq, search for next */
355 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
356 goto __again;
357 /* found it */
358 dev->base_addr = pnp_port_start(idev, 0);
359 dev->irq = pnp_irq(idev, 0);
360 printk(KERN_INFO "smc-ultra.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
361 (char *) ultra_device_ids[i].driver_data,
362 dev->base_addr, dev->irq);
363 if (ultra_probe1(dev, dev->base_addr) != 0) { /* Shouldn't happen. */
364 printk(KERN_ERR "smc-ultra.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
365 pnp_device_detach(idev);
366 return -ENXIO;
367 }
368 ei_status.priv = (unsigned long)idev;
369 break;
370 }
371 if (!idev)
372 continue;
373 return 0;
374 }
375
376 return -ENODEV;
377 }
378 #endif
379
380 static int
381 ultra_open(struct net_device *dev)
382 {
383 int retval;
384 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
385 unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
386 0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
387
388 retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
389 if (retval)
390 return retval;
391
392 outb(0x00, ioaddr); /* Disable shared memory for safety. */
393 outb(0x80, ioaddr + 5);
394 /* Set the IRQ line. */
395 outb(inb(ioaddr + 4) | 0x80, ioaddr + 4);
396 outb((inb(ioaddr + 13) & ~0x4C) | irq2reg[dev->irq], ioaddr + 13);
397 outb(inb(ioaddr + 4) & 0x7f, ioaddr + 4);
398
399 if (ei_status.block_input == &ultra_pio_input) {
400 outb(0x11, ioaddr + 6); /* Enable interrupts and PIO. */
401 outb(0x01, ioaddr + 0x19); /* Enable ring read auto-wrap. */
402 } else
403 outb(0x01, ioaddr + 6); /* Enable interrupts and memory. */
404 /* Set the early receive warning level in window 0 high enough not
405 to receive ERW interrupts. */
406 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
407 outb(0xff, dev->base_addr + EN0_ERWCNT);
408 ei_open(dev);
409 return 0;
410 }
411
412 static void
413 ultra_reset_8390(struct net_device *dev)
414 {
415 int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC base addr */
416
417 outb(ULTRA_RESET, cmd_port);
418 if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
419 ei_status.txing = 0;
420
421 outb(0x00, cmd_port); /* Disable shared memory for safety. */
422 outb(0x80, cmd_port + 5);
423 if (ei_status.block_input == &ultra_pio_input)
424 outb(0x11, cmd_port + 6); /* Enable interrupts and PIO. */
425 else
426 outb(0x01, cmd_port + 6); /* Enable interrupts and memory. */
427
428 if (ei_debug > 1) printk("reset done\n");
429 }
430
431 /* Grab the 8390 specific header. Similar to the block_input routine, but
432 we don't need to be concerned with ring wrap as the header will be at
433 the start of a page, so we optimize accordingly. */
434
435 static void
436 ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
437 {
438 void __iomem *hdr_start = ei_status.mem + ((ring_page - START_PG)<<8);
439
440 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem on */
441 #ifdef __BIG_ENDIAN
442 /* Officially this is what we are doing, but the readl() is faster */
443 /* unfortunately it isn't endian aware of the struct */
444 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
445 hdr->count = le16_to_cpu(hdr->count);
446 #else
447 ((unsigned int*)hdr)[0] = readl(hdr_start);
448 #endif
449 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
450 }
451
452 /* Block input and output are easy on shared memory ethercards, the only
453 complication is when the ring buffer wraps. */
454
455 static void
456 ultra_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
457 {
458 void __iomem *xfer_start = ei_status.mem + ring_offset - (START_PG<<8);
459
460 /* Enable shared memory. */
461 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
462
463 if (ring_offset + count > ei_status.stop_page*256) {
464 /* We must wrap the input move. */
465 int semi_count = ei_status.stop_page*256 - ring_offset;
466 memcpy_fromio(skb->data, xfer_start, semi_count);
467 count -= semi_count;
468 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
469 } else {
470 memcpy_fromio(skb->data, xfer_start, count);
471 }
472
473 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
474 }
475
476 static void
477 ultra_block_output(struct net_device *dev, int count, const unsigned char *buf,
478 int start_page)
479 {
480 void __iomem *shmem = ei_status.mem + ((start_page - START_PG)<<8);
481
482 /* Enable shared memory. */
483 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
484
485 memcpy_toio(shmem, buf, count);
486
487 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
488 }
489
490 /* The identical operations for programmed I/O cards.
491 The PIO model is trivial to use: the 16 bit start address is written
492 byte-sequentially to IOPA, with no intervening I/O operations, and the
493 data is read or written to the IOPD data port.
494 The only potential complication is that the address register is shared
495 and must be always be rewritten between each read/write direction change.
496 This is no problem for us, as the 8390 code ensures that we are single
497 threaded. */
498 static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
499 int ring_page)
500 {
501 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
502 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
503 outb(ring_page, ioaddr + IOPA);
504 insw(ioaddr + IOPD, hdr, sizeof(struct e8390_pkt_hdr)>>1);
505 }
506
507 static void ultra_pio_input(struct net_device *dev, int count,
508 struct sk_buff *skb, int ring_offset)
509 {
510 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
511 char *buf = skb->data;
512
513 /* For now set the address again, although it should already be correct. */
514 outb(ring_offset, ioaddr + IOPA); /* Set the address, LSB first. */
515 outb(ring_offset >> 8, ioaddr + IOPA);
516 /* We know skbuffs are padded to at least word alignment. */
517 insw(ioaddr + IOPD, buf, (count+1)>>1);
518 }
519
520 static void ultra_pio_output(struct net_device *dev, int count,
521 const unsigned char *buf, const int start_page)
522 {
523 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
524 outb(0x00, ioaddr + IOPA); /* Set the address, LSB first. */
525 outb(start_page, ioaddr + IOPA);
526 /* An extra odd byte is OK here as well. */
527 outsw(ioaddr + IOPD, buf, (count+1)>>1);
528 }
529
530 static int
531 ultra_close_card(struct net_device *dev)
532 {
533 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
534
535 netif_stop_queue(dev);
536
537 if (ei_debug > 1)
538 printk("%s: Shutting down ethercard.\n", dev->name);
539
540 outb(0x00, ioaddr + 6); /* Disable interrupts. */
541 free_irq(dev->irq, dev);
542
543 NS8390_init(dev, 0);
544
545 /* We should someday disable shared memory and change to 8-bit mode
546 "just in case"... */
547
548 return 0;
549 }
550
551
552 #ifdef MODULE
553 #define MAX_ULTRA_CARDS 4 /* Max number of Ultra cards per module */
554 static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
555 static int io[MAX_ULTRA_CARDS];
556 static int irq[MAX_ULTRA_CARDS];
557
558 module_param_array(io, int, NULL, 0);
559 module_param_array(irq, int, NULL, 0);
560 MODULE_PARM_DESC(io, "I/O base address(es)");
561 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
562 MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
563 MODULE_LICENSE("GPL");
564
565 /* This is set up so that only a single autoprobe takes place per call.
566 ISA device autoprobes on a running machine are not recommended. */
567 int __init
568 init_module(void)
569 {
570 struct net_device *dev;
571 int this_dev, found = 0;
572
573 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
574 if (io[this_dev] == 0) {
575 if (this_dev != 0) break; /* only autoprobe 1st one */
576 printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
577 }
578 dev = alloc_ei_netdev();
579 if (!dev)
580 break;
581 dev->irq = irq[this_dev];
582 dev->base_addr = io[this_dev];
583 if (do_ultra_probe(dev) == 0) {
584 dev_ultra[found++] = dev;
585 continue;
586 }
587 free_netdev(dev);
588 printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
589 break;
590 }
591 if (found)
592 return 0;
593 return -ENXIO;
594 }
595
596 static void cleanup_card(struct net_device *dev)
597 {
598 /* NB: ultra_close_card() does free_irq */
599 #ifdef __ISAPNP__
600 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
601 if (idev)
602 pnp_device_detach(idev);
603 #endif
604 release_region(dev->base_addr - ULTRA_NIC_OFFSET, ULTRA_IO_EXTENT);
605 iounmap(ei_status.mem);
606 }
607
608 void __exit
609 cleanup_module(void)
610 {
611 int this_dev;
612
613 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
614 struct net_device *dev = dev_ultra[this_dev];
615 if (dev) {
616 unregister_netdev(dev);
617 cleanup_card(dev);
618 free_netdev(dev);
619 }
620 }
621 }
622 #endif /* MODULE */
linux-next