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