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