![[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; /* ENODEV would be more accurate. */
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), 0);
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 if (dev->priv == NULL)
420 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
421 memset(dev->priv, 0, sizeof(struct net_local));
422
423 dev->open = el16_open;
424 dev->stop = el16_close;
425 dev->hard_start_xmit = el16_send_packet;
426 dev->get_stats = el16_get_stats;
427
428 ether_setup(dev); /* Generic ethernet behaviour */
429
430 return 0;
431 }
432
433
434
435 static int
436 el16_open(struct device *dev)
/* */
437 {
438 irq2dev_map[dev->irq] = dev;
439
440 /* Initialize the 82586 memory and start it. */
441 init_82586_mem(dev);
442
443 dev->tbusy = 0;
444 dev->interrupt = 0;
445 dev->start = 1;
446
447 #ifdef MODULE
448 MOD_INC_USE_COUNT;
449 #endif
450
451 return 0;
452 }
453
454 static int
455 el16_send_packet(struct sk_buff *skb, struct device *dev)
/* */
456 {
457 struct net_local *lp = (struct net_local *)dev->priv;
458 int ioaddr = dev->base_addr;
459 short *shmem = (short*)dev->mem_start;
460
461 if (dev->tbusy) {
462 /* If we get here, some higher level has decided we are broken.
463 There should really be a "kick me" function call instead. */
464 int tickssofar = jiffies - dev->trans_start;
465 if (tickssofar < 5)
466 return 1;
467 if (net_debug > 1)
468 printk("%s: transmit timed out, %s? ", dev->name,
469 shmem[iSCB_STATUS>>1] & 0x8000 ? "IRQ conflict" :
470 "network cable problem");
471 /* Try to restart the adaptor. */
472 if (lp->last_restart == lp->stats.tx_packets) {
473 if (net_debug > 1) printk("Resetting board.\n");
474 /* Completely reset the adaptor. */
475 init_82586_mem(dev);
476 } else {
477 /* Issue the channel attention signal and hope it "gets better". */
478 if (net_debug > 1) printk("Kicking board.\n");
479 shmem[iSCB_CMD>>1] = 0xf000|CUC_START|RX_START;
480 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
481 lp->last_restart = lp->stats.tx_packets;
482 }
483 dev->tbusy=0;
484 dev->trans_start = jiffies;
485 }
486
487 /* If some higher layer thinks we've missed an tx-done interrupt
488 we are passed NULL. Caution: dev_tint() handles the cli()/sti()
489 itself. */
490 if (skb == NULL) {
491 dev_tint(dev);
492 return 0;
493 }
494
495 /* Block a timer-based transmit from overlapping. */
496 if (set_bit(0, (void*)&dev->tbusy) != 0)
497 printk("%s: Transmitter access conflict.\n", dev->name);
498 else {
499 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
500 unsigned char *buf = skb->data;
501
502 /* Disable the 82586's input to the interrupt line. */
503 outb(0x80, ioaddr + MISC_CTRL);
504 hardware_send_packet(dev, buf, length);
505 dev->trans_start = jiffies;
506 /* Enable the 82586 interrupt input. */
507 outb(0x84, ioaddr + MISC_CTRL);
508 }
509
510 dev_kfree_skb (skb, FREE_WRITE);
511
512 /* You might need to clean up and record Tx statistics here. */
513
514 return 0;
515 }
516
517 /* The typical workload of the driver:
518 Handle the network interface interrupts. */
519 static void
520 el16_interrupt(int irq, struct pt_regs *regs)
/* */
521 {
522 struct device *dev = (struct device *)(irq2dev_map[irq]);
523 struct net_local *lp;
524 int ioaddr, status, boguscount = 0;
525 ushort ack_cmd = 0;
526 ushort *shmem;
527
528 if (dev == NULL) {
529 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
530 return;
531 }
532 dev->interrupt = 1;
533
534 ioaddr = dev->base_addr;
535 lp = (struct net_local *)dev->priv;
536 shmem = ((ushort*)dev->mem_start);
537
538 status = shmem[iSCB_STATUS>>1];
539
540 if (net_debug > 4) {
541 printk("%s: 3c507 interrupt, status %4.4x.\n", dev->name, status);
542 }
543
544 /* Disable the 82586's input to the interrupt line. */
545 outb(0x80, ioaddr + MISC_CTRL);
546
547 /* Reap the Tx packet buffers. */
548 while (lp->tx_reap != lp->tx_head) {
549 unsigned short tx_status = shmem[lp->tx_reap>>1];
550
551 if (tx_status == 0) {
552 if (net_debug > 5) printk("Couldn't reap %#x.\n", lp->tx_reap);
553 break;
554 }
555 if (tx_status & 0x2000) {
556 lp->stats.tx_packets++;
557 lp->stats.collisions += tx_status & 0xf;
558 dev->tbusy = 0;
559 mark_bh(NET_BH); /* Inform upper layers. */
560 } else {
561 lp->stats.tx_errors++;
562 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
563 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
564 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
565 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
566 }
567 if (net_debug > 5)
568 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
569 lp->tx_reap += TX_BUF_SIZE;
570 if (lp->tx_reap > RX_BUF_START - TX_BUF_SIZE)
571 lp->tx_reap = TX_BUF_START;
572 if (++boguscount > 4)
573 break;
574 }
575
576 if (status & 0x4000) { /* Packet received. */
577 if (net_debug > 5)
578 printk("Received packet, rx_head %04x.\n", lp->rx_head);
579 el16_rx(dev);
580 }
581
582 /* Acknowledge the interrupt sources. */
583 ack_cmd = status & 0xf000;
584
585 if ((status & 0x0700) != 0x0200 && dev->start) {
586 if (net_debug)
587 printk("%s: Command unit stopped, status %04x, restarting.\n",
588 dev->name, status);
589 /* If this ever occurs we should really re-write the idle loop, reset
590 the Tx list, and do a complete restart of the command unit.
591 For now we rely on the Tx timeout if the resume doesn't work. */
592 ack_cmd |= CUC_RESUME;
593 }
594
595 if ((status & 0x0070) != 0x0040 && dev->start) {
596 static void init_rx_bufs(struct device *);
597 /* The Rx unit is not ready, it must be hung. Restart the receiver by
598 initializing the rx buffers, and issuing an Rx start command. */
599 if (net_debug)
600 printk("%s: Rx unit stopped, status %04x, restarting.\n",
601 dev->name, status);
602 init_rx_bufs(dev);
603 shmem[iSCB_RFA >> 1] = RX_BUF_START;
604 ack_cmd |= RX_START;
605 }
606
607 shmem[iSCB_CMD>>1] = ack_cmd;
608 outb(0, ioaddr + SIGNAL_CA); /* Issue channel-attn. */
609
610 /* Clear the latched interrupt. */
611 outb(0, ioaddr + RESET_IRQ);
612
613 /* Enable the 82586's interrupt input. */
614 outb(0x84, ioaddr + MISC_CTRL);
615
616 return;
617 }
618
619 static int
620 el16_close(struct device *dev)
/* */
621 {
622 int ioaddr = dev->base_addr;
623 ushort *shmem = (short*)dev->mem_start;
624
625 dev->tbusy = 1;
626 dev->start = 0;
627
628 /* Flush the Tx and disable Rx. */
629 shmem[iSCB_CMD >> 1] = RX_SUSPEND | CUC_SUSPEND;
630 outb(0, ioaddr + SIGNAL_CA);
631
632 /* Disable the 82586's input to the interrupt line. */
633 outb(0x80, ioaddr + MISC_CTRL);
634
635 /* We always physically use the IRQ line, so we don't do free_irq().
636 We do remove ourselves from the map. */
637
638 irq2dev_map[dev->irq] = 0;
639
640 /* Update the statistics here. */
641
642 #ifdef MODULE
643 MOD_DEC_USE_COUNT;
644 #endif
645
646 return 0;
647 }
648
649 /* Get the current statistics. This may be called with the card open or
650 closed. */
651 static struct enet_statistics *
652 el16_get_stats(struct device *dev)
/* */
653 {
654 struct net_local *lp = (struct net_local *)dev->priv;
655
656 /* ToDo: decide if there are any useful statistics from the SCB. */
657
658 return &lp->stats;
659 }
660
661 /* Initialize the Rx-block list. */
662 static void
663 init_rx_bufs(struct device *dev)
/* */
664 {
665 struct net_local *lp = (struct net_local *)dev->priv;
666 unsigned short *write_ptr;
667 unsigned short SCB_base = SCB_BASE;
668
669 int cur_rxbuf = lp->rx_head = RX_BUF_START;
670
671 /* Initialize each Rx frame + data buffer. */
672 do { /* While there is room for one more. */
673
674 write_ptr = (unsigned short *)(dev->mem_start + cur_rxbuf);
675
676 *write_ptr++ = 0x0000; /* Status */
677 *write_ptr++ = 0x0000; /* Command */
678 *write_ptr++ = cur_rxbuf + RX_BUF_SIZE; /* Link */
679 *write_ptr++ = cur_rxbuf + 22; /* Buffer offset */
680 *write_ptr++ = 0x0000; /* Pad for dest addr. */
681 *write_ptr++ = 0x0000;
682 *write_ptr++ = 0x0000;
683 *write_ptr++ = 0x0000; /* Pad for source addr. */
684 *write_ptr++ = 0x0000;
685 *write_ptr++ = 0x0000;
686 *write_ptr++ = 0x0000; /* Pad for protocol. */
687
688 *write_ptr++ = 0x0000; /* Buffer: Actual count */
689 *write_ptr++ = -1; /* Buffer: Next (none). */
690 *write_ptr++ = cur_rxbuf + 0x20 + SCB_base; /* Buffer: Address low */
691 *write_ptr++ = 0x0000;
692 /* Finally, the number of bytes in the buffer. */
693 *write_ptr++ = 0x8000 + RX_BUF_SIZE-0x20;
694
695 lp->rx_tail = cur_rxbuf;
696 cur_rxbuf += RX_BUF_SIZE;
697 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
698
699 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
700 the list a ring. */
701 write_ptr = (unsigned short *)
702 (dev->mem_start + lp->rx_tail + 2);
703 *write_ptr++ = 0xC000; /* Command, mark as last. */
704 *write_ptr++ = lp->rx_head; /* Link */
705
706 }
707
708 void
709 init_82586_mem(struct device *dev)
/* */
710 {
711 struct net_local *lp = (struct net_local *)dev->priv;
712 short ioaddr = dev->base_addr;
713 ushort *shmem = (short*)dev->mem_start;
714
715 /* Enable loopback to protect the wire while starting up,
716 and hold the 586 in reset during the memory initialization. */
717 outb(0x20, ioaddr + MISC_CTRL);
718
719 /* Fix the ISCP address and base. */
720 init_words[3] = SCB_BASE;
721 init_words[7] = SCB_BASE;
722
723 /* Write the words at 0xfff6 (address-aliased to 0xfffff6). */
724 memcpy((void*)dev->mem_end-10, init_words, 10);
725
726 /* Write the words at 0x0000. */
727 memcpy((char*)dev->mem_start, init_words + 5, sizeof(init_words) - 10);
728
729 /* Fill in the station address. */
730 memcpy((char*)dev->mem_start+SA_OFFSET, dev->dev_addr,
731 sizeof(dev->dev_addr));
732
733 /* The Tx-block list is written as needed. We just set up the values. */
734 lp->tx_cmd_link = IDLELOOP + 4;
735 lp->tx_head = lp->tx_reap = TX_BUF_START;
736
737 init_rx_bufs(dev);
738
739 /* Start the 586 by releasing the reset line, but leave loopback. */
740 outb(0xA0, ioaddr + MISC_CTRL);
741
742 /* This was time consuming to track down: you need to give two channel
743 attention signals to reliably start up the i82586. */
744 outb(0, ioaddr + SIGNAL_CA);
745
746 {
747 int boguscnt = 50;
748 while (shmem[iSCB_STATUS>>1] == 0)
749 if (--boguscnt == 0) {
750 printk("%s: i82586 initialization timed out with status %04x,"
751 "cmd %04x.\n", dev->name,
752 shmem[iSCB_STATUS>>1], shmem[iSCB_CMD>>1]);
753 break;
754 }
755 /* Issue channel-attn -- the 82586 won't start. */
756 outb(0, ioaddr + SIGNAL_CA);
757 }
758
759 /* Disable loopback and enable interrupts. */
760 outb(0x84, ioaddr + MISC_CTRL);
761 if (net_debug > 4)
762 printk("%s: Initialized 82586, status %04x.\n", dev->name,
763 shmem[iSCB_STATUS>>1]);
764 return;
765 }
766
767 static void
768 hardware_send_packet(struct device *dev, void *buf, short length)
/* */
769 {
770 struct net_local *lp = (struct net_local *)dev->priv;
771 short ioaddr = dev->base_addr;
772 ushort tx_block = lp->tx_head;
773 ushort *write_ptr = (ushort *)(dev->mem_start + tx_block);
774
775 /* Set the write pointer to the Tx block, and put out the header. */
776 *write_ptr++ = 0x0000; /* Tx status */
777 *write_ptr++ = CMD_INTR|CmdTx; /* Tx command */
778 *write_ptr++ = tx_block+16; /* Next command is a NoOp. */
779 *write_ptr++ = tx_block+8; /* Data Buffer offset. */
780
781 /* Output the data buffer descriptor. */
782 *write_ptr++ = length | 0x8000; /* Byte count parameter. */
783 *write_ptr++ = -1; /* No next data buffer. */
784 *write_ptr++ = tx_block+22+SCB_BASE;/* Buffer follows the NoOp command. */
785 *write_ptr++ = 0x0000; /* Buffer address high bits (always zero). */
786
787 /* Output the Loop-back NoOp command. */
788 *write_ptr++ = 0x0000; /* Tx status */
789 *write_ptr++ = CmdNOp; /* Tx command */
790 *write_ptr++ = tx_block+16; /* Next is myself. */
791
792 /* Output the packet at the write pointer. */
793 memcpy(write_ptr, buf, length);
794
795 /* Set the old command link pointing to this send packet. */
796 *(ushort*)(dev->mem_start + lp->tx_cmd_link) = tx_block;
797 lp->tx_cmd_link = tx_block + 20;
798
799 /* Set the next free tx region. */
800 lp->tx_head = tx_block + TX_BUF_SIZE;
801 if (lp->tx_head > RX_BUF_START - TX_BUF_SIZE)
802 lp->tx_head = TX_BUF_START;
803
804 if (net_debug > 4) {
805 printk("%s: 3c507 @%x send length = %d, tx_block %3x, next %3x.\n",
806 dev->name, ioaddr, length, tx_block, lp->tx_head);
807 }
808
809 if (lp->tx_head != lp->tx_reap)
810 dev->tbusy = 0;
811 }
812
813 static void
814 el16_rx(struct device *dev)
/* */
815 {
816 struct net_local *lp = (struct net_local *)dev->priv;
817 short *shmem = (short*)dev->mem_start;
818 ushort rx_head = lp->rx_head;
819 ushort rx_tail = lp->rx_tail;
820 ushort boguscount = 10;
821 short frame_status;
822
823 while ((frame_status = shmem[rx_head>>1]) < 0) { /* Command complete */
824 ushort *read_frame = (short *)(dev->mem_start + rx_head);
825 ushort rfd_cmd = read_frame[1];
826 ushort next_rx_frame = read_frame[2];
827 ushort data_buffer_addr = read_frame[3];
828 ushort *data_frame = (short *)(dev->mem_start + data_buffer_addr);
829 ushort pkt_len = data_frame[0];
830
831 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
832 || pkt_len & 0xC000 != 0xC000) {
833 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
834 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
835 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
836 pkt_len);
837 } else if ((frame_status & 0x2000) == 0) {
838 /* Frame Rxed, but with error. */
839 lp->stats.rx_errors++;
840 if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
841 if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
842 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
843 if (frame_status & 0x0100) lp->stats.rx_over_errors++;
844 if (frame_status & 0x0080) lp->stats.rx_length_errors++;
845 } else {
846 /* Malloc up new buffer. */
847 struct sk_buff *skb;
848
849 pkt_len &= 0x3fff;
850 skb = dev_alloc_skb(pkt_len+2);
851 if (skb == NULL) {
852 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
853 lp->stats.rx_dropped++;
854 break;
855 }
856
857 skb_reserve(skb,2);
858 skb->dev = dev;
859
860 /* 'skb->data' points to the start of sk_buff data area. */
861 memcpy(skb_put(skb,pkt_len), data_frame + 5, pkt_len);
862
863 skb->protocol=eth_type_trans(skb,dev);
864 netif_rx(skb);
865 lp->stats.rx_packets++;
866 }
867
868 /* Clear the status word and set End-of-List on the rx frame. */
869 read_frame[0] = 0;
870 read_frame[1] = 0xC000;
871 /* Clear the end-of-list on the prev. RFD. */
872 *(short*)(dev->mem_start + rx_tail + 2) = 0x0000;
873
874 rx_tail = rx_head;
875 rx_head = next_rx_frame;
876 if (--boguscount == 0)
877 break;
878 }
879
880 lp->rx_head = rx_head;
881 lp->rx_tail = rx_tail;
882 }
883 #ifdef MODULE
884 char kernel_version[] = UTS_RELEASE;
885 static char devicename[9] = { 0, };
886 static struct device dev_3c507 = {
887 devicename, /* device name is inserted by linux/drivers/net/net_init.c */
888 0, 0, 0, 0,
889 0, 0,
890 0, 0, 0, NULL, el16_probe
891 };
892
893 int io = 0x300;
894 int irq = 0;
895
896 int init_module(void)
/* */
897 {
898 if (io == 0)
899 printk("3c507: You should not use auto-probing with insmod!\n");
900 dev_3c507.base_addr = io;
901 dev_3c507.irq = irq;
902 if (register_netdev(&dev_3c507) != 0) {
903 printk("3c507: register_netdev() returned non-zero.\n");
904 return -EIO;
905 }
906 return 0;
907 }
908
909 void
910 cleanup_module(void)
/* ![[last]](../icons/n_last.png)
*/
911 {
912 if (MOD_IN_USE)
913 printk("3c507: device busy, remove delayed\n");
914 else
915 {
916 unregister_netdev(&dev_3c507);
917
918 /* If we don't do this, we can't re-insmod it later. */
919 free_irq(dev_3c507.irq);
920 release_region(dev_3c507.base_addr, EL16_IO_EXTENT);
921 }
922 }
923 #endif /* MODULE */
924
925 /*
926 * Local variables:
927 * 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"
928 * version-control: t
929 * kept-new-versions: 5
930 * tab-width: 4
931 * c-indent-level: 4
932 * End:
933 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/