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