git.oblomov.eu Git - linux-2.6/blob - drivers/net/wd.c

   1 /* wd.c: A WD80x3 ethernet driver for linux. */
   2 /*
   3         Written 1993-94 by Donald Becker.
   4
   5         Copyright 1993 United States Government as represented by the
   6         Director, National Security Agency.
   7
   8         This software may be used and distributed according to the terms
   9         of the GNU General Public License, incorporated herein by reference.
  10
  11         The author may be reached as becker@scyld.com, or C/O
  12         Scyld Computing Corporation
  13         410 Severn Ave., Suite 210
  14         Annapolis MD 21403
  15
  16         This is a driver for WD8003 and WD8013 "compatible" ethercards.
  17
  18         Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
  19
  20         Changelog:
  21
  22         Paul Gortmaker  : multiple card support for module users, support
  23                           for non-standard memory sizes.
  24
  25
  26 */
  27
  28 static const char version[] =
  29         "wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  30
  31 #include <linux/module.h>
  32 #include <linux/kernel.h>
  33 #include <linux/errno.h>
  34 #include <linux/string.h>
  35 #include <linux/init.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/delay.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/etherdevice.h>
  40
  41 #include <asm/io.h>
  42 #include <asm/system.h>
  43
  44 #include "8390.h"
  45
  46 #define DRV_NAME "wd"
  47
  48 /* A zero-terminated list of I/O addresses to be probed. */
  49 static unsigned int wd_portlist[] __initdata =
  50 {0x300, 0x280, 0x380, 0x240, 0};
  51
  52 static int wd_probe1(struct net_device *dev, int ioaddr);
  53
  54 static int wd_open(struct net_device *dev);
  55 static void wd_reset_8390(struct net_device *dev);
  56 static void wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  57                                                 int ring_page);
  58 static void wd_block_input(struct net_device *dev, int count,
  59                                                   struct sk_buff *skb, int ring_offset);
  60 static void wd_block_output(struct net_device *dev, int count,
  61                                                         const unsigned char *buf, int start_page);
  62 static int wd_close(struct net_device *dev);
  63
  64 \f
  65 #define WD_START_PG             0x00    /* First page of TX buffer */
  66 #define WD03_STOP_PG    0x20    /* Last page +1 of RX ring */
  67 #define WD13_STOP_PG    0x40    /* Last page +1 of RX ring */
  68
  69 #define WD_CMDREG               0               /* Offset to ASIC command register. */
  70 #define  WD_RESET               0x80    /* Board reset, in WD_CMDREG. */
  71 #define  WD_MEMENB              0x40    /* Enable the shared memory. */
  72 #define WD_CMDREG5              5               /* Offset to 16-bit-only ASIC register 5. */
  73 #define  ISA16                  0x80    /* Enable 16 bit access from the ISA bus. */
  74 #define  NIC16                  0x40    /* Enable 16 bit access from the 8390. */
  75 #define WD_NIC_OFFSET   16              /* Offset to the 8390 from the base_addr. */
  76 #define WD_IO_EXTENT    32
  77
  78 \f
  79 /*      Probe for the WD8003 and WD8013.  These cards have the station
  80         address PROM at I/O ports <base>+8 to <base>+13, with a checksum
  81         following. A Soundblaster can have the same checksum as an WDethercard,
  82         so we have an extra exclusionary check for it.
  83
  84         The wd_probe1() routine initializes the card and fills the
  85         station address field. */
  86
  87 static int __init do_wd_probe(struct net_device *dev)
  88 {
  89         int i;
  90         struct resource *r;
  91         int base_addr = dev->base_addr;
  92         int irq = dev->irq;
  93         int mem_start = dev->mem_start;
  94         int mem_end = dev->mem_end;
  95
  96         SET_MODULE_OWNER(dev);
  97
  98         if (base_addr > 0x1ff) {        /* Check a user specified location. */
  99                 r = request_region(base_addr, WD_IO_EXTENT, "wd-probe");
 100                 if ( r == NULL)
 101                         return -EBUSY;
 102                 i = wd_probe1(dev, base_addr);
 103                 if (i != 0)
 104                         release_region(base_addr, WD_IO_EXTENT);
 105                 else
 106                         r->name = dev->name;
 107                 return i;
 108         }
 109         else if (base_addr != 0)        /* Don't probe at all. */
 110                 return -ENXIO;
 111
 112         for (i = 0; wd_portlist[i]; i++) {
 113                 int ioaddr = wd_portlist[i];
 114                 r = request_region(ioaddr, WD_IO_EXTENT, "wd-probe");
 115                 if (r == NULL)
 116                         continue;
 117                 if (wd_probe1(dev, ioaddr) == 0) {
 118                         r->name = dev->name;
 119                         return 0;
 120                 }
 121                 release_region(ioaddr, WD_IO_EXTENT);
 122                 dev->irq = irq;
 123                 dev->mem_start = mem_start;
 124                 dev->mem_end = mem_end;
 125         }
 126
 127         return -ENODEV;
 128 }
 129
 130 static void cleanup_card(struct net_device *dev)
 131 {
 132         free_irq(dev->irq, dev);
 133         release_region(dev->base_addr - WD_NIC_OFFSET, WD_IO_EXTENT);
 134         iounmap(ei_status.mem);
 135 }
 136
 137 #ifndef MODULE
 138 struct net_device * __init wd_probe(int unit)
 139 {
 140         struct net_device *dev = alloc_ei_netdev();
 141         int err;
 142
 143         if (!dev)
 144                 return ERR_PTR(-ENOMEM);
 145
 146         sprintf(dev->name, "eth%d", unit);
 147         netdev_boot_setup_check(dev);
 148
 149         err = do_wd_probe(dev);
 150         if (err)
 151                 goto out;
 152         return dev;
 153 out:
 154         free_netdev(dev);
 155         return ERR_PTR(err);
 156 }
 157 #endif
 158
 159 static int __init wd_probe1(struct net_device *dev, int ioaddr)
 160 {
 161         int i;
 162         int err;
 163         int checksum = 0;
 164         int ancient = 0;                        /* An old card without config registers. */
 165         int word16 = 0;                         /* 0 = 8 bit, 1 = 16 bit */
 166         const char *model_name;
 167         static unsigned version_printed;
 168
 169         for (i = 0; i < 8; i++)
 170                 checksum += inb(ioaddr + 8 + i);
 171         if (inb(ioaddr + 8) == 0xff     /* Extra check to avoid soundcard. */
 172                 || inb(ioaddr + 9) == 0xff
 173                 || (checksum & 0xff) != 0xFF)
 174                 return -ENODEV;
 175
 176         /* Check for semi-valid mem_start/end values if supplied. */
 177         if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
 178                 printk(KERN_WARNING "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
 179                 dev->mem_start = 0;
 180                 dev->mem_end = 0;
 181         }
 182
 183         if (ei_debug  &&  version_printed++ == 0)
 184                 printk(version);
 185
 186         printk("%s: WD80x3 at %#3x,", dev->name, ioaddr);
 187         for (i = 0; i < 6; i++)
 188                 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
 189
 190         /* The following PureData probe code was contributed by
 191            Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
 192            configuration differently from others so we have to check for them.
 193            This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
 194            */
 195         if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
 196                 unsigned char reg5 = inb(ioaddr+5);
 197
 198                 switch (inb(ioaddr+2)) {
 199                 case 0x03: word16 = 0; model_name = "PDI8023-8";        break;
 200                 case 0x05: word16 = 0; model_name = "PDUC8023"; break;
 201                 case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
 202                         /* Either 0x01 (dumb) or they've released a new version. */
 203                 default:         word16 = 0; model_name = "PDI8023";    break;
 204                 }
 205                 dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
 206                 dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
 207         } else {                                                                /* End of PureData probe */
 208                 /* This method of checking for a 16-bit board is borrowed from the
 209                    we.c driver.  A simpler method is just to look in ASIC reg. 0x03.
 210                    I'm comparing the two method in alpha test to make certain they
 211                    return the same result. */
 212                 /* Check for the old 8 bit board - it has register 0/8 aliasing.
 213                    Do NOT check i>=6 here -- it hangs the old 8003 boards! */
 214                 for (i = 0; i < 6; i++)
 215                         if (inb(ioaddr+i) != inb(ioaddr+8+i))
 216                                 break;
 217                 if (i >= 6) {
 218                         ancient = 1;
 219                         model_name = "WD8003-old";
 220                         word16 = 0;
 221                 } else {
 222                         int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
 223                         outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
 224                         if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
 225                                 && (tmp & 0x01) == 0x01 ) {                             /* In a 16 slot. */
 226                                 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
 227                                 /* Magic to set ASIC to word-wide mode. */
 228                                 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
 229                                 outb(tmp, ioaddr+1);
 230                                 model_name = "WD8013";
 231                                 word16 = 1;             /* We have a 16bit board here! */
 232                         } else {
 233                                 model_name = "WD8003";
 234                                 word16 = 0;
 235                         }
 236                         outb(tmp, ioaddr+1);                    /* Restore original reg1 value. */
 237                 }
 238 #ifndef final_version
 239                 if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
 240                         printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
 241                                    word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8);
 242 #endif
 243         }
 244
 245 #if defined(WD_SHMEM) && WD_SHMEM > 0x80000
 246         /* Allow a compile-time override.        */
 247         dev->mem_start = WD_SHMEM;
 248 #else
 249         if (dev->mem_start == 0) {
 250                 /* Sanity and old 8003 check */
 251                 int reg0 = inb(ioaddr);
 252                 if (reg0 == 0xff || reg0 == 0) {
 253                         /* Future plan: this could check a few likely locations first. */
 254                         dev->mem_start = 0xd0000;
 255                         printk(" assigning address %#lx", dev->mem_start);
 256                 } else {
 257                         int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
 258                         /* Some boards don't have the register 5 -- it returns 0xff. */
 259                         if (high_addr_bits == 0x1f || word16 == 0)
 260                                 high_addr_bits = 0x01;
 261                         dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
 262                 }
 263         }
 264 #endif
 265
 266         /* The 8390 isn't at the base address -- the ASIC regs are there! */
 267         dev->base_addr = ioaddr+WD_NIC_OFFSET;
 268
 269         if (dev->irq < 2) {
 270                 int irqmap[] = {9,3,5,7,10,11,15,4};
 271                 int reg1 = inb(ioaddr+1);
 272                 int reg4 = inb(ioaddr+4);
 273                 if (ancient || reg1 == 0xff) {  /* Ack!! No way to read the IRQ! */
 274                         short nic_addr = ioaddr+WD_NIC_OFFSET;
 275                         unsigned long irq_mask;
 276
 277                         /* We have an old-style ethercard that doesn't report its IRQ
 278                            line.  Do autoirq to find the IRQ line. Note that this IS NOT
 279                            a reliable way to trigger an interrupt. */
 280                         outb_p(E8390_NODMA + E8390_STOP, nic_addr);
 281                         outb(0x00, nic_addr+EN0_IMR);   /* Disable all intrs. */
 282
 283                         irq_mask = probe_irq_on();
 284                         outb_p(0xff, nic_addr + EN0_IMR);       /* Enable all interrupts. */
 285                         outb_p(0x00, nic_addr + EN0_RCNTLO);
 286                         outb_p(0x00, nic_addr + EN0_RCNTHI);
 287                         outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
 288                         mdelay(20);
 289                         dev->irq = probe_irq_off(irq_mask);
 290
 291                         outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
 292
 293                         if (ei_debug > 2)
 294                                 printk(" autoirq is %d", dev->irq);
 295                         if (dev->irq < 2)
 296                                 dev->irq = word16 ? 10 : 5;
 297                 } else
 298                         dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
 299         } else if (dev->irq == 2)               /* Fixup bogosity: IRQ2 is really IRQ9 */
 300                 dev->irq = 9;
 301
 302         /* Snarf the interrupt now.  There's no point in waiting since we cannot
 303            share and the board will usually be enabled. */
 304         i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
 305         if (i) {
 306                 printk (" unable to get IRQ %d.\n", dev->irq);
 307                 return i;
 308         }
 309
 310         /* OK, were are certain this is going to work.  Setup the device. */
 311         ei_status.name = model_name;
 312         ei_status.word16 = word16;
 313         ei_status.tx_start_page = WD_START_PG;
 314         ei_status.rx_start_page = WD_START_PG + TX_PAGES;
 315
 316         /* Don't map in the shared memory until the board is actually opened. */
 317
 318         /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
 319         if (dev->mem_end != 0) {
 320                 ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
 321                 ei_status.priv = dev->mem_end - dev->mem_start;
 322         } else {
 323                 ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
 324                 dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
 325                 ei_status.priv = (ei_status.stop_page - WD_START_PG)*256;
 326         }
 327
 328         ei_status.mem = ioremap(dev->mem_start, ei_status.priv);
 329         if (!ei_status.mem) {
 330                 free_irq(dev->irq, dev);
 331                 return -ENOMEM;
 332         }
 333
 334         printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
 335                    model_name, dev->irq, dev->mem_start, dev->mem_end-1);
 336
 337         ei_status.reset_8390 = &wd_reset_8390;
 338         ei_status.block_input = &wd_block_input;
 339         ei_status.block_output = &wd_block_output;
 340         ei_status.get_8390_hdr = &wd_get_8390_hdr;
 341         dev->open = &wd_open;
 342         dev->stop = &wd_close;
 343 #ifdef CONFIG_NET_POLL_CONTROLLER
 344         dev->poll_controller = ei_poll;
 345 #endif
 346         NS8390_init(dev, 0);
 347
 348 #if 1
 349         /* Enable interrupt generation on softconfig cards -- M.U */
 350         /* .. but possibly potentially unsafe - Donald */
 351         if (inb(ioaddr+14) & 0x20)
 352                 outb(inb(ioaddr+4)|0x80, ioaddr+4);
 353 #endif
 354
 355         err = register_netdev(dev);
 356         if (err)
 357                 free_irq(dev->irq, dev);
 358         return err;
 359 }
 360
 361 static int
 362 wd_open(struct net_device *dev)
 363 {
 364   int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 365
 366   /* Map in the shared memory. Always set register 0 last to remain
 367          compatible with very old boards. */
 368   ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
 369   ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
 370
 371   if (ei_status.word16)
 372           outb(ei_status.reg5, ioaddr+WD_CMDREG5);
 373   outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
 374
 375   ei_open(dev);
 376   return 0;
 377 }
 378
 379 static void
 380 wd_reset_8390(struct net_device *dev)
 381 {
 382         int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 383
 384         outb(WD_RESET, wd_cmd_port);
 385         if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies);
 386         ei_status.txing = 0;
 387
 388         /* Set up the ASIC registers, just in case something changed them. */
 389         outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
 390         if (ei_status.word16)
 391                 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
 392
 393         if (ei_debug > 1) printk("reset done\n");
 394         return;
 395 }
 396
 397 /* Grab the 8390 specific header. Similar to the block_input routine, but
 398    we don't need to be concerned with ring wrap as the header will be at
 399    the start of a page, so we optimize accordingly. */
 400
 401 static void
 402 wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 403 {
 404
 405         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 406         void __iomem *hdr_start = ei_status.mem + ((ring_page - WD_START_PG)<<8);
 407
 408         /* We'll always get a 4 byte header read followed by a packet read, so
 409            we enable 16 bit mode before the header, and disable after the body. */
 410         if (ei_status.word16)
 411                 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 412
 413 #ifdef __BIG_ENDIAN
 414         /* Officially this is what we are doing, but the readl() is faster */
 415         /* unfortunately it isn't endian aware of the struct               */
 416         memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 417         hdr->count = le16_to_cpu(hdr->count);
 418 #else
 419         ((unsigned int*)hdr)[0] = readl(hdr_start);
 420 #endif
 421 }
 422
 423 /* Block input and output are easy on shared memory ethercards, and trivial
 424    on the Western digital card where there is no choice of how to do it.
 425    The only complications are that the ring buffer wraps, and need to map
 426    switch between 8- and 16-bit modes. */
 427
 428 static void
 429 wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 430 {
 431         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 432         unsigned long offset = ring_offset - (WD_START_PG<<8);
 433         void __iomem *xfer_start = ei_status.mem + offset;
 434
 435         if (offset + count > ei_status.priv) {
 436                 /* We must wrap the input move. */
 437                 int semi_count = ei_status.priv - offset;
 438                 memcpy_fromio(skb->data, xfer_start, semi_count);
 439                 count -= semi_count;
 440                 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
 441         } else {
 442                 /* Packet is in one chunk -- we can copy + cksum. */
 443                 eth_io_copy_and_sum(skb, xfer_start, count, 0);
 444         }
 445
 446         /* Turn off 16 bit access so that reboot works.  ISA brain-damage */
 447         if (ei_status.word16)
 448                 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 449 }
 450
 451 static void
 452 wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
 453                                 int start_page)
 454 {
 455         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 456         void __iomem *shmem = ei_status.mem + ((start_page - WD_START_PG)<<8);
 457
 458
 459         if (ei_status.word16) {
 460                 /* Turn on and off 16 bit access so that reboot works. */
 461                 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 462                 memcpy_toio(shmem, buf, count);
 463                 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 464         } else
 465                 memcpy_toio(shmem, buf, count);
 466 }
 467
 468
 469 static int
 470 wd_close(struct net_device *dev)
 471 {
 472         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 473
 474         if (ei_debug > 1)
 475                 printk("%s: Shutting down ethercard.\n", dev->name);
 476         ei_close(dev);
 477
 478         /* Change from 16-bit to 8-bit shared memory so reboot works. */
 479         if (ei_status.word16)
 480                 outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
 481
 482         /* And disable the shared memory. */
 483         outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
 484
 485         return 0;
 486 }
 487
 488 \f
 489 #ifdef MODULE
 490 #define MAX_WD_CARDS    4       /* Max number of wd cards per module */
 491 static struct net_device *dev_wd[MAX_WD_CARDS];
 492 static int io[MAX_WD_CARDS];
 493 static int irq[MAX_WD_CARDS];
 494 static int mem[MAX_WD_CARDS];
 495 static int mem_end[MAX_WD_CARDS];       /* for non std. mem size */
 496
 497 module_param_array(io, int, NULL, 0);
 498 module_param_array(irq, int, NULL, 0);
 499 module_param_array(mem, int, NULL, 0);
 500 module_param_array(mem_end, int, NULL, 0);
 501 MODULE_PARM_DESC(io, "I/O base address(es)");
 502 MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
 503 MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
 504 MODULE_PARM_DESC(mem_end, "memory end address(es)");
 505 MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
 506 MODULE_LICENSE("GPL");
 507
 508 /* This is set up so that only a single autoprobe takes place per call.
 509 ISA device autoprobes on a running machine are not recommended. */
 510 int
 511 init_module(void)
 512 {
 513         struct net_device *dev;
 514         int this_dev, found = 0;
 515
 516         for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
 517                 if (io[this_dev] == 0)  {
 518                         if (this_dev != 0) break; /* only autoprobe 1st one */
 519                         printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
 520                 }
 521                 dev = alloc_ei_netdev();
 522                 if (!dev)
 523                         break;
 524                 dev->irq = irq[this_dev];
 525                 dev->base_addr = io[this_dev];
 526                 dev->mem_start = mem[this_dev];
 527                 dev->mem_end = mem_end[this_dev];
 528                 if (do_wd_probe(dev) == 0) {
 529                         dev_wd[found++] = dev;
 530                         continue;
 531                 }
 532                 free_netdev(dev);
 533                 printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
 534                 break;
 535         }
 536         if (found)
 537                 return 0;
 538         return -ENXIO;
 539 }
 540
 541 void
 542 cleanup_module(void)
 543 {
 544         int this_dev;
 545
 546         for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
 547                 struct net_device *dev = dev_wd[this_dev];
 548                 if (dev) {
 549                         unregister_netdev(dev);
 550                         cleanup_card(dev);
 551                         free_netdev(dev);
 552                 }
 553         }
 554 }
 555 #endif /* MODULE */