drivers/net/smc-ultra.c

   1 /* smc-ultra.c: A SMC Ultra ethernet driver for linux. */
   2 /*
   3         This is a driver for the SMC Ultra and SMC EtherEZ ISA ethercards.
   4
   5         Written 1993-1998 by Donald Becker.
   6
   7         Copyright 1993 United States Government as represented by the
   8         Director, National Security Agency.
   9
  10         This software may be used and distributed according to the terms
  11         of the GNU General Public License, incorporated herein by reference.
  12
  13         The author may be reached as becker@scyld.com, or C/O
  14         Scyld Computing Corporation
  15         410 Severn Ave., Suite 210
  16         Annapolis MD 21403
  17
  18         This driver uses the cards in the 8390-compatible mode.
  19         Most of the run-time complexity is handled by the generic code in
  20         8390.c.  The code in this file is responsible for
  21
  22                 ultra_probe()           Detecting and initializing the card.
  23                 ultra_probe1()
  24                 ultra_probe_isapnp()
  25
  26                 ultra_open()            The card-specific details of starting, stopping
  27                 ultra_reset_8390()      and resetting the 8390 NIC core.
  28                 ultra_close()
  29
  30                 ultra_block_input()             Routines for reading and writing blocks of
  31                 ultra_block_output()    packet buffer memory.
  32                 ultra_pio_input()
  33                 ultra_pio_output()
  34
  35         This driver enables the shared memory only when doing the actual data
  36         transfers to avoid a bug in early version of the card that corrupted
  37         data transferred by a AHA1542.
  38
  39         This driver now supports the programmed-I/O (PIO) data transfer mode of
  40         the EtherEZ. It does not use the non-8390-compatible "Altego" mode.
  41         That support (if available) is in smc-ez.c.
  42
  43         Changelog:
  44
  45         Paul Gortmaker  : multiple card support for module users.
  46         Donald Becker   : 4/17/96 PIO support, minor potential problems avoided.
  47         Donald Becker   : 6/6/96 correctly set auto-wrap bit.
  48         Alexander Sotirov : 1/20/01 Added support for ISAPnP cards
  49
  50         Note about the ISA PnP support:
  51
  52         This driver can not autoprobe for more than one SMC EtherEZ PnP card.
  53         You have to configure the second card manually through the /proc/isapnp
  54         interface and then load the module with an explicit io=0x___ option.
  55 */
  56
  57 static const char version[] =
  58         "smc-ultra.c:v2.02 2/3/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  59
  60 #include <linux/config.h>
  61 #include <linux/module.h>
  62 #include <linux/kernel.h>
  63 #include <linux/errno.h>
  64 #include <linux/string.h>
  65 #include <linux/init.h>
  66 #include <linux/isapnp.h>
  67 #include <linux/netdevice.h>
  68 #include <linux/etherdevice.h>
  69
  70 #include <asm/io.h>
  71 #include <asm/system.h>
  72
  73 #include "8390.h"
  74
  75 /* A zero-terminated list of I/O addresses to be probed. */
  76 static unsigned int ultra_portlist[] __initdata =
  77 {0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
  78
  79 int ultra_probe(struct net_device *dev);
  80 static int ultra_probe1(struct net_device *dev, int ioaddr);
  81
  82 #ifdef __ISAPNP__
  83 static int ultra_probe_isapnp(struct net_device *dev);
  84 #endif
  85
  86 static int ultra_open(struct net_device *dev);
  87 static void ultra_reset_8390(struct net_device *dev);
  88 static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  89                                                 int ring_page);
  90 static void ultra_block_input(struct net_device *dev, int count,
  91                                                   struct sk_buff *skb, int ring_offset);
  92 static void ultra_block_output(struct net_device *dev, int count,
  93                                                         const unsigned char *buf, const int start_page);
  94 static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  95                                                 int ring_page);
  96 static void ultra_pio_input(struct net_device *dev, int count,
  97                                                   struct sk_buff *skb, int ring_offset);
  98 static void ultra_pio_output(struct net_device *dev, int count,
  99                                                          const unsigned char *buf, const int start_page);
 100 static int ultra_close_card(struct net_device *dev);
 101
 102 #ifdef __ISAPNP__
 103 static struct isapnp_device_id ultra_device_ids[] __initdata = {
 104         {       ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
 105                 ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
 106                 (long) "SMC EtherEZ (8416)" },
 107         { }     /* terminate list */
 108 };
 109
 110 MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
 111 #endif
 112
 113 \f
 114 #define START_PG                0x00    /* First page of TX buffer */
 115
 116 #define ULTRA_CMDREG    0               /* Offset to ASIC command register. */
 117 #define  ULTRA_RESET    0x80    /* Board reset, in ULTRA_CMDREG. */
 118 #define  ULTRA_MEMENB   0x40    /* Enable the shared memory. */
 119 #define IOPD    0x02                    /* I/O Pipe Data (16 bits), PIO operation. */
 120 #define IOPA    0x07                    /* I/O Pipe Address for PIO operation. */
 121 #define ULTRA_NIC_OFFSET  16    /* NIC register offset from the base_addr. */
 122 #define ULTRA_IO_EXTENT 32
 123 #define EN0_ERWCNT              0x08    /* Early receive warning count. */
 124 \f
 125 /*      Probe for the Ultra.  This looks like a 8013 with the station
 126         address PROM at I/O ports <base>+8 to <base>+13, with a checksum
 127         following.
 128 */
 129
 130 int __init ultra_probe(struct net_device *dev)
 131 {
 132         int i;
 133         int base_addr = dev->base_addr;
 134
 135         SET_MODULE_OWNER(dev);
 136
 137         if (base_addr > 0x1ff)          /* Check a single specified location. */
 138                 return ultra_probe1(dev, base_addr);
 139         else if (base_addr != 0)        /* Don't probe at all. */
 140                 return -ENXIO;
 141
 142 #ifdef __ISAPNP__
 143         /* Look for any installed ISAPnP cards */
 144         if (isapnp_present() && (ultra_probe_isapnp(dev) == 0))
 145                 return 0;
 146
 147         printk(KERN_NOTICE "smc-ultra.c: No ISAPnP cards found, trying standard ones...\n");
 148 #endif
 149
 150         for (i = 0; ultra_portlist[i]; i++)
 151                 if (ultra_probe1(dev, ultra_portlist[i]) == 0)
 152                         return 0;
 153
 154         return -ENODEV;
 155 }
 156
 157 static int __init ultra_probe1(struct net_device *dev, int ioaddr)
 158 {
 159         int i, retval;
 160         int checksum = 0;
 161         const char *model_name;
 162         unsigned char eeprom_irq = 0;
 163         static unsigned version_printed;
 164         /* Values from various config regs. */
 165         unsigned char num_pages, irqreg, addr, piomode;
 166         unsigned char idreg = inb(ioaddr + 7);
 167         unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
 168
 169         if (!request_region(ioaddr, ULTRA_IO_EXTENT, dev->name))
 170                 return -EBUSY;
 171
 172         /* Check the ID nibble. */
 173         if ((idreg & 0xF0) != 0x20                      /* SMC Ultra */
 174                 && (idreg & 0xF0) != 0x40) {            /* SMC EtherEZ */
 175                 retval = -ENODEV;
 176                 goto out;
 177         }
 178
 179         /* Select the station address register set. */
 180         outb(reg4, ioaddr + 4);
 181
 182         for (i = 0; i < 8; i++)
 183                 checksum += inb(ioaddr + 8 + i);
 184         if ((checksum & 0xff) != 0xFF) {
 185                 retval = -ENODEV;
 186                 goto out;
 187         }
 188
 189         if (ei_debug  &&  version_printed++ == 0)
 190                 printk(version);
 191
 192         model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
 193
 194         printk("%s: %s at %#3x,", dev->name, model_name, ioaddr);
 195
 196         for (i = 0; i < 6; i++)
 197                 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
 198
 199         /* Switch from the station address to the alternate register set and
 200            read the useful registers there. */
 201         outb(0x80 | reg4, ioaddr + 4);
 202
 203         /* Enabled FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
 204         outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
 205         piomode = inb(ioaddr + 0x8);
 206         addr = inb(ioaddr + 0xb);
 207         irqreg = inb(ioaddr + 0xd);
 208
 209         /* Switch back to the station address register set so that the MS-DOS driver
 210            can find the card after a warm boot. */
 211         outb(reg4, ioaddr + 4);
 212
 213         if (dev->irq < 2) {
 214                 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
 215                 int irq;
 216
 217                 /* The IRQ bits are split. */
 218                 irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
 219
 220                 if (irq == 0) {
 221                         printk(", failed to detect IRQ line.\n");
 222                         retval =  -EAGAIN;
 223                         goto out;
 224                 }
 225                 dev->irq = irq;
 226                 eeprom_irq = 1;
 227         }
 228
 229         /* Allocate dev->priv and fill in 8390 specific dev fields. */
 230         if (ethdev_init(dev)) {
 231                 printk (", no memory for dev->priv.\n");
 232                 retval = -ENOMEM;
 233                 goto out;
 234         }
 235
 236         /* The 8390 isn't at the base address, so fake the offset */
 237         dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
 238
 239         {
 240                 int addr_tbl[4] = {0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000};
 241                 short num_pages_tbl[4] = {0x20, 0x40, 0x80, 0xff};
 242
 243                 dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
 244                 num_pages = num_pages_tbl[(addr >> 4) & 3];
 245         }
 246
 247         ei_status.name = model_name;
 248         ei_status.word16 = 1;
 249         ei_status.tx_start_page = START_PG;
 250         ei_status.rx_start_page = START_PG + TX_PAGES;
 251         ei_status.stop_page = num_pages;
 252
 253         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
 254         dev->mem_end = ei_status.rmem_end
 255                 = dev->mem_start + (ei_status.stop_page - START_PG)*256;
 256
 257         if (piomode) {
 258                 printk(",%s IRQ %d programmed-I/O mode.\n",
 259                            eeprom_irq ? "EEPROM" : "assigned ", dev->irq);
 260                 ei_status.block_input = &ultra_pio_input;
 261                 ei_status.block_output = &ultra_pio_output;
 262                 ei_status.get_8390_hdr = &ultra_pio_get_hdr;
 263         } else {
 264                 printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
 265                            dev->irq, dev->mem_start, dev->mem_end-1);
 266                 ei_status.block_input = &ultra_block_input;
 267                 ei_status.block_output = &ultra_block_output;
 268                 ei_status.get_8390_hdr = &ultra_get_8390_hdr;
 269         }
 270         ei_status.reset_8390 = &ultra_reset_8390;
 271         dev->open = &ultra_open;
 272         dev->stop = &ultra_close_card;
 273         NS8390_init(dev, 0);
 274
 275         return 0;
 276 out:
 277         release_region(ioaddr, ULTRA_IO_EXTENT);
 278         return retval;
 279 }
 280
 281 #ifdef __ISAPNP__
 282 static int __init ultra_probe_isapnp(struct net_device *dev)
 283 {
 284         int i;
 285
 286         for (i = 0; ultra_device_ids[i].vendor != 0; i++) {
 287                 struct pnp_dev *idev = NULL;
 288
 289                 while ((idev = pnp_find_dev(NULL,
 290                                             ultra_device_ids[i].vendor,
 291                                             ultra_device_ids[i].function,
 292                                             idev))) {
 293                         /* Avoid already found cards from previous calls */
 294                         if (pnp_device_attach(idev) < 0)
 295                                 continue;
 296                         if (pnp_activate_dev(idev) < 0) {
 297                               __again:
 298                                 pnp_device_detach(idev);
 299                                 continue;
 300                         }
 301                         /* if no io and irq, search for next */
 302                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
 303                                 goto __again;
 304                         /* found it */
 305                         dev->base_addr = pnp_port_start(idev, 0);
 306                         dev->irq = pnp_irq(idev, 0);
 307                         printk(KERN_INFO "smc-ultra.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
 308                                 (char *) ultra_device_ids[i].driver_data,
 309                                 dev->base_addr, dev->irq);
 310                         if (ultra_probe1(dev, dev->base_addr) != 0) {      /* Shouldn't happen. */
 311                                 printk(KERN_ERR "smc-ultra.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
 312                                 pnp_device_detach(idev);
 313                                 return -ENXIO;
 314                         }
 315                         ei_status.priv = (unsigned long)idev;
 316                         break;
 317                 }
 318                 if (!idev)
 319                         continue;
 320                 return 0;
 321         }
 322
 323         return -ENODEV;
 324 }
 325 #endif
 326
 327 static int
 328 ultra_open(struct net_device *dev)
 329 {
 330         int retval;
 331         int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
 332         unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
 333                                    0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
 334
 335         retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
 336         if (retval)
 337                 return retval;
 338
 339         outb(0x00, ioaddr);     /* Disable shared memory for safety. */
 340         outb(0x80, ioaddr + 5);
 341         /* Set the IRQ line. */
 342         outb(inb(ioaddr + 4) | 0x80, ioaddr + 4);
 343         outb((inb(ioaddr + 13) & ~0x4C) | irq2reg[dev->irq], ioaddr + 13);
 344         outb(inb(ioaddr + 4) & 0x7f, ioaddr + 4);
 345
 346         if (ei_status.block_input == &ultra_pio_input) {
 347                 outb(0x11, ioaddr + 6);         /* Enable interrupts and PIO. */
 348                 outb(0x01, ioaddr + 0x19);      /* Enable ring read auto-wrap. */
 349         } else
 350                 outb(0x01, ioaddr + 6);         /* Enable interrupts and memory. */
 351         /* Set the early receive warning level in window 0 high enough not
 352            to receive ERW interrupts. */
 353         outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
 354         outb(0xff, dev->base_addr + EN0_ERWCNT);
 355         ei_open(dev);
 356         return 0;
 357 }
 358
 359 static void
 360 ultra_reset_8390(struct net_device *dev)
 361 {
 362         int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC base addr */
 363
 364         outb(ULTRA_RESET, cmd_port);
 365         if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
 366         ei_status.txing = 0;
 367
 368         outb(0x00, cmd_port);   /* Disable shared memory for safety. */
 369         outb(0x80, cmd_port + 5);
 370         if (ei_status.block_input == &ultra_pio_input)
 371                 outb(0x11, cmd_port + 6);               /* Enable interrupts and PIO. */
 372         else
 373                 outb(0x01, cmd_port + 6);               /* Enable interrupts and memory. */
 374
 375         if (ei_debug > 1) printk("reset done\n");
 376         return;
 377 }
 378
 379 /* Grab the 8390 specific header. Similar to the block_input routine, but
 380    we don't need to be concerned with ring wrap as the header will be at
 381    the start of a page, so we optimize accordingly. */
 382
 383 static void
 384 ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 385 {
 386         unsigned long hdr_start = dev->mem_start + ((ring_page - START_PG)<<8);
 387
 388         outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);  /* shmem on */
 389 #ifdef __BIG_ENDIAN
 390         /* Officially this is what we are doing, but the readl() is faster */
 391         /* unfortunately it isn't endian aware of the struct               */
 392         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 393         hdr->count = le16_to_cpu(hdr->count);
 394 #else
 395         ((unsigned int*)hdr)[0] = isa_readl(hdr_start);
 396 #endif
 397         outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
 398 }
 399
 400 /* Block input and output are easy on shared memory ethercards, the only
 401    complication is when the ring buffer wraps. */
 402
 403 static void
 404 ultra_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 405 {
 406         unsigned long xfer_start = dev->mem_start + ring_offset - (START_PG<<8);
 407
 408         /* Enable shared memory. */
 409         outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
 410
 411         if (xfer_start + count > ei_status.rmem_end) {
 412                 /* We must wrap the input move. */
 413                 int semi_count = ei_status.rmem_end - xfer_start;
 414                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 415                 count -= semi_count;
 416                 isa_memcpy_fromio(skb->data + semi_count, ei_status.rmem_start, count);
 417         } else {
 418                 /* Packet is in one chunk -- we can copy + cksum. */
 419                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 420         }
 421
 422         outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET);  /* Disable memory. */
 423 }
 424
 425 static void
 426 ultra_block_output(struct net_device *dev, int count, const unsigned char *buf,
 427                                 int start_page)
 428 {
 429         unsigned long shmem = dev->mem_start + ((start_page - START_PG)<<8);
 430
 431         /* Enable shared memory. */
 432         outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
 433
 434         isa_memcpy_toio(shmem, buf, count);
 435
 436         outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
 437 }
 438
 439 /* The identical operations for programmed I/O cards.
 440    The PIO model is trivial to use: the 16 bit start address is written
 441    byte-sequentially to IOPA, with no intervening I/O operations, and the
 442    data is read or written to the IOPD data port.
 443    The only potential complication is that the address register is shared
 444    and must be always be rewritten between each read/write direction change.
 445    This is no problem for us, as the 8390 code ensures that we are single
 446    threaded. */
 447 static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
 448                                                 int ring_page)
 449 {
 450         int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
 451         outb(0x00, ioaddr + IOPA);      /* Set the address, LSB first. */
 452         outb(ring_page, ioaddr + IOPA);
 453         insw(ioaddr + IOPD, hdr, sizeof(struct e8390_pkt_hdr)>>1);
 454 }
 455
 456 static void ultra_pio_input(struct net_device *dev, int count,
 457                                                   struct sk_buff *skb, int ring_offset)
 458 {
 459         int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
 460     char *buf = skb->data;
 461
 462         /* For now set the address again, although it should already be correct. */
 463         outb(ring_offset, ioaddr + IOPA);       /* Set the address, LSB first. */
 464         outb(ring_offset >> 8, ioaddr + IOPA);
 465         /* We know skbuffs are padded to at least word alignment. */
 466         insw(ioaddr + IOPD, buf, (count+1)>>1);
 467 }
 468
 469 static void ultra_pio_output(struct net_device *dev, int count,
 470                                                         const unsigned char *buf, const int start_page)
 471 {
 472         int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
 473         outb(0x00, ioaddr + IOPA);      /* Set the address, LSB first. */
 474         outb(start_page, ioaddr + IOPA);
 475         /* An extra odd byte is OK here as well. */
 476         outsw(ioaddr + IOPD, buf, (count+1)>>1);
 477 }
 478
 479 static int
 480 ultra_close_card(struct net_device *dev)
 481 {
 482         int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
 483
 484         netif_stop_queue(dev);
 485
 486         if (ei_debug > 1)
 487                 printk("%s: Shutting down ethercard.\n", dev->name);
 488
 489         outb(0x00, ioaddr + 6);         /* Disable interrupts. */
 490         free_irq(dev->irq, dev);
 491
 492         NS8390_init(dev, 0);
 493
 494         /* We should someday disable shared memory and change to 8-bit mode
 495            "just in case"... */
 496
 497         return 0;
 498 }
 499
 500 \f
 501 #ifdef MODULE
 502 #define MAX_ULTRA_CARDS 4       /* Max number of Ultra cards per module */
 503 static struct net_device dev_ultra[MAX_ULTRA_CARDS];
 504 static int io[MAX_ULTRA_CARDS];
 505 static int irq[MAX_ULTRA_CARDS];
 506
 507 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_ULTRA_CARDS) "i");
 508 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_ULTRA_CARDS) "i");
 509 MODULE_PARM_DESC(io, "I/O base address(es)");
 510 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
 511 MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
 512 MODULE_LICENSE("GPL");
 513
 514 /* This is set up so that only a single autoprobe takes place per call.
 515 ISA device autoprobes on a running machine are not recommended. */
 516 int
 517 init_module(void)
 518 {
 519         int this_dev, found = 0;
 520
 521         for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
 522                 struct net_device *dev = &dev_ultra[this_dev];
 523                 dev->irq = irq[this_dev];
 524                 dev->base_addr = io[this_dev];
 525                 dev->init = ultra_probe;
 526                 if (io[this_dev] == 0)  {
 527                         if (this_dev != 0) break; /* only autoprobe 1st one */
 528                         printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
 529                 }
 530                 if (register_netdev(dev) != 0) {
 531                         printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
 532                         if (found != 0) return 0;       /* Got at least one. */
 533                         return -ENXIO;
 534                 }
 535                 found++;
 536         }
 537
 538         return 0;
 539 }
 540
 541 void
 542 cleanup_module(void)
 543 {
 544         int this_dev;
 545
 546         for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
 547                 struct net_device *dev = &dev_ultra[this_dev];
 548                 if (dev->priv != NULL) {
 549                         /* NB: ultra_close_card() does free_irq */
 550                         int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
 551
 552 #ifdef __ISAPNP__
 553                         struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
 554                         if (idev)
 555                                 pnp_device_detach(idev);
 556 #endif
 557
 558                         unregister_netdev(dev);
 559                         release_region(ioaddr, ULTRA_IO_EXTENT);
 560                         kfree(dev->priv);
 561                 }
 562         }
 563 }
 564 #endif /* MODULE */
 565
 566 \f
 567
 568 /*
 569  * Local variables:
 570  *  compile-command: "gcc -D__KERNEL__ -Wall -O6 -I/usr/src/linux/net/inet -c smc-ultra.c"
 571  *  version-control: t
 572  *  kept-new-versions: 5
 573  *  c-indent-level: 4
 574  *  c-basic-offset: 4
 575  *  tab-width: 4
 576  * End:
 577  */