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
el16_probe(int unit)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
el16_probe1(struct net_device * dev,int ioaddr)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(" %pM", dev->dev_addr);
408
409 if (mem_start)
410 net_debug = mem_start & 7;
411
412 #ifdef MEM_BASE
413 dev->mem_start = MEM_BASE;
414 dev->mem_end = dev->mem_start + 0x10000;
415 #else
416 {
417 int base;
418 int size;
419 char mem_config = inb(ioaddr + MEM_CONFIG);
420 if (mem_config & 0x20) {
421 size = 64*1024;
422 base = 0xf00000 + (mem_config & 0x08 ? 0x080000
423 : ((mem_config & 3) << 17));
424 } else {
425 size = ((mem_config & 3) + 1) << 14;
426 base = 0x0c0000 + ( (mem_config & 0x18) << 12);
427 }
428 dev->mem_start = base;
429 dev->mem_end = base + size;
430 }
431 #endif
432
433 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
434 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
435
436 printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
437 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
438
439 if (net_debug)
440 printk(version);
441
442 lp = netdev_priv(dev);
443 memset(lp, 0, sizeof(*lp));
444 spin_lock_init(&lp->lock);
445 lp->base = ioremap(dev->mem_start, RX_BUF_END);
446 if (!lp->base) {
447 printk(KERN_ERR "3c507: unable to remap memory\n");
448 retval = -EAGAIN;
449 goto out1;
450 }
451
452 dev->open = el16_open;
453 dev->stop = el16_close;
454 dev->hard_start_xmit = el16_send_packet;
455 dev->tx_timeout = el16_tx_timeout;
456 dev->watchdog_timeo = TX_TIMEOUT;
457 dev->ethtool_ops = &netdev_ethtool_ops;
458 dev->flags &= ~IFF_MULTICAST; /* Multicast doesn't work */
459 return 0;
460 out1:
461 free_irq(dev->irq, dev);
462 out:
463 release_region(ioaddr, EL16_IO_EXTENT);
464 return retval;
465 }
466
el16_open(struct net_device * dev)467 static int el16_open(struct net_device *dev)
468 {
469 /* Initialize the 82586 memory and start it. */
470 init_82586_mem(dev);
471
472 netif_start_queue(dev);
473 return 0;
474 }
475
476
el16_tx_timeout(struct net_device * dev)477 static void el16_tx_timeout (struct net_device *dev)
478 {
479 struct net_local *lp = netdev_priv(dev);
480 int ioaddr = dev->base_addr;
481 void __iomem *shmem = lp->base;
482
483 if (net_debug > 1)
484 printk ("%s: transmit timed out, %s? ", dev->name,
485 readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
486 "network cable problem");
487 /* Try to restart the adaptor. */
488 if (lp->last_restart == dev->stats.tx_packets) {
489 if (net_debug > 1)
490 printk ("Resetting board.\n");
491 /* Completely reset the adaptor. */
492 init_82586_mem (dev);
493 lp->tx_pkts_in_ring = 0;
494 } else {
495 /* Issue the channel attention signal and hope it "gets better". */
496 if (net_debug > 1)
497 printk ("Kicking board.\n");
498 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
499 outb (0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
500 lp->last_restart = dev->stats.tx_packets;
501 }
502 dev->trans_start = jiffies;
503 netif_wake_queue (dev);
504 }
505
506
el16_send_packet(struct sk_buff * skb,struct net_device * dev)507 static int el16_send_packet (struct sk_buff *skb, struct net_device *dev)
508 {
509 struct net_local *lp = netdev_priv(dev);
510 int ioaddr = dev->base_addr;
511 unsigned long flags;
512 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
513 unsigned char *buf = skb->data;
514
515 netif_stop_queue (dev);
516
517 spin_lock_irqsave (&lp->lock, flags);
518
519 dev->stats.tx_bytes += length;
520 /* Disable the 82586's input to the interrupt line. */
521 outb (0x80, ioaddr + MISC_CTRL);
522
523 hardware_send_packet (dev, buf, skb->len, length - skb->len);
524
525 dev->trans_start = jiffies;
526 /* Enable the 82586 interrupt input. */
527 outb (0x84, ioaddr + MISC_CTRL);
528
529 spin_unlock_irqrestore (&lp->lock, flags);
530
531 dev_kfree_skb (skb);
532
533 /* You might need to clean up and record Tx statistics here. */
534
535 return 0;
536 }
537
538 /* The typical workload of the driver:
539 Handle the network interface interrupts. */
el16_interrupt(int irq,void * dev_id)540 static irqreturn_t el16_interrupt(int irq, void *dev_id)
541 {
542 struct net_device *dev = dev_id;
543 struct net_local *lp;
544 int ioaddr, status, boguscount = 0;
545 ushort ack_cmd = 0;
546 void __iomem *shmem;
547
548 if (dev == NULL) {
549 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
550 return IRQ_NONE;
551 }
552
553 ioaddr = dev->base_addr;
554 lp = netdev_priv(dev);
555 shmem = lp->base;
556
557 spin_lock(&lp->lock);
558
559 status = readw(shmem+iSCB_STATUS);
560
561 if (net_debug > 4) {
562 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
563 }
564
565 /* Disable the 82586's input to the interrupt line. */
566 outb(0x80, ioaddr + MISC_CTRL);
567
568 /* Reap the Tx packet buffers. */
569 while (lp->tx_pkts_in_ring) {
570 unsigned short tx_status = readw(shmem+lp->tx_reap);
571 if (!(tx_status & 0x8000)) {
572 if (net_debug > 5)
573 printk("Tx command incomplete (%#x).\n", lp->tx_reap);
574 break;
575 }
576 /* Tx unsuccessful or some interesting status bit set. */
577 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
578 dev->stats.tx_errors++;
579 if (tx_status & 0x0600) dev->stats.tx_carrier_errors++;
580 if (tx_status & 0x0100) dev->stats.tx_fifo_errors++;
581 if (!(tx_status & 0x0040)) dev->stats.tx_heartbeat_errors++;
582 if (tx_status & 0x0020) dev->stats.tx_aborted_errors++;
583 dev->stats.collisions += tx_status & 0xf;
584 }
585 dev->stats.tx_packets++;
586 if (net_debug > 5)
587 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
588 lp->tx_reap += TX_BUF_SIZE;
589 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
590 lp->tx_reap = TX_BUF_START;
591
592 lp->tx_pkts_in_ring--;
593 /* There is always more space in the Tx ring buffer now. */
594 netif_wake_queue(dev);
595
596 if (++boguscount > 10)
597 break;
598 }
599
600 if (status & 0x4000) { /* Packet received. */
601 if (net_debug > 5)
602 printk("Received packet, rx_head %04x.\n", lp->rx_head);
603 el16_rx(dev);
604 }
605
606 /* Acknowledge the interrupt sources. */
607 ack_cmd = status & 0xf000;
608
609 if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
610 if (net_debug)
611 printk("%s: Command unit stopped, status %04x, restarting.\n",
612 dev->name, status);
613 /* If this ever occurs we should really re-write the idle loop, reset
614 the Tx list, and do a complete restart of the command unit.
615 For now we rely on the Tx timeout if the resume doesn't work. */
616 ack_cmd |= CUC_RESUME;
617 }
618
619 if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
620 /* The Rx unit is not ready, it must be hung. Restart the receiver by
621 initializing the rx buffers, and issuing an Rx start command. */
622 if (net_debug)
623 printk("%s: Rx unit stopped, status %04x, restarting.\n",
624 dev->name, status);
625 init_rx_bufs(dev);
626 writew(RX_BUF_START,shmem+iSCB_RFA);
627 ack_cmd |= RX_START;
628 }
629
630 writew(ack_cmd,shmem+iSCB_CMD);
631 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
632
633 /* Clear the latched interrupt. */
634 outb(0, ioaddr + RESET_IRQ);
635
636 /* Enable the 82586's interrupt input. */
637 outb(0x84, ioaddr + MISC_CTRL);
638 spin_unlock(&lp->lock);
639 return IRQ_HANDLED;
640 }
641
el16_close(struct net_device * dev)642 static int el16_close(struct net_device *dev)
643 {
644 struct net_local *lp = netdev_priv(dev);
645 int ioaddr = dev->base_addr;
646 void __iomem *shmem = lp->base;
647
648 netif_stop_queue(dev);
649
650 /* Flush the Tx and disable Rx. */
651 writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
652 outb(0, ioaddr + SIGNAL_CA);
653
654 /* Disable the 82586's input to the interrupt line. */
655 outb(0x80, ioaddr + MISC_CTRL);
656
657 /* We always physically use the IRQ line, so we don't do free_irq(). */
658
659 /* Update the statistics here. */
660
661 return 0;
662 }
663
664 /* Initialize the Rx-block list. */
init_rx_bufs(struct net_device * dev)665 static void init_rx_bufs(struct net_device *dev)
666 {
667 struct net_local *lp = netdev_priv(dev);
668 void __iomem *write_ptr;
669 unsigned short SCB_base = SCB_BASE;
670
671 int cur_rxbuf = lp->rx_head = RX_BUF_START;
672
673 /* Initialize each Rx frame + data buffer. */
674 do { /* While there is room for one more. */
675
676 write_ptr = lp->base + cur_rxbuf;
677
678 writew(0x0000,write_ptr); /* Status */
679 writew(0x0000,write_ptr+=2); /* Command */
680 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2); /* Link */
681 writew(cur_rxbuf + 22,write_ptr+=2); /* Buffer offset */
682 writew(0x0000,write_ptr+=2); /* Pad for dest addr. */
683 writew(0x0000,write_ptr+=2);
684 writew(0x0000,write_ptr+=2);
685 writew(0x0000,write_ptr+=2); /* Pad for source addr. */
686 writew(0x0000,write_ptr+=2);
687 writew(0x0000,write_ptr+=2);
688 writew(0x0000,write_ptr+=2); /* Pad for protocol. */
689
690 writew(0x0000,write_ptr+=2); /* Buffer: Actual count */
691 writew(-1,write_ptr+=2); /* Buffer: Next (none). */
692 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
693 writew(0x0000,write_ptr+=2);
694 /* Finally, the number of bytes in the buffer. */
695 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
696
697 lp->rx_tail = cur_rxbuf;
698 cur_rxbuf += RX_BUF_SIZE;
699 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
700
701 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
702 the list a ring. */
703 write_ptr = lp->base + lp->rx_tail + 2;
704 writew(0xC000,write_ptr); /* Command, mark as last. */
705 writew(lp->rx_head,write_ptr+2); /* Link */
706 }
707
init_82586_mem(struct net_device * dev)708 static void init_82586_mem(struct net_device *dev)
709 {
710 struct net_local *lp = netdev_priv(dev);
711 short ioaddr = dev->base_addr;
712 void __iomem *shmem = lp->base;
713
714 /* Enable loopback to protect the wire while starting up,
715 and hold the 586 in reset during the memory initialization. */
716 outb(0x20, ioaddr + MISC_CTRL);
717
718 /* Fix the ISCP address and base. */
719 init_words[3] = SCB_BASE;
720 init_words[7] = SCB_BASE;
721
722 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
723 memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
724
725 /* Write the words at 0x0000. */
726 memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
727
728 /* Fill in the station address. */
729 memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr,
730 sizeof(dev->dev_addr));
731
732 /* The Tx-block list is written as needed. We just set up the values. */
733 lp->tx_cmd_link = IDLELOOP + 4;
734 lp->tx_head = lp->tx_reap = TX_BUF_START;
735
736 init_rx_bufs(dev);
737
738 /* Start the 586 by releasing the reset line, but leave loopback. */
739 outb(0xA0, ioaddr + MISC_CTRL);
740
741 /* This was time consuming to track down: you need to give two channel
742 attention signals to reliably start up the i82586. */
743 outb(0, ioaddr + SIGNAL_CA);
744
745 {
746 int boguscnt = 50;
747 while (readw(shmem+iSCB_STATUS) == 0)
748 if (--boguscnt == 0) {
749 printk("%s: i82586 initialization timed out with status %04x, "
750 "cmd %04x.\n", dev->name,
751 readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
752 break;
753 }
754 /* Issue channel-attn -- the 82586 won't start. */
755 outb(0, ioaddr + SIGNAL_CA);
756 }
757
758 /* Disable loopback and enable interrupts. */
759 outb(0x84, ioaddr + MISC_CTRL);
760 if (net_debug > 4)
761 printk("%s: Initialized 82586, status %04x.\n", dev->name,
762 readw(shmem+iSCB_STATUS));
763 return;
764 }
765
hardware_send_packet(struct net_device * dev,void * buf,short length,short pad)766 static void hardware_send_packet(struct net_device *dev, void *buf, short length, short pad)
767 {
768 struct net_local *lp = netdev_priv(dev);
769 short ioaddr = dev->base_addr;
770 ushort tx_block = lp->tx_head;
771 void __iomem *write_ptr = lp->base + tx_block;
772 static char padding[ETH_ZLEN];
773
774 /* Set the write pointer to the Tx block, and put out the header. */
775 writew(0x0000,write_ptr); /* Tx status */
776 writew(CMD_INTR|CmdTx,write_ptr+=2); /* Tx command */
777 writew(tx_block+16,write_ptr+=2); /* Next command is a NoOp. */
778 writew(tx_block+8,write_ptr+=2); /* Data Buffer offset. */
779
780 /* Output the data buffer descriptor. */
781 writew((pad + length) | 0x8000,write_ptr+=2); /* Byte count parameter. */
782 writew(-1,write_ptr+=2); /* No next data buffer. */
783 writew(tx_block+22+SCB_BASE,write_ptr+=2); /* Buffer follows the NoOp command. */
784 writew(0x0000,write_ptr+=2); /* Buffer address high bits (always zero). */
785
786 /* Output the Loop-back NoOp command. */
787 writew(0x0000,write_ptr+=2); /* Tx status */
788 writew(CmdNOp,write_ptr+=2); /* Tx command */
789 writew(tx_block+16,write_ptr+=2); /* Next is myself. */
790
791 /* Output the packet at the write pointer. */
792 memcpy_toio(write_ptr+2, buf, length);
793 if (pad)
794 memcpy_toio(write_ptr+length+2, padding, pad);
795
796 /* Set the old command link pointing to this send packet. */
797 writew(tx_block,lp->base + lp->tx_cmd_link);
798 lp->tx_cmd_link = tx_block + 20;
799
800 /* Set the next free tx region. */
801 lp->tx_head = tx_block + TX_BUF_SIZE;
802 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
803 lp->tx_head = TX_BUF_START;
804
805 if (net_debug > 4) {
806 printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
807 dev->name, ioaddr, length, tx_block, lp->tx_head);
808 }
809
810 /* Grimly block further packets if there has been insufficient reaping. */
811 if (++lp->tx_pkts_in_ring < NUM_TX_BUFS)
812 netif_wake_queue(dev);
813 }
814
el16_rx(struct net_device * dev)815 static void el16_rx(struct net_device *dev)
816 {
817 struct net_local *lp = netdev_priv(dev);
818 void __iomem *shmem = lp->base;
819 ushort rx_head = lp->rx_head;
820 ushort rx_tail = lp->rx_tail;
821 ushort boguscount = 10;
822 short frame_status;
823
824 while ((frame_status = readw(shmem+rx_head)) < 0) { /* Command complete */
825 void __iomem *read_frame = lp->base + rx_head;
826 ushort rfd_cmd = readw(read_frame+2);
827 ushort next_rx_frame = readw(read_frame+4);
828 ushort data_buffer_addr = readw(read_frame+6);
829 void __iomem *data_frame = lp->base + data_buffer_addr;
830 ushort pkt_len = readw(data_frame);
831
832 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
833 || (pkt_len & 0xC000) != 0xC000) {
834 printk(KERN_ERR "%s: Rx frame at %#x corrupted, "
835 "status %04x cmd %04x next %04x "
836 "data-buf @%04x %04x.\n",
837 dev->name, rx_head, frame_status, rfd_cmd,
838 next_rx_frame, data_buffer_addr, 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(KERN_ERR "%s: Memory squeeze, "
855 "dropping packet.\n",
856 dev->name);
857 dev->stats.rx_dropped++;
858 break;
859 }
860
861 skb_reserve(skb,2);
862
863 /* 'skb->data' points to the start of sk_buff data area. */
864 memcpy_fromio(skb_put(skb,pkt_len), data_frame + 10, pkt_len);
865
866 skb->protocol=eth_type_trans(skb,dev);
867 netif_rx(skb);
868 dev->stats.rx_packets++;
869 dev->stats.rx_bytes += pkt_len;
870 }
871
872 /* Clear the status word and set End-of-List on the rx frame. */
873 writew(0,read_frame);
874 writew(0xC000,read_frame+2);
875 /* Clear the end-of-list on the prev. RFD. */
876 writew(0x0000,lp->base + rx_tail + 2);
877
878 rx_tail = rx_head;
879 rx_head = next_rx_frame;
880 if (--boguscount == 0)
881 break;
882 }
883
884 lp->rx_head = rx_head;
885 lp->rx_tail = rx_tail;
886 }
887
netdev_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)888 static void netdev_get_drvinfo(struct net_device *dev,
889 struct ethtool_drvinfo *info)
890 {
891 strcpy(info->driver, DRV_NAME);
892 strcpy(info->version, DRV_VERSION);
893 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
894 }
895
netdev_get_msglevel(struct net_device * dev)896 static u32 netdev_get_msglevel(struct net_device *dev)
897 {
898 return debug;
899 }
900
netdev_set_msglevel(struct net_device * dev,u32 level)901 static void netdev_set_msglevel(struct net_device *dev, u32 level)
902 {
903 debug = level;
904 }
905
906 static const struct ethtool_ops netdev_ethtool_ops = {
907 .get_drvinfo = netdev_get_drvinfo,
908 .get_msglevel = netdev_get_msglevel,
909 .set_msglevel = netdev_set_msglevel,
910 };
911
912 #ifdef MODULE
913 static struct net_device *dev_3c507;
914 module_param(io, int, 0);
915 module_param(irq, int, 0);
916 MODULE_PARM_DESC(io, "EtherLink16 I/O base address");
917 MODULE_PARM_DESC(irq, "(ignored)");
918
init_module(void)919 int __init init_module(void)
920 {
921 if (io == 0)
922 printk("3c507: You should not use auto-probing with insmod!\n");
923 dev_3c507 = el16_probe(-1);
924 return IS_ERR(dev_3c507) ? PTR_ERR(dev_3c507) : 0;
925 }
926
927 void __exit
cleanup_module(void)928 cleanup_module(void)
929 {
930 struct net_device *dev = dev_3c507;
931 unregister_netdev(dev);
932 free_irq(dev->irq, dev);
933 iounmap(((struct net_local *)netdev_priv(dev))->base);
934 release_region(dev->base_addr, EL16_IO_EXTENT);
935 free_netdev(dev);
936 }
937 #endif /* MODULE */
938 MODULE_LICENSE("GPL");
939