root/drivers/net/eexpress.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. express_probe
  2. eexp_probe1
  3. eexp_open
  4. eexp_send_packet
  5. eexp_interrupt
  6. eexp_close
  7. eexp_get_stats
  8. set_multicast_list
  9. read_eeprom
  10. init_82586_mem
  11. init_rx_bufs
  12. hardware_send_packet
  13. eexp_rx
  14. init_module
  15. cleanup_module

   1 /* eexpress.c: Intel EtherExpress device driver for Linux. */
   2 /*
   3         Written 1993 by Donald Becker.
   4         Copyright 1993 United States Government as represented by the Director,
   5         National Security Agency.  This software may only be used and distributed
   6         according to the terms of the GNU Public License as modified by SRC,
   7         incorporated herein by reference.
   8 
   9         The author may be reached as becker@super.org or
  10         C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
  11 
  12         Things remaining to do:
  13         Check that the 586 and ASIC are reset/unreset at the right times.
  14         Check tx and rx buffer setup.
  15         The current Tx is single-buffer-only.
  16         Move the theory of operation and memory map documentation.
  17         Rework the board error reset
  18         The statistics need to be updated correctly.
  19 
  20         Modularized by Pauline Middelink <middelin@polyware.iaf.nl>
  21         Changed to support io= irq= by Alan Cox <Alan.Cox@linux.org>
  22 */
  23 
  24 static const char *version =
  25         "eexpress.c:v0.07 1/19/94 Donald Becker (becker@super.org)\n";
  26 
  27 /*
  28   Sources:
  29         This driver wouldn't have been written with the availability of the
  30         Crynwr driver source code.      It provided a known-working implementation
  31         that filled in the gaping holes of the Intel documentation.  Three cheers
  32         for Russ Nelson.
  33 
  34         Intel Microcommunications Databook, Vol. 1, 1990. It provides just enough
  35         info that the casual reader might think that it documents the i82586.
  36 */
  37 
  38 #include <linux/module.h>
  39 
  40 #include <linux/kernel.h>
  41 #include <linux/sched.h>
  42 #include <linux/types.h>
  43 #include <linux/fcntl.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/ptrace.h>
  46 #include <linux/ioport.h>
  47 #include <linux/string.h>
  48 #include <linux/in.h>
  49 #include <asm/system.h>
  50 #include <asm/bitops.h>
  51 #include <asm/io.h>
  52 #include <asm/dma.h>
  53 #include <linux/errno.h>
  54 
  55 #include <linux/netdevice.h>
  56 #include <linux/etherdevice.h>
  57 #include <linux/skbuff.h>
  58 #include <linux/malloc.h>
  59 
  60 /* use 0 for production, 1 for verification, 2..7 for debug */
  61 #ifndef NET_DEBUG
  62 #define NET_DEBUG 2
  63 #endif
  64 static unsigned int net_debug = NET_DEBUG;
  65 
  66 /*
  67                         Details of the i82586.
  68 
  69    You'll really need the databook to understand the details of this part,
  70    but the outline is that the i82586 has two separate processing units.
  71 
  72    The Rx unit uses a list of frame descriptors and a list of data buffer
  73    descriptors.  We use full-sized (1518 byte) data buffers, so there is
  74    a one-to-one pairing of frame descriptors to buffer descriptors.
  75 
  76    The Tx ("command") unit executes a list of commands that look like:
  77                 Status word             Written by the 82586 when the command is done.
  78                 Command word    Command in lower 3 bits, post-command action in upper 3
  79                 Link word               The address of the next command.
  80                 Parameters              (as needed).
  81 
  82         Some definitions related to the Command Word are:
  83  */
  84 #define CMD_EOL         0x8000                  /* The last command of the list, stop. */
  85 #define CMD_SUSP        0x4000                  /* Suspend after doing cmd. */
  86 #define CMD_INTR        0x2000                  /* Interrupt after doing cmd. */
  87 
  88 enum commands {
  89         CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
  90         CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
  91 
  92 /* Information that need to be kept for each board. */
  93 struct net_local {
  94         struct enet_statistics stats;
  95         int last_restart;
  96         short rx_head;
  97         short rx_tail;
  98         short tx_head;
  99         short tx_cmd_link;
 100         short tx_reap;
 101 };
 102 
 103 /*
 104                 Details of the EtherExpress Implementation
 105   The EtherExpress takes an unusual approach to host access to packet buffer
 106   memory.  The host can use either the Dataport, with independent
 107   autoincrementing read and write pointers, or it can I/O map 32 bytes of the
 108   memory using the "Shadow Memory Pointer" (SMB) as follows:
 109                         ioaddr                                          Normal EtherExpress registers
 110                         ioaddr+0x4000...0x400f          Buffer Memory at SMB...SMB+15
 111                         ioaddr+0x8000...0x800f          Buffer Memory at SMB+16...SMB+31
 112                         ioaddr+0xC000...0xC007          "" SMB+16...SMB+23 (hardware flaw?)
 113                         ioaddr+0xC008...0xC00f          Buffer Memory at 0x0008...0x000f
 114   The last I/O map set is useful if you put the i82586 System Command Block
 115   (the command mailbox) exactly at 0x0008.  (There seems to be some
 116   undocumented init structure at 0x0000-7, so I had to use the Crywnr memory
 117   setup verbatim for those four words anyway.)
 118 
 119   A problem with using either one of these mechanisms is that you must run
 120   single-threaded, or the interrupt handler must restore a changed value of
 121   the read, write, or SMB pointers.
 122 
 123   Unlike the Crynwr driver, my driver mostly ignores the I/O mapped "feature"
 124   and relies heavily on the dataport for buffer memory access.  To minimize
 125   switching, the read_pointer is dedicated to the Rx interrupt handler, and
 126   the write_pointer is used by the send_packet() routine (it's carefully saved
 127   and restored when it's needed by the interrupt handler).
 128   */
 129 
 130 /* Offsets from the base I/O address. */
 131 #define DATAPORT        0       /* Data Transfer Register. */
 132 #define WRITE_PTR       2       /* Write Address Pointer. */
 133 #define READ_PTR        4       /* Read Address Pointer. */
 134 #define SIGNAL_CA       6       /* Frob the 82586 Channel Attention line. */
 135 #define SET_IRQ         7       /* IRQ Select. */
 136 #define SHADOW_PTR      8       /* Shadow Memory Bank Pointer. */
 137 #define MEM_Ctrl        11
 138 #define MEM_Page_Ctrl   12
 139 #define Config          13
 140 #define EEPROM_Ctrl             14
 141 #define ID_PORT         15
 142 
 143 #define EEXPRESS_IO_EXTENT 16
 144 
 145 /*      EEPROM_Ctrl bits. */
 146 
 147 #define EE_SHIFT_CLK    0x01    /* EEPROM shift clock. */
 148 #define EE_CS                   0x02    /* EEPROM chip select. */
 149 #define EE_DATA_WRITE   0x04    /* EEPROM chip data in. */
 150 #define EE_DATA_READ    0x08    /* EEPROM chip data out. */
 151 #define EE_CTRL_BITS    (EE_SHIFT_CLK | EE_CS | EE_DATA_WRITE | EE_DATA_READ)
 152 #define ASIC_RESET              0x40
 153 #define _586_RESET              0x80
 154 
 155 /* Offsets to elements of the System Control Block structure. */
 156 #define SCB_STATUS      0xc008
 157 #define SCB_CMD         0xc00A
 158 #define  CUC_START       0x0100
 159 #define  CUC_RESUME      0x0200
 160 #define  CUC_SUSPEND 0x0300
 161 #define  RX_START        0x0010
 162 #define  RX_RESUME       0x0020
 163 #define  RX_SUSPEND      0x0030
 164 #define SCB_CBL         0xc00C  /* Command BLock offset. */
 165 #define SCB_RFA         0xc00E  /* Rx Frame Area offset. */
 166 
 167 /*
 168   What follows in 'init_words[]' is the "program" that is downloaded to the
 169   82586 memory.  It's mostly tables and command blocks, and starts at the
 170   reset address 0xfffff6.
 171 
 172   Even with the additional "don't care" values, doing it this way takes less
 173   program space than initializing the individual tables, and I feel it's much
 174   cleaner.
 175 
 176   The databook is particularly useless for the first two structures; they are
 177   completely undocumented.  I had to use the Crynwr driver as an example.
 178 
 179    The memory setup is as follows:
 180    */
 181 
 182 #define CONFIG_CMD      0x0018
 183 #define SET_SA_CMD      0x0024
 184 #define SA_OFFSET       0x002A
 185 #define IDLELOOP        0x30
 186 #define TDR_CMD         0x38
 187 #define TDR_TIME        0x3C
 188 #define DUMP_CMD        0x40
 189 #define DIAG_CMD        0x48
 190 #define SET_MC_CMD      0x4E
 191 #define DUMP_DATA       0x56    /* A 170 byte buffer for dump and Set-MC into. */
 192 
 193 #define TX_BUF_START    0x0100
 194 #define NUM_TX_BUFS     4
 195 #define TX_BUF_SIZE             0x0680  /* packet+header+TBD+extra (1518+14+20+16) */
 196 #define TX_BUF_END              0x2000
 197 
 198 #define RX_BUF_START    0x2000
 199 #define RX_BUF_SIZE     (0x640) /* packet+header+RBD+extra */
 200 #define RX_BUF_END              0x4000
 201 
 202 /*
 203   That's it: only 86 bytes to set up the beast, including every extra
 204   command available.  The 170 byte buffer at DUMP_DATA is shared between the
 205   Dump command (called only by the diagnostic program) and the SetMulticastList
 206   command.
 207 
 208   To complete the memory setup you only have to write the station address at
 209   SA_OFFSET and create the Tx & Rx buffer lists.
 210 
 211   The Tx command chain and buffer list is setup as follows:
 212   A Tx command table, with the data buffer pointing to...
 213   A Tx data buffer descriptor.  The packet is in a single buffer, rather than
 214      chaining together several smaller buffers.
 215   A NoOp command, which initially points to itself,
 216   And the packet data.
 217 
 218   A transmit is done by filling in the Tx command table and data buffer,
 219   re-writing the NoOp command, and finally changing the offset of the last
 220   command to point to the current Tx command.  When the Tx command is finished,
 221   it jumps to the NoOp, when it loops until the next Tx command changes the
 222   "link offset" in the NoOp.  This way the 82586 never has to go through the
 223   slow restart sequence.
 224 
 225   The Rx buffer list is set up in the obvious ring structure.  We have enough
 226   memory (and low enough interrupt latency) that we can avoid the complicated
 227   Rx buffer linked lists by alway associating a full-size Rx data buffer with
 228   each Rx data frame.
 229 
 230   I current use four transmit buffers starting at TX_BUF_START (0x0100), and
 231   use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers.
 232 
 233   */
 234 
 235 static short init_words[] = {
 236         0x0000,                                 /* Set bus size to 16 bits. */
 237         0x0000,0x0000,                  /* Set control mailbox (SCB) addr. */
 238         0,0,                                    /* pad to 0x000000. */
 239         0x0001,                                 /* Status word that's cleared when init is done. */
 240         0x0008,0,0,                             /* SCB offset, (skip, skip) */
 241 
 242         0,0xf000|RX_START|CUC_START,    /* SCB status and cmd. */
 243         CONFIG_CMD,                             /* Command list pointer, points to Configure. */
 244         RX_BUF_START,                           /* Rx block list. */
 245         0,0,0,0,                                /* Error count: CRC, align, buffer, overrun. */
 246 
 247         /* 0x0018: Configure command.  Change to put MAC data with packet. */
 248         0, CmdConfigure,                /* Status, command.             */
 249         SET_SA_CMD,                             /* Next command is Set Station Addr. */
 250         0x0804,                                 /* "4" bytes of config data, 8 byte FIFO. */
 251         0x2e40,                                 /* Magic values, including MAC data location. */
 252         0,                                              /* Unused pad word. */
 253 
 254         /* 0x0024: Setup station address command. */
 255         0, CmdSASetup,
 256         SET_MC_CMD,                             /* Next command. */
 257         0xaa00,0xb000,0x0bad,   /* Station address (to be filled in) */
 258 
 259         /* 0x0030: NOP, looping back to itself.  Point to first Tx buffer to Tx. */
 260         0, CmdNOp, IDLELOOP, 0 /* pad */,
 261 
 262         /* 0x0038: A unused Time-Domain Reflectometer command. */
 263         0, CmdTDR, IDLELOOP, 0,
 264 
 265         /* 0x0040: An unused Dump State command. */
 266         0, CmdDump, IDLELOOP, DUMP_DATA,
 267 
 268         /* 0x0048: An unused Diagnose command. */
 269         0, CmdDiagnose, IDLELOOP,
 270 
 271         /* 0x004E: An empty set-multicast-list command. */
 272 #ifdef initial_text_tx
 273         0, CmdMulticastList, DUMP_DATA, 0,
 274 #else
 275         0, CmdMulticastList, IDLELOOP, 0,
 276 #endif
 277 
 278         /* 0x0056: A continuous transmit command, only here for testing. */
 279         0, CmdTx, DUMP_DATA, DUMP_DATA+8, 0x83ff, -1, DUMP_DATA, 0,
 280 };
 281 
 282 /* Index to functions, as function prototypes. */
 283 
 284 extern int express_probe(struct device *dev);   /* Called from Space.c */
 285 
 286 static int      eexp_probe1(struct device *dev, short ioaddr);
 287 static int      eexp_open(struct device *dev);
 288 static int      eexp_send_packet(struct sk_buff *skb, struct device *dev);
 289 static void     eexp_interrupt(int irq, struct pt_regs *regs);
 290 static void eexp_rx(struct device *dev);
 291 static int      eexp_close(struct device *dev);
 292 static struct enet_statistics *eexp_get_stats(struct device *dev);
 293 static void set_multicast_list(struct device *dev);
 294 
 295 static int read_eeprom(int ioaddr, int location);
 296 static void hardware_send_packet(struct device *dev, void *buf, short length);
 297 static void init_82586_mem(struct device *dev);
 298 static void init_rx_bufs(struct device *dev);
 299 
 300 
 301 /* Check for a network adaptor of this type, and return '0' iff one exists.
 302    If dev->base_addr == 0, probe all likely locations.
 303    If dev->base_addr == 1, always return failure.
 304    If dev->base_addr == 2, (detachable devices only) allocate space for the
 305    device and return success.
 306    */
 307 int
 308 express_probe(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 309 {
 310         /* Don't probe all settable addresses, 0x[23][0-7]0, just common ones. */
 311         int *port, ports[] = {0x300, 0x270, 0x320, 0x340, 0};
 312         int base_addr = dev->base_addr;
 313 
 314         if (base_addr > 0x1ff)  /* Check a single specified location. */
 315                 return eexp_probe1(dev, base_addr);
 316         else if (base_addr > 0)
 317                 return ENXIO;           /* Don't probe at all. */
 318 
 319         for (port = &ports[0]; *port; port++) {
 320                 short id_addr = *port + ID_PORT;
 321                 unsigned short sum = 0;
 322                 int i;
 323 #ifdef notdef
 324                 for (i = 16; i > 0; i--)
 325                         sum += inb(id_addr);
 326                 printk("EtherExpress ID checksum is %04x.\n", sum);
 327 #else
 328                 for (i = 4; i > 0; i--) {
 329                         short id_val = inb(id_addr);
 330                         sum |= (id_val >> 4) << ((id_val & 3) << 2);
 331                 }
 332 #endif
 333                 if (sum == 0xbaba
 334                         && eexp_probe1(dev, *port) == 0)
 335                         return 0;
 336         }
 337 
 338         return ENODEV;
 339 }
 340 
 341 int eexp_probe1(struct device *dev, short ioaddr)
     /* [previous][next][first][last][top][bottom][index][help] */
 342 {
 343         unsigned short station_addr[3];
 344         int i;
 345 
 346         printk("%s: EtherExpress at %#x,", dev->name, ioaddr);
 347 
 348         /* The station address is stored !backwards! in the EEPROM, reverse
 349            after reading.  (Hmmm, a little brain-damage there at Intel, eh?) */
 350         station_addr[0] = read_eeprom(ioaddr, 2);
 351         station_addr[1] = read_eeprom(ioaddr, 3);
 352         station_addr[2] = read_eeprom(ioaddr, 4);
 353 
 354         /* Check the first three octets of the S.A. for the manufacturer's code. */
 355         if (station_addr[2] != 0x00aa || (station_addr[1] & 0xff00) != 0x0000) {
 356                 printk(" rejected (invalid address %04x%04x%04x).\n",
 357                            station_addr[2], station_addr[1], station_addr[0]);
 358                 return ENODEV;
 359         }
 360 
 361         /* We've committed to using the board, and can start filling in *dev. */
 362         request_region(ioaddr, EEXPRESS_IO_EXTENT, "eexpress");
 363         dev->base_addr = ioaddr;
 364 
 365         for (i = 0; i < 6; i++) {
 366                 dev->dev_addr[i] = ((unsigned char*)station_addr)[5-i];
 367                 printk(" %02x", dev->dev_addr[i]);
 368         }
 369 
 370         /* There is no reason for the driver to care, but I print out the
 371            interface to minimize bogus bug reports. */
 372         {
 373                 char irqmap[] = {0, 9, 3, 4, 5, 10, 11, 0};
 374                 const char *ifmap[] = {"AUI", "BNC", "10baseT"};
 375                 enum iftype {AUI=0, BNC=1, TP=2};
 376                 unsigned short setupval = read_eeprom(ioaddr, 0);
 377 
 378                 dev->irq = irqmap[setupval >> 13];
 379                 dev->if_port = (setupval & 0x1000) == 0 ? AUI :
 380                         read_eeprom(ioaddr, 5) & 0x1 ? TP : BNC;
 381                 printk(", IRQ %d, Interface %s.\n", dev->irq, ifmap[dev->if_port]);
 382                 /* Release the IRQ line so that it can be shared if we don't use the
 383                    ethercard. */
 384                 outb(0x00, ioaddr + SET_IRQ);
 385         }
 386 
 387         /* It's now OK to leave the board in reset, pending the open(). */
 388         outb(ASIC_RESET, ioaddr + EEPROM_Ctrl);
 389 
 390         if ((dev->mem_start & 0xf) > 0)
 391                 net_debug = dev->mem_start & 7;
 392 
 393         if (net_debug)
 394                 printk(version);
 395 
 396         /* Initialize the device structure. */
 397         dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
 398         if (dev->priv == NULL)
 399                 return -ENOMEM;
 400         memset(dev->priv, 0, sizeof(struct net_local));
 401 
 402         dev->open               = eexp_open;
 403         dev->stop               = eexp_close;
 404         dev->hard_start_xmit = eexp_send_packet;
 405         dev->get_stats  = eexp_get_stats;
 406         dev->set_multicast_list = &set_multicast_list;
 407 
 408         /* Fill in the fields of the device structure with ethernet-generic values. */
 409         
 410         ether_setup(dev);
 411         
 412         dev->flags&=~IFF_MULTICAST;
 413                 
 414         return 0;
 415 }
 416 
 417 
 418 /* Reverse IRQ map: the value to put in the SET_IRQ reg. for IRQ<index>. */
 419 static char irqrmap[]={0,0,1,2,3,4,0,0,0,1,5,6,0,0,0,0};
 420 
 421 static int
 422 eexp_open(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 423 {
 424         int ioaddr = dev->base_addr;
 425 
 426         if (dev->irq == 0  ||  irqrmap[dev->irq] == 0)
 427                 return -ENXIO;
 428 
 429         if (irq2dev_map[dev->irq] != 0
 430                 /* This is always true, but avoid the false IRQ. */
 431                 || (irq2dev_map[dev->irq] = dev) == 0
 432                 || request_irq(dev->irq, &eexp_interrupt, 0, "EExpress")) {
 433                 return -EAGAIN;
 434         }
 435 
 436         /* Initialize the 82586 memory and start it. */
 437         init_82586_mem(dev);
 438 
 439         /* Enable the interrupt line. */
 440         outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
 441 
 442         dev->tbusy = 0;
 443         dev->interrupt = 0;
 444         dev->start = 1;
 445         MOD_INC_USE_COUNT;
 446         return 0;
 447 }
 448 
 449 static int
 450 eexp_send_packet(struct sk_buff *skb, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 451 {
 452         struct net_local *lp = (struct net_local *)dev->priv;
 453         int ioaddr = dev->base_addr;
 454 
 455         if (dev->tbusy) {
 456                 /* If we get here, some higher level has decided we are broken.
 457                    There should really be a "kick me" function call instead. */
 458                 int tickssofar = jiffies - dev->trans_start;
 459                 if (tickssofar < 5)
 460                         return 1;
 461                 if (net_debug > 1)
 462                         printk("%s: transmit timed out, %s?  ", dev->name,
 463                                    inw(ioaddr+SCB_STATUS) & 0x8000 ? "IRQ conflict" :
 464                                    "network cable problem");
 465                 lp->stats.tx_errors++;
 466                 /* Try to restart the adaptor. */
 467                 if (lp->last_restart == lp->stats.tx_packets) {
 468                         if (net_debug > 1) printk("Resetting board.\n");
 469                         /* Completely reset the adaptor. */
 470                         init_82586_mem(dev);
 471                 } else {
 472                         /* Issue the channel attention signal and hope it "gets better". */
 473                         if (net_debug > 1) printk("Kicking board.\n");
 474                         outw(0xf000|CUC_START|RX_START, ioaddr + SCB_CMD);
 475                         outb(0, ioaddr + SIGNAL_CA);
 476                         lp->last_restart = lp->stats.tx_packets;
 477                 }
 478                 dev->tbusy=0;
 479                 dev->trans_start = jiffies;
 480         }
 481 
 482         /* If some higher layer thinks we've missed an tx-done interrupt
 483            we are passed NULL. Caution: dev_tint() handles the cli()/sti()
 484            itself. */
 485         if (skb == NULL) {
 486                 dev_tint(dev);
 487                 return 0;
 488         }
 489 
 490         /* Block a timer-based transmit from overlapping. */
 491         if (set_bit(0, (void*)&dev->tbusy) != 0)
 492                 printk("%s: Transmitter access conflict.\n", dev->name);
 493         else {
 494                 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 495                 unsigned char *buf = skb->data;
 496 
 497                 /* Disable the 82586's input to the interrupt line. */
 498                 outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
 499                 hardware_send_packet(dev, buf, length);
 500                 dev->trans_start = jiffies;
 501                 /* Enable the 82586 interrupt input. */
 502                 outb(0x08 | irqrmap[dev->irq], ioaddr + SET_IRQ);
 503         }
 504 
 505         dev_kfree_skb (skb, FREE_WRITE);
 506 
 507         /* You might need to clean up and record Tx statistics here. */
 508         lp->stats.tx_aborted_errors++;
 509 
 510         return 0;
 511 }
 512 
 513 /*      The typical workload of the driver:
 514         Handle the network interface interrupts. */
 515 static void
 516 eexp_interrupt(int irq, struct pt_regs *regs)
     /* [previous][next][first][last][top][bottom][index][help] */
 517 {
 518         struct device *dev = (struct device *)(irq2dev_map[irq]);
 519         struct net_local *lp;
 520         int ioaddr, status, boguscount = 0;
 521         short ack_cmd;
 522 
 523         if (dev == NULL) {
 524                 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
 525                 return;
 526         }
 527         dev->interrupt = 1;
 528         
 529         ioaddr = dev->base_addr;
 530         lp = (struct net_local *)dev->priv;
 531         
 532         status = inw(ioaddr + SCB_STATUS);
 533         
 534     if (net_debug > 4) {
 535                 printk("%s: EExp interrupt, status %4.4x.\n", dev->name, status);
 536     }
 537 
 538         /* Disable the 82586's input to the interrupt line. */
 539         outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
 540 
 541         /* Reap the Tx packet buffers. */
 542         while (lp->tx_reap != lp->tx_head) {    /* if (status & 0x8000) */
 543                 unsigned short tx_status;
 544                 outw(lp->tx_reap, ioaddr + READ_PTR);
 545                 tx_status = inw(ioaddr);
 546                 if (tx_status == 0) {
 547                         if (net_debug > 5)  printk("Couldn't reap %#x.\n", lp->tx_reap);
 548                         break;
 549                 }
 550                 if (tx_status & 0x2000) {
 551                         lp->stats.tx_packets++;
 552                         lp->stats.collisions += tx_status & 0xf;
 553                         dev->tbusy = 0;
 554                         mark_bh(NET_BH);        /* Inform upper layers. */
 555                 } else {
 556                         lp->stats.tx_errors++;
 557                         if (tx_status & 0x0600)  lp->stats.tx_carrier_errors++;
 558                         if (tx_status & 0x0100)  lp->stats.tx_fifo_errors++;
 559                         if (!(tx_status & 0x0040))  lp->stats.tx_heartbeat_errors++;
 560                         if (tx_status & 0x0020)  lp->stats.tx_aborted_errors++;
 561                 }
 562                 if (net_debug > 5)
 563                         printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
 564                 lp->tx_reap += TX_BUF_SIZE;
 565                 if (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
 566                         lp->tx_reap = TX_BUF_START;
 567                 if (++boguscount > 4)
 568                         break;
 569         }
 570 
 571         if (status & 0x4000) { /* Packet received. */
 572                 if (net_debug > 5)
 573                         printk("Received packet, rx_head %04x.\n", lp->rx_head);
 574                 eexp_rx(dev);
 575         }
 576 
 577         /* Acknowledge the interrupt sources. */
 578         ack_cmd = status & 0xf000;
 579 
 580         if ((status & 0x0700) != 0x0200  &&  dev->start) {
 581                 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
 582                 if (net_debug > 1)
 583                         printk("%s: Command unit stopped, status %04x, restarting.\n",
 584                                    dev->name, status);
 585                 /* If this ever occurs we must re-write the idle loop, reset
 586                    the Tx list, and do a complete restart of the command unit. */
 587                 outw(IDLELOOP, ioaddr + WRITE_PTR);
 588                 outw(0, ioaddr);
 589                 outw(CmdNOp, ioaddr);
 590                 outw(IDLELOOP, ioaddr);
 591                 outw(IDLELOOP, SCB_CBL);
 592                 lp->tx_cmd_link = IDLELOOP + 4;
 593                 lp->tx_head = lp->tx_reap = TX_BUF_START;
 594                 /* Restore the saved write pointer. */
 595                 outw(saved_write_ptr, ioaddr + WRITE_PTR);
 596                 ack_cmd |= CUC_START;
 597         }
 598 
 599         if ((status & 0x0070) != 0x0040  &&  dev->start) {
 600                 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
 601                 /* The Rx unit is not ready, it must be hung.  Restart the receiver by
 602                    initializing the rx buffers, and issuing an Rx start command. */
 603                 lp->stats.rx_errors++;
 604                 if (net_debug > 1) {
 605                         int cur_rxbuf = RX_BUF_START;
 606                         printk("%s: Rx unit stopped status %04x rx head %04x tail %04x.\n",
 607                                    dev->name, status, lp->rx_head, lp->rx_tail);
 608                         while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE) {
 609                                 int i;
 610                                 printk("  Rx buf at %04x:", cur_rxbuf);
 611                                 outw(cur_rxbuf, ioaddr + READ_PTR);
 612                                 for (i = 0; i < 0x20; i += 2)
 613                                         printk(" %04x", inw(ioaddr));
 614                                 printk(".\n");
 615                                 cur_rxbuf += RX_BUF_SIZE;
 616                         }
 617                 }
 618                 init_rx_bufs(dev);
 619                 outw(RX_BUF_START, SCB_RFA);
 620                 outw(saved_write_ptr, ioaddr + WRITE_PTR);
 621                 ack_cmd |= RX_START;
 622         }
 623 
 624         outw(ack_cmd, ioaddr + SCB_CMD);
 625         outb(0, ioaddr + SIGNAL_CA);
 626 
 627     if (net_debug > 5) {
 628                 printk("%s: EExp exiting interrupt, status %4.4x.\n", dev->name,
 629                            inw(ioaddr + SCB_CMD));
 630     }
 631         /* Enable the 82586's input to the interrupt line. */
 632         outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
 633         return;
 634 }
 635 
 636 static int
 637 eexp_close(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 638 {
 639         int ioaddr = dev->base_addr;
 640 
 641         dev->tbusy = 1;
 642         dev->start = 0;
 643 
 644         /* Flush the Tx and disable Rx. */
 645         outw(RX_SUSPEND | CUC_SUSPEND, ioaddr + SCB_CMD);
 646         outb(0, ioaddr + SIGNAL_CA);
 647 
 648         /* Disable the physical interrupt line. */
 649         outb(0, ioaddr + SET_IRQ);
 650 
 651         free_irq(dev->irq);
 652 
 653         irq2dev_map[dev->irq] = 0;
 654 
 655         /* Update the statistics here. */
 656 
 657         MOD_DEC_USE_COUNT;
 658         return 0;
 659 }
 660 
 661 /* Get the current statistics.  This may be called with the card open or
 662    closed. */
 663 static struct enet_statistics *
 664 eexp_get_stats(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 665 {
 666         struct net_local *lp = (struct net_local *)dev->priv;
 667 
 668         /* ToDo: decide if there are any useful statistics from the SCB. */
 669 
 670         return &lp->stats;
 671 }
 672 
 673 /* Set or clear the multicast filter for this adaptor.
 674  */
 675 static void
 676 set_multicast_list(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 677 {
 678 /* This doesn't work yet */
 679 #if 0
 680         short ioaddr = dev->base_addr;
 681         if (num_addrs < 0) {
 682                 /* Not written yet, this requires expanding the init_words config
 683                    cmd. */
 684         } else if (num_addrs > 0) {
 685                 /* Fill in the SET_MC_CMD with the number of address bytes, followed
 686                    by the list of multicast addresses to be accepted. */
 687                 outw(SET_MC_CMD + 6, ioaddr + WRITE_PTR);
 688                 outw(num_addrs * 6, ioaddr);
 689                 outsw(ioaddr, addrs, num_addrs*3);              /* 3 = addr len in words */
 690                 /* We must trigger a whole 586 reset due to a bug. */
 691         } else {
 692                 /* Not written yet, this requires expanding the init_words config
 693                    cmd. */
 694                 outw(99, ioaddr);               /* Disable promiscuous mode, use normal mode */
 695         }
 696 #endif
 697 }
 698 
 699 /* The horrible routine to read a word from the serial EEPROM. */
 700 
 701 /* The delay between EEPROM clock transitions. */
 702 #define eeprom_delay()  { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
 703 #define EE_READ_CMD (6 << 6)
 704 
 705 int
 706 read_eeprom(int ioaddr, int location)
     /* [previous][next][first][last][top][bottom][index][help] */
 707 {
 708         int i;
 709         unsigned short retval = 0;
 710         short ee_addr = ioaddr + EEPROM_Ctrl;
 711         int read_cmd = location | EE_READ_CMD;
 712         short ctrl_val = EE_CS | _586_RESET;
 713         
 714         outb(ctrl_val, ee_addr);
 715         
 716         /* Shift the read command bits out. */
 717         for (i = 8; i >= 0; i--) {
 718                 short outval = (read_cmd & (1 << i)) ? ctrl_val | EE_DATA_WRITE
 719                         : ctrl_val;
 720                 outb(outval, ee_addr);
 721                 outb(outval | EE_SHIFT_CLK, ee_addr);   /* EEPROM clock tick. */
 722                 eeprom_delay();
 723                 outb(outval, ee_addr);  /* Finish EEPROM a clock tick. */
 724                 eeprom_delay();
 725         }
 726         outb(ctrl_val, ee_addr);
 727         
 728         for (i = 16; i > 0; i--) {
 729                 outb(ctrl_val | EE_SHIFT_CLK, ee_addr);  eeprom_delay();
 730                 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
 731                 outb(ctrl_val, ee_addr);  eeprom_delay();
 732         }
 733 
 734         /* Terminate the EEPROM access. */
 735         ctrl_val &= ~EE_CS;
 736         outb(ctrl_val | EE_SHIFT_CLK, ee_addr);
 737         eeprom_delay();
 738         outb(ctrl_val, ee_addr);
 739         eeprom_delay();
 740         return retval;
 741 }
 742 
 743 static void
 744 init_82586_mem(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 745 {
 746         struct net_local *lp = (struct net_local *)dev->priv;
 747         short ioaddr = dev->base_addr;
 748 
 749         /* Enable loopback to protect the wire while starting up.
 750            This is Superstition From Crynwr. */
 751         outb(inb(ioaddr + Config) | 0x02, ioaddr + Config);
 752 
 753         /* Hold the 586 in reset during the memory initialization. */
 754         outb(_586_RESET, ioaddr + EEPROM_Ctrl);
 755 
 756         /* Place the write pointer at 0xfff6 (address-aliased to 0xfffff6). */
 757         outw(0xfff6, ioaddr + WRITE_PTR);
 758         outsw(ioaddr, init_words, sizeof(init_words)>>1);
 759 
 760         /* Fill in the station address. */
 761         outw(SA_OFFSET, ioaddr + WRITE_PTR);
 762         outsw(ioaddr, dev->dev_addr, 3);
 763 
 764         /* The Tx-block list is written as needed.  We just set up the values. */
 765 #ifdef initial_text_tx
 766         lp->tx_cmd_link = DUMP_DATA + 4;
 767 #else
 768         lp->tx_cmd_link = IDLELOOP + 4;
 769 #endif
 770         lp->tx_head = lp->tx_reap = TX_BUF_START;
 771 
 772         init_rx_bufs(dev);
 773 
 774         /* Start the 586 by releasing the reset line. */
 775         outb(0x00, ioaddr + EEPROM_Ctrl);
 776 
 777         /* This was time consuming to track down: you need to give two channel
 778            attention signals to reliably start up the i82586. */
 779         outb(0, ioaddr + SIGNAL_CA);
 780 
 781         {
 782                 int boguscnt = 50;
 783                 while (inw(ioaddr + SCB_STATUS) == 0)
 784                         if (--boguscnt == 0) {
 785                                 printk("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
 786                                            dev->name, inw(ioaddr + SCB_STATUS), inw(ioaddr + SCB_CMD));
 787                                 break;
 788                         }
 789                 /* Issue channel-attn -- the 82586 won't start without it. */
 790                 outb(0, ioaddr + SIGNAL_CA);
 791         }
 792 
 793         /* Disable loopback. */
 794         outb(inb(ioaddr + Config) & ~0x02, ioaddr + Config);
 795         if (net_debug > 4)
 796                 printk("%s: Initialized 82586, status %04x.\n", dev->name,
 797                            inw(ioaddr + SCB_STATUS));
 798         return;
 799 }
 800 
 801 /* Initialize the Rx-block list. */
 802 static void init_rx_bufs(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 803 {
 804         struct net_local *lp = (struct net_local *)dev->priv;
 805         short ioaddr = dev->base_addr;
 806 
 807         int cur_rxbuf = lp->rx_head = RX_BUF_START;
 808         
 809         /* Initialize each Rx frame + data buffer. */
 810         do {    /* While there is room for one more. */
 811                 outw(cur_rxbuf, ioaddr + WRITE_PTR);
 812                 outw(0x0000, ioaddr);                           /* Status */
 813                 outw(0x0000, ioaddr);                           /* Command */
 814                 outw(cur_rxbuf + RX_BUF_SIZE, ioaddr); /* Link */
 815                 outw(cur_rxbuf + 22, ioaddr);           /* Buffer offset */
 816                 outw(0xFeed, ioaddr);                           /* Pad for dest addr. */
 817                 outw(0xF00d, ioaddr);
 818                 outw(0xF001, ioaddr);
 819                 outw(0x0505, ioaddr);                           /* Pad for source addr. */
 820                 outw(0x2424, ioaddr);
 821                 outw(0x6565, ioaddr);
 822                 outw(0xdeaf, ioaddr);                           /* Pad for protocol. */
 823 
 824                 outw(0x0000, ioaddr);                           /* Buffer: Actual count */
 825                 outw(-1, ioaddr);                                       /* Buffer: Next (none). */
 826                 outw(cur_rxbuf + 0x20, ioaddr);         /* Buffer: Address low */
 827                 outw(0x0000, ioaddr);
 828                 /* Finally, the number of bytes in the buffer. */
 829                 outw(0x8000 + RX_BUF_SIZE-0x20, ioaddr);
 830                 
 831                 lp->rx_tail = cur_rxbuf;
 832                 cur_rxbuf += RX_BUF_SIZE;
 833         } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
 834         
 835         /* Terminate the list by setting the EOL bit, and wrap the pointer to make
 836            the list a ring. */
 837         outw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
 838         outw(0xC000, ioaddr);                                   /* Command, mark as last. */
 839         outw(lp->rx_head, ioaddr);                              /* Link */
 840 }
 841 
 842 static void
 843 hardware_send_packet(struct device *dev, void *buf, short length)
     /* [previous][next][first][last][top][bottom][index][help] */
 844 {
 845         struct net_local *lp = (struct net_local *)dev->priv;
 846         short ioaddr = dev->base_addr;
 847         short tx_block = lp->tx_head;
 848 
 849         /* Set the write pointer to the Tx block, and put out the header. */
 850         outw(tx_block, ioaddr + WRITE_PTR);
 851         outw(0x0000, ioaddr);           /* Tx status */
 852         outw(CMD_INTR|CmdTx, ioaddr);           /* Tx command */
 853         outw(tx_block+16, ioaddr);      /* Next command is a NoOp. */
 854         outw(tx_block+8, ioaddr);       /* Data Buffer offset. */
 855 
 856         /* Output the data buffer descriptor. */
 857         outw(length | 0x8000, ioaddr); /* Byte count parameter. */
 858         outw(-1, ioaddr);                       /* No next data buffer. */
 859         outw(tx_block+22, ioaddr);      /* Buffer follows the NoOp command. */
 860         outw(0x0000, ioaddr);           /* Buffer address high bits (always zero). */
 861 
 862         /* Output the Loop-back NoOp command. */
 863         outw(0x0000, ioaddr);           /* Tx status */
 864         outw(CmdNOp, ioaddr);           /* Tx command */
 865         outw(tx_block+16, ioaddr);      /* Next is myself. */
 866 
 867         /* Output the packet using the write pointer.
 868            Hmmm, it feels a little like a 3c501! */
 869         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
 870 
 871         /* Set the old command link pointing to this send packet. */
 872         outw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
 873         outw(tx_block, ioaddr);
 874         lp->tx_cmd_link = tx_block + 20;
 875 
 876         /* Set the next free tx region. */
 877         lp->tx_head = tx_block + TX_BUF_SIZE;
 878         if (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
 879                 lp->tx_head = TX_BUF_START;
 880 
 881     if (net_debug > 4) {
 882                 printk("%s: EExp @%x send length = %d, tx_block %3x, next %3x, "
 883                            "reap %4x status %4.4x.\n", dev->name, ioaddr, length,
 884                            tx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
 885     }
 886 
 887         if (lp->tx_head != lp->tx_reap)
 888                 dev->tbusy = 0;
 889 }
 890 
 891 static void
 892 eexp_rx(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 893 {
 894         struct net_local *lp = (struct net_local *)dev->priv;
 895         short ioaddr = dev->base_addr;
 896         short saved_write_ptr = inw(ioaddr + WRITE_PTR);
 897         short rx_head = lp->rx_head;
 898         short rx_tail = lp->rx_tail;
 899         short boguscount = 10;
 900         short frame_status;
 901 
 902         /* Set the read pointer to the Rx frame. */
 903         outw(rx_head, ioaddr + READ_PTR);
 904         while ((frame_status = inw(ioaddr)) < 0) {              /* Command complete */
 905                 short rfd_cmd = inw(ioaddr);
 906                 short next_rx_frame = inw(ioaddr);
 907                 short data_buffer_addr = inw(ioaddr);
 908                 short pkt_len;
 909                 
 910                 /* Set the read pointer the data buffer. */
 911                 outw(data_buffer_addr, ioaddr + READ_PTR);
 912                 pkt_len = inw(ioaddr);
 913 
 914                 if (rfd_cmd != 0  ||  data_buffer_addr != rx_head + 22
 915                         ||  (pkt_len & 0xC000) != 0xC000) {
 916                         printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
 917                                    "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
 918                                    frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
 919                                    pkt_len);
 920                 } else if ((frame_status & 0x2000) == 0) {
 921                         /* Frame Rxed, but with error. */
 922                         lp->stats.rx_errors++;
 923                         if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
 924                         if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
 925                         if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
 926                         if (frame_status & 0x0100) lp->stats.rx_over_errors++;
 927                         if (frame_status & 0x0080) lp->stats.rx_length_errors++;
 928                 } else {
 929                         /* Malloc up new buffer. */
 930                         struct sk_buff *skb;
 931 
 932                         pkt_len &= 0x3fff;
 933                         skb = dev_alloc_skb(pkt_len+2);
 934                         if (skb == NULL) {
 935                                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 936                                 lp->stats.rx_dropped++;
 937                                 break;
 938                         }
 939                         skb->dev = dev;
 940                         skb_reserve(skb,2);
 941 
 942                         outw(data_buffer_addr + 10, ioaddr + READ_PTR);
 943 
 944                         insw(ioaddr, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
 945                 
 946                         skb->protocol=eth_type_trans(skb,dev);
 947                         netif_rx(skb);
 948                         lp->stats.rx_packets++;
 949                 }
 950 
 951                 /* Clear the status word and set End-of-List on the rx frame. */
 952                 outw(rx_head, ioaddr + WRITE_PTR);
 953                 outw(0x0000, ioaddr);
 954                 outw(0xC000, ioaddr);
 955 #ifndef final_version
 956                 if (next_rx_frame != rx_head + RX_BUF_SIZE
 957                         && next_rx_frame != RX_BUF_START) {
 958                         printk("%s: Rx next frame at %#x is %#x instead of %#x.\n", dev->name,
 959                                    rx_head, next_rx_frame, rx_head + RX_BUF_SIZE);
 960                         next_rx_frame = rx_head + RX_BUF_SIZE;
 961                         if (next_rx_frame >= RX_BUF_END - RX_BUF_SIZE)
 962                                 next_rx_frame = RX_BUF_START;
 963                 }
 964 #endif
 965                 outw(rx_tail+2, ioaddr + WRITE_PTR);
 966                 outw(0x0000, ioaddr);   /* Clear the end-of-list on the prev. RFD. */
 967 
 968 #ifndef final_version
 969                 outw(rx_tail+4, ioaddr + READ_PTR);
 970                 if (inw(ioaddr) != rx_head) {
 971                         printk("%s: Rx buf link mismatch, at %04x link %04x instead of %04x.\n",
 972                                    dev->name, rx_tail, (outw(rx_tail+4, ioaddr + READ_PTR),inw(ioaddr)),
 973                                    rx_head);
 974                         outw(rx_head, ioaddr);
 975                 }
 976 #endif
 977 
 978                 rx_tail = rx_head;
 979                 rx_head = next_rx_frame;
 980                 if (--boguscount == 0)
 981                         break;
 982                 outw(rx_head, ioaddr + READ_PTR);
 983         }
 984         
 985         lp->rx_head = rx_head;
 986         lp->rx_tail = rx_tail;
 987         
 988         /* Restore the original write pointer. */
 989         outw(saved_write_ptr, ioaddr + WRITE_PTR);
 990 }
 991 
 992 #ifdef MODULE
 993 static char devicename[9] = { 0, };
 994 static struct device dev_eexpress = {
 995         devicename, /* device name is inserted by linux/drivers/net/net_init.c */
 996         0, 0, 0, 0,
 997         0, 0,
 998         0, 0, 0, NULL, express_probe };
 999         
1000 
1001 static int irq=0x300;
1002 static int io=0;        
1003 
1004 int
1005 init_module(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1006 {
1007         if (io == 0)
1008                 printk("eexpress: You should not use auto-probing with insmod!\n");
1009         dev_eexpress.base_addr=io;
1010         dev_eexpress.irq=irq;
1011         if (register_netdev(&dev_eexpress) != 0)
1012                 return -EIO;
1013         return 0;
1014 }
1015 
1016 void
1017 cleanup_module(void)
     /* [previous][next][first][last][top][bottom][index][help] */
1018 {
1019         unregister_netdev(&dev_eexpress);
1020         kfree_s(dev_eexpress.priv,sizeof(struct net_local));
1021         dev_eexpress.priv=NULL;
1022 
1023         /* If we don't do this, we can't re-insmod it later. */
1024         release_region(dev_eexpress.base_addr, EEXPRESS_IO_EXTENT);
1025 }
1026 #endif /* MODULE */
1027 /*
1028  * Local variables:
1029  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -I/usr/src/linux/drivers/net -Wall -Wstrict-prototypes -O6 -m486 -c eexpress.c"
1030  *  version-control: t
1031  *  kept-new-versions: 5
1032  *  tab-width: 4
1033  * End:
1034  */

/* [previous][next][first][last][top][bottom][index][help] */