drivers/net/3c507.c

   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
  32 static 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
  73 static 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
 115 enum 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. */
 120 struct 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
 239 static 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
 285 static int      el16_probe1(struct net_device *dev, int ioaddr);
 286 static int      el16_open(struct net_device *dev);
 287 static int      el16_send_packet(struct sk_buff *skb, struct net_device *dev);
 288 static irqreturn_t el16_interrupt(int irq, void *dev_id);
 289 static void el16_rx(struct net_device *dev);
 290 static int      el16_close(struct net_device *dev);
 291 static void el16_tx_timeout (struct net_device *dev);
 292
 293 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad);
 294 static void init_82586_mem(struct net_device *dev);
 295 static const struct ethtool_ops netdev_ethtool_ops;
 296 static void init_rx_bufs(struct net_device *);
 297
 298 static int io = 0x300;
 299 static int irq;
 300 static 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
 310 struct 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;
 346 out1:
 347         free_irq(dev->irq, dev);
 348         iounmap(((struct net_local *)netdev_priv(dev))->base);
 349         release_region(dev->base_addr, EL16_IO_EXTENT);
 350 out:
 351         free_netdev(dev);
 352         return ERR_PTR(err);
 353 }
 354
 355 static 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
 361         if (init_ID_done == 0) {
 362                 ushort lrs_state = 0xff;
 363                 /* Send the ID sequence to the ID_PORT to enable the board(s). */
 364                 outb(0x00, ID_PORT);
 365                 for(i = 0; i < 255; i++) {
 366                         outb(lrs_state, ID_PORT);
 367                         lrs_state <<= 1;
 368                         if (lrs_state & 0x100)
 369                                 lrs_state ^= 0xe7;
 370                 }
 371                 outb(0x00, ID_PORT);
 372                 init_ID_done = 1;
 373         }
 374
 375         if (!request_region(ioaddr, EL16_IO_EXTENT, DRV_NAME))
 376                 return -ENODEV;
 377
 378         if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
 379             (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
 380                 retval = -ENODEV;
 381                 goto out;
 382         }
 383
 384         if (net_debug  &&  version_printed++ == 0)
 385                 printk(version);
 386
 387         printk("%s: 3c507 at %#x,", dev->name, ioaddr);
 388
 389         /* We should make a few more checks here, like the first three octets of
 390            the S.A. for the manufacturer's code. */
 391
 392         irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
 393
 394         irqval = request_irq(irq, &el16_interrupt, 0, DRV_NAME, dev);
 395         if (irqval) {
 396                 printk(KERN_ERR "3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
 397                 retval = -EAGAIN;
 398                 goto out;
 399         }
 400
 401         /* We've committed to using the board, and can start filling in *dev. */
 402         dev->base_addr = ioaddr;
 403
 404         outb(0x01, ioaddr + MISC_CTRL);
 405         for (i = 0; i < 6; i++)
 406                 dev->dev_addr[i] = inb(ioaddr + i);
 407         printk(" %pM", dev->dev_addr);
 408
 409         if (mem_start)
 410                 net_debug = mem_start & 7;
 411
 412 #ifdef MEM_BASE
 413         dev->mem_start = MEM_BASE;
 414         dev->mem_end = dev->mem_start + 0x10000;
 415 #else
 416         {
 417                 int base;
 418                 int size;
 419                 char mem_config = inb(ioaddr + MEM_CONFIG);
 420                 if (mem_config & 0x20) {
 421                         size = 64*1024;
 422                         base = 0xf00000 + (mem_config & 0x08 ? 0x080000
 423                                                            : ((mem_config & 3) << 17));
 424                 } else {
 425                         size = ((mem_config & 3) + 1) << 14;
 426                         base = 0x0c0000 + ( (mem_config & 0x18) << 12);
 427                 }
 428                 dev->mem_start = base;
 429                 dev->mem_end = base + size;
 430         }
 431 #endif
 432
 433         dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
 434         dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
 435
 436         printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
 437                    dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
 438
 439         if (net_debug)
 440                 printk(version);
 441
 442         lp = netdev_priv(dev);
 443         memset(lp, 0, sizeof(*lp));
 444         spin_lock_init(&lp->lock);
 445         lp->base = ioremap(dev->mem_start, RX_BUF_END);
 446         if (!lp->base) {
 447                 printk(KERN_ERR "3c507: unable to remap memory\n");
 448                 retval = -EAGAIN;
 449                 goto out1;
 450         }
 451
 452         dev->open = el16_open;
 453         dev->stop = el16_close;
 454         dev->hard_start_xmit = el16_send_packet;
 455         dev->tx_timeout = el16_tx_timeout;
 456         dev->watchdog_timeo = TX_TIMEOUT;
 457         dev->ethtool_ops = &netdev_ethtool_ops;
 458         dev->flags &= ~IFF_MULTICAST;   /* Multicast doesn't work */
 459         return 0;
 460 out1:
 461         free_irq(dev->irq, dev);
 462 out:
 463         release_region(ioaddr, EL16_IO_EXTENT);
 464         return retval;
 465 }
 466
 467 static int el16_open(struct net_device *dev)
 468 {
 469         /* Initialize the 82586 memory and start it. */
 470         init_82586_mem(dev);
 471
 472         netif_start_queue(dev);
 473         return 0;
 474 }
 475
 476
 477 static void el16_tx_timeout (struct net_device *dev)
 478 {
 479         struct net_local *lp = netdev_priv(dev);
 480         int ioaddr = dev->base_addr;
 481         void __iomem *shmem = lp->base;
 482
 483         if (net_debug > 1)
 484                 printk ("%s: transmit timed out, %s?  ", dev->name,
 485                         readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
 486                         "network cable problem");
 487         /* Try to restart the adaptor. */
 488         if (lp->last_restart == dev->stats.tx_packets) {
 489                 if (net_debug > 1)
 490                         printk ("Resetting board.\n");
 491                 /* Completely reset the adaptor. */
 492                 init_82586_mem (dev);
 493                 lp->tx_pkts_in_ring = 0;
 494         } else {
 495                 /* Issue the channel attention signal and hope it "gets better". */
 496                 if (net_debug > 1)
 497                         printk ("Kicking board.\n");
 498                 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
 499                 outb (0, ioaddr + SIGNAL_CA);   /* Issue channel-attn. */
 500                 lp->last_restart = dev->stats.tx_packets;
 501         }
 502         dev->trans_start = jiffies;
 503         netif_wake_queue (dev);
 504 }
 505
 506
 507 static int el16_send_packet (struct sk_buff *skb, struct net_device *dev)
 508 {
 509         struct net_local *lp = netdev_priv(dev);
 510         int ioaddr = dev->base_addr;
 511         unsigned long flags;
 512         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 513         unsigned char *buf = skb->data;
 514
 515         netif_stop_queue (dev);
 516
 517         spin_lock_irqsave (&lp->lock, flags);
 518
 519         dev->stats.tx_bytes += length;
 520         /* Disable the 82586's input to the interrupt line. */
 521         outb (0x80, ioaddr + MISC_CTRL);
 522
 523         hardware_send_packet (dev, buf, skb->len, length - skb->len);
 524
 525         dev->trans_start = jiffies;
 526         /* Enable the 82586 interrupt input. */
 527         outb (0x84, ioaddr + MISC_CTRL);
 528
 529         spin_unlock_irqrestore (&lp->lock, flags);
 530
 531         dev_kfree_skb (skb);
 532
 533         /* You might need to clean up and record Tx statistics here. */
 534
 535         return 0;
 536 }
 537
 538 /*      The typical workload of the driver:
 539         Handle the network interface interrupts. */
 540 static irqreturn_t el16_interrupt(int irq, void *dev_id)
 541 {
 542         struct net_device *dev = dev_id;
 543         struct net_local *lp;
 544         int ioaddr, status, boguscount = 0;
 545         ushort ack_cmd = 0;
 546         void __iomem *shmem;
 547
 548         if (dev == NULL) {
 549                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 550                 return IRQ_NONE;
 551         }
 552
 553         ioaddr = dev->base_addr;
 554         lp = netdev_priv(dev);
 555         shmem = lp->base;
 556
 557         spin_lock(&lp->lock);
 558
 559         status = readw(shmem+iSCB_STATUS);
 560
 561         if (net_debug > 4) {
 562                 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
 563         }
 564
 565         /* Disable the 82586's input to the interrupt line. */
 566         outb(0x80, ioaddr + MISC_CTRL);
 567
 568         /* Reap the Tx packet buffers. */
 569         while (lp->tx_pkts_in_ring) {
 570           unsigned short tx_status = readw(shmem+lp->tx_reap);
 571           if (!(tx_status & 0x8000)) {
 572                 if (net_debug > 5)
 573                         printk("Tx command incomplete (%#x).\n", lp->tx_reap);
 574                 break;
 575           }
 576           /* Tx unsuccessful or some interesting status bit set. */
 577           if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
 578                 dev->stats.tx_errors++;
 579                 if (tx_status & 0x0600)  dev->stats.tx_carrier_errors++;
 580                 if (tx_status & 0x0100)  dev->stats.tx_fifo_errors++;
 581                 if (!(tx_status & 0x0040))  dev->stats.tx_heartbeat_errors++;
 582                 if (tx_status & 0x0020)  dev->stats.tx_aborted_errors++;
 583                 dev->stats.collisions += tx_status & 0xf;
 584           }
 585           dev->stats.tx_packets++;
 586           if (net_debug > 5)
 587                   printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
 588           lp->tx_reap += TX_BUF_SIZE;
 589           if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
 590                 lp->tx_reap = TX_BUF_START;
 591
 592           lp->tx_pkts_in_ring--;
 593           /* There is always more space in the Tx ring buffer now. */
 594           netif_wake_queue(dev);
 595
 596           if (++boguscount > 10)
 597                 break;
 598         }
 599
 600         if (status & 0x4000) { /* Packet received. */
 601                 if (net_debug > 5)
 602                         printk("Received packet, rx_head %04x.\n", lp->rx_head);
 603                 el16_rx(dev);
 604         }
 605
 606         /* Acknowledge the interrupt sources. */
 607         ack_cmd = status & 0xf000;
 608
 609         if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
 610                 if (net_debug)
 611                         printk("%s: Command unit stopped, status %04x, restarting.\n",
 612                                    dev->name, status);
 613                 /* If this ever occurs we should really re-write the idle loop, reset
 614                    the Tx list, and do a complete restart of the command unit.
 615                    For now we rely on the Tx timeout if the resume doesn't work. */
 616                 ack_cmd |= CUC_RESUME;
 617         }
 618
 619         if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
 620                 /* The Rx unit is not ready, it must be hung.  Restart the receiver by
 621                    initializing the rx buffers, and issuing an Rx start command. */
 622                 if (net_debug)
 623                         printk("%s: Rx unit stopped, status %04x, restarting.\n",
 624                                    dev->name, status);
 625                 init_rx_bufs(dev);
 626                 writew(RX_BUF_START,shmem+iSCB_RFA);
 627                 ack_cmd |= RX_START;
 628         }
 629
 630         writew(ack_cmd,shmem+iSCB_CMD);
 631         outb(0, ioaddr + SIGNAL_CA);                    /* Issue channel-attn. */
 632
 633         /* Clear the latched interrupt. */
 634         outb(0, ioaddr + RESET_IRQ);
 635
 636         /* Enable the 82586's interrupt input. */
 637         outb(0x84, ioaddr + MISC_CTRL);
 638         spin_unlock(&lp->lock);
 639         return IRQ_HANDLED;
 640 }
 641
 642 static int el16_close(struct net_device *dev)
 643 {
 644         struct net_local *lp = netdev_priv(dev);
 645         int ioaddr = dev->base_addr;
 646         void __iomem *shmem = lp->base;
 647
 648         netif_stop_queue(dev);
 649
 650         /* Flush the Tx and disable Rx. */
 651         writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
 652         outb(0, ioaddr + SIGNAL_CA);
 653
 654         /* Disable the 82586's input to the interrupt line. */
 655         outb(0x80, ioaddr + MISC_CTRL);
 656
 657         /* We always physically use the IRQ line, so we don't do free_irq(). */
 658
 659         /* Update the statistics here. */
 660
 661         return 0;
 662 }
 663
 664 /* Initialize the Rx-block list. */
 665 static void init_rx_bufs(struct net_device *dev)
 666 {
 667         struct net_local *lp = netdev_priv(dev);
 668         void __iomem *write_ptr;
 669         unsigned short SCB_base = SCB_BASE;
 670
 671         int cur_rxbuf = lp->rx_head = RX_BUF_START;
 672
 673         /* Initialize each Rx frame + data buffer. */
 674         do {    /* While there is room for one more. */
 675
 676                 write_ptr = lp->base + cur_rxbuf;
 677
 678                 writew(0x0000,write_ptr);                       /* Status */
 679                 writew(0x0000,write_ptr+=2);                    /* Command */
 680                 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2);   /* Link */
 681                 writew(cur_rxbuf + 22,write_ptr+=2);            /* Buffer offset */
 682                 writew(0x0000,write_ptr+=2);                    /* Pad for dest addr. */
 683                 writew(0x0000,write_ptr+=2);
 684                 writew(0x0000,write_ptr+=2);
 685                 writew(0x0000,write_ptr+=2);                    /* Pad for source addr. */
 686                 writew(0x0000,write_ptr+=2);
 687                 writew(0x0000,write_ptr+=2);
 688                 writew(0x0000,write_ptr+=2);                    /* Pad for protocol. */
 689
 690                 writew(0x0000,write_ptr+=2);                    /* Buffer: Actual count */
 691                 writew(-1,write_ptr+=2);                        /* Buffer: Next (none). */
 692                 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
 693                 writew(0x0000,write_ptr+=2);
 694                 /* Finally, the number of bytes in the buffer. */
 695                 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
 696
 697                 lp->rx_tail = cur_rxbuf;
 698                 cur_rxbuf += RX_BUF_SIZE;
 699         } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
 700
 701         /* Terminate the list by setting the EOL bit, and wrap the pointer to make
 702            the list a ring. */
 703         write_ptr = lp->base + lp->rx_tail + 2;
 704         writew(0xC000,write_ptr);                               /* Command, mark as last. */
 705         writew(lp->rx_head,write_ptr+2);                        /* Link */
 706 }
 707
 708 static void init_82586_mem(struct net_device *dev)
 709 {
 710         struct net_local *lp = netdev_priv(dev);
 711         short ioaddr = dev->base_addr;
 712         void __iomem *shmem = lp->base;
 713
 714         /* Enable loopback to protect the wire while starting up,
 715            and hold the 586 in reset during the memory initialization. */
 716         outb(0x20, ioaddr + MISC_CTRL);
 717
 718         /* Fix the ISCP address and base. */
 719         init_words[3] = SCB_BASE;
 720         init_words[7] = SCB_BASE;
 721
 722         /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
 723         memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
 724
 725         /* Write the words at 0x0000. */
 726         memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
 727
 728         /* Fill in the station address. */
 729         memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
 730                    sizeof(dev->dev_addr));
 731
 732         /* The Tx-block list is written as needed.  We just set up the values. */
 733         lp->tx_cmd_link = IDLELOOP + 4;
 734         lp->tx_head = lp->tx_reap = TX_BUF_START;
 735
 736         init_rx_bufs(dev);
 737
 738         /* Start the 586 by releasing the reset line, but leave loopback. */
 739         outb(0xA0, ioaddr + MISC_CTRL);
 740
 741         /* This was time consuming to track down: you need to give two channel
 742            attention signals to reliably start up the i82586. */
 743         outb(0, ioaddr + SIGNAL_CA);
 744
 745         {
 746                 int boguscnt = 50;
 747                 while (readw(shmem+iSCB_STATUS) == 0)
 748                         if (--boguscnt == 0) {
 749                                 printk("%s: i82586 initialization timed out with status %04x, "
 750                                            "cmd %04x.\n", dev->name,
 751                                            readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
 752                                 break;
 753                         }
 754                 /* Issue channel-attn -- the 82586 won't start. */
 755                 outb(0, ioaddr + SIGNAL_CA);
 756         }
 757
 758         /* Disable loopback and enable interrupts. */
 759         outb(0x84, ioaddr + MISC_CTRL);
 760         if (net_debug > 4)
 761                 printk("%s: Initialized 82586, status %04x.\n", dev->name,
 762                            readw(shmem+iSCB_STATUS));
 763         return;
 764 }
 765
 766 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
 767 {
 768         struct net_local *lp = netdev_priv(dev);
 769         short ioaddr = dev->base_addr;
 770         ushort tx_block = lp->tx_head;
 771         void __iomem *write_ptr = lp->base + tx_block;
 772         static char padding[ETH_ZLEN];
 773
 774         /* Set the write pointer to the Tx block, and put out the header. */
 775         writew(0x0000,write_ptr);                       /* Tx status */
 776         writew(CMD_INTR|CmdTx,write_ptr+=2);            /* Tx command */
 777         writew(tx_block+16,write_ptr+=2);               /* Next command is a NoOp. */
 778         writew(tx_block+8,write_ptr+=2);                        /* Data Buffer offset. */
 779
 780         /* Output the data buffer descriptor. */
 781         writew((pad + length) | 0x8000,write_ptr+=2);           /* Byte count parameter. */
 782         writew(-1,write_ptr+=2);                        /* No next data buffer. */
 783         writew(tx_block+22+SCB_BASE,write_ptr+=2);      /* Buffer follows the NoOp command. */
 784         writew(0x0000,write_ptr+=2);                    /* Buffer address high bits (always zero). */
 785
 786         /* Output the Loop-back NoOp command. */
 787         writew(0x0000,write_ptr+=2);                    /* Tx status */
 788         writew(CmdNOp,write_ptr+=2);                    /* Tx command */
 789         writew(tx_block+16,write_ptr+=2);               /* Next is myself. */
 790
 791         /* Output the packet at the write pointer. */
 792         memcpy_toio(write_ptr+2, buf, length);
 793         if (pad)
 794                 memcpy_toio(write_ptr+length+2, padding, pad);
 795
 796         /* Set the old command link pointing to this send packet. */
 797         writew(tx_block,lp->base + lp->tx_cmd_link);
 798         lp->tx_cmd_link = tx_block + 20;
 799
 800         /* Set the next free tx region. */
 801         lp->tx_head = tx_block + TX_BUF_SIZE;
 802         if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
 803                 lp->tx_head = TX_BUF_START;
 804
 805         if (net_debug > 4) {
 806                 printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
 807                            dev->name, ioaddr, length, tx_block, lp->tx_head);
 808         }
 809
 810         /* Grimly block further packets if there has been insufficient reaping. */
 811         if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
 812                 netif_wake_queue(dev);
 813 }
 814
 815 static void el16_rx(struct net_device *dev)
 816 {
 817         struct net_local *lp = netdev_priv(dev);
 818         void __iomem *shmem = lp->base;
 819         ushort rx_head = lp->rx_head;
 820         ushort rx_tail = lp->rx_tail;
 821         ushort boguscount = 10;
 822         short frame_status;
 823
 824         while ((frame_status = readw(shmem+rx_head)) < 0) {   /* Command complete */
 825                 void __iomem *read_frame = lp->base + rx_head;
 826                 ushort rfd_cmd = readw(read_frame+2);
 827                 ushort next_rx_frame = readw(read_frame+4);
 828                 ushort data_buffer_addr = readw(read_frame+6);
 829                 void __iomem *data_frame = lp->base + data_buffer_addr;
 830                 ushort pkt_len = readw(data_frame);
 831
 832                 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
 833                         || (pkt_len & 0xC000) != 0xC000) {
 834                         printk(KERN_ERR "%s: Rx frame at %#x corrupted, "
 835                                "status %04x cmd %04x next %04x "
 836                                "data-buf @%04x %04x.\n",
 837                                dev->name, rx_head, frame_status, rfd_cmd,
 838                                next_rx_frame, data_buffer_addr, pkt_len);
 839                 } else if ((frame_status & 0x2000) == 0) {
 840                         /* Frame Rxed, but with error. */
 841                         dev->stats.rx_errors++;
 842                         if (frame_status & 0x0800) dev->stats.rx_crc_errors++;
 843                         if (frame_status & 0x0400) dev->stats.rx_frame_errors++;
 844                         if (frame_status & 0x0200) dev->stats.rx_fifo_errors++;
 845                         if (frame_status & 0x0100) dev->stats.rx_over_errors++;
 846                         if (frame_status & 0x0080) dev->stats.rx_length_errors++;
 847                 } else {
 848                         /* Malloc up new buffer. */
 849                         struct sk_buff *skb;
 850
 851                         pkt_len &= 0x3fff;
 852                         skb = dev_alloc_skb(pkt_len+2);
 853                         if (skb == NULL) {
 854                                 printk(KERN_ERR "%s: Memory squeeze, "
 855                                        "dropping packet.\n",
 856                                        dev->name);
 857                                 dev->stats.rx_dropped++;
 858                                 break;
 859                         }
 860
 861                         skb_reserve(skb,2);
 862
 863                         /* 'skb->data' points to the start of sk_buff data area. */
 864                         memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
 865
 866                         skb->protocol=eth_type_trans(skb,dev);
 867                         netif_rx(skb);
 868                         dev->stats.rx_packets++;
 869                         dev->stats.rx_bytes += pkt_len;
 870                 }
 871
 872                 /* Clear the status word and set End-of-List on the rx frame. */
 873                 writew(0,read_frame);
 874                 writew(0xC000,read_frame+2);
 875                 /* Clear the end-of-list on the prev. RFD. */
 876                 writew(0x0000,lp->base + rx_tail + 2);
 877
 878                 rx_tail = rx_head;
 879                 rx_head = next_rx_frame;
 880                 if (--boguscount == 0)
 881                         break;
 882         }
 883
 884         lp->rx_head = rx_head;
 885         lp->rx_tail = rx_tail;
 886 }
 887
 888 static void netdev_get_drvinfo(struct net_device *dev,
 889                                struct ethtool_drvinfo *info)
 890 {
 891         strcpy(info->driver, DRV_NAME);
 892         strcpy(info->version, DRV_VERSION);
 893         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
 894 }
 895
 896 static u32 netdev_get_msglevel(struct net_device *dev)
 897 {
 898         return debug;
 899 }
 900
 901 static void netdev_set_msglevel(struct net_device *dev, u32 level)
 902 {
 903         debug = level;
 904 }
 905
 906 static const struct ethtool_ops netdev_ethtool_ops = {
 907         .get_drvinfo            = netdev_get_drvinfo,
 908         .get_msglevel           = netdev_get_msglevel,
 909         .set_msglevel           = netdev_set_msglevel,
 910 };
 911
 912 #ifdef MODULE
 913 static struct net_device *dev_3c507;
 914 module_param(io, int, 0);
 915 module_param(irq, int, 0);
 916 MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
 917 MODULE_PARM_DESC(irq, "(ignored)");
 918
 919 int __init init_module(void)
 920 {
 921         if (io == 0)
 922                 printk("3c507: You should not use auto-probing with insmod!\n");
 923         dev_3c507 = el16_probe(-1);
 924         return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
 925 }
 926
 927 void __exit
 928 cleanup_module(void)
 929 {
 930         struct net_device *dev = dev_3c507;
 931         unregister_netdev(dev);
 932         free_irq(dev->irq, dev);
 933         iounmap(((struct net_local *)netdev_priv(dev))->base);
 934         release_region(dev->base_addr, EL16_IO_EXTENT);
 935         free_netdev(dev);
 936 }
 937 #endif /* MODULE */
 938 MODULE_LICENSE("GPL");