![[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 /* 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 becker@super.org 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 <middelin@polyware.iaf.nl>
21 Changed to support io= irq= by Alan Cox <Alan.Cox@linux.org>
22 */
23
24 static const char *version =
25 "eexpress.c:v0.07 1/19/94 Donald Becker (becker@super.org)\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, int num_addrs, void *addrs);
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)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
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)
/* ![[previous]](../icons/left.png)
*/
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 num_addrs == -1 Promiscuous mode, receive all packets
675 num_addrs == 0 Normal mode, clear multicast list
676 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
677 best-effort filtering.
678 */
679 static void
680 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
/* */
681 {
682 /* This doesn't work yet */
683 #if 0
684 short ioaddr = dev->base_addr;
685 if (num_addrs < 0) {
686 /* Not written yet, this requires expanding the init_words config
687 cmd. */
688 } else if (num_addrs > 0) {
689 /* Fill in the SET_MC_CMD with the number of address bytes, followed
690 by the list of multicast addresses to be accepted. */
691 outw(SET_MC_CMD + 6, ioaddr + WRITE_PTR);
692 outw(num_addrs * 6, ioaddr);
693 outsw(ioaddr, addrs, num_addrs*3); /* 3 = addr len in words */
694 /* We must trigger a whole 586 reset due to a bug. */
695 } else {
696 /* Not written yet, this requires expanding the init_words config
697 cmd. */
698 outw(99, ioaddr); /* Disable promiscuous mode, use normal mode */
699 }
700 #endif
701 }
702
703 /* The horrible routine to read a word from the serial EEPROM. */
704
705 /* The delay between EEPROM clock transitions. */
706 #define eeprom_delay() { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
707 #define EE_READ_CMD (6 << 6)
708
709 int
710 read_eeprom(int ioaddr, int location)
/* */
711 {
712 int i;
713 unsigned short retval = 0;
714 short ee_addr = ioaddr + EEPROM_Ctrl;
715 int read_cmd = location | EE_READ_CMD;
716 short ctrl_val = EE_CS | _586_RESET;
717
718 outb(ctrl_val, ee_addr);
719
720 /* Shift the read command bits out. */
721 for (i = 8; i >= 0; i--) {
722 short outval = (read_cmd & (1 << i)) ? ctrl_val | EE_DATA_WRITE
723 : ctrl_val;
724 outb(outval, ee_addr);
725 outb(outval | EE_SHIFT_CLK, ee_addr); /* EEPROM clock tick. */
726 eeprom_delay();
727 outb(outval, ee_addr); /* Finish EEPROM a clock tick. */
728 eeprom_delay();
729 }
730 outb(ctrl_val, ee_addr);
731
732 for (i = 16; i > 0; i--) {
733 outb(ctrl_val | EE_SHIFT_CLK, ee_addr); eeprom_delay();
734 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
735 outb(ctrl_val, ee_addr); eeprom_delay();
736 }
737
738 /* Terminate the EEPROM access. */
739 ctrl_val &= ~EE_CS;
740 outb(ctrl_val | EE_SHIFT_CLK, ee_addr);
741 eeprom_delay();
742 outb(ctrl_val, ee_addr);
743 eeprom_delay();
744 return retval;
745 }
746
747 static void
748 init_82586_mem(struct device *dev)
/* */
749 {
750 struct net_local *lp = (struct net_local *)dev->priv;
751 short ioaddr = dev->base_addr;
752
753 /* Enable loopback to protect the wire while starting up.
754 This is Superstition From Crynwr. */
755 outb(inb(ioaddr + Config) | 0x02, ioaddr + Config);
756
757 /* Hold the 586 in reset during the memory initialization. */
758 outb(_586_RESET, ioaddr + EEPROM_Ctrl);
759
760 /* Place the write pointer at 0xfff6 (address-aliased to 0xfffff6). */
761 outw(0xfff6, ioaddr + WRITE_PTR);
762 outsw(ioaddr, init_words, sizeof(init_words)>>1);
763
764 /* Fill in the station address. */
765 outw(SA_OFFSET, ioaddr + WRITE_PTR);
766 outsw(ioaddr, dev->dev_addr, 3);
767
768 /* The Tx-block list is written as needed. We just set up the values. */
769 #ifdef initial_text_tx
770 lp->tx_cmd_link = DUMP_DATA + 4;
771 #else
772 lp->tx_cmd_link = IDLELOOP + 4;
773 #endif
774 lp->tx_head = lp->tx_reap = TX_BUF_START;
775
776 init_rx_bufs(dev);
777
778 /* Start the 586 by releasing the reset line. */
779 outb(0x00, ioaddr + EEPROM_Ctrl);
780
781 /* This was time consuming to track down: you need to give two channel
782 attention signals to reliably start up the i82586. */
783 outb(0, ioaddr + SIGNAL_CA);
784
785 {
786 int boguscnt = 50;
787 while (inw(ioaddr + SCB_STATUS) == 0)
788 if (--boguscnt == 0) {
789 printk("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
790 dev->name, inw(ioaddr + SCB_STATUS), inw(ioaddr + SCB_CMD));
791 break;
792 }
793 /* Issue channel-attn -- the 82586 won't start without it. */
794 outb(0, ioaddr + SIGNAL_CA);
795 }
796
797 /* Disable loopback. */
798 outb(inb(ioaddr + Config) & ~0x02, ioaddr + Config);
799 if (net_debug > 4)
800 printk("%s: Initialized 82586, status %04x.\n", dev->name,
801 inw(ioaddr + SCB_STATUS));
802 return;
803 }
804
805 /* Initialize the Rx-block list. */
806 static void init_rx_bufs(struct device *dev)
/* */
807 {
808 struct net_local *lp = (struct net_local *)dev->priv;
809 short ioaddr = dev->base_addr;
810
811 int cur_rxbuf = lp->rx_head = RX_BUF_START;
812
813 /* Initialize each Rx frame + data buffer. */
814 do { /* While there is room for one more. */
815 outw(cur_rxbuf, ioaddr + WRITE_PTR);
816 outw(0x0000, ioaddr); /* Status */
817 outw(0x0000, ioaddr); /* Command */
818 outw(cur_rxbuf + RX_BUF_SIZE, ioaddr); /* Link */
819 outw(cur_rxbuf + 22, ioaddr); /* Buffer offset */
820 outw(0xFeed, ioaddr); /* Pad for dest addr. */
821 outw(0xF00d, ioaddr);
822 outw(0xF001, ioaddr);
823 outw(0x0505, ioaddr); /* Pad for source addr. */
824 outw(0x2424, ioaddr);
825 outw(0x6565, ioaddr);
826 outw(0xdeaf, ioaddr); /* Pad for protocol. */
827
828 outw(0x0000, ioaddr); /* Buffer: Actual count */
829 outw(-1, ioaddr); /* Buffer: Next (none). */
830 outw(cur_rxbuf + 0x20, ioaddr); /* Buffer: Address low */
831 outw(0x0000, ioaddr);
832 /* Finally, the number of bytes in the buffer. */
833 outw(0x8000 + RX_BUF_SIZE-0x20, ioaddr);
834
835 lp->rx_tail = cur_rxbuf;
836 cur_rxbuf += RX_BUF_SIZE;
837 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
838
839 /* Terminate the list by setting the EOL bit, and wrap the pointer to make
840 the list a ring. */
841 outw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
842 outw(0xC000, ioaddr); /* Command, mark as last. */
843 outw(lp->rx_head, ioaddr); /* Link */
844 }
845
846 static void
847 hardware_send_packet(struct device *dev, void *buf, short length)
/* */
848 {
849 struct net_local *lp = (struct net_local *)dev->priv;
850 short ioaddr = dev->base_addr;
851 short tx_block = lp->tx_head;
852
853 /* Set the write pointer to the Tx block, and put out the header. */
854 outw(tx_block, ioaddr + WRITE_PTR);
855 outw(0x0000, ioaddr); /* Tx status */
856 outw(CMD_INTR|CmdTx, ioaddr); /* Tx command */
857 outw(tx_block+16, ioaddr); /* Next command is a NoOp. */
858 outw(tx_block+8, ioaddr); /* Data Buffer offset. */
859
860 /* Output the data buffer descriptor. */
861 outw(length | 0x8000, ioaddr); /* Byte count parameter. */
862 outw(-1, ioaddr); /* No next data buffer. */
863 outw(tx_block+22, ioaddr); /* Buffer follows the NoOp command. */
864 outw(0x0000, ioaddr); /* Buffer address high bits (always zero). */
865
866 /* Output the Loop-back NoOp command. */
867 outw(0x0000, ioaddr); /* Tx status */
868 outw(CmdNOp, ioaddr); /* Tx command */
869 outw(tx_block+16, ioaddr); /* Next is myself. */
870
871 /* Output the packet using the write pointer.
872 Hmmm, it feels a little like a 3c501! */
873 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
874
875 /* Set the old command link pointing to this send packet. */
876 outw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
877 outw(tx_block, ioaddr);
878 lp->tx_cmd_link = tx_block + 20;
879
880 /* Set the next free tx region. */
881 lp->tx_head = tx_block + TX_BUF_SIZE;
882 if (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
883 lp->tx_head = TX_BUF_START;
884
885 if (net_debug > 4) {
886 printk("%s: EExp @%x send length = %d, tx_block %3x, next %3x, "
887 "reap %4x status %4.4x.\n", dev->name, ioaddr, length,
888 tx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
889 }
890
891 if (lp->tx_head != lp->tx_reap)
892 dev->tbusy = 0;
893 }
894
895 static void
896 eexp_rx(struct device *dev)
/* */
897 {
898 struct net_local *lp = (struct net_local *)dev->priv;
899 short ioaddr = dev->base_addr;
900 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
901 short rx_head = lp->rx_head;
902 short rx_tail = lp->rx_tail;
903 short boguscount = 10;
904 short frame_status;
905
906 /* Set the read pointer to the Rx frame. */
907 outw(rx_head, ioaddr + READ_PTR);
908 while ((frame_status = inw(ioaddr)) < 0) { /* Command complete */
909 short rfd_cmd = inw(ioaddr);
910 short next_rx_frame = inw(ioaddr);
911 short data_buffer_addr = inw(ioaddr);
912 short pkt_len;
913
914 /* Set the read pointer the data buffer. */
915 outw(data_buffer_addr, ioaddr + READ_PTR);
916 pkt_len = inw(ioaddr);
917
918 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
919 || (pkt_len & 0xC000) != 0xC000) {
920 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
921 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
922 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
923 pkt_len);
924 } else if ((frame_status & 0x2000) == 0) {
925 /* Frame Rxed, but with error. */
926 lp->stats.rx_errors++;
927 if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
928 if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
929 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
930 if (frame_status & 0x0100) lp->stats.rx_over_errors++;
931 if (frame_status & 0x0080) lp->stats.rx_length_errors++;
932 } else {
933 /* Malloc up new buffer. */
934 struct sk_buff *skb;
935
936 pkt_len &= 0x3fff;
937 skb = dev_alloc_skb(pkt_len+2);
938 if (skb == NULL) {
939 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
940 lp->stats.rx_dropped++;
941 break;
942 }
943 skb->dev = dev;
944 skb_reserve(skb,2);
945
946 outw(data_buffer_addr + 10, ioaddr + READ_PTR);
947
948 insw(ioaddr, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
949
950 skb->protocol=eth_type_trans(skb,dev);
951 netif_rx(skb);
952 lp->stats.rx_packets++;
953 }
954
955 /* Clear the status word and set End-of-List on the rx frame. */
956 outw(rx_head, ioaddr + WRITE_PTR);
957 outw(0x0000, ioaddr);
958 outw(0xC000, ioaddr);
959 #ifndef final_version
960 if (next_rx_frame != rx_head + RX_BUF_SIZE
961 && next_rx_frame != RX_BUF_START) {
962 printk("%s: Rx next frame at %#x is %#x instead of %#x.\n", dev->name,
963 rx_head, next_rx_frame, rx_head + RX_BUF_SIZE);
964 next_rx_frame = rx_head + RX_BUF_SIZE;
965 if (next_rx_frame >= RX_BUF_END - RX_BUF_SIZE)
966 next_rx_frame = RX_BUF_START;
967 }
968 #endif
969 outw(rx_tail+2, ioaddr + WRITE_PTR);
970 outw(0x0000, ioaddr); /* Clear the end-of-list on the prev. RFD. */
971
972 #ifndef final_version
973 outw(rx_tail+4, ioaddr + READ_PTR);
974 if (inw(ioaddr) != rx_head) {
975 printk("%s: Rx buf link mismatch, at %04x link %04x instead of %04x.\n",
976 dev->name, rx_tail, (outw(rx_tail+4, ioaddr + READ_PTR),inw(ioaddr)),
977 rx_head);
978 outw(rx_head, ioaddr);
979 }
980 #endif
981
982 rx_tail = rx_head;
983 rx_head = next_rx_frame;
984 if (--boguscount == 0)
985 break;
986 outw(rx_head, ioaddr + READ_PTR);
987 }
988
989 lp->rx_head = rx_head;
990 lp->rx_tail = rx_tail;
991
992 /* Restore the original write pointer. */
993 outw(saved_write_ptr, ioaddr + WRITE_PTR);
994 }
995
996 #ifdef MODULE
997 static char devicename[9] = { 0, };
998 static struct device dev_eexpress = {
999 devicename, /* device name is inserted by linux/drivers/net/net_init.c */
1000 0, 0, 0, 0,
1001 0, 0,
1002 0, 0, 0, NULL, express_probe };
1003
1004
1005 static int irq=0x300;
1006 static int io=0;
1007
1008 int
1009 init_module(void)
/* */
1010 {
1011 if (io == 0)
1012 printk("eexpress: You should not use auto-probing with insmod!\n");
1013 dev_eexpress.base_addr=io;
1014 dev_eexpress.irq=irq;
1015 if (register_netdev(&dev_eexpress) != 0)
1016 return -EIO;
1017 return 0;
1018 }
1019
1020 void
1021 cleanup_module(void)
/* ![[last]](../icons/n_last.png)
*/
1022 {
1023 unregister_netdev(&dev_eexpress);
1024 kfree_s(dev_eexpress.priv,sizeof(struct net_local));
1025 dev_eexpress.priv=NULL;
1026
1027 /* If we don't do this, we can't re-insmod it later. */
1028 release_region(dev_eexpress.base_addr, EEXPRESS_IO_EXTENT);
1029 }
1030 #endif /* MODULE */
1031 /*
1032 * Local variables:
1033 * 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"
1034 * version-control: t
1035 * kept-new-versions: 5
1036 * tab-width: 4
1037 * End:
1038 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/