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