drivers/net/lance.c

/* */
This source file includes following definitions.
lance_init
lance_probe1
lance_open
lance_init_ring
lance_start_xmit
lance_interrupt
lance_rx
lance_close
lance_get_stats
set_multicast_list
   1 /* lance.c: An AMD LANCE ethernet driver for linux. */
   2 /*
   3     Written 1993 by Donald Becker.
   4 
   5     Copyright 1993 United States Government as represented by the
   6     Director, National Security Agency.  This software may be used and
   7     distributed according to the terms of the GNU Public License,
   8     incorporated herein by reference.
   9 
  10     This driver is for the Allied Telesis AT1500 and HP J2405A, and should work
  11     with most other LANCE-based bus-master (NE2100 clone) ethercards.
  12 
  13     The author may be reached as becker@super.org or
  14     C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
  15 */
  16 
  17 static char *version = "lance.c:v0.14g 12/21/93 becker@super.org\n";
  18 
  19 #include <linux/config.h>
  20 #include <linux/kernel.h>
  21 #include <linux/sched.h>
  22 #include <linux/string.h>
  23 #include <linux/ptrace.h>
  24 #include <linux/errno.h>
  25 #include <linux/ioport.h>
  26 #include <linux/malloc.h>
  27 #include <linux/interrupt.h>
  28 #include <asm/bitops.h>
  29 #include <asm/io.h>
  30 #include <asm/dma.h>
  31 
  32 #include "dev.h"
  33 #include "eth.h"
  34 #include "skbuff.h"
  35 #include "arp.h"
  36 
  37 #ifndef HAVE_PORTRESERVE
  38 #define check_region(addr, size)        0
  39 #define snarf_region(addr, size)        do ; while(0)
  40 #endif
  41 
  42 #ifndef HAVE_ALLOC_SKB
  43 #define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
  44 #define kfree_skbmem(buff, size) kfree_s(buff,size)
  45 #endif
  46 
  47 struct device *init_etherdev(struct device *dev, int sizeof_private,
  48                              unsigned long *mem_startp);
  49 
  50 #ifdef LANCE_DEBUG
  51 int lance_debug = LANCE_DEBUG;
  52 #else
  53 int lance_debug = 1;
  54 #endif
  55 
  56 #ifndef LANCE_DMA
  57 #define LANCE_DMA       5
  58 #endif
  59 
  60 /*
  61                 Theory of Operation
  62 
  63 I. Board Compatibility
  64 
  65 This device driver is designed for the AMD 79C960, the "PCnet-ISA
  66 single-chip ethernet controller for ISA".  This chip is used in a wide
  67 variety of boards from vendors such as Allied Telesis, HP, Kingston,
  68 and Boca.  This driver is also intended to work with older AMD 7990
  69 designs, such as the NE1500 and NE2100.  For convenience, I use the name
  70 LANCE to refer to either AMD chip.
  71 
  72 II. Board-specific settings
  73 
  74 The driver is designed to work the boards that use the faster
  75 bus-master mode, rather than in shared memory mode.  (Only older designs
  76 have on-board buffer memory needed to support the slower shared memory mode.)
  77 
  78 Most boards have jumpered settings for the I/O base, IRQ line, and DMA channel.
  79 This driver probes the likely base addresses, {0x300, 0x320, 0x340, 0x360}.
  80 After the board is found it generates an DMA-timeout interrupt and uses
  81 autoIRQ to find the IRQ line.  The DMA channel defaults to LANCE_DMA, or it
  82 can be set with the low bits of the otherwise-unused dev->mem_start value.
  83 
  84 The HP-J2405A board is an exception: with this board it's easy to read the
  85 EEPROM-set values for the base, IRQ, and DMA.  Of course you must already
  86 _know_ the base address, but that entry is for changing the EEPROM.
  87 
  88 III. Driver operation
  89 
  90 IIIa. Ring buffers
  91 The LANCE uses ring buffers of Tx and Rx descriptors.  Each entry describes
  92 the base and length of the data buffer, along with status bits.  The length
  93 of these buffers is set by LANCE_LOG_{RX,TX}_BUFFERS, which is log_2() of
  94 the buffer length (rather than being directly the buffer length) for
  95 implementation ease.  The current values are 2 (Tx) and 4 (Rx), which leads to
  96 ring sizes of 4 (Tx) and 16 (Rx).  Increasing the number of ring entries
  97 needlessly uses extra space and reduces the chance that an upper layer will
  98 be able to reorder queued Tx packets based on priority.  Decreasing the number
  99 of entries makes it more difficult to achieve back-to-back packet transmission
 100 and increases the chance that Rx ring will overflow.  (Consider the worst case
 101 of receiving back-to-back minimum-sized packets.)
 102 
 103 The LANCE has the capability to "chain" both Rx and Tx buffers, but this driver
 104 statically allocates full-sized (slightly oversized -- PKT_BUF_SZ) buffers to
 105 avoid the administrative overhead. For the Rx side this avoids dynamically
 106 allocating full-sized buffers "just in case", at the expense of a
 107 memory-to-memory data copy for each packet received.  For most systems this
 108 is an good tradeoff: the Rx buffer will always be in low memory, the copy
 109 is inexpensive, and it primes the cache for later packet processing.  For Tx
 110 the buffers are only used when needed as low-memory bounce buffers.
 111 
 112 IIIB. 16M memory limitations.
 113 For the ISA bus master mode all structures used directly by the LANCE,
 114 the initialization block, Rx and Tx rings, and data buffers, must be
 115 accessable from the ISA bus, i.e. in the lower 16M of real memory.
 116 This is a problem for current Linux kernels on >16M machines. The network
 117 devices are initialized after memory initialization, and the kernel doles out
 118 memory from the top of memory downward.  The current solution is to have a
 119 special network initialization routine that's called before memory
 120 initialization; this will eventually be generalized for all network devices.
 121 As mentioned before, low-memory "bounce-buffers" are used when needed.
 122 
 123 IIIC. Synchronization
 124 The driver runs as two independent, single-threaded flows of control.  One
 125 is the send-packet routine, which enforces single-threaded use by the
 126 dev->tbusy flag.  The other thread is the interrupt handler, which is single
 127 threaded by the hardware and other software.
 128 
 129 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
 130 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
 131 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
 132 the 'lp->tx_full' flag.
 133 
 134 The interrupt handler has exclusive control over the Rx ring and records stats
 135 from the Tx ring.  (The Tx-done interrupt can't be selectively turned off, so
 136 we can't avoid the interrupt overhead by having the Tx routine reap the Tx
 137 stats.)  After reaping the stats, it marks the queue entry as empty by setting
 138 the 'base' to zero.  Iff the 'lp->tx_full' flag is set, it clears both the
 139 tx_full and tbusy flags.
 140 
 141 */
 142 
 143 /* Set the number of Tx and Rx buffers, using Log_2(# buffers).
 144    Reasonable default values are 4 Tx buffers, and 16 Rx buffers.
 145    That translates to 2 (4 == 2^^2) and 4 (16 == 2^^4). */
 146 #ifndef LANCE_LOG_TX_BUFFERS
 147 #define LANCE_LOG_TX_BUFFERS 4
 148 #define LANCE_LOG_RX_BUFFERS 4
 149 #endif
 150 
 151 #define TX_RING_SIZE            (1 << (LANCE_LOG_TX_BUFFERS))
 152 #define TX_RING_MOD_MASK        (TX_RING_SIZE - 1)
 153 #define TX_RING_LEN_BITS        ((LANCE_LOG_TX_BUFFERS) << 29)
 154 
 155 #define RX_RING_SIZE            (1 << (LANCE_LOG_RX_BUFFERS))
 156 #define RX_RING_MOD_MASK        (RX_RING_SIZE - 1)
 157 #define RX_RING_LEN_BITS        ((LANCE_LOG_RX_BUFFERS) << 29)
 158 
 159 #define PKT_BUF_SZ      1544
 160 
 161 /* Offsets from base I/O address. */
 162 #define LANCE_DATA 0x10
 163 #define LANCE_ADDR 0x12
 164 #define LANCE_RESET 0x14
 165 #define LANCE_BUS_IF 0x16
 166 #define LANCE_TOTAL_SIZE 0x18
 167 
 168 /* The LANCE Rx and Tx ring descriptors. */
 169 struct lance_rx_head {
 170     int base;
 171     short buf_length;           /* This length is 2's complement (negative)! */
 172     short msg_length;           /* This length is "normal". */
 173 };
 174 
 175 struct lance_tx_head {
 176     int   base;
 177     short length;               /* Length is 2's complement (negative)! */
 178     short misc;
 179 };
 180 
 181 /* The LANCE initialization block, described in databook. */
 182 struct lance_init_block {
 183     unsigned short mode;        /* Pre-set mode (reg. 15) */
 184     unsigned char phys_addr[6]; /* Physical ethernet address */
 185     unsigned filter[2];         /* Multicast filter (unused). */
 186     /* Receive and transmit ring base, along with extra bits. */
 187     unsigned rx_ring;           /* Tx and Rx ring base pointers */
 188     unsigned tx_ring;
 189 };
 190 
 191 struct lance_private {
 192     char devname[8];
 193     /* These must aligned on 8-byte boundaries. */
 194     struct lance_rx_head rx_ring[RX_RING_SIZE];
 195     struct lance_tx_head tx_ring[TX_RING_SIZE];
 196     struct lance_init_block     init_block;
 197     long rx_buffs;              /* Address of Rx and Tx buffers. */
 198     /* Tx low-memory "bounce buffer" address. */
 199     char (*tx_bounce_buffs)[PKT_BUF_SZ];
 200     int cur_rx, cur_tx;         /* The next free ring entry */
 201     int dirty_rx, dirty_tx;     /* The ring entries to be free()ed. */
 202     int dma;
 203     struct enet_statistics stats;
 204     char old_lance;
 205     int pad0, pad1;             /* Used for alignment */
 206 };
 207 
 208 unsigned long lance_probe1(short ioaddr, unsigned long mem_start);
 209 static int lance_open(struct device *dev);
 210 static void lance_init_ring(struct device *dev);
 211 static int lance_start_xmit(struct sk_buff *skb, struct device *dev);
 212 static int lance_rx(struct device *dev);
 213 static void lance_interrupt(int reg_ptr);
 214 static int lance_close(struct device *dev);
 215 static struct enet_statistics *lance_get_stats(struct device *dev);
 216 #ifdef HAVE_MULTICAST
 217 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 218 #endif
 219 
 220 
 221 
 222 unsigned long lance_init(unsigned long mem_start, unsigned long mem_end)
     /*  */
 223 {
 224     int *port, ports[] = {0x300, 0x320, 0x340, 0x360, 0};
 225 
 226     for (port = &ports[0]; *port; port++) {
 227         int ioaddr = *port;
 228 
 229         if (   check_region(ioaddr, LANCE_TOTAL_SIZE) == 0
 230             && inb(ioaddr + 14) == 0x57
 231             && inb(ioaddr + 15) == 0x57) {
 232             mem_start = lance_probe1(ioaddr, mem_start);
 233         }
 234     }
 235 
 236     return mem_start;
 237 }
 238 
 239 unsigned long lance_probe1(short ioaddr, unsigned long mem_start)
     /*  */
 240 {
 241     struct device *dev;
 242     struct lance_private *lp;
 243     int hpJ2405A = 0;
 244     int i, reset_val;
 245 
 246     hpJ2405A = (inb(ioaddr) == 0x08 && inb(ioaddr+1) == 0x00
 247                 && inb(ioaddr+2) == 0x09);
 248 
 249     /* Reset the LANCE.  */
 250     reset_val = inw(ioaddr+LANCE_RESET); /* Reset the LANCE */
 251 
 252     /* The Un-Reset needed is only needed for the real NE2100, and will
 253        confuse the HP board. */
 254     if (!hpJ2405A)
 255         outw(reset_val, ioaddr+LANCE_RESET);
 256 
 257     outw(0x0000, ioaddr+LANCE_ADDR); /* Switch to window 0 */
 258     if (inw(ioaddr+LANCE_DATA) != 0x0004)
 259         return mem_start;
 260 
 261     dev = init_etherdev(0, sizeof(struct lance_private)
 262                         + PKT_BUF_SZ*(RX_RING_SIZE + TX_RING_SIZE),
 263                         &mem_start);
 264 
 265     printk("%s: LANCE at %#3x,", dev->name, ioaddr);
 266 
 267     /* There is a 16 byte station address PROM at the base address.
 268        The first six bytes are the station address. */
 269     for (i = 0; i < 6; i++)
 270         printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
 271 
 272     dev->base_addr = ioaddr;
 273     snarf_region(ioaddr, LANCE_TOTAL_SIZE);
 274 
 275     /* Make certain the data structures used by the LANCE are aligned. */
 276     dev->priv = (void *)(((int)dev->priv + 7) & ~7);
 277     lp = (struct lance_private *)dev->priv;
 278     lp->rx_buffs = (long)dev->priv + sizeof(struct lance_private);
 279     lp->tx_bounce_buffs = (char (*)[PKT_BUF_SZ])
 280                            (lp->rx_buffs + PKT_BUF_SZ*RX_RING_SIZE);
 281 
 282 #ifndef final_version
 283     /* This should never happen. */
 284     if ((int)(lp->rx_ring) & 0x07) {
 285         printk(" **ERROR** LANCE Rx and Tx rings not on even boundary.\n");
 286         return mem_start;
 287     }
 288 #endif
 289 
 290     outw(88, ioaddr+LANCE_ADDR);
 291     lp->old_lance = (inw(ioaddr+LANCE_DATA) != 0x3003);
 292 
 293 #if defined(notdef)
 294     printk(lp->old_lance ? " original LANCE (%04x)" : " PCnet-ISA LANCE (%04x)",
 295            inw(ioaddr+LANCE_DATA));
 296 #endif
 297 
 298     lp->init_block.mode = 0x0003;       /* Disable Rx and Tx. */
 299     for (i = 0; i < 6; i++)
 300         lp->init_block.phys_addr[i] = dev->dev_addr[i];
 301     lp->init_block.filter[0] = 0x00000000;
 302     lp->init_block.filter[1] = 0x00000000;
 303     lp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
 304     lp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
 305 
 306     outw(0x0001, ioaddr+LANCE_ADDR);
 307     outw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
 308     outw(0x0002, ioaddr+LANCE_ADDR);
 309     outw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
 310     outw(0x0000, ioaddr+LANCE_ADDR);
 311 
 312     if (hpJ2405A) {
 313         char dma_tbl[4] = {3, 5, 6, 7};
 314         char irq_tbl[8] = {3, 4, 5, 9, 10, 11, 12, 15};
 315         short reset_val = inw(ioaddr+LANCE_RESET);
 316         dev->dma = dma_tbl[(reset_val >> 2) & 3];
 317         dev->irq = irq_tbl[(reset_val >> 4) & 7];
 318         printk(" HP J2405A IRQ %d DMA %d.\n", dev->irq, dev->dma);
 319     } else {
 320         /* The DMA channel may be passed in on this parameter. */
 321         if (dev->mem_start & 0x07)
 322             dev->dma = dev->mem_start & 0x07;
 323         else if (dev->dma == 0)
 324             dev->dma = LANCE_DMA;
 325 
 326         /* To auto-IRQ we enable the initialization-done and DMA err,
 327            interrupts. For now we will always get a DMA error. */
 328         if (dev->irq < 2) {
 329 
 330             autoirq_setup(0);
 331 
 332             /* Trigger an initialization just for the interrupt. */
 333             outw(0x0041, ioaddr+LANCE_DATA);
 334 
 335             dev->irq = autoirq_report(1);
 336             if (dev->irq)
 337                 printk(", probed IRQ %d, fixed at DMA %d.\n",
 338                        dev->irq, dev->dma);
 339             else {
 340                 printk(", failed to detect IRQ line.\n");
 341                 return mem_start;
 342             }
 343         } else
 344             printk(" assigned IRQ %d DMA %d.\n", dev->irq, dev->dma);
 345     }
 346 
 347     if (! lp->old_lance) {
 348         /* Turn on auto-select of media (10baseT or BNC) so that the user
 349            can watch the LEDs even if the board isn't opened. */
 350         outw(0x0002, ioaddr+LANCE_ADDR);
 351         outw(0x0002, ioaddr+LANCE_BUS_IF);
 352     }
 353 
 354     if (lance_debug > 0)
 355         printk(version);
 356 
 357     /* The LANCE-specific entries in the device structure. */
 358     dev->open = &lance_open;
 359     dev->hard_start_xmit = &lance_start_xmit;
 360     dev->stop = &lance_close;
 361     dev->get_stats = &lance_get_stats;
 362 #ifdef HAVE_MULTICAST
 363     dev->set_multicast_list = &set_multicast_list;
 364 #endif
 365 
 366     return mem_start;
 367 }
 368 
 369 
 370 static int
 371 lance_open(struct device *dev)
     /*  */
 372 {
 373     struct lance_private *lp = (struct lance_private *)dev->priv;
 374     int ioaddr = dev->base_addr;
 375     int i;
 376 
 377     if (request_irq(dev->irq, &lance_interrupt)) {
 378         return -EAGAIN;
 379     }
 380 
 381     if (request_dma(dev->dma)) {
 382         free_irq(dev->irq);
 383         return -EAGAIN;
 384     }
 385     irq2dev_map[dev->irq] = dev;
 386 
 387     /* Reset the LANCE */
 388     inw(ioaddr+LANCE_RESET);
 389 
 390     /* The DMA controller is used as a no-operation slave, "cascade mode". */
 391     enable_dma(dev->dma);
 392     set_dma_mode(dev->dma, DMA_MODE_CASCADE);
 393 
 394     /* Un-Reset the LANCE, needed only for the NE2100. */
 395     if (lp->old_lance)
 396         outw(0, ioaddr+LANCE_RESET);
 397 
 398     if (! lp->old_lance) {
 399         /* This is 79C960-specific: Turn on auto-select of media (AUI, BNC). */
 400         outw(0x0002, ioaddr+LANCE_ADDR);
 401         outw(0x0002, ioaddr+LANCE_BUS_IF);
 402     }
 403 
 404     if (lance_debug > 1)
 405         printk("%s: lance_open() irq %d dma %d tx/rx rings %#x/%#x init %#x.\n",
 406                dev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
 407                (int) &lp->init_block);
 408 
 409     lance_init_ring(dev);
 410     /* Re-initialize the LANCE, and start it when done. */
 411     outw(0x0001, ioaddr+LANCE_ADDR);
 412     outw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
 413     outw(0x0002, ioaddr+LANCE_ADDR);
 414     outw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
 415 
 416     outw(0x0004, ioaddr+LANCE_ADDR);
 417     outw(0x0d15, ioaddr+LANCE_DATA);
 418 
 419     outw(0x0000, ioaddr+LANCE_ADDR);
 420     outw(0x0001, ioaddr+LANCE_DATA);
 421 
 422     dev->tbusy = 0;
 423     dev->interrupt = 0;
 424     dev->start = 1;
 425     i = 0;
 426     while (i++ < 100)
 427         if (inw(ioaddr+LANCE_DATA) & 0x0100)
 428             break;
 429     outw(0x0142, ioaddr+LANCE_DATA);
 430 
 431     if (lance_debug > 2)
 432         printk("%s: LANCE open after %d ticks, init block %#x csr0 %4.4x.\n",
 433                dev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
 434 
 435     return 0;                   /* Always succeed */
 436 }
 437 
 438 /* Initialize the LANCE Rx and Tx rings. */
 439 static void
 440 lance_init_ring(struct device *dev)
     /*  */
 441 {
 442     struct lance_private *lp = (struct lance_private *)dev->priv;
 443     int i;
 444 
 445     lp->cur_rx = lp->cur_tx = 0;
 446     lp->dirty_rx = lp->dirty_tx = 0;
 447 
 448     for (i = 0; i < RX_RING_SIZE; i++) {
 449         lp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
 450         lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
 451     }
 452     /* The Tx buffer address is filled in as needed, but we do need to clear
 453        the upper ownership bit. */
 454     for (i = 0; i < TX_RING_SIZE; i++) {
 455         lp->tx_ring[i].base = 0;
 456     }
 457 
 458     lp->init_block.mode = 0x0000;
 459     for (i = 0; i < 6; i++)
 460         lp->init_block.phys_addr[i] = dev->dev_addr[i];
 461     lp->init_block.filter[0] = 0x00000000;
 462     lp->init_block.filter[1] = 0x00000000;
 463     lp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
 464     lp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
 465 }
 466 
 467 static int
 468 lance_start_xmit(struct sk_buff *skb, struct device *dev)
     /*  */
 469 {
 470     struct lance_private *lp = (struct lance_private *)dev->priv;
 471     int ioaddr = dev->base_addr;
 472     int entry;
 473 
 474     /* Transmitter timeout, serious problems. */
 475     if (dev->tbusy) {
 476         int tickssofar = jiffies - dev->trans_start;
 477         if (tickssofar < 10)
 478             return 1;
 479         outw(0, ioaddr+LANCE_ADDR);
 480         printk("%s: transmit timed out, status %4.4x, resetting.\n",
 481                dev->name, inw(ioaddr+LANCE_DATA));
 482         outw(0x0001, ioaddr+LANCE_DATA);
 483         lp->stats.tx_errors++;
 484 #ifndef final_version
 485         {
 486             int i;
 487             printk(" Ring data dump: dirty_tx %d cur_tx %d cur_rx %d.",
 488                    lp->dirty_tx, lp->cur_tx, lp->cur_rx);
 489             for (i = 0 ; i < RX_RING_SIZE; i++)
 490                 printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
 491                        lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
 492                        lp->rx_ring[i].msg_length);
 493             for (i = 0 ; i < TX_RING_SIZE; i++)
 494                 printk(" %s%08x %04x %04x", i & 0x3 ? "" : "\n ",
 495                        lp->tx_ring[i].base, -lp->tx_ring[i].length,
 496                        lp->tx_ring[i].misc);
 497             printk("\n");
 498         }
 499 #endif
 500         lance_init_ring(dev);
 501         outw(0x0043, ioaddr+LANCE_DATA);
 502 
 503         dev->tbusy=0;
 504         dev->trans_start = jiffies;
 505 
 506         return 0;
 507     }
 508 
 509     if (skb == NULL) {
 510         dev_tint(dev);
 511         return 0;
 512     }
 513 
 514     /* Fill in the ethernet header. */
 515     if (!skb->arp  &&  dev->rebuild_header(skb->data, dev)) {
 516         skb->dev = dev;
 517         arp_queue (skb);
 518         return 0;
 519     }
 520     skb->arp=1;
 521 
 522     if (skb->len <= 0)
 523         return 0;
 524 
 525     if (lance_debug > 3) {
 526         outw(0x0000, ioaddr+LANCE_ADDR);
 527         printk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name,
 528                inw(ioaddr+LANCE_DATA));
 529         outw(0x0000, ioaddr+LANCE_DATA);
 530     }
 531 
 532     /* Block a timer-based transmit from overlapping.  This could better be
 533        done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 534     if (set_bit(0, (void*)&dev->tbusy) != 0)
 535         printk("%s: Transmitter access conflict.\n", dev->name);
 536 
 537     /* Fill in a Tx ring entry */
 538 
 539     /* Mask to ring buffer boundary. */
 540     entry = lp->cur_tx & TX_RING_MOD_MASK;
 541 
 542     /* Caution: the write order is important here, set the base address
 543        with the "ownership" bits last. */
 544 
 545     /* The old LANCE chips doesn't automatically pad buffers to min. size. */
 546     if (lp->old_lance) {
 547         lp->tx_ring[entry].length =
 548             -(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
 549     } else
 550         lp->tx_ring[entry].length = -skb->len;
 551 
 552     lp->tx_ring[entry].misc = 0x0000;
 553 
 554     /* If any part of this buffer is >16M we must copy it to a low-memory
 555        buffer. */
 556     if ((int)(skb->data) + skb->len > 0x01000000) {
 557         if (lance_debug > 5)
 558             printk("%s: bouncing a high-memory packet (%#x).\n",
 559                    dev->name, (int)(skb->data));
 560         memcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
 561         lp->tx_ring[entry].base =
 562             (int)(lp->tx_bounce_buffs + entry) | 0x83000000;
 563         if (skb->free)
 564             kfree_skb (skb, FREE_WRITE);
 565     } else {
 566         /* We can't free the packet yet, so we inform the memory management
 567            code that we are still using it. */
 568         if(skb->free==0)
 569                 skb_kept_by_device(skb);
 570         lp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
 571     }
 572     lp->cur_tx++;
 573 
 574     /* Trigger an immediate send poll. */
 575     outw(0x0000, ioaddr+LANCE_ADDR);
 576     outw(0x0048, ioaddr+LANCE_DATA);
 577 
 578     dev->trans_start = jiffies;
 579 
 580     if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
 581         dev->tbusy=0;
 582 
 583     return 0;
 584 }
 585 
 586 /* The LANCE interrupt handler. */
 587 static void
 588 lance_interrupt(int reg_ptr)
     /*  */
 589 {
 590     int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
 591     struct device *dev = (struct device *)(irq2dev_map[irq]);
 592     struct lance_private *lp;
 593     int csr0, ioaddr;
 594 
 595     if (dev == NULL) {
 596         printk ("lance_interrupt(): irq %d for unknown device.\n", irq);
 597         return;
 598     }
 599 
 600     ioaddr = dev->base_addr;
 601     lp = (struct lance_private *)dev->priv;
 602     if (dev->interrupt)
 603         printk("%s: Re-entering the interrupt handler.\n", dev->name);
 604 
 605     dev->interrupt = 1;
 606 
 607     outw(0x00, dev->base_addr + LANCE_ADDR);
 608     csr0 = inw(dev->base_addr + LANCE_DATA);
 609 
 610     /* Acknowledge all of the current interrupt sources ASAP. */
 611     outw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA);
 612 
 613     if (lance_debug > 5)
 614         printk("%s: interrupt  csr0=%#2.2x new csr=%#2.2x.\n",
 615                dev->name, csr0, inw(dev->base_addr + LANCE_DATA));
 616 
 617     if (csr0 & 0x0400)          /* Rx interrupt */
 618         lance_rx(dev);
 619 
 620     if (csr0 & 0x0200) {        /* Tx-done interrupt */
 621         int dirty_tx = lp->dirty_tx;
 622 
 623         while (dirty_tx < lp->cur_tx) {
 624             int entry = dirty_tx & TX_RING_MOD_MASK;
 625             int status = lp->tx_ring[entry].base;
 626             void *databuff;
 627             
 628             if (status < 0)
 629                 break;          /* It still hasn't been Txed */
 630 
 631             lp->tx_ring[entry].base = 0;
 632             databuff = (void*)(status & 0x00ffffff);
 633 
 634             if (status & 0x40000000) { /* There was an major error, log it. */
 635                 int err_status = lp->tx_ring[entry].misc;
 636                 lp->stats.tx_errors++;
 637                 if (err_status & 0x0400) lp->stats.tx_aborted_errors++;
 638                 if (err_status & 0x0800) lp->stats.tx_carrier_errors++;
 639                 if (err_status & 0x1000) lp->stats.tx_window_errors++;
 640                 if (err_status & 0x4000) lp->stats.tx_fifo_errors++;
 641                 /* Perhaps we should re-init() after the FIFO error. */
 642             } else {
 643                 if (status & 0x18000000)
 644                     lp->stats.collisions++;
 645                 lp->stats.tx_packets++;
 646             }
 647 
 648             /* We don't free the skb if it's a data-only copy in the bounce
 649                buffer.  The address checks here are sorted -- the first test
 650                should always work.  */
 651             if (databuff >= (void*)(&lp->tx_bounce_buffs[TX_RING_SIZE])
 652                 || databuff < (void*)(lp->tx_bounce_buffs)) {
 653                 struct sk_buff *skb = ((struct sk_buff *)databuff) - 1;
 654                 if (skb->free)
 655                     kfree_skb(skb, FREE_WRITE);
 656                 else
 657                     skb_device_release(skb,FREE_WRITE);
 658                 /* Warning: skb may well vanish at the point you call
 659                    device_release! */
 660             }
 661             dirty_tx++;
 662         }
 663 
 664 #ifndef final_version
 665         if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
 666             printk("out-of-sync dirty pointer, %d vs. %d.\n",
 667                    dirty_tx, lp->cur_tx);
 668             dirty_tx += TX_RING_SIZE;
 669         }
 670 #endif
 671 
 672         if (dev->tbusy  &&  dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
 673             /* The ring is no longer full, clear tbusy. */
 674             dev->tbusy = 0;
 675             mark_bh(INET_BH);
 676         }
 677 
 678         lp->dirty_tx = dirty_tx;
 679     }
 680 
 681     if (csr0 & 0x8000) {
 682         if (csr0 & 0x4000) lp->stats.tx_errors++;
 683         if (csr0 & 0x1000) lp->stats.rx_errors++;
 684     }
 685 
 686     /* Clear the interrupts we've handled. */
 687     outw(0x0000, dev->base_addr + LANCE_ADDR);
 688     outw(0x7f40, dev->base_addr + LANCE_DATA);
 689 
 690     if (lance_debug > 4)
 691         printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
 692                dev->name, inw(ioaddr + LANCE_ADDR),
 693                inw(dev->base_addr + LANCE_DATA));
 694 
 695     dev->interrupt = 0;
 696     return;
 697 }
 698 
 699 static int
 700 lance_rx(struct device *dev)
     /*  */
 701 {
 702     struct lance_private *lp = (struct lance_private *)dev->priv;
 703     int entry = lp->cur_rx & RX_RING_MOD_MASK;
 704         
 705     /* If we own the next entry, it's a new packet. Send it up. */
 706     while (lp->rx_ring[entry].base >= 0) {
 707         int status = lp->rx_ring[entry].base >> 24;
 708 
 709         if (status != 0x03) {           /* There was an error. */
 710             /* There is an tricky error noted by John Murphy,
 711                <murf@perftech.com> to Russ Nelson: Even with full-sized
 712                buffers it's possible for a jabber packet to use two
 713                buffers, with only the last correctly noting the error. */
 714             if (status & 0x01)  /* Only count a general error at the */
 715                 lp->stats.rx_errors++; /* end of a packet.*/
 716             if (status & 0x20) lp->stats.rx_frame_errors++;
 717             if (status & 0x10) lp->stats.rx_over_errors++;
 718             if (status & 0x08) lp->stats.rx_crc_errors++;
 719             if (status & 0x04) lp->stats.rx_fifo_errors++;
 720         } else {
 721             /* Malloc up new buffer, compatible with net-2e. */
 722             short pkt_len = lp->rx_ring[entry].msg_length;
 723             int sksize = sizeof(struct sk_buff) + pkt_len;
 724             struct sk_buff *skb;
 725 
 726             skb = alloc_skb(sksize, GFP_ATOMIC);
 727             if (skb == NULL) {
 728                 printk("%s: Memory squeeze, deferring packet.\n", dev->name);
 729                 lp->stats.rx_dropped++; /* Really, deferred. */
 730                 break;
 731             }
 732             skb->mem_len = sksize;
 733             skb->mem_addr = skb;
 734             skb->len = pkt_len;
 735             skb->dev = dev;
 736             memcpy(skb->data,
 737                    (unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
 738                    pkt_len);
 739 #ifdef HAVE_NETIF_RX
 740             netif_rx(skb);
 741 #else
 742             skb->lock = 0;
 743             if (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
 744                 kfree_skbmem(skb, sksize);
 745                 lp->stats.rx_dropped++;
 746                 break;
 747             }
 748 #endif
 749             lp->stats.rx_packets++;
 750         }
 751 
 752         lp->rx_ring[entry].base |= 0x80000000;
 753         entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
 754     }
 755 
 756     /* We should check that at least two ring entries are free.  If not,
 757        we should free one and mark stats->rx_dropped++. */
 758 
 759     return 0;
 760 }
 761 
 762 static int
 763 lance_close(struct device *dev)
     /*  */
 764 {
 765     int ioaddr = dev->base_addr;
 766     struct lance_private *lp = (struct lance_private *)dev->priv;
 767 
 768     dev->start = 0;
 769     dev->tbusy = 1;
 770 
 771     outw(112, ioaddr+LANCE_ADDR);
 772     lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
 773 
 774     outw(0, ioaddr+LANCE_ADDR);
 775 
 776     if (lance_debug > 1)
 777         printk("%s: Shutting down ethercard, status was %2.2x.\n",
 778                dev->name, inw(ioaddr+LANCE_DATA));
 779 
 780     /* We stop the LANCE here -- it occasionally polls
 781        memory if we don't. */
 782     outw(0x0004, ioaddr+LANCE_DATA);
 783 
 784     disable_dma(dev->dma);
 785 
 786     free_irq(dev->irq);
 787     free_dma(dev->dma);
 788 
 789     irq2dev_map[dev->irq] = 0;
 790 
 791     return 0;
 792 }
 793 
 794 static struct enet_statistics *
 795 lance_get_stats(struct device *dev)
     /*  */
 796 {
 797     struct lance_private *lp = (struct lance_private *)dev->priv;
 798     short ioaddr = dev->base_addr;
 799     short saved_addr;
 800 
 801     cli();
 802     saved_addr = inw(ioaddr+LANCE_ADDR);
 803     outw(112, ioaddr+LANCE_ADDR);
 804     lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
 805     outw(saved_addr, ioaddr+LANCE_ADDR);
 806     sti();
 807 
 808     return &lp->stats;
 809 }
 810 
 811 #ifdef HAVE_MULTICAST
 812 /* Set or clear the multicast filter for this adaptor.
 813    num_addrs == -1      Promiscuous mode, receive all packets
 814    num_addrs == 0       Normal mode, clear multicast list
 815    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 816                         best-effort filtering.
 817  */
 818 static void
 819 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
 820 {
 821     short ioaddr = dev->base_addr;
 822 
 823     /* We take the simple way out and always enable promiscuous mode. */
 824     outw(0, ioaddr+LANCE_ADDR);
 825     outw(0x0004, ioaddr+LANCE_DATA); /* Temporarily stop the lance.  */
 826 
 827     outw(15, ioaddr+LANCE_ADDR);
 828     if (num_addrs >= 0) {
 829         short multicast_table[4];
 830         int i;
 831         /* We don't use the multicast table, but rely on upper-layer filtering. */
 832         memset(multicast_table, (num_addrs == 0) ? 0 : -1, sizeof(multicast_table));
 833         for (i = 0; i < 4; i++) {
 834             outw(8 + i, ioaddr+LANCE_ADDR);
 835             outw(multicast_table[i], ioaddr+LANCE_DATA);
 836         }
 837         outw(0x0000, ioaddr+LANCE_DATA); /* Unset promiscuous mode */
 838     } else {
 839         outw(0x8000, ioaddr+LANCE_DATA); /* Set promiscuous mode */
 840     }
 841 
 842     outw(0, ioaddr+LANCE_ADDR);
 843     outw(0x0142, ioaddr+LANCE_DATA); /* Resume normal operation. */
 844 }
 845 #endif
 846 
 847 #ifdef HAVE_DEVLIST
 848 static unsigned int lance_portlist[] = {0x300, 0x320, 0x340, 0x360, 0};
 849 struct netdev_entry lance_drv =
 850 {"lance", lance_probe1, LANCE_TOTAL_SIZE, lance_portlist};
 851 #endif
 852 
 853 /*
 854  * Local variables:
 855  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c lance.c"
 856  * End:
 857  */
/* */
root/drivers/net/lance.c

DEFINITIONS
