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