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