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