![[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 const char *version =
27 "3c507.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
28
29
30 #ifdef MODULE
31 #include <linux/module.h>
32 #include <linux/version.h>
33 #endif
34
35 #include <linux/config.h>
36
37 /*
38 Sources:
39 This driver wouldn't have been written with the availability of the
40 Crynwr driver source code. It provided a known-working implementation
41 that filled in the gaping holes of the Intel documentation. Three cheers
42 for Russ Nelson.
43
44 Intel Microcommunications Databook, Vol. 1, 1990. It provides just enough
45 info that the casual reader might think that it documents the i82586 :-<.
46 */
47
48 #include <linux/kernel.h>
49 #include <linux/sched.h>
50 #include <linux/types.h>
51 #include <linux/fcntl.h>
52 #include <linux/interrupt.h>
53 #include <linux/ptrace.h>
54 #include <linux/ioport.h>
55 #include <linux/in.h>
56 #include <linux/string.h>
57 #include <asm/system.h>
58 #include <asm/bitops.h>
59 #include <asm/io.h>
60 #include <asm/dma.h>
61 #include <linux/errno.h>
62
63 #include <linux/netdevice.h>
64 #include <linux/etherdevice.h>
65 #include <linux/skbuff.h>
66 #include <linux/malloc.h>
67
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
75 /* A zero-terminated list of common I/O addresses to be probed. */
76 static unsigned int netcard_portlist[] =
77 { 0x300, 0x320, 0x340, 0x280, 0};
78
79 /*
80 Details of the i82586.
81
82 You'll really need the databook to understand the details of this part,
83 but the outline is that the i82586 has two separate processing units.
84 Both are started from a list of three configuration tables, of which only
85 the last, the System Control Block (SCB), is used after reset-time. The SCB
86 has the following fields:
87 Status word
88 Command word
89 Tx/Command block addr.
90 Rx block addr.
91 The command word accepts the following controls for the Tx and Rx units:
92 */
93
94 #define CUC_START 0x0100
95 #define CUC_RESUME 0x0200
96 #define CUC_SUSPEND 0x0300
97 #define RX_START 0x0010
98 #define RX_RESUME 0x0020
99 #define RX_SUSPEND 0x0030
100
101 /* The Rx unit uses a list of frame descriptors and a list of data buffer
102 descriptors. We use full-sized (1518 byte) data buffers, so there is
103 a one-to-one pairing of frame descriptors to buffer descriptors.
104
105 The Tx ("command") unit executes a list of commands that look like:
106 Status word Written by the 82586 when the command is done.
107 Command word Command in lower 3 bits, post-command action in upper 3
108 Link word The address of the next command.
109 Parameters (as needed).
110
111 Some definitions related to the Command Word are:
112 */
113 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
114 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
115 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
116
117 enum commands {
118 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
119 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
120
121 /* Information that need to be kept for each board. */
122 struct net_local {
123 struct enet_statistics stats;
124 int last_restart;
125 ushort rx_head;
126 ushort rx_tail;
127 ushort tx_head;
128 ushort tx_cmd_link;
129 ushort tx_reap;
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 4
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 /*
205 That's it: only 86 bytes to set up the beast, including every extra
206 command available. The 170 byte buffer at DUMP_DATA is shared between the
207 Dump command (called only by the diagnostic program) and the SetMulticastList
208 command.
209
210 To complete the memory setup you only have to write the station address at
211 SA_OFFSET and create the Tx & Rx buffer lists.
212
213 The Tx command chain and buffer list is setup as follows:
214 A Tx command table, with the data buffer pointing to...
215 A Tx data buffer descriptor. The packet is in a single buffer, rather than
216 chaining together several smaller buffers.
217 A NoOp command, which initially points to itself,
218 And the packet data.
219
220 A transmit is done by filling in the Tx command table and data buffer,
221 re-writing the NoOp command, and finally changing the offset of the last
222 command to point to the current Tx command. When the Tx command is finished,
223 it jumps to the NoOp, when it loops until the next Tx command changes the
224 "link offset" in the NoOp. This way the 82586 never has to go through the
225 slow restart sequence.
226
227 The Rx buffer list is set up in the obvious ring structure. We have enough
228 memory (and low enough interrupt latency) that we can avoid the complicated
229 Rx buffer linked lists by alway associating a full-size Rx data buffer with
230 each Rx data frame.
231
232 I current use four transmit buffers starting at TX_BUF_START (0x0100), and
233 use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers.
234
235 */
236
237 unsigned short init_words[] = {
238 /* System Configuration Pointer (SCP). */
239 0x0000, /* Set bus size to 16 bits. */
240 0,0, /* pad words. */
241 0x0000,0x0000, /* ISCP phys addr, set in init_82586_mem(). */
242
243 /* Intermediate System Configuration Pointer (ISCP). */
244 0x0001, /* Status word that's cleared when init is done. */
245 0x0008,0,0, /* SCB offset, (skip, skip) */
246
247 /* System Control Block (SCB). */
248 0,0xf000|RX_START|CUC_START, /* SCB status and cmd. */
249 CONFIG_CMD, /* Command list pointer, points to Configure. */
250 RX_BUF_START, /* Rx block list. */
251 0,0,0,0, /* Error count: CRC, align, buffer, overrun. */
252
253 /* 0x0018: Configure command. Change to put MAC data with packet. */
254 0, CmdConfigure, /* Status, command. */
255 SET_SA_CMD, /* Next command is Set Station Addr. */
256 0x0804, /* "4" bytes of config data, 8 byte FIFO. */
257 0x2e40, /* Magic values, including MAC data location. */
258 0, /* Unused pad word. */
259
260 /* 0x0024: Setup station address command. */
261 0, CmdSASetup,
262 SET_MC_CMD, /* Next command. */
263 0xaa00,0xb000,0x0bad, /* Station address (to be filled in) */
264
265 /* 0x0030: NOP, looping back to itself. Point to first Tx buffer to Tx. */
266 0, CmdNOp, IDLELOOP, 0 /* pad */,
267
268 /* 0x0038: A unused Time-Domain Reflectometer command. */
269 0, CmdTDR, IDLELOOP, 0,
270
271 /* 0x0040: An unused Dump State command. */
272 0, CmdDump, IDLELOOP, DUMP_DATA,
273
274 /* 0x0048: An unused Diagnose command. */
275 0, CmdDiagnose, IDLELOOP,
276
277 /* 0x004E: An empty set-multicast-list command. */
278 0, CmdMulticastList, IDLELOOP, 0,
279 };
280
281 /* Index to functions, as function prototypes. */
282
283 extern int el16_probe(struct device *dev); /* Called from Space.c */
284
285 static int el16_probe1(struct device *dev, int ioaddr);
286 static int el16_open(struct device *dev);
287 static int el16_send_packet(struct sk_buff *skb, struct device *dev);
288 static void el16_interrupt(int irq, struct pt_regs *regs);
289 static void el16_rx(struct device *dev);
290 static int el16_close(struct device *dev);
291 static struct enet_statistics *el16_get_stats(struct device *dev);
292
293 static void hardware_send_packet(struct device *dev, void *buf, short length);
294 void init_82586_mem(struct device *dev);
295
296
297 #ifdef HAVE_DEVLIST
298 struct netdev_entry netcard_drv =
299 {"3c507", el16_probe1, EL16_IO_EXTENT, netcard_portlist};
300 #endif
301
302 /* Check for a network adaptor of this type, and return '0' iff one exists.
303 If dev->base_addr == 0, probe all likely locations.
304 If dev->base_addr == 1, always return failure.
305 If dev->base_addr == 2, (detachable devices only) allocate space for the
306 device and return success.
307 */
308 int
309 el16_probe(struct device *dev)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
310 {
311 int base_addr = dev ? dev->base_addr : 0;
312 int i;
313
314 if (base_addr > 0x1ff) /* Check a single specified location. */
315 return el16_probe1(dev, base_addr);
316 else if (base_addr != 0)
317 return ENXIO; /* Don't probe at all. */
318
319 for (i = 0; netcard_portlist[i]; i++) {
320 int ioaddr = netcard_portlist[i];
321 if (check_region(ioaddr, EL16_IO_EXTENT))
322 continue;
323 if (el16_probe1(dev, ioaddr) == 0)
324 return 0;
325 }
326
327 return ENODEV;
328 }
329
330 int el16_probe1(struct device *dev, int ioaddr)
/* ![[previous]](../icons/left.png)
*/
331 {
332 static unsigned char init_ID_done = 0, version_printed = 0;
333 int i, irq, irqval;
334
335 if (init_ID_done == 0) {
336 ushort lrs_state = 0xff;
337 /* Send the ID sequence to the ID_PORT to enable the board(s). */
338 outb(0x00, ID_PORT);
339 for(i = 0; i < 255; i++) {
340 outb(lrs_state, ID_PORT);
341 lrs_state <<= 1;
342 if (lrs_state & 0x100)
343 lrs_state ^= 0xe7;
344 }
345 outb(0x00, ID_PORT);
346 init_ID_done = 1;
347 }
348
349 if (inb(ioaddr) == '*' && inb(ioaddr+1) == '3'
350 && inb(ioaddr+2) == 'C' && inb(ioaddr+3) == 'O')
351 ;
352 else
353 return ENODEV;
354
355 /* Allocate a new 'dev' if needed. */
356 if (dev == NULL)
357 dev = init_etherdev(0, sizeof(struct net_local));
358
359 if (net_debug && version_printed++ == 0)
360 printk(version);
361
362 printk("%s: 3c507 at %#x,", dev->name, ioaddr);
363
364 /* We should make a few more checks here, like the first three octets of
365 the S.A. for the manufacturer's code. */
366
367 irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
368
369 irqval = request_irq(irq, &el16_interrupt, 0, "3c507");
370 if (irqval) {
371 printk ("unable to get IRQ %d (irqval=%d).\n", irq, irqval);
372 return EAGAIN;
373 }
374
375 /* We've committed to using the board, and can start filling in *dev. */
376 request_region(ioaddr, EL16_IO_EXTENT, "3c507");
377 dev->base_addr = ioaddr;
378
379 outb(0x01, ioaddr + MISC_CTRL);
380 for (i = 0; i < 6; i++) {
381 dev->dev_addr[i] = inb(ioaddr + i);
382 printk(" %02x", dev->dev_addr[i]);
383 }
384
385 if ((dev->mem_start & 0xf) > 0)
386 net_debug = dev->mem_start & 7;
387
388 #ifdef MEM_BASE
389 dev->mem_start = MEM_BASE;
390 dev->mem_end = dev->mem_start + 0x10000;
391 #else
392 {
393 int base;
394 int size;
395 char mem_config = inb(ioaddr + MEM_CONFIG);
396 if (mem_config & 0x20) {
397 size = 64*1024;
398 base = 0xf00000 + (mem_config & 0x08 ? 0x080000
399 : ((mem_config & 3) << 17));
400 } else {
401 size = ((mem_config & 3) + 1) << 14;
402 base = 0x0c0000 + ( (mem_config & 0x18) << 12);
403 }
404 dev->mem_start = base;
405 dev->mem_end = base + size;
406 }
407 #endif
408
409 dev->if_port = (inb(ioaddr + ROM_CONFIG) & 0x80) ? 1 : 0;
410 dev->irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
411
412 printk(", IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->irq,
413 dev->if_port ? "ex" : "in", dev->mem_start, dev->mem_end-1);
414
415 if (net_debug)
416 printk(version);
417
418 /* Initialize the device structure. */
419 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
420 if (dev->priv == NULL)
421 return -ENOMEM;
422 memset(dev->priv, 0, sizeof(struct net_local));
423
424 dev->open = el16_open;
425 dev->stop = el16_close;
426 dev->hard_start_xmit = el16_send_packet;
427 dev->get_stats = el16_get_stats;
428
429 ether_setup(dev); /* Generic ethernet behaviour */
430
431 dev->flags&=~IFF_MULTICAST; /* Multicast doesn't work */
432
433 return 0;
434 }
435
436
437
438 static int
439 el16_open(struct device *dev)
/* */
440 {
441 irq2dev_map[dev->irq] = dev;
442
443 /* Initialize the 82586 memory and start it. */
444 init_82586_mem(dev);
445
446 dev->tbusy = 0;
447 dev->interrupt = 0;
448 dev->start = 1;
449
450 #ifdef MODULE
451 MOD_INC_USE_COUNT;
452 #endif
453
454 return 0;
455 }
456
457 static int
458 el16_send_packet(struct sk_buff *skb, struct device *dev)
/* */
459 {
460 struct net_local *lp = (struct net_local *)dev->priv;
461 int ioaddr = dev->base_addr;
462 short *shmem = (short*)dev->mem_start;
463
464 if (dev->tbusy) {
465 /* If we get here, some higher level has decided we are broken.
466 There should really be a "kick me" function call instead. */
467 int tickssofar = jiffies - dev->trans_start;
468 if (tickssofar < 5)
469 return 1;
470 if (net_debug > 1)
471 printk("%s: transmit timed out, %s? ", dev->name,
472 shmem[iSCB_STATUS>>1] & 0x8000 ? "IRQ conflict" :
473 "network cable problem");
474 /* Try to restart the adaptor. */
475 if (lp->last_restart == lp->stats.tx_packets) {
476 if (net_debug > 1) printk("Resetting board.\n");
477 /* Completely reset the adaptor. */
478 init_82586_mem(dev);
479 } else {
480 /* Issue the channel attention signal and hope it "gets better". */
481 if (net_debug > 1) printk("Kicking board.\n");
482 shmem[iSCB_CMD>>1] = 0xf000|CUC_START|RX_START;
483 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
484 lp->last_restart = lp->stats.tx_packets;
485 }
486 dev->tbusy=0;
487 dev->trans_start = jiffies;
488 }
489
490 /* If some higher layer thinks we've missed an tx-done interrupt
491 we are passed NULL. Caution: dev_tint() handles the cli()/sti()
492 itself. */
493 if (skb == NULL) {
494 dev_tint(dev);
495 return 0;
496 }
497
498 /* Block a timer-based transmit from overlapping. */
499 if (set_bit(0, (void*)&dev->tbusy) != 0)
500 printk("%s: Transmitter access conflict.\n", dev->name);
501 else {
502 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
503 unsigned char *buf = skb->data;
504
505 /* Disable the 82586's input to the interrupt line. */
506 outb(0x80, ioaddr + MISC_CTRL);
507 hardware_send_packet(dev, buf, length);
508 dev->trans_start = jiffies;
509 /* Enable the 82586 interrupt input. */
510 outb(0x84, ioaddr + MISC_CTRL);
511 }
512
513 dev_kfree_skb (skb, FREE_WRITE);
514
515 /* You might need to clean up and record Tx statistics here. */
516
517 return 0;
518 }
519
520 /* The typical workload of the driver:
521 Handle the network interface interrupts. */
522 static void
523 el16_interrupt(int irq, struct pt_regs *regs)
/* */
524 {
525 struct device *dev = (struct device *)(irq2dev_map[irq]);
526 struct net_local *lp;
527 int ioaddr, status, boguscount = 0;
528 ushort ack_cmd = 0;
529 ushort *shmem;
530
531 if (dev == NULL) {
532 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
533 return;
534 }
535 dev->interrupt = 1;
536
537 ioaddr = dev->base_addr;
538 lp = (struct net_local *)dev->priv;
539 shmem = ((ushort*)dev->mem_start);
540
541 status = shmem[iSCB_STATUS>>1];
542
543 if (net_debug > 4) {
544 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
545 }
546
547 /* Disable the 82586's input to the interrupt line. */
548 outb(0x80, ioaddr + MISC_CTRL);
549
550 /* Reap the Tx packet buffers. */
551 while (lp->tx_reap != lp->tx_head) {
552 unsigned short tx_status = shmem[lp->tx_reap>>1];
553
554 if (tx_status == 0) {
555 if (net_debug > 5) printk("Couldn't reap %#x.\n", lp->tx_reap);
556 break;
557 }
558 if (tx_status & 0x2000) {
559 lp->stats.tx_packets++;
560 lp->stats.collisions += tx_status & 0xf;
561 dev->tbusy = 0;
562 mark_bh(NET_BH); /* Inform upper layers. */
563 } else {
564 lp->stats.tx_errors++;
565 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
566 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
567 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
568 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
569 }
570 if (net_debug > 5)
571 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
572 lp->tx_reap += TX_BUF_SIZE;
573 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
574 lp->tx_reap = TX_BUF_START;
575 if (++boguscount > 4)
576 break;
577 }
578
579 if (status & 0x4000) { /* Packet received. */
580 if (net_debug > 5)
581 printk("Received packet, rx_head %04x.\n", lp->rx_head);
582 el16_rx(dev);
583 }
584
585 /* Acknowledge the interrupt sources. */
586 ack_cmd = status & 0xf000;
587
588 if ((status & 0x0700) != 0x0200 && dev->start) {
589 if (net_debug)
590 printk("%s: Command unit stopped, status %04x, restarting.\n",
591 dev->name, status);
592 /* If this ever occurs we should really re-write the idle loop, reset
593 the Tx list, and do a complete restart of the command unit.
594 For now we rely on the Tx timeout if the resume doesn't work. */
595 ack_cmd |= CUC_RESUME;
596 }
597
598 if ((status & 0x0070) != 0x0040 && dev->start) {
599 static void init_rx_bufs(struct device *);
600 /* The Rx unit is not ready, it must be hung. Restart the receiver by
601 initializing the rx buffers, and issuing an Rx start command. */
602 if (net_debug)
603 printk("%s: Rx unit stopped, status %04x, restarting.\n",
604 dev->name, status);
605 init_rx_bufs(dev);
606 shmem[iSCB_RFA >> 1] = RX_BUF_START;
607 ack_cmd |= RX_START;
608 }
609
610 shmem[iSCB_CMD>>1] = ack_cmd;
611 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
612
613 /* Clear the latched interrupt. */
614 outb(0, ioaddr + RESET_IRQ);
615
616 /* Enable the 82586's interrupt input. */
617 outb(0x84, ioaddr + MISC_CTRL);
618
619 return;
620 }
621
622 static int
623 el16_close(struct device *dev)
/* */
624 {
625 int ioaddr = dev->base_addr;
626 ushort *shmem = (short*)dev->mem_start;
627
628 dev->tbusy = 1;
629 dev->start = 0;
630
631 /* Flush the Tx and disable Rx. */
632 shmem[iSCB_CMD >> 1] = RX_SUSPEND | CUC_SUSPEND;
633 outb(0, ioaddr + SIGNAL_CA);
634
635 /* Disable the 82586's input to the interrupt line. */
636 outb(0x80, ioaddr + MISC_CTRL);
637
638 /* We always physically use the IRQ line, so we don't do free_irq().
639 We do remove ourselves from the map. */
640
641 irq2dev_map[dev->irq] = 0;
642
643 /* Update the statistics here. */
644
645 #ifdef MODULE
646 MOD_DEC_USE_COUNT;
647 #endif
648
649 return 0;
650 }
651
652 /* Get the current statistics. This may be called with the card open or
653 closed. */
654 static struct enet_statistics *
655 el16_get_stats(struct device *dev)
/* */
656 {
657 struct net_local *lp = (struct net_local *)dev->priv;
658
659 /* ToDo: decide if there are any useful statistics from the SCB. */
660
661 return &lp->stats;
662 }
663
664 /* Initialize the Rx-block list. */
665 static void
666 init_rx_bufs(struct device *dev)
/* */
667 {
668 struct net_local *lp = (struct net_local *)dev->priv;
669 unsigned short *write_ptr;
670 unsigned short SCB_base = SCB_BASE;
671
672 int cur_rxbuf = lp->rx_head = RX_BUF_START;
673
674 /* Initialize each Rx frame + data buffer. */
675 do { /* While there is room for one more. */
676
677 write_ptr = (unsigned short *)(dev->mem_start + cur_rxbuf);
678
679 *write_ptr++ = 0x0000; /* Status */
680 *write_ptr++ = 0x0000; /* Command */
681 *write_ptr++ = cur_rxbuf + RX_BUF_SIZE; /* Link */
682 *write_ptr++ = cur_rxbuf + 22; /* Buffer offset */
683 *write_ptr++ = 0x0000; /* Pad for dest addr. */
684 *write_ptr++ = 0x0000;
685 *write_ptr++ = 0x0000;
686 *write_ptr++ = 0x0000; /* Pad for source addr. */
687 *write_ptr++ = 0x0000;
688 *write_ptr++ = 0x0000;
689 *write_ptr++ = 0x0000; /* Pad for protocol. */
690
691 *write_ptr++ = 0x0000; /* Buffer: Actual count */
692 *write_ptr++ = -1; /* Buffer: Next (none). */
693 *write_ptr++ = cur_rxbuf + 0x20 + SCB_base; /* Buffer: Address low */
694 *write_ptr++ = 0x0000;
695 /* Finally, the number of bytes in the buffer. */
696 *write_ptr++ = 0x8000 + RX_BUF_SIZE-0x20;
697
698 lp->rx_tail = cur_rxbuf;
699 cur_rxbuf += RX_BUF_SIZE;
700 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
701
702 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
703 the list a ring. */
704 write_ptr = (unsigned short *)
705 (dev->mem_start + lp->rx_tail + 2);
706 *write_ptr++ = 0xC000; /* Command, mark as last. */
707 *write_ptr++ = lp->rx_head; /* Link */
708
709 }
710
711 void
712 init_82586_mem(struct device *dev)
/* */
713 {
714 struct net_local *lp = (struct net_local *)dev->priv;
715 short ioaddr = dev->base_addr;
716 ushort *shmem = (short*)dev->mem_start;
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((void*)dev->mem_end-10, init_words, 10);
728
729 /* Write the words at 0x0000. */
730 memcpy((char*)dev->mem_start, init_words + 5, sizeof(init_words) - 10);
731
732 /* Fill in the station address. */
733 memcpy((char*)dev->mem_start+SA_OFFSET, dev->dev_addr,
734 sizeof(dev->dev_addr));
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 (shmem[iSCB_STATUS>>1] == 0)
752 if (--boguscnt == 0) {
753 printk("%s: i82586 initialization timed out with status %04x,"
754 "cmd %04x.\n", dev->name,
755 shmem[iSCB_STATUS>>1], shmem[iSCB_CMD>>1]);
756 break;
757 }
758 /* Issue channel-attn -- the 82586 won't start. */
759 outb(0, ioaddr + SIGNAL_CA);
760 }
761
762 /* Disable loopback and enable interrupts. */
763 outb(0x84, ioaddr + MISC_CTRL);
764 if (net_debug > 4)
765 printk("%s: Initialized 82586, status %04x.\n", dev->name,
766 shmem[iSCB_STATUS>>1]);
767 return;
768 }
769
770 static void
771 hardware_send_packet(struct device *dev, void *buf, short length)
/* */
772 {
773 struct net_local *lp = (struct net_local *)dev->priv;
774 short ioaddr = dev->base_addr;
775 ushort tx_block = lp->tx_head;
776 ushort *write_ptr = (ushort *)(dev->mem_start + tx_block);
777
778 /* Set the write pointer to the Tx block, and put out the header. */
779 *write_ptr++ = 0x0000; /* Tx status */
780 *write_ptr++ = CMD_INTR|CmdTx; /* Tx command */
781 *write_ptr++ = tx_block+16; /* Next command is a NoOp. */
782 *write_ptr++ = tx_block+8; /* Data Buffer offset. */
783
784 /* Output the data buffer descriptor. */
785 *write_ptr++ = length | 0x8000; /* Byte count parameter. */
786 *write_ptr++ = -1; /* No next data buffer. */
787 *write_ptr++ = tx_block+22+SCB_BASE;/* Buffer follows the NoOp command. */
788 *write_ptr++ = 0x0000; /* Buffer address high bits (always zero). */
789
790 /* Output the Loop-back NoOp command. */
791 *write_ptr++ = 0x0000; /* Tx status */
792 *write_ptr++ = CmdNOp; /* Tx command */
793 *write_ptr++ = tx_block+16; /* Next is myself. */
794
795 /* Output the packet at the write pointer. */
796 memcpy(write_ptr, buf, length);
797
798 /* Set the old command link pointing to this send packet. */
799 *(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
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 printk("%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 if (lp->tx_head != lp->tx_reap)
813 dev->tbusy = 0;
814 }
815
816 static void
817 el16_rx(struct device *dev)
/* */
818 {
819 struct net_local *lp = (struct net_local *)dev->priv;
820 short *shmem = (short*)dev->mem_start;
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 = shmem[rx_head>>1]) < 0) { /* Command complete */
827 ushort *read_frame = (short *)(dev->mem_start + rx_head);
828 ushort rfd_cmd = read_frame[1];
829 ushort next_rx_frame = read_frame[2];
830 ushort data_buffer_addr = read_frame[3];
831 ushort *data_frame = (short *)(dev->mem_start + data_buffer_addr);
832 ushort pkt_len = data_frame[0];
833
834 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
835 || (pkt_len & 0xC000) != 0xC000) {
836 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
837 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
838 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
839 pkt_len);
840 } else if ((frame_status & 0x2000) == 0) {
841 /* Frame Rxed, but with error. */
842 lp->stats.rx_errors++;
843 if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
844 if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
845 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
846 if (frame_status & 0x0100) lp->stats.rx_over_errors++;
847 if (frame_status & 0x0080) lp->stats.rx_length_errors++;
848 } else {
849 /* Malloc up new buffer. */
850 struct sk_buff *skb;
851
852 pkt_len &= 0x3fff;
853 skb = dev_alloc_skb(pkt_len+2);
854 if (skb == NULL) {
855 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
856 lp->stats.rx_dropped++;
857 break;
858 }
859
860 skb_reserve(skb,2);
861 skb->dev = dev;
862
863 /* 'skb->data' points to the start of sk_buff data area. */
864 memcpy(skb_put(skb,pkt_len), data_frame + 5, pkt_len);
865
866 skb->protocol=eth_type_trans(skb,dev);
867 netif_rx(skb);
868 lp->stats.rx_packets++;
869 }
870
871 /* Clear the status word and set End-of-List on the rx frame. */
872 read_frame[0] = 0;
873 read_frame[1] = 0xC000;
874 /* Clear the end-of-list on the prev. RFD. */
875 *(short*)(dev->mem_start + rx_tail + 2) = 0x0000;
876
877 rx_tail = rx_head;
878 rx_head = next_rx_frame;
879 if (--boguscount == 0)
880 break;
881 }
882
883 lp->rx_head = rx_head;
884 lp->rx_tail = rx_tail;
885 }
886 #ifdef MODULE
887 char kernel_version[] = UTS_RELEASE;
888 static char devicename[9] = { 0, };
889 static struct device dev_3c507 = {
890 devicename, /* device name is inserted by linux/drivers/net/net_init.c */
891 0, 0, 0, 0,
892 0, 0,
893 0, 0, 0, NULL, el16_probe
894 };
895
896 int io = 0x300;
897 int irq = 0;
898
899 int init_module(void)
/* */
900 {
901 if (io == 0)
902 printk("3c507: You should not use auto-probing with insmod!\n");
903 dev_3c507.base_addr = io;
904 dev_3c507.irq = irq;
905 if (register_netdev(&dev_3c507) != 0) {
906 printk("3c507: register_netdev() returned non-zero.\n");
907 return -EIO;
908 }
909 return 0;
910 }
911
912 void
913 cleanup_module(void)
/* ![[last]](../icons/n_last.png)
*/
914 {
915 if (MOD_IN_USE)
916 printk("3c507: device busy, remove delayed\n");
917 else
918 {
919 unregister_netdev(&dev_3c507);
920 kfree(dev_3c507.priv);
921 dev_3c507.priv = NULL;
922
923 /* If we don't do this, we can't re-insmod it later. */
924 free_irq(dev_3c507.irq);
925 release_region(dev_3c507.base_addr, EL16_IO_EXTENT);
926 }
927 }
928 #endif /* MODULE */
929
930 /*
931 * Local variables:
932 * 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"
933 * version-control: t
934 * kept-new-versions: 5
935 * tab-width: 4
936 * c-indent-level: 4
937 * End:
938 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/