drivers/net/ethernet/8390/smc-ultra.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
ultra_poll
do_ultra_probe
ultra_probe
ultra_probe1
ultra_probe_isapnp
ultra_open
ultra_reset_8390
ultra_get_8390_hdr
ultra_block_input
ultra_block_output
ultra_pio_get_hdr
ultra_pio_input
ultra_pio_output
ultra_close_card
init_module
cleanup_card
cleanup_module
   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 
 526 static 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 
 536 static int
 537 ultra_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 */
 560 static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
 561 static int io[MAX_ULTRA_CARDS];
 562 static int irq[MAX_ULTRA_CARDS];
 563 
 564 module_param_hw_array(io, int, ioport, NULL, 0);
 565 module_param_hw_array(irq, int, irq, NULL, 0);
 566 module_param_named(msg_enable, ultra_msg_enable, uint, 0444);
 567 MODULE_PARM_DESC(io, "I/O base address(es)");
 568 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
 569 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
 570 MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
 571 MODULE_LICENSE("GPL");
 572 
 573 /* This is set up so that only a single autoprobe takes place per call.
 574 ISA device autoprobes on a running machine are not recommended. */
 575 int __init
 576 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 
 604 static 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 
 616 void __exit
 617 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 #endif /* MODULE */
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/8390/smc-ultra.c

DEFINITIONS
