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