![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eexpress.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net|
Return to eexpress.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net |
1.1 root 1: /* eexpress.c: Intel EtherExpress device driver for Linux. */
2: /*
3: Written 1993 by Donald Becker.
4: Copyright 1993 United States Government as represented by the Director,
5: National Security Agency. This software may only be used and distributed
6: according to the terms of the GNU Public License as modified by SRC,
7: incorporated herein by reference.
8:
9: The author may be reached as [email protected] or
10: C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
11:
12: Things remaining to do:
13: Check that the 586 and ASIC are reset/unreset at the right times.
14: Check tx and rx buffer setup.
15: The current Tx is single-buffer-only.
16: Move the theory of operation and memory map documentation.
17: Rework the board error reset
18: The statistics need to be updated correctly.
19:
20: Modularized by Pauline Middelink <[email protected]>
21: Changed to support io= irq= by Alan Cox <[email protected]>
22: */
23:
24: static const char *version =
25: "eexpress.c:v0.07 1/19/94 Donald Becker ([email protected])\n";
26:
27: /*
28: Sources:
29: This driver wouldn't have been written with the availability of the
30: Crynwr driver source code. It provided a known-working implementation
31: that filled in the gaping holes of the Intel documentation. Three cheers
32: for Russ Nelson.
33:
34: Intel Microcommunications Databook, Vol. 1, 1990. It provides just enough
35: info that the casual reader might think that it documents the i82586.
36: */
37:
38: #include <linux/module.h>
39:
40: #include <linux/kernel.h>
41: #include <linux/sched.h>
42: #include <linux/types.h>
43: #include <linux/fcntl.h>
44: #include <linux/interrupt.h>
45: #include <linux/ptrace.h>
46: #include <linux/ioport.h>
47: #include <linux/string.h>
48: #include <linux/in.h>
49: #include <asm/system.h>
50: #include <asm/bitops.h>
51: #include <asm/io.h>
52: #include <asm/dma.h>
53: #include <linux/errno.h>
54:
55: #include <linux/netdevice.h>
56: #include <linux/etherdevice.h>
57: #include <linux/skbuff.h>
58: #include <linux/malloc.h>
59:
60: /* use 0 for production, 1 for verification, 2..7 for debug */
61: #ifndef NET_DEBUG
62: #define NET_DEBUG 2
63: #endif
64: static unsigned int net_debug = NET_DEBUG;
65:
66: /*
67: Details of the i82586.
68:
69: You'll really need the databook to understand the details of this part,
70: but the outline is that the i82586 has two separate processing units.
71:
72: The Rx unit uses a list of frame descriptors and a list of data buffer
73: descriptors. We use full-sized (1518 byte) data buffers, so there is
74: a one-to-one pairing of frame descriptors to buffer descriptors.
75:
76: The Tx ("command") unit executes a list of commands that look like:
77: Status word Written by the 82586 when the command is done.
78: Command word Command in lower 3 bits, post-command action in upper 3
79: Link word The address of the next command.
80: Parameters (as needed).
81:
82: Some definitions related to the Command Word are:
83: */
84: #define CMD_EOL 0x8000 /* The last command of the list, stop. */
85: #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
86: #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
87:
88: enum commands {
89: CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
90: CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
91:
92: /* Information that need to be kept for each board. */
93: struct net_local {
94: struct enet_statistics stats;
95: int last_restart;
96: short rx_head;
97: short rx_tail;
98: short tx_head;
99: short tx_cmd_link;
100: short tx_reap;
101: };
102:
103: /*
104: Details of the EtherExpress Implementation
105: The EtherExpress takes an unusual approach to host access to packet buffer
106: memory. The host can use either the Dataport, with independent
107: autoincrementing read and write pointers, or it can I/O map 32 bytes of the
108: memory using the "Shadow Memory Pointer" (SMB) as follows:
109: ioaddr Normal EtherExpress registers
110: ioaddr+0x4000...0x400f Buffer Memory at SMB...SMB+15
111: ioaddr+0x8000...0x800f Buffer Memory at SMB+16...SMB+31
112: ioaddr+0xC000...0xC007 "" SMB+16...SMB+23 (hardware flaw?)
113: ioaddr+0xC008...0xC00f Buffer Memory at 0x0008...0x000f
114: The last I/O map set is useful if you put the i82586 System Command Block
115: (the command mailbox) exactly at 0x0008. (There seems to be some
116: undocumented init structure at 0x0000-7, so I had to use the Crywnr memory
117: setup verbatim for those four words anyway.)
118:
119: A problem with using either one of these mechanisms is that you must run
120: single-threaded, or the interrupt handler must restore a changed value of
121: the read, write, or SMB pointers.
122:
123: Unlike the Crynwr driver, my driver mostly ignores the I/O mapped "feature"
124: and relies heavily on the dataport for buffer memory access. To minimize
125: switching, the read_pointer is dedicated to the Rx interrupt handler, and
126: the write_pointer is used by the send_packet() routine (it's carefully saved
127: and restored when it's needed by the interrupt handler).
128: */
129:
130: /* Offsets from the base I/O address. */
131: #define DATAPORT 0 /* Data Transfer Register. */
132: #define WRITE_PTR 2 /* Write Address Pointer. */
133: #define READ_PTR 4 /* Read Address Pointer. */
134: #define SIGNAL_CA 6 /* Frob the 82586 Channel Attention line. */
135: #define SET_IRQ 7 /* IRQ Select. */
136: #define SHADOW_PTR 8 /* Shadow Memory Bank Pointer. */
137: #define MEM_Ctrl 11
138: #define MEM_Page_Ctrl 12
139: #define Config 13
140: #define EEPROM_Ctrl 14
141: #define ID_PORT 15
142:
143: #define EEXPRESS_IO_EXTENT 16
144:
145: /* EEPROM_Ctrl bits. */
146:
147: #define EE_SHIFT_CLK 0x01 /* EEPROM shift clock. */
148: #define EE_CS 0x02 /* EEPROM chip select. */
149: #define EE_DATA_WRITE 0x04 /* EEPROM chip data in. */
150: #define EE_DATA_READ 0x08 /* EEPROM chip data out. */
151: #define EE_CTRL_BITS (EE_SHIFT_CLK | EE_CS | EE_DATA_WRITE | EE_DATA_READ)
152: #define ASIC_RESET 0x40
153: #define _586_RESET 0x80
154:
155: /* Offsets to elements of the System Control Block structure. */
156: #define SCB_STATUS 0xc008
157: #define SCB_CMD 0xc00A
158: #define CUC_START 0x0100
159: #define CUC_RESUME 0x0200
160: #define CUC_SUSPEND 0x0300
161: #define RX_START 0x0010
162: #define RX_RESUME 0x0020
163: #define RX_SUSPEND 0x0030
164: #define SCB_CBL 0xc00C /* Command BLock offset. */
165: #define SCB_RFA 0xc00E /* Rx Frame Area offset. */
166:
167: /*
168: What follows in 'init_words[]' is the "program" that is downloaded to the
169: 82586 memory. It's mostly tables and command blocks, and starts at the
170: reset address 0xfffff6.
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; they are
177: completely undocumented. I had 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 0x0680 /* packet+header+TBD+extra (1518+14+20+16) */
196: #define TX_BUF_END 0x2000
197:
198: #define RX_BUF_START 0x2000
199: #define RX_BUF_SIZE (0x640) /* packet+header+RBD+extra */
200: #define RX_BUF_END 0x4000
201:
202: /*
203: That's it: only 86 bytes to set up the beast, including every extra
204: command available. The 170 byte buffer at DUMP_DATA is shared between the
205: Dump command (called only by the diagnostic program) and the SetMulticastList
206: command.
207:
208: To complete the memory setup you only have to write the station address at
209: SA_OFFSET and create the Tx & Rx buffer lists.
210:
211: The Tx command chain and buffer list is setup as follows:
212: A Tx command table, with the data buffer pointing to...
213: A Tx data buffer descriptor. The packet is in a single buffer, rather than
214: chaining together several smaller buffers.
215: A NoOp command, which initially points to itself,
216: And the packet data.
217:
218: A transmit is done by filling in the Tx command table and data buffer,
219: re-writing the NoOp command, and finally changing the offset of the last
220: command to point to the current Tx command. When the Tx command is finished,
221: it jumps to the NoOp, when it loops until the next Tx command changes the
222: "link offset" in the NoOp. This way the 82586 never has to go through the
223: slow restart sequence.
224:
225: The Rx buffer list is set up in the obvious ring structure. We have enough
226: memory (and low enough interrupt latency) that we can avoid the complicated
227: Rx buffer linked lists by alway associating a full-size Rx data buffer with
228: each Rx data frame.
229:
230: I current use four transmit buffers starting at TX_BUF_START (0x0100), and
231: use the rest of memory, from RX_BUF_START to RX_BUF_END, for Rx buffers.
232:
233: */
234:
235: static short init_words[] = {
236: 0x0000, /* Set bus size to 16 bits. */
237: 0x0000,0x0000, /* Set control mailbox (SCB) addr. */
238: 0,0, /* pad to 0x000000. */
239: 0x0001, /* Status word that's cleared when init is done. */
240: 0x0008,0,0, /* SCB offset, (skip, skip) */
241:
242: 0,0xf000|RX_START|CUC_START, /* SCB status and cmd. */
243: CONFIG_CMD, /* Command list pointer, points to Configure. */
244: RX_BUF_START, /* Rx block list. */
245: 0,0,0,0, /* Error count: CRC, align, buffer, overrun. */
246:
247: /* 0x0018: Configure command. Change to put MAC data with packet. */
248: 0, CmdConfigure, /* Status, command. */
249: SET_SA_CMD, /* Next command is Set Station Addr. */
250: 0x0804, /* "4" bytes of config data, 8 byte FIFO. */
251: 0x2e40, /* Magic values, including MAC data location. */
252: 0, /* Unused pad word. */
253:
254: /* 0x0024: Setup station address command. */
255: 0, CmdSASetup,
256: SET_MC_CMD, /* Next command. */
257: 0xaa00,0xb000,0x0bad, /* Station address (to be filled in) */
258:
259: /* 0x0030: NOP, looping back to itself. Point to first Tx buffer to Tx. */
260: 0, CmdNOp, IDLELOOP, 0 /* pad */,
261:
262: /* 0x0038: A unused Time-Domain Reflectometer command. */
263: 0, CmdTDR, IDLELOOP, 0,
264:
265: /* 0x0040: An unused Dump State command. */
266: 0, CmdDump, IDLELOOP, DUMP_DATA,
267:
268: /* 0x0048: An unused Diagnose command. */
269: 0, CmdDiagnose, IDLELOOP,
270:
271: /* 0x004E: An empty set-multicast-list command. */
272: #ifdef initial_text_tx
273: 0, CmdMulticastList, DUMP_DATA, 0,
274: #else
275: 0, CmdMulticastList, IDLELOOP, 0,
276: #endif
277:
278: /* 0x0056: A continuous transmit command, only here for testing. */
279: 0, CmdTx, DUMP_DATA, DUMP_DATA+8, 0x83ff, -1, DUMP_DATA, 0,
280: };
281:
282: /* Index to functions, as function prototypes. */
283:
284: extern int express_probe(struct device *dev); /* Called from Space.c */
285:
286: static int eexp_probe1(struct device *dev, short ioaddr);
287: static int eexp_open(struct device *dev);
288: static int eexp_send_packet(struct sk_buff *skb, struct device *dev);
289: static void eexp_interrupt(int irq, struct pt_regs *regs);
290: static void eexp_rx(struct device *dev);
291: static int eexp_close(struct device *dev);
292: static struct enet_statistics *eexp_get_stats(struct device *dev);
293: static void set_multicast_list(struct device *dev);
294:
295: static int read_eeprom(int ioaddr, int location);
296: static void hardware_send_packet(struct device *dev, void *buf, short length);
297: static void init_82586_mem(struct device *dev);
298: static void init_rx_bufs(struct device *dev);
299:
300:
301: /* Check for a network adaptor of this type, and return '0' iff one exists.
302: If dev->base_addr == 0, probe all likely locations.
303: If dev->base_addr == 1, always return failure.
304: If dev->base_addr == 2, (detachable devices only) allocate space for the
305: device and return success.
306: */
307: int
308: express_probe(struct device *dev)
309: {
310: /* Don't probe all settable addresses, 0x[23][0-7]0, just common ones. */
311: int *port, ports[] = {0x300, 0x270, 0x320, 0x340, 0};
312: int base_addr = dev->base_addr;
313:
314: if (base_addr > 0x1ff) /* Check a single specified location. */
315: return eexp_probe1(dev, base_addr);
316: else if (base_addr > 0)
317: return ENXIO; /* Don't probe at all. */
318:
319: for (port = &ports[0]; *port; port++) {
320: short id_addr = *port + ID_PORT;
321: unsigned short sum = 0;
322: int i;
323: #ifdef notdef
324: for (i = 16; i > 0; i--)
325: sum += inb(id_addr);
326: printk("EtherExpress ID checksum is %04x.\n", sum);
327: #else
328: for (i = 4; i > 0; i--) {
329: short id_val = inb(id_addr);
330: sum |= (id_val >> 4) << ((id_val & 3) << 2);
331: }
332: #endif
333: if (sum == 0xbaba
334: && eexp_probe1(dev, *port) == 0)
335: return 0;
336: }
337:
338: return ENODEV;
339: }
340:
341: int eexp_probe1(struct device *dev, short ioaddr)
342: {
343: unsigned short station_addr[3];
344: int i;
345:
346: printk("%s: EtherExpress at %#x,", dev->name, ioaddr);
347:
348: /* The station address is stored !backwards! in the EEPROM, reverse
349: after reading. (Hmmm, a little brain-damage there at Intel, eh?) */
350: station_addr[0] = read_eeprom(ioaddr, 2);
351: station_addr[1] = read_eeprom(ioaddr, 3);
352: station_addr[2] = read_eeprom(ioaddr, 4);
353:
354: /* Check the first three octets of the S.A. for the manufacturer's code. */
355: if (station_addr[2] != 0x00aa || (station_addr[1] & 0xff00) != 0x0000) {
356: printk(" rejected (invalid address %04x%04x%04x).\n",
357: station_addr[2], station_addr[1], station_addr[0]);
358: return ENODEV;
359: }
360:
361: /* We've committed to using the board, and can start filling in *dev. */
362: request_region(ioaddr, EEXPRESS_IO_EXTENT, "eexpress");
363: dev->base_addr = ioaddr;
364:
365: for (i = 0; i < 6; i++) {
366: dev->dev_addr[i] = ((unsigned char*)station_addr)[5-i];
367: printk(" %02x", dev->dev_addr[i]);
368: }
369:
370: /* There is no reason for the driver to care, but I print out the
371: interface to minimize bogus bug reports. */
372: {
373: char irqmap[] = {0, 9, 3, 4, 5, 10, 11, 0};
374: const char *ifmap[] = {"AUI", "BNC", "10baseT"};
375: enum iftype {AUI=0, BNC=1, TP=2};
376: unsigned short setupval = read_eeprom(ioaddr, 0);
377:
378: dev->irq = irqmap[setupval >> 13];
379: dev->if_port = (setupval & 0x1000) == 0 ? AUI :
380: read_eeprom(ioaddr, 5) & 0x1 ? TP : BNC;
381: printk(", IRQ %d, Interface %s.\n", dev->irq, ifmap[dev->if_port]);
382: /* Release the IRQ line so that it can be shared if we don't use the
383: ethercard. */
384: outb(0x00, ioaddr + SET_IRQ);
385: }
386:
387: /* It's now OK to leave the board in reset, pending the open(). */
388: outb(ASIC_RESET, ioaddr + EEPROM_Ctrl);
389:
390: if ((dev->mem_start & 0xf) > 0)
391: net_debug = dev->mem_start & 7;
392:
393: if (net_debug)
394: printk(version);
395:
396: /* Initialize the device structure. */
397: dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
398: if (dev->priv == NULL)
399: return -ENOMEM;
400: memset(dev->priv, 0, sizeof(struct net_local));
401:
402: dev->open = eexp_open;
403: dev->stop = eexp_close;
404: dev->hard_start_xmit = eexp_send_packet;
405: dev->get_stats = eexp_get_stats;
406: dev->set_multicast_list = &set_multicast_list;
407:
408: /* Fill in the fields of the device structure with ethernet-generic values. */
409:
410: ether_setup(dev);
411:
412: dev->flags&=~IFF_MULTICAST;
413:
414: return 0;
415: }
416:
417:
418: /* Reverse IRQ map: the value to put in the SET_IRQ reg. for IRQ<index>. */
419: static char irqrmap[]={0,0,1,2,3,4,0,0,0,1,5,6,0,0,0,0};
420:
421: static int
422: eexp_open(struct device *dev)
423: {
424: int ioaddr = dev->base_addr;
425:
426: if (dev->irq == 0 || irqrmap[dev->irq] == 0)
427: return -ENXIO;
428:
429: if (irq2dev_map[dev->irq] != 0
430: /* This is always true, but avoid the false IRQ. */
431: || (irq2dev_map[dev->irq] = dev) == 0
432: || request_irq(dev->irq, &eexp_interrupt, 0, "EExpress")) {
433: return -EAGAIN;
434: }
435:
436: /* Initialize the 82586 memory and start it. */
437: init_82586_mem(dev);
438:
439: /* Enable the interrupt line. */
440: outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
441:
442: dev->tbusy = 0;
443: dev->interrupt = 0;
444: dev->start = 1;
445: MOD_INC_USE_COUNT;
446: return 0;
447: }
448:
449: static int
450: eexp_send_packet(struct sk_buff *skb, struct device *dev)
451: {
452: struct net_local *lp = (struct net_local *)dev->priv;
453: int ioaddr = dev->base_addr;
454:
455: if (dev->tbusy) {
456: /* If we get here, some higher level has decided we are broken.
457: There should really be a "kick me" function call instead. */
458: int tickssofar = jiffies - dev->trans_start;
459: if (tickssofar < 5)
460: return 1;
461: if (net_debug > 1)
462: printk("%s: transmit timed out, %s? ", dev->name,
463: inw(ioaddr+SCB_STATUS) & 0x8000 ? "IRQ conflict" :
464: "network cable problem");
465: lp->stats.tx_errors++;
466: /* Try to restart the adaptor. */
467: if (lp->last_restart == lp->stats.tx_packets) {
468: if (net_debug > 1) printk("Resetting board.\n");
469: /* Completely reset the adaptor. */
470: init_82586_mem(dev);
471: } else {
472: /* Issue the channel attention signal and hope it "gets better". */
473: if (net_debug > 1) printk("Kicking board.\n");
474: outw(0xf000|CUC_START|RX_START, ioaddr + SCB_CMD);
475: outb(0, ioaddr + SIGNAL_CA);
476: lp->last_restart = lp->stats.tx_packets;
477: }
478: dev->tbusy=0;
479: dev->trans_start = jiffies;
480: }
481:
482: /* If some higher layer thinks we've missed an tx-done interrupt
483: we are passed NULL. Caution: dev_tint() handles the cli()/sti()
484: itself. */
485: if (skb == NULL) {
486: dev_tint(dev);
487: return 0;
488: }
489:
490: /* Block a timer-based transmit from overlapping. */
491: if (set_bit(0, (void*)&dev->tbusy) != 0)
492: printk("%s: Transmitter access conflict.\n", dev->name);
493: else {
494: short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
495: unsigned char *buf = skb->data;
496:
497: /* Disable the 82586's input to the interrupt line. */
498: outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
499: hardware_send_packet(dev, buf, length);
500: dev->trans_start = jiffies;
501: /* Enable the 82586 interrupt input. */
502: outb(0x08 | irqrmap[dev->irq], ioaddr + SET_IRQ);
503: }
504:
505: dev_kfree_skb (skb, FREE_WRITE);
506:
507: /* You might need to clean up and record Tx statistics here. */
508: lp->stats.tx_aborted_errors++;
509:
510: return 0;
511: }
512:
513: /* The typical workload of the driver:
514: Handle the network interface interrupts. */
515: static void
516: eexp_interrupt(int irq, struct pt_regs *regs)
517: {
518: struct device *dev = (struct device *)(irq2dev_map[irq]);
519: struct net_local *lp;
520: int ioaddr, status, boguscount = 0;
521: short ack_cmd;
522:
523: if (dev == NULL) {
524: printk ("net_interrupt(): irq %d for unknown device.\n", irq);
525: return;
526: }
527: dev->interrupt = 1;
528:
529: ioaddr = dev->base_addr;
530: lp = (struct net_local *)dev->priv;
531:
532: status = inw(ioaddr + SCB_STATUS);
533:
534: if (net_debug > 4) {
535: printk("%s: EExp interrupt, status %4.4x.\n", dev->name, status);
536: }
537:
538: /* Disable the 82586's input to the interrupt line. */
539: outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
540:
541: /* Reap the Tx packet buffers. */
542: while (lp->tx_reap != lp->tx_head) { /* if (status & 0x8000) */
543: unsigned short tx_status;
544: outw(lp->tx_reap, ioaddr + READ_PTR);
545: tx_status = inw(ioaddr);
546: if (tx_status == 0) {
547: if (net_debug > 5) printk("Couldn't reap %#x.\n", lp->tx_reap);
548: break;
549: }
550: if (tx_status & 0x2000) {
551: lp->stats.tx_packets++;
552: lp->stats.collisions += tx_status & 0xf;
553: dev->tbusy = 0;
554: mark_bh(NET_BH); /* Inform upper layers. */
555: } else {
556: lp->stats.tx_errors++;
557: if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
558: if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
559: if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
560: if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
561: }
562: if (net_debug > 5)
563: printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
564: lp->tx_reap += TX_BUF_SIZE;
565: if (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
566: lp->tx_reap = TX_BUF_START;
567: if (++boguscount > 4)
568: break;
569: }
570:
571: if (status & 0x4000) { /* Packet received. */
572: if (net_debug > 5)
573: printk("Received packet, rx_head %04x.\n", lp->rx_head);
574: eexp_rx(dev);
575: }
576:
577: /* Acknowledge the interrupt sources. */
578: ack_cmd = status & 0xf000;
579:
580: if ((status & 0x0700) != 0x0200 && dev->start) {
581: short saved_write_ptr = inw(ioaddr + WRITE_PTR);
582: if (net_debug > 1)
583: printk("%s: Command unit stopped, status %04x, restarting.\n",
584: dev->name, status);
585: /* If this ever occurs we must re-write the idle loop, reset
586: the Tx list, and do a complete restart of the command unit. */
587: outw(IDLELOOP, ioaddr + WRITE_PTR);
588: outw(0, ioaddr);
589: outw(CmdNOp, ioaddr);
590: outw(IDLELOOP, ioaddr);
591: outw(IDLELOOP, SCB_CBL);
592: lp->tx_cmd_link = IDLELOOP + 4;
593: lp->tx_head = lp->tx_reap = TX_BUF_START;
594: /* Restore the saved write pointer. */
595: outw(saved_write_ptr, ioaddr + WRITE_PTR);
596: ack_cmd |= CUC_START;
597: }
598:
599: if ((status & 0x0070) != 0x0040 && dev->start) {
600: short saved_write_ptr = inw(ioaddr + WRITE_PTR);
601: /* The Rx unit is not ready, it must be hung. Restart the receiver by
602: initializing the rx buffers, and issuing an Rx start command. */
603: lp->stats.rx_errors++;
604: if (net_debug > 1) {
605: int cur_rxbuf = RX_BUF_START;
606: printk("%s: Rx unit stopped status %04x rx head %04x tail %04x.\n",
607: dev->name, status, lp->rx_head, lp->rx_tail);
608: while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE) {
609: int i;
610: printk(" Rx buf at %04x:", cur_rxbuf);
611: outw(cur_rxbuf, ioaddr + READ_PTR);
612: for (i = 0; i < 0x20; i += 2)
613: printk(" %04x", inw(ioaddr));
614: printk(".\n");
615: cur_rxbuf += RX_BUF_SIZE;
616: }
617: }
618: init_rx_bufs(dev);
619: outw(RX_BUF_START, SCB_RFA);
620: outw(saved_write_ptr, ioaddr + WRITE_PTR);
621: ack_cmd |= RX_START;
622: }
623:
624: outw(ack_cmd, ioaddr + SCB_CMD);
625: outb(0, ioaddr + SIGNAL_CA);
626:
627: if (net_debug > 5) {
628: printk("%s: EExp exiting interrupt, status %4.4x.\n", dev->name,
629: inw(ioaddr + SCB_CMD));
630: }
631: /* Enable the 82586's input to the interrupt line. */
632: outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
633: return;
634: }
635:
636: static int
637: eexp_close(struct device *dev)
638: {
639: int ioaddr = dev->base_addr;
640:
641: dev->tbusy = 1;
642: dev->start = 0;
643:
644: /* Flush the Tx and disable Rx. */
645: outw(RX_SUSPEND | CUC_SUSPEND, ioaddr + SCB_CMD);
646: outb(0, ioaddr + SIGNAL_CA);
647:
648: /* Disable the physical interrupt line. */
649: outb(0, ioaddr + SET_IRQ);
650:
651: free_irq(dev->irq);
652:
653: irq2dev_map[dev->irq] = 0;
654:
655: /* Update the statistics here. */
656:
657: MOD_DEC_USE_COUNT;
658: return 0;
659: }
660:
661: /* Get the current statistics. This may be called with the card open or
662: closed. */
663: static struct enet_statistics *
664: eexp_get_stats(struct device *dev)
665: {
666: struct net_local *lp = (struct net_local *)dev->priv;
667:
668: /* ToDo: decide if there are any useful statistics from the SCB. */
669:
670: return &lp->stats;
671: }
672:
673: /* Set or clear the multicast filter for this adaptor.
674: */
675: static void
676: set_multicast_list(struct device *dev)
677: {
678: /* This doesn't work yet */
679: #if 0
680: short ioaddr = dev->base_addr;
681: if (num_addrs < 0) {
682: /* Not written yet, this requires expanding the init_words config
683: cmd. */
684: } else if (num_addrs > 0) {
685: /* Fill in the SET_MC_CMD with the number of address bytes, followed
686: by the list of multicast addresses to be accepted. */
687: outw(SET_MC_CMD + 6, ioaddr + WRITE_PTR);
688: outw(num_addrs * 6, ioaddr);
689: outsw(ioaddr, addrs, num_addrs*3); /* 3 = addr len in words */
690: /* We must trigger a whole 586 reset due to a bug. */
691: } else {
692: /* Not written yet, this requires expanding the init_words config
693: cmd. */
694: outw(99, ioaddr); /* Disable promiscuous mode, use normal mode */
695: }
696: #endif
697: }
698:
699: /* The horrible routine to read a word from the serial EEPROM. */
700:
701: /* The delay between EEPROM clock transitions. */
702: #define eeprom_delay() { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
703: #define EE_READ_CMD (6 << 6)
704:
705: int
706: read_eeprom(int ioaddr, int location)
707: {
708: int i;
709: unsigned short retval = 0;
710: short ee_addr = ioaddr + EEPROM_Ctrl;
711: int read_cmd = location | EE_READ_CMD;
712: short ctrl_val = EE_CS | _586_RESET;
713:
714: outb(ctrl_val, ee_addr);
715:
716: /* Shift the read command bits out. */
717: for (i = 8; i >= 0; i--) {
718: short outval = (read_cmd & (1 << i)) ? ctrl_val | EE_DATA_WRITE
719: : ctrl_val;
720: outb(outval, ee_addr);
721: outb(outval | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
722: eeprom_delay();
723: outb(outval, ee_addr); /* Finish EEPROM a clock tick. */
724: eeprom_delay();
725: }
726: outb(ctrl_val, ee_addr);
727:
728: for (i = 16; i > 0; i--) {
729: outb(ctrl_val | EE_SHIFT_CLK, ee_addr); eeprom_delay();
730: retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
731: outb(ctrl_val, ee_addr); eeprom_delay();
732: }
733:
734: /* Terminate the EEPROM access. */
735: ctrl_val &= ~EE_CS;
736: outb(ctrl_val | EE_SHIFT_CLK, ee_addr);
737: eeprom_delay();
738: outb(ctrl_val, ee_addr);
739: eeprom_delay();
740: return retval;
741: }
742:
743: static void
744: init_82586_mem(struct device *dev)
745: {
746: struct net_local *lp = (struct net_local *)dev->priv;
747: short ioaddr = dev->base_addr;
748:
749: /* Enable loopback to protect the wire while starting up.
750: This is Superstition From Crynwr. */
751: outb(inb(ioaddr + Config) | 0x02, ioaddr + Config);
752:
753: /* Hold the 586 in reset during the memory initialization. */
754: outb(_586_RESET, ioaddr + EEPROM_Ctrl);
755:
756: /* Place the write pointer at 0xfff6 (address-aliased to 0xfffff6). */
757: outw(0xfff6, ioaddr + WRITE_PTR);
758: outsw(ioaddr, init_words, sizeof(init_words)>>1);
759:
760: /* Fill in the station address. */
761: outw(SA_OFFSET, ioaddr + WRITE_PTR);
762: outsw(ioaddr, dev->dev_addr, 3);
763:
764: /* The Tx-block list is written as needed. We just set up the values. */
765: #ifdef initial_text_tx
766: lp->tx_cmd_link = DUMP_DATA + 4;
767: #else
768: lp->tx_cmd_link = IDLELOOP + 4;
769: #endif
770: lp->tx_head = lp->tx_reap = TX_BUF_START;
771:
772: init_rx_bufs(dev);
773:
774: /* Start the 586 by releasing the reset line. */
775: outb(0x00, ioaddr + EEPROM_Ctrl);
776:
777: /* This was time consuming to track down: you need to give two channel
778: attention signals to reliably start up the i82586. */
779: outb(0, ioaddr + SIGNAL_CA);
780:
781: {
782: int boguscnt = 50;
783: while (inw(ioaddr + SCB_STATUS) == 0)
784: if (--boguscnt == 0) {
785: printk("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
786: dev->name, inw(ioaddr + SCB_STATUS), inw(ioaddr + SCB_CMD));
787: break;
788: }
789: /* Issue channel-attn -- the 82586 won't start without it. */
790: outb(0, ioaddr + SIGNAL_CA);
791: }
792:
793: /* Disable loopback. */
794: outb(inb(ioaddr + Config) & ~0x02, ioaddr + Config);
795: if (net_debug > 4)
796: printk("%s: Initialized 82586, status %04x.\n", dev->name,
797: inw(ioaddr + SCB_STATUS));
798: return;
799: }
800:
801: /* Initialize the Rx-block list. */
802: static void init_rx_bufs(struct device *dev)
803: {
804: struct net_local *lp = (struct net_local *)dev->priv;
805: short ioaddr = dev->base_addr;
806:
807: int cur_rxbuf = lp->rx_head = RX_BUF_START;
808:
809: /* Initialize each Rx frame + data buffer. */
810: do { /* While there is room for one more. */
811: outw(cur_rxbuf, ioaddr + WRITE_PTR);
812: outw(0x0000, ioaddr); /* Status */
813: outw(0x0000, ioaddr); /* Command */
814: outw(cur_rxbuf + RX_BUF_SIZE, ioaddr); /* Link */
815: outw(cur_rxbuf + 22, ioaddr); /* Buffer offset */
816: outw(0xFeed, ioaddr); /* Pad for dest addr. */
817: outw(0xF00d, ioaddr);
818: outw(0xF001, ioaddr);
819: outw(0x0505, ioaddr); /* Pad for source addr. */
820: outw(0x2424, ioaddr);
821: outw(0x6565, ioaddr);
822: outw(0xdeaf, ioaddr); /* Pad for protocol. */
823:
824: outw(0x0000, ioaddr); /* Buffer: Actual count */
825: outw(-1, ioaddr); /* Buffer: Next (none). */
826: outw(cur_rxbuf + 0x20, ioaddr); /* Buffer: Address low */
827: outw(0x0000, ioaddr);
828: /* Finally, the number of bytes in the buffer. */
829: outw(0x8000 + RX_BUF_SIZE-0x20, ioaddr);
830:
831: lp->rx_tail = cur_rxbuf;
832: cur_rxbuf += RX_BUF_SIZE;
833: } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
834:
835: /* Terminate the list by setting the EOL bit, and wrap the pointer to make
836: the list a ring. */
837: outw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
838: outw(0xC000, ioaddr); /* Command, mark as last. */
839: outw(lp->rx_head, ioaddr); /* Link */
840: }
841:
842: static void
843: hardware_send_packet(struct device *dev, void *buf, short length)
844: {
845: struct net_local *lp = (struct net_local *)dev->priv;
846: short ioaddr = dev->base_addr;
847: short tx_block = lp->tx_head;
848:
849: /* Set the write pointer to the Tx block, and put out the header. */
850: outw(tx_block, ioaddr + WRITE_PTR);
851: outw(0x0000, ioaddr); /* Tx status */
852: outw(CMD_INTR|CmdTx, ioaddr); /* Tx command */
853: outw(tx_block+16, ioaddr); /* Next command is a NoOp. */
854: outw(tx_block+8, ioaddr); /* Data Buffer offset. */
855:
856: /* Output the data buffer descriptor. */
857: outw(length | 0x8000, ioaddr); /* Byte count parameter. */
858: outw(-1, ioaddr); /* No next data buffer. */
859: outw(tx_block+22, ioaddr); /* Buffer follows the NoOp command. */
860: outw(0x0000, ioaddr); /* Buffer address high bits (always zero). */
861:
862: /* Output the Loop-back NoOp command. */
863: outw(0x0000, ioaddr); /* Tx status */
864: outw(CmdNOp, ioaddr); /* Tx command */
865: outw(tx_block+16, ioaddr); /* Next is myself. */
866:
867: /* Output the packet using the write pointer.
868: Hmmm, it feels a little like a 3c501! */
869: outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
870:
871: /* Set the old command link pointing to this send packet. */
872: outw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
873: outw(tx_block, ioaddr);
874: lp->tx_cmd_link = tx_block + 20;
875:
876: /* Set the next free tx region. */
877: lp->tx_head = tx_block + TX_BUF_SIZE;
878: if (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
879: lp->tx_head = TX_BUF_START;
880:
881: if (net_debug > 4) {
882: printk("%s: EExp @%x send length = %d, tx_block %3x, next %3x, "
883: "reap %4x status %4.4x.\n", dev->name, ioaddr, length,
884: tx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
885: }
886:
887: if (lp->tx_head != lp->tx_reap)
888: dev->tbusy = 0;
889: }
890:
891: static void
892: eexp_rx(struct device *dev)
893: {
894: struct net_local *lp = (struct net_local *)dev->priv;
895: short ioaddr = dev->base_addr;
896: short saved_write_ptr = inw(ioaddr + WRITE_PTR);
897: short rx_head = lp->rx_head;
898: short rx_tail = lp->rx_tail;
899: short boguscount = 10;
900: short frame_status;
901:
902: /* Set the read pointer to the Rx frame. */
903: outw(rx_head, ioaddr + READ_PTR);
904: while ((frame_status = inw(ioaddr)) < 0) { /* Command complete */
905: short rfd_cmd = inw(ioaddr);
906: short next_rx_frame = inw(ioaddr);
907: short data_buffer_addr = inw(ioaddr);
908: short pkt_len;
909:
910: /* Set the read pointer the data buffer. */
911: outw(data_buffer_addr, ioaddr + READ_PTR);
912: pkt_len = inw(ioaddr);
913:
914: if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
915: || (pkt_len & 0xC000) != 0xC000) {
916: printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
917: "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
918: frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
919: pkt_len);
920: } else if ((frame_status & 0x2000) == 0) {
921: /* Frame Rxed, but with error. */
922: lp->stats.rx_errors++;
923: if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
924: if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
925: if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
926: if (frame_status & 0x0100) lp->stats.rx_over_errors++;
927: if (frame_status & 0x0080) lp->stats.rx_length_errors++;
928: } else {
929: /* Malloc up new buffer. */
930: struct sk_buff *skb;
931:
932: pkt_len &= 0x3fff;
933: skb = dev_alloc_skb(pkt_len+2);
934: if (skb == NULL) {
935: printk("%s: Memory squeeze, dropping packet.\n", dev->name);
936: lp->stats.rx_dropped++;
937: break;
938: }
939: skb->dev = dev;
940: skb_reserve(skb,2);
941:
942: outw(data_buffer_addr + 10, ioaddr + READ_PTR);
943:
944: insw(ioaddr, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
945:
946: skb->protocol=eth_type_trans(skb,dev);
947: netif_rx(skb);
948: lp->stats.rx_packets++;
949: }
950:
951: /* Clear the status word and set End-of-List on the rx frame. */
952: outw(rx_head, ioaddr + WRITE_PTR);
953: outw(0x0000, ioaddr);
954: outw(0xC000, ioaddr);
955: #ifndef final_version
956: if (next_rx_frame != rx_head + RX_BUF_SIZE
957: && next_rx_frame != RX_BUF_START) {
958: printk("%s: Rx next frame at %#x is %#x instead of %#x.\n", dev->name,
959: rx_head, next_rx_frame, rx_head + RX_BUF_SIZE);
960: next_rx_frame = rx_head + RX_BUF_SIZE;
961: if (next_rx_frame >= RX_BUF_END - RX_BUF_SIZE)
962: next_rx_frame = RX_BUF_START;
963: }
964: #endif
965: outw(rx_tail+2, ioaddr + WRITE_PTR);
966: outw(0x0000, ioaddr); /* Clear the end-of-list on the prev. RFD. */
967:
968: #ifndef final_version
969: outw(rx_tail+4, ioaddr + READ_PTR);
970: if (inw(ioaddr) != rx_head) {
971: printk("%s: Rx buf link mismatch, at %04x link %04x instead of %04x.\n",
972: dev->name, rx_tail, (outw(rx_tail+4, ioaddr + READ_PTR),inw(ioaddr)),
973: rx_head);
974: outw(rx_head, ioaddr);
975: }
976: #endif
977:
978: rx_tail = rx_head;
979: rx_head = next_rx_frame;
980: if (--boguscount == 0)
981: break;
982: outw(rx_head, ioaddr + READ_PTR);
983: }
984:
985: lp->rx_head = rx_head;
986: lp->rx_tail = rx_tail;
987:
988: /* Restore the original write pointer. */
989: outw(saved_write_ptr, ioaddr + WRITE_PTR);
990: }
991:
992: #ifdef MODULE
993: static char devicename[9] = { 0, };
994: static struct device dev_eexpress = {
995: devicename, /* device name is inserted by linux/drivers/net/net_init.c */
996: 0, 0, 0, 0,
997: 0, 0,
998: 0, 0, 0, NULL, express_probe };
999:
1000:
1001: static int irq=0x300;
1002: static int io=0;
1003:
1004: int
1005: init_module(void)
1006: {
1007: if (io == 0)
1008: printk("eexpress: You should not use auto-probing with insmod!\n");
1009: dev_eexpress.base_addr=io;
1010: dev_eexpress.irq=irq;
1011: if (register_netdev(&dev_eexpress) != 0)
1012: return -EIO;
1013: return 0;
1014: }
1015:
1016: void
1017: cleanup_module(void)
1018: {
1019: unregister_netdev(&dev_eexpress);
1020: kfree_s(dev_eexpress.priv,sizeof(struct net_local));
1021: dev_eexpress.priv=NULL;
1022:
1023: /* If we don't do this, we can't re-insmod it later. */
1024: release_region(dev_eexpress.base_addr, EEXPRESS_IO_EXTENT);
1025: }
1026: #endif /* MODULE */
1027: /*
1028: * Local variables:
1029: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -I/usr/src/linux/drivers/net -Wall -Wstrict-prototypes -O6 -m486 -c eexpress.c"
1030: * version-control: t
1031: * kept-new-versions: 5
1032: * tab-width: 4
1033: * End:
1034: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.