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