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