drivers/net/3c503.c

   1 /* 3c503.c: A shared-memory NS8390 ethernet driver for linux. */
   2 /*
   3     Written 1992-94 by Donald Becker.
   4
   5     Copyright 1993 United States Government as represented by the
   6     Director, National Security Agency.  This software may be used and
   7     distributed according to the terms of the GNU General Public License,
   8     incorporated herein by reference.
   9
  10     The author may be reached as becker@scyld.com, or C/O
  11         Scyld Computing Corporation
  12         410 Severn Ave., Suite 210
  13         Annapolis MD 21403
  14
  15
  16     This driver should work with the 3c503 and 3c503/16.  It should be used
  17     in shared memory mode for best performance, although it may also work
  18     in programmed-I/O mode.
  19
  20     Sources:
  21     EtherLink II Technical Reference Manual,
  22     EtherLink II/16 Technical Reference Manual Supplement,
  23     3Com Corporation, 5400 Bayfront Plaza, Santa Clara CA 95052-8145
  24
  25     The Crynwr 3c503 packet driver.
  26
  27     Changelog:
  28
  29     Paul Gortmaker      : add support for the 2nd 8kB of RAM on 16 bit cards.
  30     Paul Gortmaker      : multiple card support for module users.
  31     rjohnson@analogic.com : Fix up PIO interface for efficient operation.
  32     Jeff Garzik         : ethtool support
  33
  34 */
  35
  36 #define DRV_NAME        "3c503"
  37 #define DRV_VERSION     "1.10a"
  38 #define DRV_RELDATE     "11/17/2001"
  39
  40
  41 static const char version[] =
  42     DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE "  Donald Becker (becker@scyld.com)\n";
  43
  44 #include <linux/module.h>
  45 #include <linux/kernel.h>
  46 #include <linux/errno.h>
  47 #include <linux/string.h>
  48 #include <linux/delay.h>
  49 #include <linux/netdevice.h>
  50 #include <linux/etherdevice.h>
  51 #include <linux/init.h>
  52 #include <linux/ethtool.h>
  53
  54 #include <asm/uaccess.h>
  55 #include <asm/io.h>
  56 #include <asm/system.h>
  57 #include <asm/byteorder.h>
  58
  59 #include "8390.h"
  60 #include "3c503.h"
  61 #define WRD_COUNT 4
  62
  63 static int el2_pio_probe(struct net_device *dev);
  64 static int el2_probe1(struct net_device *dev, int ioaddr);
  65
  66 /* A zero-terminated list of I/O addresses to be probed in PIO mode. */
  67 static unsigned int netcard_portlist[] __initdata =
  68         { 0x300,0x310,0x330,0x350,0x250,0x280,0x2a0,0x2e0,0};
  69
  70 #define EL2_IO_EXTENT   16
  71
  72 static int el2_open(struct net_device *dev);
  73 static int el2_close(struct net_device *dev);
  74 static void el2_reset_8390(struct net_device *dev);
  75 static void el2_init_card(struct net_device *dev);
  76 static void el2_block_output(struct net_device *dev, int count,
  77                              const unsigned char *buf, int start_page);
  78 static void el2_block_input(struct net_device *dev, int count, struct sk_buff *skb,
  79                            int ring_offset);
  80 static void el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  81                          int ring_page);
  82 static const struct ethtool_ops netdev_ethtool_ops;
  83
  84
  85 /* This routine probes for a memory-mapped 3c503 board by looking for
  86    the "location register" at the end of the jumpered boot PROM space.
  87    This works even if a PROM isn't there.
  88
  89    If the ethercard isn't found there is an optional probe for
  90    ethercard jumpered to programmed-I/O mode.
  91    */
  92 static int __init do_el2_probe(struct net_device *dev)
  93 {
  94     int *addr, addrs[] = { 0xddffe, 0xd9ffe, 0xcdffe, 0xc9ffe, 0};
  95     int base_addr = dev->base_addr;
  96     int irq = dev->irq;
  97
  98     if (base_addr > 0x1ff)      /* Check a single specified location. */
  99         return el2_probe1(dev, base_addr);
 100     else if (base_addr != 0)            /* Don't probe at all. */
 101         return -ENXIO;
 102
 103     for (addr = addrs; *addr; addr++) {
 104         void __iomem *p = ioremap(*addr, 1);
 105         unsigned base_bits;
 106         int i;
 107
 108         if (!p)
 109                 continue;
 110         base_bits = readb(p);
 111         iounmap(p);
 112         i = ffs(base_bits) - 1;
 113         if (i == -1 || base_bits != (1 << i))
 114             continue;
 115         if (el2_probe1(dev, netcard_portlist[i]) == 0)
 116             return 0;
 117         dev->irq = irq;
 118     }
 119 #if ! defined(no_probe_nonshared_memory)
 120     return el2_pio_probe(dev);
 121 #else
 122     return -ENODEV;
 123 #endif
 124 }
 125
 126 /*  Try all of the locations that aren't obviously empty.  This touches
 127     a lot of locations, and is much riskier than the code above. */
 128 static int __init
 129 el2_pio_probe(struct net_device *dev)
 130 {
 131     int i;
 132     int base_addr = dev->base_addr;
 133     int irq = dev->irq;
 134
 135     if (base_addr > 0x1ff)      /* Check a single specified location. */
 136         return el2_probe1(dev, base_addr);
 137     else if (base_addr != 0)    /* Don't probe at all. */
 138         return -ENXIO;
 139
 140     for (i = 0; netcard_portlist[i]; i++) {
 141         if (el2_probe1(dev, netcard_portlist[i]) == 0)
 142             return 0;
 143         dev->irq = irq;
 144     }
 145
 146     return -ENODEV;
 147 }
 148
 149 #ifndef MODULE
 150 struct net_device * __init el2_probe(int unit)
 151 {
 152         struct net_device *dev = alloc_ei_netdev();
 153         int err;
 154
 155         if (!dev)
 156                 return ERR_PTR(-ENOMEM);
 157
 158         sprintf(dev->name, "eth%d", unit);
 159         netdev_boot_setup_check(dev);
 160
 161         err = do_el2_probe(dev);
 162         if (err)
 163                 goto out;
 164         return dev;
 165 out:
 166         free_netdev(dev);
 167         return ERR_PTR(err);
 168 }
 169 #endif
 170
 171 /* Probe for the Etherlink II card at I/O port base IOADDR,
 172    returning non-zero on success.  If found, set the station
 173    address and memory parameters in DEVICE. */
 174 static int __init
 175 el2_probe1(struct net_device *dev, int ioaddr)
 176 {
 177     int i, iobase_reg, membase_reg, saved_406, wordlength, retval;
 178     static unsigned version_printed;
 179     unsigned long vendor_id;
 180
 181     if (!request_region(ioaddr, EL2_IO_EXTENT, DRV_NAME))
 182         return -EBUSY;
 183
 184     if (!request_region(ioaddr + 0x400, 8, DRV_NAME)) {
 185         retval = -EBUSY;
 186         goto out;
 187     }
 188
 189     /* Reset and/or avoid any lurking NE2000 */
 190     if (inb(ioaddr + 0x408) == 0xff) {
 191         mdelay(1);
 192         retval = -ENODEV;
 193         goto out1;
 194     }
 195
 196     /* We verify that it's a 3C503 board by checking the first three octets
 197        of its ethernet address. */
 198     iobase_reg = inb(ioaddr+0x403);
 199     membase_reg = inb(ioaddr+0x404);
 200     /* ASIC location registers should be 0 or have only a single bit set. */
 201     if (   (iobase_reg  & (iobase_reg - 1))
 202         || (membase_reg & (membase_reg - 1))) {
 203         retval = -ENODEV;
 204         goto out1;
 205     }
 206     saved_406 = inb_p(ioaddr + 0x406);
 207     outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */
 208     outb_p(ECNTRL_THIN, ioaddr + 0x406);
 209     /* Map the station addr PROM into the lower I/O ports. We now check
 210        for both the old and new 3Com prefix */
 211     outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406);
 212     vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2);
 213     if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) {
 214         /* Restore the register we frobbed. */
 215         outb(saved_406, ioaddr + 0x406);
 216         retval = -ENODEV;
 217         goto out1;
 218     }
 219
 220     if (ei_debug  &&  version_printed++ == 0)
 221         printk(version);
 222
 223     dev->base_addr = ioaddr;
 224
 225     printk("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
 226
 227     /* Retrieve and print the ethernet address. */
 228     for (i = 0; i < 6; i++)
 229         printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
 230
 231     /* Map the 8390 back into the window. */
 232     outb(ECNTRL_THIN, ioaddr + 0x406);
 233
 234     /* Check for EL2/16 as described in tech. man. */
 235     outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
 236     outb_p(0, ioaddr + EN0_DCFG);
 237     outb_p(E8390_PAGE2, ioaddr + E8390_CMD);
 238     wordlength = inb_p(ioaddr + EN0_DCFG) & ENDCFG_WTS;
 239     outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
 240
 241     /* Probe for, turn on and clear the board's shared memory. */
 242     if (ei_debug > 2) printk(" memory jumpers %2.2x ", membase_reg);
 243     outb(EGACFR_NORM, ioaddr + 0x405);  /* Enable RAM */
 244
 245     /* This should be probed for (or set via an ioctl()) at run-time.
 246        Right now we use a sleazy hack to pass in the interface number
 247        at boot-time via the low bits of the mem_end field.  That value is
 248        unused, and the low bits would be discarded even if it was used. */
 249 #if defined(EI8390_THICK) || defined(EL2_AUI)
 250     ei_status.interface_num = 1;
 251 #else
 252     ei_status.interface_num = dev->mem_end & 0xf;
 253 #endif
 254     printk(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
 255
 256     if ((membase_reg & 0xf0) == 0) {
 257         dev->mem_start = 0;
 258         ei_status.name = "3c503-PIO";
 259         ei_status.mem = NULL;
 260     } else {
 261         dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
 262             ((membase_reg & 0xA0) ? 0x4000 : 0);
 263 #define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256
 264         ei_status.mem = ioremap(dev->mem_start, EL2_MEMSIZE);
 265
 266 #ifdef EL2MEMTEST
 267         /* This has never found an error, but someone might care.
 268            Note that it only tests the 2nd 8kB on 16kB 3c503/16
 269            cards between card addr. 0x2000 and 0x3fff. */
 270         {                       /* Check the card's memory. */
 271             void __iomem *mem_base = ei_status.mem;
 272             unsigned int test_val = 0xbbadf00d;
 273             writel(0xba5eba5e, mem_base);
 274             for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) {
 275                 writel(test_val, mem_base + i);
 276                 if (readl(mem_base) != 0xba5eba5e
 277                     || readl(mem_base + i) != test_val) {
 278                     printk("3c503: memory failure or memory address conflict.\n");
 279                     dev->mem_start = 0;
 280                     ei_status.name = "3c503-PIO";
 281                     iounmap(mem_base);
 282                     ei_status.mem = NULL;
 283                     break;
 284                 }
 285                 test_val += 0x55555555;
 286                 writel(0, mem_base + i);
 287             }
 288         }
 289 #endif  /* EL2MEMTEST */
 290
 291         if (dev->mem_start)
 292                 dev->mem_end = dev->mem_start + EL2_MEMSIZE;
 293
 294         if (wordlength) {       /* No Tx pages to skip over to get to Rx */
 295                 ei_status.priv = 0;
 296                 ei_status.name = "3c503/16";
 297         } else {
 298                 ei_status.priv = TX_PAGES * 256;
 299                 ei_status.name = "3c503";
 300         }
 301     }
 302
 303     /*
 304         Divide up the memory on the card. This is the same regardless of
 305         whether shared-mem or PIO is used. For 16 bit cards (16kB RAM),
 306         we use the entire 8k of bank1 for an Rx ring. We only use 3k
 307         of the bank0 for 2 full size Tx packet slots. For 8 bit cards,
 308         (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining
 309         5kB for an Rx ring.  */
 310
 311     if (wordlength) {
 312         ei_status.tx_start_page = EL2_MB0_START_PG;
 313         ei_status.rx_start_page = EL2_MB1_START_PG;
 314     } else {
 315         ei_status.tx_start_page = EL2_MB1_START_PG;
 316         ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
 317     }
 318
 319     /* Finish setting the board's parameters. */
 320     ei_status.stop_page = EL2_MB1_STOP_PG;
 321     ei_status.word16 = wordlength;
 322     ei_status.reset_8390 = &el2_reset_8390;
 323     ei_status.get_8390_hdr = &el2_get_8390_hdr;
 324     ei_status.block_input = &el2_block_input;
 325     ei_status.block_output = &el2_block_output;
 326
 327     if (dev->irq == 2)
 328         dev->irq = 9;
 329     else if (dev->irq > 5 && dev->irq != 9) {
 330         printk("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
 331                dev->irq);
 332         dev->irq = 0;
 333     }
 334
 335     ei_status.saved_irq = dev->irq;
 336
 337     dev->open = &el2_open;
 338     dev->stop = &el2_close;
 339     dev->ethtool_ops = &netdev_ethtool_ops;
 340 #ifdef CONFIG_NET_POLL_CONTROLLER
 341     dev->poll_controller = ei_poll;
 342 #endif
 343
 344     retval = register_netdev(dev);
 345     if (retval)
 346         goto out1;
 347
 348     if (dev->mem_start)
 349         printk("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
 350                 dev->name, ei_status.name, (wordlength+1)<<3,
 351                 dev->mem_start, dev->mem_end-1);
 352
 353     else
 354     {
 355         ei_status.tx_start_page = EL2_MB1_START_PG;
 356         ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
 357         printk("\n%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
 358                dev->name, ei_status.name, (wordlength+1)<<3);
 359     }
 360     release_region(ioaddr + 0x400, 8);
 361     return 0;
 362 out1:
 363     release_region(ioaddr + 0x400, 8);
 364 out:
 365     release_region(ioaddr, EL2_IO_EXTENT);
 366     return retval;
 367 }
 368
 369 static int
 370 el2_open(struct net_device *dev)
 371 {
 372     int retval = -EAGAIN;
 373
 374     if (dev->irq < 2) {
 375         int irqlist[] = {5, 9, 3, 4, 0};
 376         int *irqp = irqlist;
 377
 378         outb(EGACFR_NORM, E33G_GACFR);  /* Enable RAM and interrupts. */
 379         do {
 380             if (request_irq (*irqp, NULL, 0, "bogus", dev) != -EBUSY) {
 381                 /* Twinkle the interrupt, and check if it's seen. */
 382                 unsigned long cookie = probe_irq_on();
 383                 outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
 384                 outb_p(0x00, E33G_IDCFR);
 385                 if (*irqp == probe_irq_off(cookie)      /* It's a good IRQ line! */
 386                     && ((retval = request_irq(dev->irq = *irqp,
 387                     ei_interrupt, 0, dev->name, dev)) == 0))
 388                     break;
 389             }
 390         } while (*++irqp);
 391         if (*irqp == 0) {
 392             outb(EGACFR_IRQOFF, E33G_GACFR);    /* disable interrupts. */
 393             return retval;
 394         }
 395     } else {
 396         if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
 397             return retval;
 398         }
 399     }
 400
 401     el2_init_card(dev);
 402     ei_open(dev);
 403     return 0;
 404 }
 405
 406 static int
 407 el2_close(struct net_device *dev)
 408 {
 409     free_irq(dev->irq, dev);
 410     dev->irq = ei_status.saved_irq;
 411     outb(EGACFR_IRQOFF, E33G_GACFR);    /* disable interrupts. */
 412
 413     ei_close(dev);
 414     return 0;
 415 }
 416
 417 /* This is called whenever we have a unrecoverable failure:
 418        transmit timeout
 419        Bad ring buffer packet header
 420  */
 421 static void
 422 el2_reset_8390(struct net_device *dev)
 423 {
 424     if (ei_debug > 1) {
 425         printk("%s: Resetting the 3c503 board...", dev->name);
 426         printk("%#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
 427                E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
 428     }
 429     outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
 430     ei_status.txing = 0;
 431     outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
 432     el2_init_card(dev);
 433     if (ei_debug > 1) printk("done\n");
 434 }
 435
 436 /* Initialize the 3c503 GA registers after a reset. */
 437 static void
 438 el2_init_card(struct net_device *dev)
 439 {
 440     /* Unmap the station PROM and select the DIX or BNC connector. */
 441     outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
 442
 443     /* Set ASIC copy of rx's first and last+1 buffer pages */
 444     /* These must be the same as in the 8390. */
 445     outb(ei_status.rx_start_page, E33G_STARTPG);
 446     outb(ei_status.stop_page,  E33G_STOPPG);
 447
 448     /* Point the vector pointer registers somewhere ?harmless?. */
 449     outb(0xff, E33G_VP2);       /* Point at the ROM restart location 0xffff0 */
 450     outb(0xff, E33G_VP1);
 451     outb(0x00, E33G_VP0);
 452     /* Turn off all interrupts until we're opened. */
 453     outb_p(0x00,  dev->base_addr + EN0_IMR);
 454     /* Enable IRQs iff started. */
 455     outb(EGACFR_NORM, E33G_GACFR);
 456
 457     /* Set the interrupt line. */
 458     outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
 459     outb_p((WRD_COUNT << 1), E33G_DRQCNT);      /* Set burst size to 8 */
 460     outb_p(0x20, E33G_DMAAH);   /* Put a valid addr in the GA DMA */
 461     outb_p(0x00, E33G_DMAAL);
 462     return;                     /* We always succeed */
 463 }
 464
 465 /*
 466  * Either use the shared memory (if enabled on the board) or put the packet
 467  * out through the ASIC FIFO.
 468  */
 469 static void
 470 el2_block_output(struct net_device *dev, int count,
 471                  const unsigned char *buf, int start_page)
 472 {
 473     unsigned short int *wrd;
 474     int boguscount;             /* timeout counter */
 475     unsigned short word;        /* temporary for better machine code */
 476     void __iomem *base = ei_status.mem;
 477
 478     if (ei_status.word16)      /* Tx packets go into bank 0 on EL2/16 card */
 479         outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
 480     else
 481         outb(EGACFR_NORM, E33G_GACFR);
 482
 483     if (base) { /* Shared memory transfer */
 484         memcpy_toio(base + ((start_page - ei_status.tx_start_page) << 8),
 485                         buf, count);
 486         outb(EGACFR_NORM, E33G_GACFR);  /* Back to bank1 in case on bank0 */
 487         return;
 488     }
 489
 490 /*
 491  *  No shared memory, put the packet out the other way.
 492  *  Set up then start the internal memory transfer to Tx Start Page
 493  */
 494
 495     word = (unsigned short)start_page;
 496     outb(word&0xFF, E33G_DMAAH);
 497     outb(word>>8, E33G_DMAAL);
 498
 499     outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
 500            | ECNTRL_START, E33G_CNTRL);
 501
 502 /*
 503  *  Here I am going to write data to the FIFO as quickly as possible.
 504  *  Note that E33G_FIFOH is defined incorrectly. It is really
 505  *  E33G_FIFOL, the lowest port address for both the byte and
 506  *  word write. Variable 'count' is NOT checked. Caller must supply a
 507  *  valid count. Note that I may write a harmless extra byte to the
 508  *  8390 if the byte-count was not even.
 509  */
 510     wrd = (unsigned short int *) buf;
 511     count  = (count + 1) >> 1;
 512     for(;;)
 513     {
 514         boguscount = 0x1000;
 515         while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
 516         {
 517             if(!boguscount--)
 518             {
 519                 printk("%s: FIFO blocked in el2_block_output.\n", dev->name);
 520                 el2_reset_8390(dev);
 521                 goto blocked;
 522             }
 523         }
 524         if(count > WRD_COUNT)
 525         {
 526             outsw(E33G_FIFOH, wrd, WRD_COUNT);
 527             wrd   += WRD_COUNT;
 528             count -= WRD_COUNT;
 529         }
 530         else
 531         {
 532             outsw(E33G_FIFOH, wrd, count);
 533             break;
 534         }
 535     }
 536     blocked:;
 537     outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
 538     return;
 539 }
 540
 541 /* Read the 4 byte, page aligned 8390 specific header. */
 542 static void
 543 el2_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 544 {
 545     int boguscount;
 546     void __iomem *base = ei_status.mem;
 547     unsigned short word;
 548
 549     if (base) {       /* Use the shared memory. */
 550         void __iomem *hdr_start = base + ((ring_page - EL2_MB1_START_PG)<<8);
 551         memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 552         hdr->count = le16_to_cpu(hdr->count);
 553         return;
 554     }
 555
 556 /*
 557  *  No shared memory, use programmed I/O.
 558  */
 559
 560     word = (unsigned short)ring_page;
 561     outb(word&0xFF, E33G_DMAAH);
 562     outb(word>>8, E33G_DMAAL);
 563
 564     outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
 565            | ECNTRL_START, E33G_CNTRL);
 566     boguscount = 0x1000;
 567     while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
 568     {
 569         if(!boguscount--)
 570         {
 571             printk("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
 572             memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
 573             el2_reset_8390(dev);
 574             goto blocked;
 575         }
 576     }
 577     insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
 578     blocked:;
 579     outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
 580 }
 581
 582
 583 static void
 584 el2_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 585 {
 586     int boguscount = 0;
 587     void __iomem *base = ei_status.mem;
 588     unsigned short int *buf;
 589     unsigned short word;
 590
 591     /* Maybe enable shared memory just be to be safe... nahh.*/
 592     if (base) { /* Use the shared memory. */
 593         ring_offset -= (EL2_MB1_START_PG<<8);
 594         if (ring_offset + count > EL2_MEMSIZE) {
 595             /* We must wrap the input move. */
 596             int semi_count = EL2_MEMSIZE - ring_offset;
 597             memcpy_fromio(skb->data, base + ring_offset, semi_count);
 598             count -= semi_count;
 599             memcpy_fromio(skb->data + semi_count, base + ei_status.priv, count);
 600         } else {
 601                 memcpy_fromio(skb->data, base + ring_offset, count);
 602         }
 603         return;
 604     }
 605
 606 /*
 607  *  No shared memory, use programmed I/O.
 608  */
 609     word = (unsigned short) ring_offset;
 610     outb(word>>8, E33G_DMAAH);
 611     outb(word&0xFF, E33G_DMAAL);
 612
 613     outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
 614            | ECNTRL_START, E33G_CNTRL);
 615
 616 /*
 617  *  Here I also try to get data as fast as possible. I am betting that I
 618  *  can read one extra byte without clobbering anything in the kernel because
 619  *  this would only occur on an odd byte-count and allocation of skb->data
 620  *  is word-aligned. Variable 'count' is NOT checked. Caller must check
 621  *  for a valid count.
 622  *  [This is currently quite safe.... but if one day the 3c503 explodes
 623  *   you know where to come looking ;)]
 624  */
 625
 626     buf =  (unsigned short int *) skb->data;
 627     count =  (count + 1) >> 1;
 628     for(;;)
 629     {
 630         boguscount = 0x1000;
 631         while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
 632         {
 633             if(!boguscount--)
 634             {
 635                 printk("%s: FIFO blocked in el2_block_input.\n", dev->name);
 636                 el2_reset_8390(dev);
 637                 goto blocked;
 638             }
 639         }
 640         if(count > WRD_COUNT)
 641         {
 642             insw(E33G_FIFOH, buf, WRD_COUNT);
 643             buf   += WRD_COUNT;
 644             count -= WRD_COUNT;
 645         }
 646         else
 647         {
 648             insw(E33G_FIFOH, buf, count);
 649             break;
 650         }
 651     }
 652     blocked:;
 653     outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
 654     return;
 655 }
 656
 657
 658 static void netdev_get_drvinfo(struct net_device *dev,
 659                                struct ethtool_drvinfo *info)
 660 {
 661         strcpy(info->driver, DRV_NAME);
 662         strcpy(info->version, DRV_VERSION);
 663         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
 664 }
 665
 666 static const struct ethtool_ops netdev_ethtool_ops = {
 667         .get_drvinfo            = netdev_get_drvinfo,
 668 };
 669
 670 #ifdef MODULE
 671 #define MAX_EL2_CARDS   4       /* Max number of EL2 cards per module */
 672
 673 static struct net_device *dev_el2[MAX_EL2_CARDS];
 674 static int io[MAX_EL2_CARDS];
 675 static int irq[MAX_EL2_CARDS];
 676 static int xcvr[MAX_EL2_CARDS]; /* choose int. or ext. xcvr */
 677 module_param_array(io, int, NULL, 0);
 678 module_param_array(irq, int, NULL, 0);
 679 module_param_array(xcvr, int, NULL, 0);
 680 MODULE_PARM_DESC(io, "I/O base address(es)");
 681 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
 682 MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
 683 MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver");
 684 MODULE_LICENSE("GPL");
 685
 686 /* This is set up so that only a single autoprobe takes place per call.
 687 ISA device autoprobes on a running machine are not recommended. */
 688 int __init
 689 init_module(void)
 690 {
 691         struct net_device *dev;
 692         int this_dev, found = 0;
 693
 694         for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
 695                 if (io[this_dev] == 0)  {
 696                         if (this_dev != 0) break; /* only autoprobe 1st one */
 697                         printk(KERN_NOTICE "3c503.c: Presently autoprobing (not recommended) for a single card.\n");
 698                 }
 699                 dev = alloc_ei_netdev();
 700                 if (!dev)
 701                         break;
 702                 dev->irq = irq[this_dev];
 703                 dev->base_addr = io[this_dev];
 704                 dev->mem_end = xcvr[this_dev];  /* low 4bits = xcvr sel. */
 705                 if (do_el2_probe(dev) == 0) {
 706                         dev_el2[found++] = dev;
 707                         continue;
 708                 }
 709                 free_netdev(dev);
 710                 printk(KERN_WARNING "3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
 711                 break;
 712         }
 713         if (found)
 714                 return 0;
 715         return -ENXIO;
 716 }
 717
 718 static void cleanup_card(struct net_device *dev)
 719 {
 720         /* NB: el2_close() handles free_irq */
 721         release_region(dev->base_addr, EL2_IO_EXTENT);
 722         if (ei_status.mem)
 723                 iounmap(ei_status.mem);
 724 }
 725
 726 void __exit
 727 cleanup_module(void)
 728 {
 729         int this_dev;
 730
 731         for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
 732                 struct net_device *dev = dev_el2[this_dev];
 733                 if (dev) {
 734                         unregister_netdev(dev);
 735                         cleanup_card(dev);
 736                         free_netdev(dev);
 737                 }
 738         }
 739 }
 740 #endif /* MODULE */