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