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