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