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