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