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