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