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/uaccess.h>
67
68 /* use 0 for production, 1 for verification, 2..7 for debug */
69 #ifndef NET_DEBUG
70 #define NET_DEBUG 1
71 #endif
72 static unsigned int net_debug = NET_DEBUG;
73 #define debug net_debug
74
75
76 /*
77 Details of the i82586.
78
79 You'll really need the databook to understand the details of this part,
80 but the outline is that the i82586 has two separate processing units.
81 Both are started from a list of three configuration tables, of which only
82 the last, the System Control Block (SCB), is used after reset-time. The SCB
83 has the following fields:
84 Status word
85 Command word
86 Tx/Command block addr.
87 Rx block addr.
88 The command word accepts the following controls for the Tx and Rx units:
89 */
90
91 #define CUC_START 0x0100
92 #define CUC_RESUME 0x0200
93 #define CUC_SUSPEND 0x0300
94 #define RX_START 0x0010
95 #define RX_RESUME 0x0020
96 #define RX_SUSPEND 0x0030
97
98 /* The Rx unit uses a list of frame descriptors and a list of data buffer
99 descriptors. We use full-sized (1518 byte) data buffers, so there is
100 a one-to-one pairing of frame descriptors to buffer descriptors.
101
102 The Tx ("command") unit executes a list of commands that look like:
103 Status word Written by the 82586 when the command is done.
104 Command word Command in lower 3 bits, post-command action in upper 3
105 Link word The address of the next command.
106 Parameters (as needed).
107
108 Some definitions related to the Command Word are:
109 */
110 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
111 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
112 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
113
114 enum commands {
115 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
116 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
117
118 /* Information that need to be kept for each board. */
119 struct net_local {
120 int last_restart;
121 ushort rx_head;
122 ushort rx_tail;
123 ushort tx_head;
124 ushort tx_cmd_link;
125 ushort tx_reap;
126 ushort tx_pkts_in_ring;
127 spinlock_t lock;
128 void __iomem *base;
129 };
130
131 /*
132 Details of the EtherLink16 Implementation
133 The 3c507 is a generic shared-memory i82586 implementation.
134 The host can map 16K, 32K, 48K, or 64K of the 64K memory into
135 0x0[CD][08]0000, or all 64K into 0xF[02468]0000.
136 */
137
138 /* Offsets from the base I/O address. */
139 #define SA_DATA 0 /* Station address data, or 3Com signature. */
140 #define MISC_CTRL 6 /* Switch the SA_DATA banks, and bus config bits. */
141 #define RESET_IRQ 10 /* Reset the latched IRQ line. */
142 #define SIGNAL_CA 11 /* Frob the 82586 Channel Attention line. */
143 #define ROM_CONFIG 13
144 #define MEM_CONFIG 14
145 #define IRQ_CONFIG 15
146 #define EL16_IO_EXTENT 16
147
148 /* The ID port is used at boot-time to locate the ethercard. */
149 #define ID_PORT 0x100
150
151 /* Offsets to registers in the mailbox (SCB). */
152 #define iSCB_STATUS 0x8
153 #define iSCB_CMD 0xA
154 #define iSCB_CBL 0xC /* Command BLock offset. */
155 #define iSCB_RFA 0xE /* Rx Frame Area offset. */
156
157 /* Since the 3c507 maps the shared memory window so that the last byte is
158 at 82586 address FFFF, the first byte is at 82586 address 0, 16K, 32K, or
159 48K corresponding to window sizes of 64K, 48K, 32K and 16K respectively.
160 We can account for this be setting the 'SBC Base' entry in the ISCP table
161 below for all the 16 bit offset addresses, and also adding the 'SCB Base'
162 value to all 24 bit physical addresses (in the SCP table and the TX and RX
163 Buffer Descriptors).
164 -Mark
165 */
166 #define SCB_BASE ((unsigned)64*1024 - (dev->mem_end - dev->mem_start))
167
168 /*
169 What follows in 'init_words[]' is the "program" that is downloaded to the
170 82586 memory. It's mostly tables and command blocks, and starts at the
171 reset address 0xfffff6. This is designed to be similar to the EtherExpress,
172 thus the unusual location of the SCB at 0x0008.
173
174 Even with the additional "don't care" values, doing it this way takes less
175 program space than initializing the individual tables, and I feel it's much
176 cleaner.
177
178 The databook is particularly useless for the first two structures, I had
179 to use the Crynwr driver as an example.
180
181 The memory setup is as follows:
182 */
183
184 #define CONFIG_CMD 0x0018
185 #define SET_SA_CMD 0x0024
186 #define SA_OFFSET 0x002A
187 #define IDLELOOP 0x30
188 #define TDR_CMD 0x38
189 #define TDR_TIME 0x3C
190 #define DUMP_CMD 0x40
191 #define DIAG_CMD 0x48
192 #define SET_MC_CMD 0x4E
193 #define DUMP_DATA 0x56 /* A 170 byte buffer for dump and Set-MC into. */
194
195 #define TX_BUF_START 0x0100
196 #define NUM_TX_BUFS 5
197 #define TX_BUF_SIZE (1518+14+20+16) /* packet+header+TBD */
198
199 #define RX_BUF_START 0x2000
200 #define RX_BUF_SIZE (1518+14+18) /* packet+header+RBD */
201 #define RX_BUF_END (dev->mem_end - dev->mem_start)
202
203 #define TX_TIMEOUT (HZ/20)
204
205 /*
206 That's it: only 86 bytes to set up the beast, including every extra
207 command available. The 170 byte buffer at DUMP_DATA is shared between the
208 Dump command (called only by the diagnostic program) and the SetMulticastList
209 command.
210
211 To complete the memory setup you only have to write the station address at
212 SA_OFFSET and create the Tx & Rx buffer lists.
213
214 The Tx command chain and buffer list is setup as follows:
215 A Tx command table, with the data buffer pointing to...
216 A Tx data buffer descriptor. The packet is in a single buffer, rather than
217 chaining together several smaller buffers.
218 A NoOp command, which initially points to itself,
219 And the packet data.
220
221 A transmit is done by filling in the Tx command table and data buffer,
222 re-writing the NoOp command, and finally changing the offset of the last
223 command to point to the current Tx command. When the Tx command is finished,
224 it jumps to the NoOp, when it loops until the next Tx command changes the
225 "link offset" in the NoOp. This way the 82586 never has to go through the
226 slow restart sequence.
227
228 The Rx buffer list is set up in the obvious ring structure. We have enough
229 memory (and low enough interrupt latency) that we can avoid the complicated
230 Rx buffer linked lists by alway associating a full-size Rx data buffer with
231 each Rx data frame.
232
233 I current use four transmit buffers starting at TX_BUF_START (0x0100), and
234 use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers.
235
236 */
237
238 static unsigned short init_words[] = {
239 /* System Configuration Pointer (SCP). */
240 0x0000, /* Set bus size to 16 bits. */
241 0,0, /* pad words. */
242 0x0000,0x0000, /* ISCP phys addr, set in init_82586_mem(). */
243
244 /* Intermediate System Configuration Pointer (ISCP). */
245 0x0001, /* Status word that's cleared when init is done. */
246 0x0008,0,0, /* SCB offset, (skip, skip) */
247
248 /* System Control Block (SCB). */
249 0,0xf000|RX_START|CUC_START, /* SCB status and cmd. */
250 CONFIG_CMD, /* Command list pointer, points to Configure. */
251 RX_BUF_START, /* Rx block list. */
252 0,0,0,0, /* Error count: CRC, align, buffer, overrun. */
253
254 /* 0x0018: Configure command. Change to put MAC data with packet. */
255 0, CmdConfigure, /* Status, command. */
256 SET_SA_CMD, /* Next command is Set Station Addr. */
257 0x0804, /* "4" bytes of config data, 8 byte FIFO. */
258 0x2e40, /* Magic values, including MAC data location. */
259 0, /* Unused pad word. */
260
261 /* 0x0024: Setup station address command. */
262 0, CmdSASetup,
263 SET_MC_CMD, /* Next command. */
264 0xaa00,0xb000,0x0bad, /* Station address (to be filled in) */
265
266 /* 0x0030: NOP, looping back to itself. Point to first Tx buffer to Tx. */
267 0, CmdNOp, IDLELOOP, 0 /* pad */,
268
269 /* 0x0038: A unused Time-Domain Reflectometer command. */
270 0, CmdTDR, IDLELOOP, 0,
271
272 /* 0x0040: An unused Dump State command. */
273 0, CmdDump, IDLELOOP, DUMP_DATA,
274
275 /* 0x0048: An unused Diagnose command. */
276 0, CmdDiagnose, IDLELOOP,
277
278 /* 0x004E: An empty set-multicast-list command. */
279 0, CmdMulticastList, IDLELOOP, 0,
280 };
281
282 /* Index to functions, as function prototypes. */
283
284 static int el16_probe1(struct net_device *dev, int ioaddr);
285 static int el16_open(struct net_device *dev);
286 static netdev_tx_t el16_send_packet(struct sk_buff *skb,
287 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 const unsigned ports[] = { 0x300, 0x320, 0x340, 0x280, 0};
314 const 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 const struct net_device_ops netdev_ops = {
356 .ndo_open = el16_open,
357 .ndo_stop = el16_close,
358 .ndo_start_xmit = el16_send_packet,
359 .ndo_tx_timeout = el16_tx_timeout,
360 .ndo_change_mtu = eth_change_mtu,
361 .ndo_set_mac_address = eth_mac_addr,
362 .ndo_validate_addr = eth_validate_addr,
363 };
364
el16_probe1(struct net_device * dev,int ioaddr)365 static int __init el16_probe1(struct net_device *dev, int ioaddr)
366 {
367 static unsigned char init_ID_done;
368 int i, irq, irqval, retval;
369 struct net_local *lp;
370
371 if (init_ID_done == 0) {
372 ushort lrs_state = 0xff;
373 /* Send the ID sequence to the ID_PORT to enable the board(s). */
374 outb(0x00, ID_PORT);
375 for(i = 0; i < 255; i++) {
376 outb(lrs_state, ID_PORT);
377 lrs_state <<= 1;
378 if (lrs_state & 0x100)
379 lrs_state ^= 0xe7;
380 }
381 outb(0x00, ID_PORT);
382 init_ID_done = 1;
383 }
384
385 if (!request_region(ioaddr, EL16_IO_EXTENT, DRV_NAME))
386 return -ENODEV;
387
388 if ((inb(ioaddr) != '*') || (inb(ioaddr + 1) != '3') ||
389 (inb(ioaddr + 2) != 'C') || (inb(ioaddr + 3) != 'O')) {
390 retval = -ENODEV;
391 goto out;
392 }
393
394 pr_info("%s: 3c507 at %#x,", dev->name, ioaddr);
395
396 /* We should make a few more checks here, like the first three octets of
397 the S.A. for the manufacturer's code. */
398
399 irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
400
401 irqval = request_irq(irq, el16_interrupt, 0, DRV_NAME, dev);
402 if (irqval) {
403 pr_cont("\n");
404 pr_err("3c507: unable to get IRQ %d (irqval=%d).\n", irq, irqval);
405 retval = -EAGAIN;
406 goto out;
407 }
408
409 /* We've committed to using the board, and can start filling in *dev. */
410 dev->base_addr = ioaddr;
411
412 outb(0x01, ioaddr + MISC_CTRL);
413 for (i = 0; i < 6; i++)
414 dev->dev_addr[i] = inb(ioaddr + i);
415 pr_cont(" %pM", dev->dev_addr);
416
417 if (mem_start)
418 net_debug = mem_start & 7;
419
420 #ifdef MEM_BASE
421 dev->mem_start = MEM_BASE;
422 dev->mem_end = dev->mem_start + 0x10000;
423 #else
424 {
425 int base;
426 int size;
427 char mem_config = inb(ioaddr + MEM_CONFIG);
428 if (mem_config & 0x20) {
429 size = 64*1024;
430 base = 0xf00000 + (mem_config & 0x08 ? 0x080000
431 : ((mem_config & 3) << 17));
432 } else {
433 size = ((mem_config & 3) + 1) << 14;
434 base = 0x0c0000 + ( (mem_config & 0x18) << 12);
435 }
436 dev->mem_start = base;
437 dev->mem_end = base + size;
438 }
439 #endif
440
441 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
442 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
443
444 pr_cont(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
445 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
446
447 if (net_debug)
448 pr_debug("%s", version);
449
450 lp = netdev_priv(dev);
451 spin_lock_init(&lp->lock);
452 lp->base = ioremap(dev->mem_start, RX_BUF_END);
453 if (!lp->base) {
454 pr_err("3c507: unable to remap memory\n");
455 retval = -EAGAIN;
456 goto out1;
457 }
458
459 dev->netdev_ops = &netdev_ops;
460 dev->watchdog_timeo = TX_TIMEOUT;
461 dev->ethtool_ops = &netdev_ethtool_ops;
462 dev->flags &= ~IFF_MULTICAST; /* Multicast doesn't work */
463 return 0;
464 out1:
465 free_irq(dev->irq, dev);
466 out:
467 release_region(ioaddr, EL16_IO_EXTENT);
468 return retval;
469 }
470
el16_open(struct net_device * dev)471 static int el16_open(struct net_device *dev)
472 {
473 /* Initialize the 82586 memory and start it. */
474 init_82586_mem(dev);
475
476 netif_start_queue(dev);
477 return 0;
478 }
479
480
el16_tx_timeout(struct net_device * dev)481 static void el16_tx_timeout (struct net_device *dev)
482 {
483 struct net_local *lp = netdev_priv(dev);
484 int ioaddr = dev->base_addr;
485 void __iomem *shmem = lp->base;
486
487 if (net_debug > 1)
488 pr_debug("%s: transmit timed out, %s? ", dev->name,
489 readw(shmem + iSCB_STATUS) & 0x8000 ? "IRQ conflict" :
490 "network cable problem");
491 /* Try to restart the adaptor. */
492 if (lp->last_restart == dev->stats.tx_packets) {
493 if (net_debug > 1)
494 pr_cont("Resetting board.\n");
495 /* Completely reset the adaptor. */
496 init_82586_mem (dev);
497 lp->tx_pkts_in_ring = 0;
498 } else {
499 /* Issue the channel attention signal and hope it "gets better". */
500 if (net_debug > 1)
501 pr_cont("Kicking board.\n");
502 writew(0xf000 | CUC_START | RX_START, shmem + iSCB_CMD);
503 outb (0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
504 lp->last_restart = dev->stats.tx_packets;
505 }
506 dev->trans_start = jiffies; /* prevent tx timeout */
507 netif_wake_queue (dev);
508 }
509
510
el16_send_packet(struct sk_buff * skb,struct net_device * dev)511 static netdev_tx_t el16_send_packet (struct sk_buff *skb,
512 struct net_device *dev)
513 {
514 struct net_local *lp = netdev_priv(dev);
515 int ioaddr = dev->base_addr;
516 unsigned long flags;
517 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
518 unsigned char *buf = skb->data;
519
520 netif_stop_queue (dev);
521
522 spin_lock_irqsave (&lp->lock, flags);
523
524 dev->stats.tx_bytes += length;
525 /* Disable the 82586's input to the interrupt line. */
526 outb (0x80, ioaddr + MISC_CTRL);
527
528 hardware_send_packet (dev, buf, skb->len, length - skb->len);
529
530 /* Enable the 82586 interrupt input. */
531 outb (0x84, ioaddr + MISC_CTRL);
532
533 spin_unlock_irqrestore (&lp->lock, flags);
534
535 dev_kfree_skb (skb);
536
537 /* You might need to clean up and record Tx statistics here. */
538
539 return NETDEV_TX_OK;
540 }
541
542 /* The typical workload of the driver:
543 Handle the network interface interrupts. */
el16_interrupt(int irq,void * dev_id)544 static irqreturn_t el16_interrupt(int irq, void *dev_id)
545 {
546 struct net_device *dev = dev_id;
547 struct net_local *lp;
548 int ioaddr, status, boguscount = 0;
549 ushort ack_cmd = 0;
550 void __iomem *shmem;
551
552 if (dev == NULL) {
553 pr_err("net_interrupt(): irq %d for unknown device.\n", irq);
554 return IRQ_NONE;
555 }
556
557 ioaddr = dev->base_addr;
558 lp = netdev_priv(dev);
559 shmem = lp->base;
560
561 spin_lock(&lp->lock);
562
563 status = readw(shmem+iSCB_STATUS);
564
565 if (net_debug > 4) {
566 pr_debug("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
567 }
568
569 /* Disable the 82586's input to the interrupt line. */
570 outb(0x80, ioaddr + MISC_CTRL);
571
572 /* Reap the Tx packet buffers. */
573 while (lp->tx_pkts_in_ring) {
574 unsigned short tx_status = readw(shmem+lp->tx_reap);
575 if (!(tx_status & 0x8000)) {
576 if (net_debug > 5)
577 pr_debug("Tx command incomplete (%#x).\n", lp->tx_reap);
578 break;
579 }
580 /* Tx unsuccessful or some interesting status bit set. */
581 if (!(tx_status & 0x2000) || (tx_status & 0x0f3f)) {
582 dev->stats.tx_errors++;
583 if (tx_status & 0x0600) dev->stats.tx_carrier_errors++;
584 if (tx_status & 0x0100) dev->stats.tx_fifo_errors++;
585 if (!(tx_status & 0x0040)) dev->stats.tx_heartbeat_errors++;
586 if (tx_status & 0x0020) dev->stats.tx_aborted_errors++;
587 dev->stats.collisions += tx_status & 0xf;
588 }
589 dev->stats.tx_packets++;
590 if (net_debug > 5)
591 pr_debug("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
592 lp->tx_reap += TX_BUF_SIZE;
593 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
594 lp->tx_reap = TX_BUF_START;
595
596 lp->tx_pkts_in_ring--;
597 /* There is always more space in the Tx ring buffer now. */
598 netif_wake_queue(dev);
599
600 if (++boguscount > 10)
601 break;
602 }
603
604 if (status & 0x4000) { /* Packet received. */
605 if (net_debug > 5)
606 pr_debug("Received packet, rx_head %04x.\n", lp->rx_head);
607 el16_rx(dev);
608 }
609
610 /* Acknowledge the interrupt sources. */
611 ack_cmd = status & 0xf000;
612
613 if ((status & 0x0700) != 0x0200 && netif_running(dev)) {
614 if (net_debug)
615 pr_debug("%s: Command unit stopped, status %04x, restarting.\n",
616 dev->name, status);
617 /* If this ever occurs we should really re-write the idle loop, reset
618 the Tx list, and do a complete restart of the command unit.
619 For now we rely on the Tx timeout if the resume doesn't work. */
620 ack_cmd |= CUC_RESUME;
621 }
622
623 if ((status & 0x0070) != 0x0040 && netif_running(dev)) {
624 /* The Rx unit is not ready, it must be hung. Restart the receiver by
625 initializing the rx buffers, and issuing an Rx start command. */
626 if (net_debug)
627 pr_debug("%s: Rx unit stopped, status %04x, restarting.\n",
628 dev->name, status);
629 init_rx_bufs(dev);
630 writew(RX_BUF_START,shmem+iSCB_RFA);
631 ack_cmd |= RX_START;
632 }
633
634 writew(ack_cmd,shmem+iSCB_CMD);
635 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
636
637 /* Clear the latched interrupt. */
638 outb(0, ioaddr + RESET_IRQ);
639
640 /* Enable the 82586's interrupt input. */
641 outb(0x84, ioaddr + MISC_CTRL);
642 spin_unlock(&lp->lock);
643 return IRQ_HANDLED;
644 }
645
el16_close(struct net_device * dev)646 static int el16_close(struct net_device *dev)
647 {
648 struct net_local *lp = netdev_priv(dev);
649 int ioaddr = dev->base_addr;
650 void __iomem *shmem = lp->base;
651
652 netif_stop_queue(dev);
653
654 /* Flush the Tx and disable Rx. */
655 writew(RX_SUSPEND | CUC_SUSPEND,shmem+iSCB_CMD);
656 outb(0, ioaddr + SIGNAL_CA);
657
658 /* Disable the 82586's input to the interrupt line. */
659 outb(0x80, ioaddr + MISC_CTRL);
660
661 /* We always physically use the IRQ line, so we don't do free_irq(). */
662
663 /* Update the statistics here. */
664
665 return 0;
666 }
667
668 /* Initialize the Rx-block list. */
init_rx_bufs(struct net_device * dev)669 static void init_rx_bufs(struct net_device *dev)
670 {
671 struct net_local *lp = netdev_priv(dev);
672 void __iomem *write_ptr;
673 unsigned short SCB_base = SCB_BASE;
674
675 int cur_rxbuf = lp->rx_head = RX_BUF_START;
676
677 /* Initialize each Rx frame + data buffer. */
678 do { /* While there is room for one more. */
679
680 write_ptr = lp->base + cur_rxbuf;
681
682 writew(0x0000,write_ptr); /* Status */
683 writew(0x0000,write_ptr+=2); /* Command */
684 writew(cur_rxbuf + RX_BUF_SIZE,write_ptr+=2); /* Link */
685 writew(cur_rxbuf + 22,write_ptr+=2); /* Buffer offset */
686 writew(0x0000,write_ptr+=2); /* Pad for dest addr. */
687 writew(0x0000,write_ptr+=2);
688 writew(0x0000,write_ptr+=2);
689 writew(0x0000,write_ptr+=2); /* Pad for source addr. */
690 writew(0x0000,write_ptr+=2);
691 writew(0x0000,write_ptr+=2);
692 writew(0x0000,write_ptr+=2); /* Pad for protocol. */
693
694 writew(0x0000,write_ptr+=2); /* Buffer: Actual count */
695 writew(-1,write_ptr+=2); /* Buffer: Next (none). */
696 writew(cur_rxbuf + 0x20 + SCB_base,write_ptr+=2);/* Buffer: Address low */
697 writew(0x0000,write_ptr+=2);
698 /* Finally, the number of bytes in the buffer. */
699 writew(0x8000 + RX_BUF_SIZE-0x20,write_ptr+=2);
700
701 lp->rx_tail = cur_rxbuf;
702 cur_rxbuf += RX_BUF_SIZE;
703 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
704
705 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
706 the list a ring. */
707 write_ptr = lp->base + lp->rx_tail + 2;
708 writew(0xC000,write_ptr); /* Command, mark as last. */
709 writew(lp->rx_head,write_ptr+2); /* Link */
710 }
711
init_82586_mem(struct net_device * dev)712 static void init_82586_mem(struct net_device *dev)
713 {
714 struct net_local *lp = netdev_priv(dev);
715 short ioaddr = dev->base_addr;
716 void __iomem *shmem = lp->base;
717
718 /* Enable loopback to protect the wire while starting up,
719 and hold the 586 in reset during the memory initialization. */
720 outb(0x20, ioaddr + MISC_CTRL);
721
722 /* Fix the ISCP address and base. */
723 init_words[3] = SCB_BASE;
724 init_words[7] = SCB_BASE;
725
726 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
727 memcpy_toio(lp->base + RX_BUF_END - 10, init_words, 10);
728
729 /* Write the words at 0x0000. */
730 memcpy_toio(lp->base, init_words + 5, sizeof(init_words) - 10);
731
732 /* Fill in the station address. */
733 memcpy_toio(lp->base+SA_OFFSET, dev->dev_addr, ETH_ALEN);
734
735 /* The Tx-block list is written as needed. We just set up the values. */
736 lp->tx_cmd_link = IDLELOOP + 4;
737 lp->tx_head = lp->tx_reap = TX_BUF_START;
738
739 init_rx_bufs(dev);
740
741 /* Start the 586 by releasing the reset line, but leave loopback. */
742 outb(0xA0, ioaddr + MISC_CTRL);
743
744 /* This was time consuming to track down: you need to give two channel
745 attention signals to reliably start up the i82586. */
746 outb(0, ioaddr + SIGNAL_CA);
747
748 {
749 int boguscnt = 50;
750 while (readw(shmem+iSCB_STATUS) == 0)
751 if (--boguscnt == 0) {
752 pr_warning("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
753 dev->name, readw(shmem+iSCB_STATUS), readw(shmem+iSCB_CMD));
754 break;
755 }
756 /* Issue channel-attn -- the 82586 won't start. */
757 outb(0, ioaddr + SIGNAL_CA);
758 }
759
760 /* Disable loopback and enable interrupts. */
761 outb(0x84, ioaddr + MISC_CTRL);
762 if (net_debug > 4)
763 pr_debug("%s: Initialized 82586, status %04x.\n", dev->name,
764 readw(shmem+iSCB_STATUS));
765 }
766
hardware_send_packet(struct net_device * dev,void * buf,short length,short pad)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 pr_debug("%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
el16_rx(struct net_device * dev)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 pr_err("%s: Rx frame at %#x corrupted, "
836 "status %04x cmd %04x next %04x "
837 "data-buf @%04x %04x.\n",
838 dev->name, rx_head, frame_status, rfd_cmd,
839 next_rx_frame, data_buffer_addr, pkt_len);
840 } else if ((frame_status & 0x2000) == 0) {
841 /* Frame Rxed, but with error. */
842 dev->stats.rx_errors++;
843 if (frame_status & 0x0800) dev->stats.rx_crc_errors++;
844 if (frame_status & 0x0400) dev->stats.rx_frame_errors++;
845 if (frame_status & 0x0200) dev->stats.rx_fifo_errors++;
846 if (frame_status & 0x0100) dev->stats.rx_over_errors++;
847 if (frame_status & 0x0080) dev->stats.rx_length_errors++;
848 } else {
849 /* Malloc up new buffer. */
850 struct sk_buff *skb;
851
852 pkt_len &= 0x3fff;
853 skb = netdev_alloc_skb(dev, pkt_len + 2);
854 if (skb == NULL) {
855 pr_err("%s: Memory squeeze, 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 pr_notice("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