linux/drivers/net/ethernet/8390/smc-ultra.c
<<
>>
Prefs
   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
  57static 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. */
  78static unsigned int ultra_portlist[] __initdata =
  79{0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
  80
  81static int ultra_probe1(struct net_device *dev, int ioaddr);
  82
  83#ifdef __ISAPNP__
  84static int ultra_probe_isapnp(struct net_device *dev);
  85#endif
  86
  87static int ultra_open(struct net_device *dev);
  88static void ultra_reset_8390(struct net_device *dev);
  89static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  90                                                int ring_page);
  91static void ultra_block_input(struct net_device *dev, int count,
  92                                                  struct sk_buff *skb, int ring_offset);
  93static void ultra_block_output(struct net_device *dev, int count,
  94                                                        const unsigned char *buf, const int start_page);
  95static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  96                                                int ring_page);
  97static void ultra_pio_input(struct net_device *dev, int count,
  98                                                  struct sk_buff *skb, int ring_offset);
  99static void ultra_pio_output(struct net_device *dev, int count,
 100                                                         const unsigned char *buf, const int start_page);
 101static int ultra_close_card(struct net_device *dev);
 102
 103#ifdef __ISAPNP__
 104static 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
 111MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
 112#endif
 113
 114static 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
 128static 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
 140static 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
 167struct 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;
 182out:
 183        free_netdev(dev);
 184        return ERR_PTR(err);
 185}
 186#endif
 187
 188static 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
 203static 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;
 331out:
 332        release_region(ioaddr, ULTRA_IO_EXTENT);
 333        return retval;
 334}
 335
 336#ifdef __ISAPNP__
 337static 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
 385static int
 386ultra_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
 417static void
 418ultra_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
 441static void
 442ultra_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
 461static void
 462ultra_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
 482static void
 483ultra_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. */
 504static 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
 513static 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
 526static void ultra_pio_output(struct net_device *dev, int count,
 527                                                        const unsigned char *buf, const int start_page)
 528{
 529        int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
 530        outb(0x00, ioaddr + IOPA);      /* Set the address, LSB first. */
 531        outb(start_page, ioaddr + IOPA);
 532        /* An extra odd byte is OK here as well. */
 533        outsw(ioaddr + IOPD, buf, (count+1)>>1);
 534}
 535
 536static int
 537ultra_close_card(struct net_device *dev)
 538{
 539        int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
 540        struct ei_device *ei_local = netdev_priv(dev);
 541
 542        netif_stop_queue(dev);
 543
 544        netif_dbg(ei_local, ifdown, dev, "Shutting down ethercard.\n");
 545
 546        outb(0x00, ioaddr + 6);         /* Disable interrupts. */
 547        free_irq(dev->irq, dev);
 548
 549        NS8390_init(dev, 0);
 550
 551        /* We should someday disable shared memory and change to 8-bit mode
 552           "just in case"... */
 553
 554        return 0;
 555}
 556
 557
 558#ifdef MODULE
 559#define MAX_ULTRA_CARDS 4       /* Max number of Ultra cards per module */
 560static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
 561static int io[MAX_ULTRA_CARDS];
 562static int irq[MAX_ULTRA_CARDS];
 563
 564module_param_hw_array(io, int, ioport, NULL, 0);
 565module_param_hw_array(irq, int, irq, NULL, 0);
 566module_param_named(msg_enable, ultra_msg_enable, uint, 0444);
 567MODULE_PARM_DESC(io, "I/O base address(es)");
 568MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
 569MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
 570MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
 571MODULE_LICENSE("GPL");
 572
 573/* This is set up so that only a single autoprobe takes place per call.
 574ISA device autoprobes on a running machine are not recommended. */
 575int __init
 576init_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
 604static void cleanup_card(struct net_device *dev)
 605{
 606        /* NB: ultra_close_card() does free_irq */
 607#ifdef __ISAPNP__
 608        struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
 609        if (idev)
 610                pnp_device_detach(idev);
 611#endif
 612        release_region(dev->base_addr - ULTRA_NIC_OFFSET, ULTRA_IO_EXTENT);
 613        iounmap(ei_status.mem);
 614}
 615
 616void __exit
 617cleanup_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#endif /* MODULE */
 631