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 }
 135
 136 #ifndef MODULE
 137 struct net_device * __init wd_probe(int unit)
 138 {
 139         struct net_device *dev = alloc_ei_netdev();
 140         int err;
 141
 142         if (!dev)
 143                 return ERR_PTR(-ENOMEM);
 144
 145         sprintf(dev->name, "eth%d", unit);
 146         netdev_boot_setup_check(dev);
 147
 148         err = do_wd_probe(dev);
 149         if (err)
 150                 goto out;
 151         err = register_netdev(dev);
 152         if (err)
 153                 goto out1;
 154         return dev;
 155 out1:
 156         cleanup_card(dev);
 157 out:
 158         free_netdev(dev);
 159         return ERR_PTR(err);
 160 }
 161 #endif
 162
 163 static int __init wd_probe1(struct net_device *dev, int ioaddr)
 164 {
 165         int i;
 166         int checksum = 0;
 167         int ancient = 0;                        /* An old card without config registers. */
 168         int word16 = 0;                         /* 0 = 8 bit, 1 = 16 bit */
 169         const char *model_name;
 170         static unsigned version_printed;
 171
 172         for (i = 0; i < 8; i++)
 173                 checksum += inb(ioaddr + 8 + i);
 174         if (inb(ioaddr + 8) == 0xff     /* Extra check to avoid soundcard. */
 175                 || inb(ioaddr + 9) == 0xff
 176                 || (checksum & 0xff) != 0xFF)
 177                 return -ENODEV;
 178
 179         /* Check for semi-valid mem_start/end values if supplied. */
 180         if ((dev->mem_start % 0x2000) || (dev->mem_end % 0x2000)) {
 181                 printk(KERN_WARNING "wd.c: user supplied mem_start or mem_end not on 8kB boundary - ignored.\n");
 182                 dev->mem_start = 0;
 183                 dev->mem_end = 0;
 184         }
 185
 186         if (ei_debug  &&  version_printed++ == 0)
 187                 printk(version);
 188
 189         printk("%s: WD80x3 at %#3x,", dev->name, ioaddr);
 190         for (i = 0; i < 6; i++)
 191                 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
 192
 193         /* The following PureData probe code was contributed by
 194            Mike Jagdis <jaggy@purplet.demon.co.uk>. Puredata does software
 195            configuration differently from others so we have to check for them.
 196            This detects an 8 bit, 16 bit or dumb (Toshiba, jumpered) card.
 197            */
 198         if (inb(ioaddr+0) == 'P' && inb(ioaddr+1) == 'D') {
 199                 unsigned char reg5 = inb(ioaddr+5);
 200
 201                 switch (inb(ioaddr+2)) {
 202                 case 0x03: word16 = 0; model_name = "PDI8023-8";        break;
 203                 case 0x05: word16 = 0; model_name = "PDUC8023"; break;
 204                 case 0x0a: word16 = 1; model_name = "PDI8023-16"; break;
 205                         /* Either 0x01 (dumb) or they've released a new version. */
 206                 default:         word16 = 0; model_name = "PDI8023";    break;
 207                 }
 208                 dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
 209                 dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
 210         } else {                                                                /* End of PureData probe */
 211                 /* This method of checking for a 16-bit board is borrowed from the
 212                    we.c driver.  A simpler method is just to look in ASIC reg. 0x03.
 213                    I'm comparing the two method in alpha test to make certain they
 214                    return the same result. */
 215                 /* Check for the old 8 bit board - it has register 0/8 aliasing.
 216                    Do NOT check i>=6 here -- it hangs the old 8003 boards! */
 217                 for (i = 0; i < 6; i++)
 218                         if (inb(ioaddr+i) != inb(ioaddr+8+i))
 219                                 break;
 220                 if (i >= 6) {
 221                         ancient = 1;
 222                         model_name = "WD8003-old";
 223                         word16 = 0;
 224                 } else {
 225                         int tmp = inb(ioaddr+1); /* fiddle with 16bit bit */
 226                         outb( tmp ^ 0x01, ioaddr+1 ); /* attempt to clear 16bit bit */
 227                         if (((inb( ioaddr+1) & 0x01) == 0x01) /* A 16 bit card */
 228                                 && (tmp & 0x01) == 0x01 ) {                             /* In a 16 slot. */
 229                                 int asic_reg5 = inb(ioaddr+WD_CMDREG5);
 230                                 /* Magic to set ASIC to word-wide mode. */
 231                                 outb( NIC16 | (asic_reg5&0x1f), ioaddr+WD_CMDREG5);
 232                                 outb(tmp, ioaddr+1);
 233                                 model_name = "WD8013";
 234                                 word16 = 1;             /* We have a 16bit board here! */
 235                         } else {
 236                                 model_name = "WD8003";
 237                                 word16 = 0;
 238                         }
 239                         outb(tmp, ioaddr+1);                    /* Restore original reg1 value. */
 240                 }
 241 #ifndef final_version
 242                 if ( !ancient && (inb(ioaddr+1) & 0x01) != (word16 & 0x01))
 243                         printk("\nWD80?3: Bus width conflict, %d (probe) != %d (reg report).",
 244                                    word16 ? 16 : 8, (inb(ioaddr+1) & 0x01) ? 16 : 8);
 245 #endif
 246         }
 247
 248 #if defined(WD_SHMEM) && WD_SHMEM > 0x80000
 249         /* Allow a compile-time override.        */
 250         dev->mem_start = WD_SHMEM;
 251 #else
 252         if (dev->mem_start == 0) {
 253                 /* Sanity and old 8003 check */
 254                 int reg0 = inb(ioaddr);
 255                 if (reg0 == 0xff || reg0 == 0) {
 256                         /* Future plan: this could check a few likely locations first. */
 257                         dev->mem_start = 0xd0000;
 258                         printk(" assigning address %#lx", dev->mem_start);
 259                 } else {
 260                         int high_addr_bits = inb(ioaddr+WD_CMDREG5) & 0x1f;
 261                         /* Some boards don't have the register 5 -- it returns 0xff. */
 262                         if (high_addr_bits == 0x1f || word16 == 0)
 263                                 high_addr_bits = 0x01;
 264                         dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
 265                 }
 266         }
 267 #endif
 268
 269         /* The 8390 isn't at the base address -- the ASIC regs are there! */
 270         dev->base_addr = ioaddr+WD_NIC_OFFSET;
 271
 272         if (dev->irq < 2) {
 273                 int irqmap[] = {9,3,5,7,10,11,15,4};
 274                 int reg1 = inb(ioaddr+1);
 275                 int reg4 = inb(ioaddr+4);
 276                 if (ancient || reg1 == 0xff) {  /* Ack!! No way to read the IRQ! */
 277                         short nic_addr = ioaddr+WD_NIC_OFFSET;
 278                         unsigned long irq_mask;
 279
 280                         /* We have an old-style ethercard that doesn't report its IRQ
 281                            line.  Do autoirq to find the IRQ line. Note that this IS NOT
 282                            a reliable way to trigger an interrupt. */
 283                         outb_p(E8390_NODMA + E8390_STOP, nic_addr);
 284                         outb(0x00, nic_addr+EN0_IMR);   /* Disable all intrs. */
 285
 286                         irq_mask = probe_irq_on();
 287                         outb_p(0xff, nic_addr + EN0_IMR);       /* Enable all interrupts. */
 288                         outb_p(0x00, nic_addr + EN0_RCNTLO);
 289                         outb_p(0x00, nic_addr + EN0_RCNTHI);
 290                         outb(E8390_RREAD+E8390_START, nic_addr); /* Trigger it... */
 291                         mdelay(20);
 292                         dev->irq = probe_irq_off(irq_mask);
 293
 294                         outb_p(0x00, nic_addr+EN0_IMR); /* Mask all intrs. again. */
 295
 296                         if (ei_debug > 2)
 297                                 printk(" autoirq is %d", dev->irq);
 298                         if (dev->irq < 2)
 299                                 dev->irq = word16 ? 10 : 5;
 300                 } else
 301                         dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
 302         } else if (dev->irq == 2)               /* Fixup bogosity: IRQ2 is really IRQ9 */
 303                 dev->irq = 9;
 304
 305         /* Snarf the interrupt now.  There's no point in waiting since we cannot
 306            share and the board will usually be enabled. */
 307         i = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
 308         if (i) {
 309                 printk (" unable to get IRQ %d.\n", dev->irq);
 310                 return i;
 311         }
 312
 313         /* OK, were are certain this is going to work.  Setup the device. */
 314         ei_status.name = model_name;
 315         ei_status.word16 = word16;
 316         ei_status.tx_start_page = WD_START_PG;
 317         ei_status.rx_start_page = WD_START_PG + TX_PAGES;
 318
 319         /* Don't map in the shared memory until the board is actually opened. */
 320         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
 321
 322         /* Some cards (eg WD8003EBT) can be jumpered for more (32k!) memory. */
 323         if (dev->mem_end != 0) {
 324                 ei_status.stop_page = (dev->mem_end - dev->mem_start)/256;
 325         } else {
 326                 ei_status.stop_page = word16 ? WD13_STOP_PG : WD03_STOP_PG;
 327                 dev->mem_end = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
 328         }
 329         ei_status.rmem_end = dev->mem_end;
 330
 331         printk(" %s, IRQ %d, shared memory at %#lx-%#lx.\n",
 332                    model_name, dev->irq, dev->mem_start, dev->mem_end-1);
 333
 334         ei_status.reset_8390 = &wd_reset_8390;
 335         ei_status.block_input = &wd_block_input;
 336         ei_status.block_output = &wd_block_output;
 337         ei_status.get_8390_hdr = &wd_get_8390_hdr;
 338         dev->open = &wd_open;
 339         dev->stop = &wd_close;
 340 #ifdef CONFIG_NET_POLL_CONTROLLER
 341         dev->poll_controller = ei_poll;
 342 #endif
 343         NS8390_init(dev, 0);
 344
 345 #if 1
 346         /* Enable interrupt generation on softconfig cards -- M.U */
 347         /* .. but possibly potentially unsafe - Donald */
 348         if (inb(ioaddr+14) & 0x20)
 349                 outb(inb(ioaddr+4)|0x80, ioaddr+4);
 350 #endif
 351
 352         return 0;
 353 }
 354
 355 static int
 356 wd_open(struct net_device *dev)
 357 {
 358   int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 359
 360   /* Map in the shared memory. Always set register 0 last to remain
 361          compatible with very old boards. */
 362   ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
 363   ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
 364
 365   if (ei_status.word16)
 366           outb(ei_status.reg5, ioaddr+WD_CMDREG5);
 367   outb(ei_status.reg0, ioaddr); /* WD_CMDREG */
 368
 369   ei_open(dev);
 370   return 0;
 371 }
 372
 373 static void
 374 wd_reset_8390(struct net_device *dev)
 375 {
 376         int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 377
 378         outb(WD_RESET, wd_cmd_port);
 379         if (ei_debug > 1) printk("resetting the WD80x3 t=%lu...", jiffies);
 380         ei_status.txing = 0;
 381
 382         /* Set up the ASIC registers, just in case something changed them. */
 383         outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
 384         if (ei_status.word16)
 385                 outb(NIC16 | ((dev->mem_start>>19) & 0x1f), wd_cmd_port+WD_CMDREG5);
 386
 387         if (ei_debug > 1) printk("reset done\n");
 388         return;
 389 }
 390
 391 /* Grab the 8390 specific header. Similar to the block_input routine, but
 392    we don't need to be concerned with ring wrap as the header will be at
 393    the start of a page, so we optimize accordingly. */
 394
 395 static void
 396 wd_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 397 {
 398
 399         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 400         unsigned long hdr_start = dev->mem_start + ((ring_page - WD_START_PG)<<8);
 401
 402         /* We'll always get a 4 byte header read followed by a packet read, so
 403            we enable 16 bit mode before the header, and disable after the body. */
 404         if (ei_status.word16)
 405                 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 406
 407 #ifdef __BIG_ENDIAN
 408         /* Officially this is what we are doing, but the readl() is faster */
 409         /* unfortunately it isn't endian aware of the struct               */
 410         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 411         hdr->count = le16_to_cpu(hdr->count);
 412 #else
 413         ((unsigned int*)hdr)[0] = isa_readl(hdr_start);
 414 #endif
 415 }
 416
 417 /* Block input and output are easy on shared memory ethercards, and trivial
 418    on the Western digital card where there is no choice of how to do it.
 419    The only complications are that the ring buffer wraps, and need to map
 420    switch between 8- and 16-bit modes. */
 421
 422 static void
 423 wd_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 424 {
 425         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 426         unsigned long xfer_start = dev->mem_start + ring_offset - (WD_START_PG<<8);
 427
 428         if (xfer_start + count > ei_status.rmem_end) {
 429                 /* We must wrap the input move. */
 430                 int semi_count = ei_status.rmem_end - xfer_start;
 431                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 432                 count -= semi_count;
 433                 isa_memcpy_fromio(skb->data + semi_count, ei_status.rmem_start, count);
 434         } else {
 435                 /* Packet is in one chunk -- we can copy + cksum. */
 436                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 437         }
 438
 439         /* Turn off 16 bit access so that reboot works.  ISA brain-damage */
 440         if (ei_status.word16)
 441                 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 442 }
 443
 444 static void
 445 wd_block_output(struct net_device *dev, int count, const unsigned char *buf,
 446                                 int start_page)
 447 {
 448         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 449         long shmem = dev->mem_start + ((start_page - WD_START_PG)<<8);
 450
 451
 452         if (ei_status.word16) {
 453                 /* Turn on and off 16 bit access so that reboot works. */
 454                 outb(ISA16 | ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 455                 isa_memcpy_toio(shmem, buf, count);
 456                 outb(ei_status.reg5, wd_cmdreg+WD_CMDREG5);
 457         } else
 458                 isa_memcpy_toio(shmem, buf, count);
 459 }
 460
 461
 462 static int
 463 wd_close(struct net_device *dev)
 464 {
 465         int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
 466
 467         if (ei_debug > 1)
 468                 printk("%s: Shutting down ethercard.\n", dev->name);
 469         ei_close(dev);
 470
 471         /* Change from 16-bit to 8-bit shared memory so reboot works. */
 472         if (ei_status.word16)
 473                 outb(ei_status.reg5, wd_cmdreg + WD_CMDREG5 );
 474
 475         /* And disable the shared memory. */
 476         outb(ei_status.reg0 & ~WD_MEMENB, wd_cmdreg);
 477
 478         return 0;
 479 }
 480
 481 \f
 482 #ifdef MODULE
 483 #define MAX_WD_CARDS    4       /* Max number of wd cards per module */
 484 static struct net_device *dev_wd[MAX_WD_CARDS];
 485 static int io[MAX_WD_CARDS];
 486 static int irq[MAX_WD_CARDS];
 487 static int mem[MAX_WD_CARDS];
 488 static int mem_end[MAX_WD_CARDS];       /* for non std. mem size */
 489
 490 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_WD_CARDS) "i");
 491 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_WD_CARDS) "i");
 492 MODULE_PARM(mem, "1-" __MODULE_STRING(MAX_WD_CARDS) "i");
 493 MODULE_PARM(mem_end, "1-" __MODULE_STRING(MAX_WD_CARDS) "i");
 494 MODULE_PARM_DESC(io, "I/O base address(es)");
 495 MODULE_PARM_DESC(irq, "IRQ number(s) (ignored for PureData boards)");
 496 MODULE_PARM_DESC(mem, "memory base address(es)(ignored for PureData boards)");
 497 MODULE_PARM_DESC(mem_end, "memory end address(es)");
 498 MODULE_DESCRIPTION("ISA Western Digital wd8003/wd8013 ; SMC Elite, Elite16 ethernet driver");
 499 MODULE_LICENSE("GPL");
 500
 501 /* This is set up so that only a single autoprobe takes place per call.
 502 ISA device autoprobes on a running machine are not recommended. */
 503 int
 504 init_module(void)
 505 {
 506         struct net_device *dev;
 507         int this_dev, found = 0;
 508
 509         for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
 510                 if (io[this_dev] == 0)  {
 511                         if (this_dev != 0) break; /* only autoprobe 1st one */
 512                         printk(KERN_NOTICE "wd.c: Presently autoprobing (not recommended) for a single card.\n");
 513                 }
 514                 dev = alloc_ei_netdev();
 515                 if (!dev)
 516                         break;
 517                 dev->irq = irq[this_dev];
 518                 dev->base_addr = io[this_dev];
 519                 dev->mem_start = mem[this_dev];
 520                 dev->mem_end = mem_end[this_dev];
 521                 if (do_wd_probe(dev) == 0) {
 522                         if (register_netdev(dev) == 0) {
 523                                 dev_wd[found++] = dev;
 524                                 continue;
 525                         }
 526                         cleanup_card(dev);
 527                 }
 528                 free_netdev(dev);
 529                 printk(KERN_WARNING "wd.c: No wd80x3 card found (i/o = 0x%x).\n", io[this_dev]);
 530                 break;
 531         }
 532         if (found)
 533                 return 0;
 534         return -ENXIO;
 535 }
 536
 537 void
 538 cleanup_module(void)
 539 {
 540         int this_dev;
 541
 542         for (this_dev = 0; this_dev < MAX_WD_CARDS; this_dev++) {
 543                 struct net_device *dev = dev_wd[this_dev];
 544                 if (dev) {
 545                         unregister_netdev(dev);
 546                         cleanup_card(dev);
 547                         free_netdev(dev);
 548                 }
 549         }
 550 }
 551 #endif /* MODULE */