linux/drivers/net/3c507.c
<<
>>
Prefs
   1/* 3c507.c: An EtherLink16 device driver for Linux. */
   2/*
   3        Written 1993,1994 by Donald Becker.
   4
   5        Copyright 1993 United States Government as represented by the
   6        Director, National Security Agency.
   7
   8        This software may be used and distributed according to the terms
   9        of the GNU General Public License, incorporated herein by reference.
  10
  11        The author may be reached as becker@scyld.com, or C/O
  12        Scyld Computing Corporation
  13        410 Severn Ave., Suite 210
  14        Annapolis MD 21403
  15
  16
  17        Thanks go to jennings@Montrouge.SMR.slb.com ( Patrick Jennings)
  18        and jrs@world.std.com (Rick Sladkey) for testing and bugfixes.
  19        Mark Salazar <leslie@access.digex.net> made the changes for cards with
  20        only 16K packet buffers.
  21
  22        Things remaining to do:
  23        Verify that the tx and rx buffers don't have fencepost errors.
  24        Move the theory of operation and memory map documentation.
  25        The statistics need to be updated correctly.
  26*/
  27
  28#define DRV_NAME                "3c507"
  29#define DRV_VERSION             "1.10a"
  30#define DRV_RELDATE             "11/17/2001"
  31
  32static const char version[] =
  33        DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Donald Becker (becker@scyld.com)\n";
  34
  35/*
  36  Sources:
  37        This driver wouldn't have been written with the availability of the
  38        Crynwr driver source code.      It provided a known-working implementation
  39        that filled in the gaping holes of the Intel documentation.  Three cheers
  40        for Russ Nelson.
  41
  42        Intel Microcommunications Databook, Vol. 1, 1990.  It provides just enough
  43        info that the casual reader might think that it documents the i82586 :-<.
  44*/
  45
  46#include <linux/module.h>
  47#include <linux/kernel.h>
  48#include <linux/types.h>
  49#include <linux/fcntl.h>
  50#include <linux/interrupt.h>
  51#include <linux/ioport.h>
  52#include <linux/in.h>
  53#include <linux/string.h>
  54#include <linux/spinlock.h>
  55#include <linux/ethtool.h>
  56#include <linux/errno.h>
  57#include <linux/netdevice.h>
  58#include <linux/etherdevice.h>
  59#include <linux/skbuff.h>
  60#include <linux/slab.h>
  61#include <linux/init.h>
  62#include <linux/bitops.h>
  63
  64#include <asm/dma.h>
  65#include <asm/io.h>
  66#include <asm/system.h>
  67#include <asm/uaccess.h>
  68
  69/* use 0 for production, 1 for verification, 2..7 for debug */
  70#ifndef NET_DEBUG
  71#define NET_DEBUG 1
  72#endif
  73static unsigned int net_debug = NET_DEBUG;
  74#define debug net_debug
  75
  76
  77/*
  78                        Details of the i82586.
  79
  80   You'll really need the databook to understand the details of this part,
  81   but the outline is that the i82586 has two separate processing units.
  82   Both are started from a list of three configuration tables, of which only
  83   the last, the System Control Block (SCB), is used after reset-time.  The SCB
  84   has the following fields:
  85                Status word
  86                Command word
  87                Tx/Command block addr.
  88                Rx block addr.
  89   The command word accepts the following controls for the Tx and Rx units:
  90  */
  91
  92#define  CUC_START       0x0100
  93#define  CUC_RESUME      0x0200
  94#define  CUC_SUSPEND 0x0300
  95#define  RX_START        0x0010
  96#define  RX_RESUME       0x0020
  97#define  RX_SUSPEND      0x0030
  98
  99/* The Rx unit uses a list of frame descriptors and a list of data buffer
 100   descriptors.  We use full-sized (1518 byte) data buffers, so there is
 101   a one-to-one pairing of frame descriptors to buffer descriptors.
 102
 103   The Tx ("command") unit executes a list of commands that look like:
 104                Status word             Written by the 82586 when the command is done.
 105                Command word    Command in lower 3 bits, post-command action in upper 3
 106                Link word               The address of the next command.
 107                Parameters              (as needed).
 108
 109        Some definitions related to the Command Word are:
 110 */
 111#define CMD_EOL         0x8000                  /* The last command of the list, stop. */
 112#define CMD_SUSP        0x4000                  /* Suspend after doing cmd. */
 113#define CMD_INTR        0x2000                  /* Interrupt after doing cmd. */
 114
 115enum commands {
 116        CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
 117        CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
 118
 119/* Information that need to be kept for each board. */
 120struct net_local {
 121        int last_restart;
 122        ushort rx_head;
 123        ushort rx_tail;
 124        ushort tx_head;
 125        ushort tx_cmd_link;
 126        ushort tx_reap;
 127        ushort tx_pkts_in_ring;
 128        spinlock_t lock;
 129        void __iomem *base;
 130};
 131
 132/*
 133                Details of the EtherLink16 Implementation
 134  The 3c507 is a generic shared-memory i82586 implementation.
 135  The host can map 16K, 32K, 48K, or 64K of the 64K memory into
 136  0x0[CD][08]0000, or all 64K into 0xF[02468]0000.
 137  */
 138
 139/* Offsets from the base I/O address. */
 140#define SA_DATA         0       /* Station address data, or 3Com signature. */
 141#define MISC_CTRL       6       /* Switch the SA_DATA banks, and bus config bits. */
 142#define RESET_IRQ       10      /* Reset the latched IRQ line. */
 143#define SIGNAL_CA       11      /* Frob the 82586 Channel Attention line. */
 144#define ROM_CONFIG      13
 145#define MEM_CONFIG      14
 146#define IRQ_CONFIG      15
 147#define EL16_IO_EXTENT 16
 148
 149/* The ID port is used at boot-time to locate the ethercard. */
 150#define ID_PORT         0x100
 151
 152/* Offsets to registers in the mailbox (SCB). */
 153#define iSCB_STATUS     0x8
 154#define iSCB_CMD                0xA
 155#define iSCB_CBL                0xC     /* Command BLock offset. */
 156#define iSCB_RFA                0xE     /* Rx Frame Area offset. */
 157
 158/*  Since the 3c507 maps the shared memory window so that the last byte is
 159        at 82586 address FFFF, the first byte is at 82586 address 0, 16K, 32K, or
 160        48K corresponding to window sizes of 64K, 48K, 32K and 16K respectively.
 161        We can account for this be setting the 'SBC Base' entry in the ISCP table
 162        below for all the 16 bit offset addresses, and also adding the 'SCB Base'
 163        value to all 24 bit physical addresses (in the SCP table and the TX and RX
 164        Buffer Descriptors).
 165                                        -Mark
 166        */
 167#define SCB_BASE                ((unsigned)64*1024 - (dev->mem_end - dev->mem_start))
 168
 169/*
 170  What follows in 'init_words[]' is the "program" that is downloaded to the
 171  82586 memory.  It's mostly tables and command blocks, and starts at the
 172  reset address 0xfffff6.  This is designed to be similar to the EtherExpress,
 173  thus the unusual location of the SCB at 0x0008.
 174
 175  Even with the additional "don't care" values, doing it this way takes less
 176  program space than initializing the individual tables, and I feel it's much
 177  cleaner.
 178
 179  The databook is particularly useless for the first two structures, I had
 180  to use the Crynwr driver as an example.
 181
 182   The memory setup is as follows:
 183   */
 184
 185#define CONFIG_CMD      0x0018
 186#define SET_SA_CMD      0x0024
 187#define SA_OFFSET       0x002A
 188#define IDLELOOP        0x30
 189#define TDR_CMD         0x38
 190#define TDR_TIME        0x3C
 191#define DUMP_CMD        0x40
 192#define DIAG_CMD        0x48
 193#define SET_MC_CMD      0x4E
 194#define DUMP_DATA       0x56    /* A 170 byte buffer for dump and Set-MC into. */
 195
 196#define TX_BUF_START    0x0100
 197#define NUM_TX_BUFS     5
 198#define TX_BUF_SIZE     (1518+14+20+16) /* packet+header+TBD */
 199
 200#define RX_BUF_START    0x2000
 201#define RX_BUF_SIZE     (1518+14+18)    /* packet+header+RBD */
 202#define RX_BUF_END              (dev->mem_end - dev->mem_start)
 203
 204#define TX_TIMEOUT 5
 205
 206/*
 207  That's it: only 86 bytes to set up the beast, including every extra
 208  command available.  The 170 byte buffer at DUMP_DATA is shared between the
 209  Dump command (called only by the diagnostic program) and the SetMulticastList
 210  command.
 211
 212  To complete the memory setup you only have to write the station address at
 213  SA_OFFSET and create the Tx & Rx buffer lists.
 214
 215  The Tx command chain and buffer list is setup as follows:
 216  A Tx command table, with the data buffer pointing to...
 217  A Tx data buffer descriptor.  The packet is in a single buffer, rather than
 218        chaining together several smaller buffers.
 219  A NoOp command, which initially points to itself,
 220  And the packet data.
 221
 222  A transmit is done by filling in the Tx command table and data buffer,
 223  re-writing the NoOp command, and finally changing the offset of the last
 224  command to point to the current Tx command.  When the Tx command is finished,
 225  it jumps to the NoOp, when it loops until the next Tx command changes the
 226  "link offset" in the NoOp.  This way the 82586 never has to go through the
 227  slow restart sequence.
 228
 229  The Rx buffer list is set up in the obvious ring structure.  We have enough
 230  memory (and low enough interrupt latency) that we can avoid the complicated
 231  Rx buffer linked lists by alway associating a full-size Rx data buffer with
 232  each Rx data frame.
 233
 234  I current use four transmit buffers starting at TX_BUF_START (0x0100), and
 235  use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers.
 236
 237  */
 238
 239static unsigned short init_words[] = {
 240        /*      System Configuration Pointer (SCP). */
 241        0x0000,                                 /* Set bus size to 16 bits. */
 242        0,0,                                    /* pad words. */
 243        0x0000,0x0000,                  /* ISCP phys addr, set in init_82586_mem(). */
 244
 245        /*      Intermediate System Configuration Pointer (ISCP). */
 246        0x0001,                                 /* Status word that's cleared when init is done. */
 247        0x0008,0,0,                             /* SCB offset, (skip, skip) */
 248
 249        /* System Control Block (SCB). */
 250        0,0xf000|RX_START|CUC_START,    /* SCB status and cmd. */
 251        CONFIG_CMD,                             /* Command list pointer, points to Configure. */
 252        RX_BUF_START,                           /* Rx block list. */
 253        0,0,0,0,                                /* Error count: CRC, align, buffer, overrun. */
 254
 255        /* 0x0018: Configure command.  Change to put MAC data with packet. */
 256        0, CmdConfigure,                /* Status, command.             */
 257        SET_SA_CMD,                             /* Next command is Set Station Addr. */
 258        0x0804,                                 /* "4" bytes of config data, 8 byte FIFO. */
 259        0x2e40,                                 /* Magic values, including MAC data location. */
 260        0,                                              /* Unused pad word. */
 261
 262        /* 0x0024: Setup station address command. */
 263        0, CmdSASetup,
 264        SET_MC_CMD,                             /* Next command. */
 265        0xaa00,0xb000,0x0bad,   /* Station address (to be filled in) */
 266
 267        /* 0x0030: NOP, looping back to itself.  Point to first Tx buffer to Tx. */
 268        0, CmdNOp, IDLELOOP, 0 /* pad */,
 269
 270        /* 0x0038: A unused Time-Domain Reflectometer command. */
 271        0, CmdTDR, IDLELOOP, 0,
 272
 273        /* 0x0040: An unused Dump State command. */
 274        0, CmdDump, IDLELOOP, DUMP_DATA,
 275
 276        /* 0x0048: An unused Diagnose command. */
 277        0, CmdDiagnose, IDLELOOP,
 278
 279        /* 0x004E: An empty set-multicast-list command. */
 280        0, CmdMulticastList, IDLELOOP, 0,
 281};
 282
 283/* Index to functions, as function prototypes. */
 284
 285static int      el16_probe1(struct net_device *dev, int ioaddr);
 286static int      el16_open(struct net_device *dev);
 287static int      el16_send_packet(struct sk_buff *skb, struct net_device *dev);
 288static irqreturn_t el16_interrupt(int irq, void *dev_id);
 289static void el16_rx(struct net_device *dev);
 290static int      el16_close(struct net_device *dev);
 291static void el16_tx_timeout (struct net_device *dev);
 292
 293static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad);
 294static void init_82586_mem(struct net_device *dev);
 295static const struct ethtool_ops netdev_ethtool_ops;
 296static void init_rx_bufs(struct net_device *);
 297
 298static int io = 0x300;
 299static int irq;
 300static int mem_start;
 301
 302
 303/* Check for a network adaptor of this type, and return '0' iff one exists.
 304        If dev->base_addr == 0, probe all likely locations.
 305        If dev->base_addr == 1, always return failure.
 306        If dev->base_addr == 2, (detachable devices only) allocate space for the
 307        device and return success.
 308        */
 309
 310struct net_device * __init el16_probe(int unit)
 311{
 312        struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
 313        static unsigned ports[] = { 0x300, 0x320, 0x340, 0x280, 0};
 314        unsigned *port;
 315        int err = -ENODEV;
 316
 317        if (!dev)
 318                return ERR_PTR(-ENODEV);
 319
 320        if (unit >= 0) {
 321                sprintf(dev->name, "eth%d", unit);
 322                netdev_boot_setup_check(dev);
 323                io = dev->base_addr;
 324                irq = dev->irq;
 325                mem_start = dev->mem_start & 15;
 326        }
 327
 328        if (io > 0x1ff)         /* Check a single specified location. */
 329                err = el16_probe1(dev, io);
 330        else if (io != 0)
 331                err = -ENXIO;           /* Don't probe at all. */
 332        else {
 333                for (port = ports; *port; port++) {
 334                        err = el16_probe1(dev, *port);
 335                        if (!err)
 336                                break;
 337                }
 338        }
 339
 340        if (err)
 341                goto out;
 342        err = register_netdev(dev);
 343        if (err)
 344                goto out1;
 345        return dev;
 346out1:
 347        free_irq(dev->irq, dev);
 348        iounmap(((struct net_local *)netdev_priv(dev))->base);
 349        release_region(dev->base_addr, EL16_IO_EXTENT);
 350out:
 351        free_netdev(dev);
 352        return ERR_PTR(err);
 353}
 354
 355static int __init el16_probe1(struct net_device *dev, int ioaddr)
 356{
 357        static unsigned char init_ID_done, version_printed;
 358        int i, irq, irqval, retval;
 359        struct net_local *lp;
 360        DECLARE_MAC_BUF(mac);
 361
 362        if (init_ID_done == 0) {
 363                ushort lrs_state = 0xff;
 364                /* Send the ID sequence to the ID_PORT to enable the board(s). */
 365                outb(0x00, ID_PORT);
 366                for(i = 0; i < 255; i++) {
 367                        outb(lrs_state, ID_PORT);
 368                        lrs_state <<= 1;
 369                        if (lrs_state & 0x100)
 370                                lrs_state ^= 0xe7;
 371                }
 372                outb(0x00, ID_PORT);
 373                init_ID_done = 1;
 374        }
 375
 376        if (!request_region(ioaddr, EL16_IO_EXTENT, DRV_NAME))
 377                return -ENODEV;
 378
 379        if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
 380            (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
 381                retval = -ENODEV;
 382                goto out;
 383        }
 384
 385        if (net_debug  &&  version_printed++ == 0)
 386                printk(version);
 387
 388        printk("%s: 3c507 at %#x,", dev->name, ioaddr);
 389
 390        /* We should make a few more checks here, like the first three octets of
 391           the S.A. for the manufacturer's code. */
 392
 393        irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
 394
 395        irqval = request_irq(irq, &el16_interrupt, 0, DRV_NAME, dev);
 396        if (irqval) {
 397                printk(KERN_ERR "3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
 398                retval = -EAGAIN;
 399                goto out;
 400        }
 401
 402        /* We've committed to using the board, and can start filling in *dev. */
 403        dev->base_addr = ioaddr;
 404
 405        outb(0x01, ioaddr + MISC_CTRL);
 406        for (i = 0; i < 6; i++)
 407                dev->dev_addr[i] = inb(ioaddr + i);
 408        printk(" %s", print_mac(mac, dev->dev_addr));
 409
 410        if (mem_start)
 411                net_debug = mem_start & 7;
 412
 413#ifdef MEM_BASE
 414        dev->mem_start = MEM_BASE;
 415        dev->mem_end = dev->mem_start + 0x10000;
 416#else
 417        {
 418                int base;
 419                int size;
 420                char mem_config = inb(ioaddr + MEM_CONFIG);
 421                if (mem_config & 0x20) {
 422                        size = 64*1024;
 423                        base = 0xf00000 + (mem_config & 0x08 ? 0x080000
 424                                                           : ((mem_config & 3) << 17));
 425                } else {
 426                        size = ((mem_config & 3) + 1) << 14;
 427                        base = 0x0c0000 + ( (mem_config & 0x18) << 12);
 428                }
 429                dev->mem_start = base;
 430                dev->mem_end = base + size;
 431        }
 432#endif
 433
 434        dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
 435        dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
 436
 437        printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
 438                   dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
 439
 440        if (net_debug)
 441                printk(version);
 442
 443        lp = netdev_priv(dev);
 444        memset(lp, 0, sizeof(*lp));
 445        spin_lock_init(&lp->lock);
 446        lp->base = ioremap(dev->mem_start, RX_BUF_END);
 447        if (!lp->base) {
 448                printk(KERN_ERR "3c507: unable to remap memory\n");
 449                retval = -EAGAIN;
 450                goto out1;
 451        }
 452
 453        dev->open = el16_open;
 454        dev->stop = el16_close;
 455        dev->hard_start_xmit = el16_send_packet;
 456        dev->tx_timeout = el16_tx_timeout;
 457        dev->watchdog_timeo = TX_TIMEOUT;
 458        dev->ethtool_ops = &netdev_ethtool_ops;
 459        dev->flags &= ~IFF_MULTICAST;   /* Multicast doesn't work */
 460        return 0;
 461out1:
 462        free_irq(dev->irq, dev);
 463out:
 464        release_region(ioaddr, EL16_IO_EXTENT);
 465        return retval;
 466}
 467
 468static int el16_open(struct net_device *dev)
 469{
 470        /* Initialize the 82586 memory and start it. */
 471        init_82586_mem(dev);
 472
 473        netif_start_queue(dev);
 474        return 0;
 475}
 476
 477
 478static void el16_tx_timeout (struct net_device *dev)
 479{
 480        struct net_local *lp = netdev_priv(dev);
 481        int ioaddr = dev->base_addr;
 482        void __iomem *shmem = lp->base;
 483
 484        if (net_debug > 1)
 485                printk ("%s: transmit timed out, %s?  ", dev->name,
 486                        readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
 487                        "network cable problem");
 488        /* Try to restart the adaptor. */
 489        if (lp->last_restart == dev->stats.tx_packets) {
 490                if (net_debug > 1)
 491                        printk ("Resetting board.\n");
 492                /* Completely reset the adaptor. */
 493                init_82586_mem (dev);
 494                lp->tx_pkts_in_ring = 0;
 495        } else {
 496                /* Issue the channel attention signal and hope it "gets better". */
 497                if (net_debug > 1)
 498                        printk ("Kicking board.\n");
 499                writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
 500                outb (0, ioaddr + SIGNAL_CA);   /* Issue channel-attn. */
 501                lp->last_restart = dev->stats.tx_packets;
 502        }
 503        dev->trans_start = jiffies;
 504        netif_wake_queue (dev);
 505}
 506
 507
 508static int el16_send_packet (struct sk_buff *skb, struct net_device *dev)
 509{
 510        struct net_local *lp = netdev_priv(dev);
 511        int ioaddr = dev->base_addr;
 512        unsigned long flags;
 513        short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 514        unsigned char *buf = skb->data;
 515
 516        netif_stop_queue (dev);
 517
 518        spin_lock_irqsave (&lp->lock, flags);
 519
 520        dev->stats.tx_bytes += length;
 521        /* Disable the 82586's input to the interrupt line. */
 522        outb (0x80, ioaddr + MISC_CTRL);
 523
 524        hardware_send_packet (dev, buf, skb->len, length - skb->len);
 525
 526        dev->trans_start = jiffies;
 527        /* Enable the 82586 interrupt input. */
 528        outb (0x84, ioaddr + MISC_CTRL);
 529
 530        spin_unlock_irqrestore (&lp->lock, flags);
 531
 532        dev_kfree_skb (skb);
 533
 534        /* You might need to clean up and record Tx statistics here. */
 535
 536        return 0;
 537}
 538
 539/*      The typical workload of the driver:
 540        Handle the network interface interrupts. */
 541static irqreturn_t el16_interrupt(int irq, void *dev_id)
 542{
 543        struct net_device *dev = dev_id;
 544        struct net_local *lp;
 545        int ioaddr, status, boguscount = 0;
 546        ushort ack_cmd = 0;
 547        void __iomem *shmem;
 548
 549        if (dev == NULL) {
 550                printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 551                return IRQ_NONE;
 552        }
 553
 554        ioaddr = dev->base_addr;
 555        lp = netdev_priv(dev);
 556        shmem = lp->base;
 557
 558        spin_lock(&lp->lock);
 559
 560        status = readw(shmem+iSCB_STATUS);
 561
 562        if (net_debug > 4) {
 563                printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
 564        }
 565
 566        /* Disable the 82586's input to the interrupt line. */
 567        outb(0x80, ioaddr + MISC_CTRL);
 568
 569        /* Reap the Tx packet buffers. */
 570        while (lp->tx_pkts_in_ring) {
 571          unsigned short tx_status = readw(shmem+lp->tx_reap);
 572          if (!(tx_status & 0x8000)) {
 573                if (net_debug > 5)
 574                        printk("Tx command incomplete (%#x).\n", lp->tx_reap);
 575                break;
 576          }
 577          /* Tx unsuccessful or some interesting status bit set. */
 578          if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
 579                dev->stats.tx_errors++;
 580                if (tx_status & 0x0600)  dev->stats.tx_carrier_errors++;
 581                if (tx_status & 0x0100)  dev->stats.tx_fifo_errors++;
 582                if (!(tx_status & 0x0040))  dev->stats.tx_heartbeat_errors++;
 583                if (tx_status & 0x0020)  dev->stats.tx_aborted_errors++;
 584                dev->stats.collisions += tx_status & 0xf;
 585          }
 586          dev->stats.tx_packets++;
 587          if (net_debug > 5)
 588                  printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
 589          lp->tx_reap += TX_BUF_SIZE;
 590          if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
 591                lp->tx_reap = TX_BUF_START;
 592
 593          lp->tx_pkts_in_ring--;
 594          /* There is always more space in the Tx ring buffer now. */
 595          netif_wake_queue(dev);
 596
 597          if (++boguscount > 10)
 598                break;
 599        }
 600
 601        if (status & 0x4000) { /* Packet received. */
 602                if (net_debug > 5)
 603                        printk("Received packet, rx_head %04x.\n", lp->rx_head);
 604                el16_rx(dev);
 605        }
 606
 607        /* Acknowledge the interrupt sources. */
 608        ack_cmd = status & 0xf000;
 609
 610        if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
 611                if (net_debug)
 612                        printk("%s: Command unit stopped, status %04x, restarting.\n",
 613                                   dev->name, status);
 614                /* If this ever occurs we should really re-write the idle loop, reset
 615                   the Tx list, and do a complete restart of the command unit.
 616                   For now we rely on the Tx timeout if the resume doesn't work. */
 617                ack_cmd |= CUC_RESUME;
 618        }
 619
 620        if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
 621                /* The Rx unit is not ready, it must be hung.  Restart the receiver by
 622                   initializing the rx buffers, and issuing an Rx start command. */
 623                if (net_debug)
 624                        printk("%s: Rx unit stopped, status %04x, restarting.\n",
 625                                   dev->name, status);
 626                init_rx_bufs(dev);
 627                writew(RX_BUF_START,shmem+iSCB_RFA);
 628                ack_cmd |= RX_START;
 629        }
 630
 631        writew(ack_cmd,shmem+iSCB_CMD);
 632        outb(0, ioaddr + SIGNAL_CA);                    /* Issue channel-attn. */
 633
 634        /* Clear the latched interrupt. */
 635        outb(0, ioaddr + RESET_IRQ);
 636
 637        /* Enable the 82586's interrupt input. */
 638        outb(0x84, ioaddr + MISC_CTRL);
 639        spin_unlock(&lp->lock);
 640        return IRQ_HANDLED;
 641}
 642
 643static int el16_close(struct net_device *dev)
 644{
 645        struct net_local *lp = netdev_priv(dev);
 646        int ioaddr = dev->base_addr;
 647        void __iomem *shmem = lp->base;
 648
 649        netif_stop_queue(dev);
 650
 651        /* Flush the Tx and disable Rx. */
 652        writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
 653        outb(0, ioaddr + SIGNAL_CA);
 654
 655        /* Disable the 82586's input to the interrupt line. */
 656        outb(0x80, ioaddr + MISC_CTRL);
 657
 658        /* We always physically use the IRQ line, so we don't do free_irq(). */
 659
 660        /* Update the statistics here. */
 661
 662        return 0;
 663}
 664
 665/* Initialize the Rx-block list. */
 666static void init_rx_bufs(struct net_device *dev)
 667{
 668        struct net_local *lp = netdev_priv(dev);
 669        void __iomem *write_ptr;
 670        unsigned short SCB_base = SCB_BASE;
 671
 672        int cur_rxbuf = lp->rx_head = RX_BUF_START;
 673
 674        /* Initialize each Rx frame + data buffer. */
 675        do {    /* While there is room for one more. */
 676
 677                write_ptr = lp->base + cur_rxbuf;
 678
 679                writew(0x0000,write_ptr);                       /* Status */
 680                writew(0x0000,write_ptr+=2);                    /* Command */
 681                writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2);   /* Link */
 682                writew(cur_rxbuf + 22,write_ptr+=2);            /* Buffer offset */
 683                writew(0x0000,write_ptr+=2);                    /* Pad for dest addr. */
 684                writew(0x0000,write_ptr+=2);
 685                writew(0x0000,write_ptr+=2);
 686                writew(0x0000,write_ptr+=2);                    /* Pad for source addr. */
 687                writew(0x0000,write_ptr+=2);
 688                writew(0x0000,write_ptr+=2);
 689                writew(0x0000,write_ptr+=2);                    /* Pad for protocol. */
 690
 691                writew(0x0000,write_ptr+=2);                    /* Buffer: Actual count */
 692                writew(-1,write_ptr+=2);                        /* Buffer: Next (none). */
 693                writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
 694                writew(0x0000,write_ptr+=2);
 695                /* Finally, the number of bytes in the buffer. */
 696                writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
 697
 698                lp->rx_tail = cur_rxbuf;
 699                cur_rxbuf += RX_BUF_SIZE;
 700        } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
 701
 702        /* Terminate the list by setting the EOL bit, and wrap the pointer to make
 703           the list a ring. */
 704        write_ptr = lp->base + lp->rx_tail + 2;
 705        writew(0xC000,write_ptr);                               /* Command, mark as last. */
 706        writew(lp->rx_head,write_ptr+2);                        /* Link */
 707}
 708
 709static void init_82586_mem(struct net_device *dev)
 710{
 711        struct net_local *lp = netdev_priv(dev);
 712        short ioaddr = dev->base_addr;
 713        void __iomem *shmem = lp->base;
 714
 715        /* Enable loopback to protect the wire while starting up,
 716           and hold the 586 in reset during the memory initialization. */
 717        outb(0x20, ioaddr + MISC_CTRL);
 718
 719        /* Fix the ISCP address and base. */
 720        init_words[3] = SCB_BASE;
 721        init_words[7] = SCB_BASE;
 722
 723        /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
 724        memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
 725
 726        /* Write the words at 0x0000. */
 727        memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
 728
 729        /* Fill in the station address. */
 730        memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
 731                   sizeof(dev->dev_addr));
 732
 733        /* The Tx-block list is written as needed.  We just set up the values. */
 734        lp->tx_cmd_link = IDLELOOP + 4;
 735        lp->tx_head = lp->tx_reap = TX_BUF_START;
 736
 737        init_rx_bufs(dev);
 738
 739        /* Start the 586 by releasing the reset line, but leave loopback. */
 740        outb(0xA0, ioaddr + MISC_CTRL);
 741
 742        /* This was time consuming to track down: you need to give two channel
 743           attention signals to reliably start up the i82586. */
 744        outb(0, ioaddr + SIGNAL_CA);
 745
 746        {
 747                int boguscnt = 50;
 748                while (readw(shmem+iSCB_STATUS) == 0)
 749                        if (--boguscnt == 0) {
 750                                printk("%s: i82586 initialization timed out with status %04x, "
 751                                           "cmd %04x.\n", dev->name,
 752                                           readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
 753                                break;
 754                        }
 755                /* Issue channel-attn -- the 82586 won't start. */
 756                outb(0, ioaddr + SIGNAL_CA);
 757        }
 758
 759        /* Disable loopback and enable interrupts. */
 760        outb(0x84, ioaddr + MISC_CTRL);
 761        if (net_debug > 4)
 762                printk("%s: Initialized 82586, status %04x.\n", dev->name,
 763                           readw(shmem+iSCB_STATUS));
 764        return;
 765}
 766
 767static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
 768{
 769        struct net_local *lp = netdev_priv(dev);
 770        short ioaddr = dev->base_addr;
 771        ushort tx_block = lp->tx_head;
 772        void __iomem *write_ptr = lp->base + tx_block;
 773        static char padding[ETH_ZLEN];
 774
 775        /* Set the write pointer to the Tx block, and put out the header. */
 776        writew(0x0000,write_ptr);                       /* Tx status */
 777        writew(CMD_INTR|CmdTx,write_ptr+=2);            /* Tx command */
 778        writew(tx_block+16,write_ptr+=2);               /* Next command is a NoOp. */
 779        writew(tx_block+8,write_ptr+=2);                        /* Data Buffer offset. */
 780
 781        /* Output the data buffer descriptor. */
 782        writew((pad + length) | 0x8000,write_ptr+=2);           /* Byte count parameter. */
 783        writew(-1,write_ptr+=2);                        /* No next data buffer. */
 784        writew(tx_block+22+SCB_BASE,write_ptr+=2);      /* Buffer follows the NoOp command. */
 785        writew(0x0000,write_ptr+=2);                    /* Buffer address high bits (always zero). */
 786
 787        /* Output the Loop-back NoOp command. */
 788        writew(0x0000,write_ptr+=2);                    /* Tx status */
 789        writew(CmdNOp,write_ptr+=2);                    /* Tx command */
 790        writew(tx_block+16,write_ptr+=2);               /* Next is myself. */
 791
 792        /* Output the packet at the write pointer. */
 793        memcpy_toio(write_ptr+2, buf, length);
 794        if (pad)
 795                memcpy_toio(write_ptr+length+2, padding, pad);
 796
 797        /* Set the old command link pointing to this send packet. */
 798        writew(tx_block,lp->base + lp->tx_cmd_link);
 799        lp->tx_cmd_link = tx_block + 20;
 800
 801        /* Set the next free tx region. */
 802        lp->tx_head = tx_block + TX_BUF_SIZE;
 803        if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
 804                lp->tx_head = TX_BUF_START;
 805
 806        if (net_debug > 4) {
 807                printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
 808                           dev->name, ioaddr, length, tx_block, lp->tx_head);
 809        }
 810
 811        /* Grimly block further packets if there has been insufficient reaping. */
 812        if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
 813                netif_wake_queue(dev);
 814}
 815
 816static void el16_rx(struct net_device *dev)
 817{
 818        struct net_local *lp = netdev_priv(dev);
 819        void __iomem *shmem = lp->base;
 820        ushort rx_head = lp->rx_head;
 821        ushort rx_tail = lp->rx_tail;
 822        ushort boguscount = 10;
 823        short frame_status;
 824
 825        while ((frame_status = readw(shmem+rx_head)) < 0) {   /* Command complete */
 826                void __iomem *read_frame = lp->base + rx_head;
 827                ushort rfd_cmd = readw(read_frame+2);
 828                ushort next_rx_frame = readw(read_frame+4);
 829                ushort data_buffer_addr = readw(read_frame+6);
 830                void __iomem *data_frame = lp->base + data_buffer_addr;
 831                ushort pkt_len = readw(data_frame);
 832
 833                if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
 834                        || (pkt_len & 0xC000) != 0xC000) {
 835                        printk(KERN_ERR "%s: Rx frame at %#x corrupted, "
 836                               "status %04x cmd %04x next %04x "
 837                               "data-buf @%04x %04x.\n",
 838                               dev->name, rx_head, frame_status, rfd_cmd,
 839                               next_rx_frame, data_buffer_addr, pkt_len);
 840                } else if ((frame_status & 0x2000) == 0) {
 841                        /* Frame Rxed, but with error. */
 842                        dev->stats.rx_errors++;
 843                        if (frame_status & 0x0800) dev->stats.rx_crc_errors++;
 844                        if (frame_status & 0x0400) dev->stats.rx_frame_errors++;
 845                        if (frame_status & 0x0200) dev->stats.rx_fifo_errors++;
 846                        if (frame_status & 0x0100) dev->stats.rx_over_errors++;
 847                        if (frame_status & 0x0080) dev->stats.rx_length_errors++;
 848                } else {
 849                        /* Malloc up new buffer. */
 850                        struct sk_buff *skb;
 851
 852                        pkt_len &= 0x3fff;
 853                        skb = dev_alloc_skb(pkt_len+2);
 854                        if (skb == NULL) {
 855                                printk(KERN_ERR "%s: Memory squeeze, "
 856                                       "dropping packet.\n",
 857                                       dev->name);
 858                                dev->stats.rx_dropped++;
 859                                break;
 860                        }
 861
 862                        skb_reserve(skb,2);
 863
 864                        /* 'skb->data' points to the start of sk_buff data area. */
 865                        memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
 866
 867                        skb->protocol=eth_type_trans(skb,dev);
 868                        netif_rx(skb);
 869                        dev->last_rx = jiffies;
 870                        dev->stats.rx_packets++;
 871                        dev->stats.rx_bytes += pkt_len;
 872                }
 873
 874                /* Clear the status word and set End-of-List on the rx frame. */
 875                writew(0,read_frame);
 876                writew(0xC000,read_frame+2);
 877                /* Clear the end-of-list on the prev. RFD. */
 878                writew(0x0000,lp->base + rx_tail + 2);
 879
 880                rx_tail = rx_head;
 881                rx_head = next_rx_frame;
 882                if (--boguscount == 0)
 883                        break;
 884        }
 885
 886        lp->rx_head = rx_head;
 887        lp->rx_tail = rx_tail;
 888}
 889
 890static void netdev_get_drvinfo(struct net_device *dev,
 891                               struct ethtool_drvinfo *info)
 892{
 893        strcpy(info->driver, DRV_NAME);
 894        strcpy(info->version, DRV_VERSION);
 895        sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
 896}
 897
 898static u32 netdev_get_msglevel(struct net_device *dev)
 899{
 900        return debug;
 901}
 902
 903static void netdev_set_msglevel(struct net_device *dev, u32 level)
 904{
 905        debug = level;
 906}
 907
 908static const struct ethtool_ops netdev_ethtool_ops = {
 909        .get_drvinfo            = netdev_get_drvinfo,
 910        .get_msglevel           = netdev_get_msglevel,
 911        .set_msglevel           = netdev_set_msglevel,
 912};
 913
 914#ifdef MODULE
 915static struct net_device *dev_3c507;
 916module_param(io, int, 0);
 917module_param(irq, int, 0);
 918MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
 919MODULE_PARM_DESC(irq, "(ignored)");
 920
 921int __init init_module(void)
 922{
 923        if (io == 0)
 924                printk("3c507: You should not use auto-probing with insmod!\n");
 925        dev_3c507 = el16_probe(-1);
 926        return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
 927}
 928
 929void __exit
 930cleanup_module(void)
 931{
 932        struct net_device *dev = dev_3c507;
 933        unregister_netdev(dev);
 934        free_irq(dev->irq, dev);
 935        iounmap(((struct net_local *)netdev_priv(dev))->base);
 936        release_region(dev->base_addr, EL16_IO_EXTENT);
 937        free_netdev(dev);
 938}
 939#endif /* MODULE */
 940MODULE_LICENSE("GPL");
 941
 942
 943/*
 944 * Local variables:
 945 *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -I/usr/src/linux/drivers/net -Wall -Wstrict-prototypes -O6 -m486 -c 3c507.c"
 946 *  version-control: t
 947 *  kept-new-versions: 5
 948 *  tab-width: 4
 949 *  c-indent-level: 4
 950 * End:
 951 */
 952
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.