SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/smc-ultra.c

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