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