This source file includes following definitions.
- express_probe
- eexp_probe1
- eexp_open
- eexp_send_packet
- eexp_interrupt
- eexp_close
- eexp_get_stats
- set_multicast_list
- read_eeprom
- init_82586_mem
- init_rx_bufs
- hardware_send_packet
- eexp_rx
- init_module
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
31
32
33
34
35
36
37
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
66 #ifndef NET_DEBUG
67 #define NET_DEBUG 2
68 #endif
69 static unsigned int net_debug = NET_DEBUG;
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89 #define CMD_EOL 0x8000
90 #define CMD_SUSP 0x4000
91 #define CMD_INTR 0x2000
92
93 enum commands {
94 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
95 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
96
97
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136 #define DATAPORT 0
137 #define WRITE_PTR 2
138 #define READ_PTR 4
139 #define SIGNAL_CA 6
140 #define SET_IRQ 7
141 #define SHADOW_PTR 8
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
151
152 #define EE_SHIFT_CLK 0x01
153 #define EE_CS 0x02
154 #define EE_DATA_WRITE 0x04
155 #define EE_DATA_READ 0x08
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
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
170 #define SCB_RFA 0xc00E
171
172
173
174
175
176
177
178
179
180
181
182
183
184
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
197
198 #define TX_BUF_START 0x0100
199 #define NUM_TX_BUFS 4
200 #define TX_BUF_SIZE 0x0680
201 #define TX_BUF_END 0x2000
202
203 #define RX_BUF_START 0x2000
204 #define RX_BUF_SIZE (0x640)
205 #define RX_BUF_END 0x4000
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240 static short init_words[] = {
241 0x0000,
242 0x0000,0x0000,
243 0,0,
244 0x0001,
245 0x0008,0,0,
246
247 0,0xf000|RX_START|CUC_START,
248 CONFIG_CMD,
249 RX_BUF_START,
250 0,0,0,0,
251
252
253 0, CmdConfigure,
254 SET_SA_CMD,
255 0x0804,
256 0x2e40,
257 0,
258
259
260 0, CmdSASetup,
261 SET_MC_CMD,
262 0xaa00,0xb000,0x0bad,
263
264
265 0, CmdNOp, IDLELOOP, 0 ,
266
267
268 0, CmdTDR, IDLELOOP, 0,
269
270
271 0, CmdDump, IDLELOOP, DUMP_DATA,
272
273
274 0, CmdDiagnose, IDLELOOP,
275
276
277 #ifdef initial_text_tx
278 0, CmdMulticastList, DUMP_DATA, 0,
279 #else
280 0, CmdMulticastList, IDLELOOP, 0,
281 #endif
282
283
284 0, CmdTx, DUMP_DATA, DUMP_DATA+8, 0x83ff, -1, DUMP_DATA, 0,
285 };
286
287
288
289 extern int express_probe(struct device *dev);
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
307
308
309
310
311
312 int
313 express_probe(struct device *dev)
314 {
315
316 int *port, ports[] = {0x300, 0x270, 0x320, 0x340, 0};
317 int base_addr = dev->base_addr;
318
319 if (base_addr > 0x1ff)
320 return eexp_probe1(dev, base_addr);
321 else if (base_addr > 0)
322 return ENXIO;
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;
344 }
345
346 int eexp_probe1(struct device *dev, short ioaddr)
347 {
348 unsigned short station_addr[3];
349 int i;
350
351 printk("%s: EtherExpress at %#x,", dev->name, ioaddr);
352
353
354
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
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
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
376
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
388
389 outb(0x00, ioaddr + SET_IRQ);
390 }
391
392
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
402 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
403 if (dev->priv == NULL)
404 return -ENOMEM;
405 memset(dev->priv, 0, sizeof(struct net_local));
406
407 dev->open = eexp_open;
408 dev->stop = eexp_close;
409 dev->hard_start_xmit = eexp_send_packet;
410 dev->get_stats = eexp_get_stats;
411 dev->set_multicast_list = &set_multicast_list;
412
413
414
415 ether_setup(dev);
416
417 return 0;
418 }
419
420
421
422 static char irqrmap[]={0,0,1,2,3,4,0,0,0,1,5,6,0,0,0,0};
423
424 static int
425 eexp_open(struct device *dev)
426 {
427 int ioaddr = dev->base_addr;
428
429 if (dev->irq == 0 || irqrmap[dev->irq] == 0)
430 return -ENXIO;
431
432 if (irq2dev_map[dev->irq] != 0
433
434 || (irq2dev_map[dev->irq] = dev) == 0
435 || request_irq(dev->irq, &eexp_interrupt, 0, "EExpress")) {
436 return -EAGAIN;
437 }
438
439
440 init_82586_mem(dev);
441
442
443 outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
444
445 dev->tbusy = 0;
446 dev->interrupt = 0;
447 dev->start = 1;
448 #ifdef MODULE
449 MOD_INC_USE_COUNT;
450 #endif
451 return 0;
452 }
453
454 static int
455 eexp_send_packet(struct sk_buff *skb, struct device *dev)
456 {
457 struct net_local *lp = (struct net_local *)dev->priv;
458 int ioaddr = dev->base_addr;
459
460 if (dev->tbusy) {
461
462
463 int tickssofar = jiffies - dev->trans_start;
464 if (tickssofar < 5)
465 return 1;
466 if (net_debug > 1)
467 printk("%s: transmit timed out, %s? ", dev->name,
468 inw(ioaddr+SCB_STATUS) & 0x8000 ? "IRQ conflict" :
469 "network cable problem");
470 lp->stats.tx_errors++;
471
472 if (lp->last_restart == lp->stats.tx_packets) {
473 if (net_debug > 1) printk("Resetting board.\n");
474
475 init_82586_mem(dev);
476 } else {
477
478 if (net_debug > 1) printk("Kicking board.\n");
479 outw(0xf000|CUC_START|RX_START, ioaddr + SCB_CMD);
480 outb(0, ioaddr + SIGNAL_CA);
481 lp->last_restart = lp->stats.tx_packets;
482 }
483 dev->tbusy=0;
484 dev->trans_start = jiffies;
485 }
486
487
488
489
490 if (skb == NULL) {
491 dev_tint(dev);
492 return 0;
493 }
494
495
496 if (set_bit(0, (void*)&dev->tbusy) != 0)
497 printk("%s: Transmitter access conflict.\n", dev->name);
498 else {
499 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
500 unsigned char *buf = skb->data;
501
502
503 outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
504 hardware_send_packet(dev, buf, length);
505 dev->trans_start = jiffies;
506
507 outb(0x08 | irqrmap[dev->irq], ioaddr + SET_IRQ);
508 }
509
510 dev_kfree_skb (skb, FREE_WRITE);
511
512
513 lp->stats.tx_aborted_errors++;
514
515 return 0;
516 }
517
518
519
520 static void
521 eexp_interrupt(int irq, struct pt_regs *regs)
522 {
523 struct device *dev = (struct device *)(irq2dev_map[irq]);
524 struct net_local *lp;
525 int ioaddr, status, boguscount = 0;
526 short ack_cmd;
527
528 if (dev == NULL) {
529 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
530 return;
531 }
532 dev->interrupt = 1;
533
534 ioaddr = dev->base_addr;
535 lp = (struct net_local *)dev->priv;
536
537 status = inw(ioaddr + SCB_STATUS);
538
539 if (net_debug > 4) {
540 printk("%s: EExp interrupt, status %4.4x.\n", dev->name, status);
541 }
542
543
544 outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
545
546
547 while (lp->tx_reap != lp->tx_head) {
548 unsigned short tx_status;
549 outw(lp->tx_reap, ioaddr + READ_PTR);
550 tx_status = inw(ioaddr);
551 if (tx_status == 0) {
552 if (net_debug > 5) printk("Couldn't reap %#x.\n", lp->tx_reap);
553 break;
554 }
555 if (tx_status & 0x2000) {
556 lp->stats.tx_packets++;
557 lp->stats.collisions += tx_status & 0xf;
558 dev->tbusy = 0;
559 mark_bh(NET_BH);
560 } else {
561 lp->stats.tx_errors++;
562 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
563 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
564 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
565 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
566 }
567 if (net_debug > 5)
568 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
569 lp->tx_reap += TX_BUF_SIZE;
570 if (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
571 lp->tx_reap = TX_BUF_START;
572 if (++boguscount > 4)
573 break;
574 }
575
576 if (status & 0x4000) {
577 if (net_debug > 5)
578 printk("Received packet, rx_head %04x.\n", lp->rx_head);
579 eexp_rx(dev);
580 }
581
582
583 ack_cmd = status & 0xf000;
584
585 if ((status & 0x0700) != 0x0200 && dev->start) {
586 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
587 if (net_debug > 1)
588 printk("%s: Command unit stopped, status %04x, restarting.\n",
589 dev->name, status);
590
591
592 outw(IDLELOOP, ioaddr + WRITE_PTR);
593 outw(0, ioaddr);
594 outw(CmdNOp, ioaddr);
595 outw(IDLELOOP, ioaddr);
596 outw(IDLELOOP, SCB_CBL);
597 lp->tx_cmd_link = IDLELOOP + 4;
598 lp->tx_head = lp->tx_reap = TX_BUF_START;
599
600 outw(saved_write_ptr, ioaddr + WRITE_PTR);
601 ack_cmd |= CUC_START;
602 }
603
604 if ((status & 0x0070) != 0x0040 && dev->start) {
605 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
606
607
608 lp->stats.rx_errors++;
609 if (net_debug > 1) {
610 int cur_rxbuf = RX_BUF_START;
611 printk("%s: Rx unit stopped status %04x rx head %04x tail %04x.\n",
612 dev->name, status, lp->rx_head, lp->rx_tail);
613 while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE) {
614 int i;
615 printk(" Rx buf at %04x:", cur_rxbuf);
616 outw(cur_rxbuf, ioaddr + READ_PTR);
617 for (i = 0; i < 0x20; i += 2)
618 printk(" %04x", inw(ioaddr));
619 printk(".\n");
620 cur_rxbuf += RX_BUF_SIZE;
621 }
622 }
623 init_rx_bufs(dev);
624 outw(RX_BUF_START, SCB_RFA);
625 outw(saved_write_ptr, ioaddr + WRITE_PTR);
626 ack_cmd |= RX_START;
627 }
628
629 outw(ack_cmd, ioaddr + SCB_CMD);
630 outb(0, ioaddr + SIGNAL_CA);
631
632 if (net_debug > 5) {
633 printk("%s: EExp exiting interrupt, status %4.4x.\n", dev->name,
634 inw(ioaddr + SCB_CMD));
635 }
636
637 outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
638 return;
639 }
640
641 static int
642 eexp_close(struct device *dev)
643 {
644 int ioaddr = dev->base_addr;
645
646 dev->tbusy = 1;
647 dev->start = 0;
648
649
650 outw(RX_SUSPEND | CUC_SUSPEND, ioaddr + SCB_CMD);
651 outb(0, ioaddr + SIGNAL_CA);
652
653
654 outb(0, ioaddr + SET_IRQ);
655
656 free_irq(dev->irq);
657
658 irq2dev_map[dev->irq] = 0;
659
660
661
662 #ifdef MODULE
663 MOD_DEC_USE_COUNT;
664 #endif
665 return 0;
666 }
667
668
669
670 static struct enet_statistics *
671 eexp_get_stats(struct device *dev)
672 {
673 struct net_local *lp = (struct net_local *)dev->priv;
674
675
676
677 return &lp->stats;
678 }
679
680
681
682
683
684
685
686 static void
687 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
688 {
689
690 #if 0
691 short ioaddr = dev->base_addr;
692 if (num_addrs < 0) {
693
694
695 } else if (num_addrs > 0) {
696
697
698 outw(SET_MC_CMD + 6, ioaddr + WRITE_PTR);
699 outw(num_addrs * 6, ioaddr);
700 outsw(ioaddr, addrs, num_addrs*3);
701
702 } else {
703
704
705 outw(99, ioaddr);
706 }
707 #endif
708 }
709
710
711
712
713 #define eeprom_delay() { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
714 #define EE_READ_CMD (6 << 6)
715
716 int
717 read_eeprom(int ioaddr, int location)
718 {
719 int i;
720 unsigned short retval = 0;
721 short ee_addr = ioaddr + EEPROM_Ctrl;
722 int read_cmd = location | EE_READ_CMD;
723 short ctrl_val = EE_CS | _586_RESET;
724
725 outb(ctrl_val, ee_addr);
726
727
728 for (i = 8; i >= 0; i--) {
729 short outval = (read_cmd & (1 << i)) ? ctrl_val | EE_DATA_WRITE
730 : ctrl_val;
731 outb(outval, ee_addr);
732 outb(outval | EE_SHIFT_CLK, ee_addr);
733 eeprom_delay();
734 outb(outval, ee_addr);
735 eeprom_delay();
736 }
737 outb(ctrl_val, ee_addr);
738
739 for (i = 16; i > 0; i--) {
740 outb(ctrl_val | EE_SHIFT_CLK, ee_addr); eeprom_delay();
741 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
742 outb(ctrl_val, ee_addr); eeprom_delay();
743 }
744
745
746 ctrl_val &= ~EE_CS;
747 outb(ctrl_val | EE_SHIFT_CLK, ee_addr);
748 eeprom_delay();
749 outb(ctrl_val, ee_addr);
750 eeprom_delay();
751 return retval;
752 }
753
754 static void
755 init_82586_mem(struct device *dev)
756 {
757 struct net_local *lp = (struct net_local *)dev->priv;
758 short ioaddr = dev->base_addr;
759
760
761
762 outb(inb(ioaddr + Config) | 0x02, ioaddr + Config);
763
764
765 outb(_586_RESET, ioaddr + EEPROM_Ctrl);
766
767
768 outw(0xfff6, ioaddr + WRITE_PTR);
769 outsw(ioaddr, init_words, sizeof(init_words)>>1);
770
771
772 outw(SA_OFFSET, ioaddr + WRITE_PTR);
773 outsw(ioaddr, dev->dev_addr, 3);
774
775
776 #ifdef initial_text_tx
777 lp->tx_cmd_link = DUMP_DATA + 4;
778 #else
779 lp->tx_cmd_link = IDLELOOP + 4;
780 #endif
781 lp->tx_head = lp->tx_reap = TX_BUF_START;
782
783 init_rx_bufs(dev);
784
785
786 outb(0x00, ioaddr + EEPROM_Ctrl);
787
788
789
790 outb(0, ioaddr + SIGNAL_CA);
791
792 {
793 int boguscnt = 50;
794 while (inw(ioaddr + SCB_STATUS) == 0)
795 if (--boguscnt == 0) {
796 printk("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
797 dev->name, inw(ioaddr + SCB_STATUS), inw(ioaddr + SCB_CMD));
798 break;
799 }
800
801 outb(0, ioaddr + SIGNAL_CA);
802 }
803
804
805 outb(inb(ioaddr + Config) & ~0x02, ioaddr + Config);
806 if (net_debug > 4)
807 printk("%s: Initialized 82586, status %04x.\n", dev->name,
808 inw(ioaddr + SCB_STATUS));
809 return;
810 }
811
812
813 static void init_rx_bufs(struct device *dev)
814 {
815 struct net_local *lp = (struct net_local *)dev->priv;
816 short ioaddr = dev->base_addr;
817
818 int cur_rxbuf = lp->rx_head = RX_BUF_START;
819
820
821 do {
822 outw(cur_rxbuf, ioaddr + WRITE_PTR);
823 outw(0x0000, ioaddr);
824 outw(0x0000, ioaddr);
825 outw(cur_rxbuf + RX_BUF_SIZE, ioaddr);
826 outw(cur_rxbuf + 22, ioaddr);
827 outw(0xFeed, ioaddr);
828 outw(0xF00d, ioaddr);
829 outw(0xF001, ioaddr);
830 outw(0x0505, ioaddr);
831 outw(0x2424, ioaddr);
832 outw(0x6565, ioaddr);
833 outw(0xdeaf, ioaddr);
834
835 outw(0x0000, ioaddr);
836 outw(-1, ioaddr);
837 outw(cur_rxbuf + 0x20, ioaddr);
838 outw(0x0000, ioaddr);
839
840 outw(0x8000 + RX_BUF_SIZE-0x20, ioaddr);
841
842 lp->rx_tail = cur_rxbuf;
843 cur_rxbuf += RX_BUF_SIZE;
844 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
845
846
847
848 outw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
849 outw(0xC000, ioaddr);
850 outw(lp->rx_head, ioaddr);
851 }
852
853 static void
854 hardware_send_packet(struct device *dev, void *buf, short length)
855 {
856 struct net_local *lp = (struct net_local *)dev->priv;
857 short ioaddr = dev->base_addr;
858 short tx_block = lp->tx_head;
859
860
861 outw(tx_block, ioaddr + WRITE_PTR);
862 outw(0x0000, ioaddr);
863 outw(CMD_INTR|CmdTx, ioaddr);
864 outw(tx_block+16, ioaddr);
865 outw(tx_block+8, ioaddr);
866
867
868 outw(length | 0x8000, ioaddr);
869 outw(-1, ioaddr);
870 outw(tx_block+22, ioaddr);
871 outw(0x0000, ioaddr);
872
873
874 outw(0x0000, ioaddr);
875 outw(CmdNOp, ioaddr);
876 outw(tx_block+16, ioaddr);
877
878
879
880 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
881
882
883 outw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
884 outw(tx_block, ioaddr);
885 lp->tx_cmd_link = tx_block + 20;
886
887
888 lp->tx_head = tx_block + TX_BUF_SIZE;
889 if (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
890 lp->tx_head = TX_BUF_START;
891
892 if (net_debug > 4) {
893 printk("%s: EExp @%x send length = %d, tx_block %3x, next %3x, "
894 "reap %4x status %4.4x.\n", dev->name, ioaddr, length,
895 tx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
896 }
897
898 if (lp->tx_head != lp->tx_reap)
899 dev->tbusy = 0;
900 }
901
902 static void
903 eexp_rx(struct device *dev)
904 {
905 struct net_local *lp = (struct net_local *)dev->priv;
906 short ioaddr = dev->base_addr;
907 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
908 short rx_head = lp->rx_head;
909 short rx_tail = lp->rx_tail;
910 short boguscount = 10;
911 short frame_status;
912
913
914 outw(rx_head, ioaddr + READ_PTR);
915 while ((frame_status = inw(ioaddr)) < 0) {
916 short rfd_cmd = inw(ioaddr);
917 short next_rx_frame = inw(ioaddr);
918 short data_buffer_addr = inw(ioaddr);
919 short pkt_len;
920
921
922 outw(data_buffer_addr, ioaddr + READ_PTR);
923 pkt_len = inw(ioaddr);
924
925 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
926 || pkt_len & 0xC000 != 0xC000) {
927 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
928 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
929 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
930 pkt_len);
931 } else if ((frame_status & 0x2000) == 0) {
932
933 lp->stats.rx_errors++;
934 if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
935 if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
936 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
937 if (frame_status & 0x0100) lp->stats.rx_over_errors++;
938 if (frame_status & 0x0080) lp->stats.rx_length_errors++;
939 } else {
940
941 struct sk_buff *skb;
942
943 pkt_len &= 0x3fff;
944 skb = dev_alloc_skb(pkt_len+2);
945 if (skb == NULL) {
946 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
947 lp->stats.rx_dropped++;
948 break;
949 }
950 skb->dev = dev;
951 skb_reserve(skb,2);
952
953 outw(data_buffer_addr + 10, ioaddr + READ_PTR);
954
955 insw(ioaddr, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
956
957 skb->protocol=eth_type_trans(skb,dev);
958 netif_rx(skb);
959 lp->stats.rx_packets++;
960 }
961
962
963 outw(rx_head, ioaddr + WRITE_PTR);
964 outw(0x0000, ioaddr);
965 outw(0xC000, ioaddr);
966 #ifndef final_version
967 if (next_rx_frame != rx_head + RX_BUF_SIZE
968 && next_rx_frame != RX_BUF_START) {
969 printk("%s: Rx next frame at %#x is %#x instead of %#x.\n", dev->name,
970 rx_head, next_rx_frame, rx_head + RX_BUF_SIZE);
971 next_rx_frame = rx_head + RX_BUF_SIZE;
972 if (next_rx_frame >= RX_BUF_END - RX_BUF_SIZE)
973 next_rx_frame = RX_BUF_START;
974 }
975 #endif
976 outw(rx_tail+2, ioaddr + WRITE_PTR);
977 outw(0x0000, ioaddr);
978
979 #ifndef final_version
980 outw(rx_tail+4, ioaddr + READ_PTR);
981 if (inw(ioaddr) != rx_head) {
982 printk("%s: Rx buf link mismatch, at %04x link %04x instead of %04x.\n",
983 dev->name, rx_tail, (outw(rx_tail+4, ioaddr + READ_PTR),inw(ioaddr)),
984 rx_head);
985 outw(rx_head, ioaddr);
986 }
987 #endif
988
989 rx_tail = rx_head;
990 rx_head = next_rx_frame;
991 if (--boguscount == 0)
992 break;
993 outw(rx_head, ioaddr + READ_PTR);
994 }
995
996 lp->rx_head = rx_head;
997 lp->rx_tail = rx_tail;
998
999
1000 outw(saved_write_ptr, ioaddr + WRITE_PTR);
1001 }
1002
1003 #ifdef MODULE
1004 char kernel_version[] = UTS_RELEASE;
1005 static char devicename[9] = { 0, };
1006 static struct device dev_eexpress = {
1007 devicename,
1008 0, 0, 0, 0,
1009 0, 0,
1010 0, 0, 0, NULL, express_probe };
1011
1012
1013 int irq=0x300;
1014 int io=0;
1015
1016 int
1017 init_module(void)
1018 {
1019 if (io == 0)
1020 printk("eexpress: You should not use auto-probing with insmod!\n");
1021 dev_eexpress.base_addr=io;
1022 dev_eexpress.irq=irq;
1023 if (register_netdev(&dev_eexpress) != 0)
1024 return -EIO;
1025 return 0;
1026 }
1027
1028 void
1029 cleanup_module(void)
1030 {
1031 if (MOD_IN_USE)
1032 printk("eexpress: device busy, remove delayed\n");
1033 else
1034 {
1035 unregister_netdev(&dev_eexpress);
1036 kfree_s(dev_eexpress.priv,sizeof(struct net_local));
1037 dev_eexpress.priv=NULL;
1038
1039
1040 release_region(dev_eexpress.base_addr, EEXPRESS_IO_EXTENT);
1041 }
1042 }
1043 #endif
1044
1045
1046
1047
1048
1049
1050
1051