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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 static char *version =
22 "eexpress.c:v0.07 1/19/94 Donald Becker (becker@super.org)\n";
23
24 #include <linux/config.h>
25
26
27
28
29
30
31
32
33
34
35
36
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/types.h>
40 #include <linux/fcntl.h>
41 #include <linux/interrupt.h>
42 #include <linux/ptrace.h>
43 #include <linux/ioport.h>
44 #include <linux/in.h>
45 #include <asm/system.h>
46 #include <asm/bitops.h>
47 #include <asm/io.h>
48 #include <asm/dma.h>
49 #include <errno.h>
50 #include <memory.h>
51
52 #include "dev.h"
53 #include "eth.h"
54 #include "skbuff.h"
55 #include "arp.h"
56
57 #ifndef HAVE_ALLOC_SKB
58 #define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
59 #else
60
61 #include <linux/malloc.h>
62 #endif
63
64
65 #ifndef NET_DEBUG
66 #define NET_DEBUG 2
67 #endif
68 static unsigned int net_debug = NET_DEBUG;
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88 #define CMD_EOL 0x8000
89 #define CMD_SUSP 0x4000
90 #define CMD_INTR 0x2000
91
92 enum commands {
93 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
94 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7};
95
96
97 struct net_local {
98 struct enet_statistics stats;
99 int last_restart;
100 short rx_head;
101 short rx_tail;
102 short tx_head;
103 short tx_cmd_link;
104 short tx_reap;
105 };
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 #define DATAPORT 0
136 #define WRITE_PTR 2
137 #define READ_PTR 4
138 #define SIGNAL_CA 6
139 #define SET_IRQ 7
140 #define SHADOW_PTR 8
141 #define MEM_Ctrl 11
142 #define MEM_Page_Ctrl 12
143 #define Config 13
144 #define EEPROM_Ctrl 14
145 #define ID_PORT 15
146
147
148
149 #define EE_SHIFT_CLK 0x01
150 #define EE_CS 0x02
151 #define EE_DATA_WRITE 0x04
152 #define EE_DATA_READ 0x08
153 #define EE_CTRL_BITS (EE_SHIFT_CLK | EE_CS | EE_DATA_WRITE | EE_DATA_READ)
154 #define ASIC_RESET 0x40
155 #define _586_RESET 0x80
156
157
158 #define SCB_STATUS 0xc008
159 #define SCB_CMD 0xc00A
160 #define CUC_START 0x0100
161 #define CUC_RESUME 0x0200
162 #define CUC_SUSPEND 0x0300
163 #define RX_START 0x0010
164 #define RX_RESUME 0x0020
165 #define RX_SUSPEND 0x0030
166 #define SCB_CBL 0xc00C
167 #define SCB_RFA 0xc00E
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184 #define CONFIG_CMD 0x0018
185 #define SET_SA_CMD 0x0024
186 #define SA_OFFSET 0x002A
187 #define IDLELOOP 0x30
188 #define TDR_CMD 0x38
189 #define TDR_TIME 0x3C
190 #define DUMP_CMD 0x40
191 #define DIAG_CMD 0x48
192 #define SET_MC_CMD 0x4E
193 #define DUMP_DATA 0x56
194
195 #define TX_BUF_START 0x0100
196 #define NUM_TX_BUFS 4
197 #define TX_BUF_SIZE 0x0680
198 #define TX_BUF_END 0x2000
199
200 #define RX_BUF_START 0x2000
201 #define RX_BUF_SIZE (0x640)
202 #define RX_BUF_END 0x4000
203
204
205
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 static short init_words[] = {
238 0x0000,
239 0x0000,0x0000,
240 0,0,
241 0x0001,
242 0x0008,0,0,
243
244 0,0xf000|RX_START|CUC_START,
245 CONFIG_CMD,
246 RX_BUF_START,
247 0,0,0,0,
248
249
250 0, CmdConfigure,
251 SET_SA_CMD,
252 0x0804,
253 0x2e40,
254 0,
255
256
257 0, CmdSASetup,
258 SET_MC_CMD,
259 0xaa00,0xb000,0x0bad,
260
261
262 0, CmdNOp, IDLELOOP, 0 ,
263
264
265 0, CmdTDR, IDLELOOP, 0,
266
267
268 0, CmdDump, IDLELOOP, DUMP_DATA,
269
270
271 0, CmdDiagnose, IDLELOOP,
272
273
274 #ifdef initial_text_tx
275 0, CmdMulticastList, DUMP_DATA, 0,
276 #else
277 0, CmdMulticastList, IDLELOOP, 0,
278 #endif
279
280
281 0, CmdTx, DUMP_DATA, DUMP_DATA+8, 0x83ff, -1, DUMP_DATA, 0,
282 };
283
284
285
286 extern int express_probe(struct device *dev);
287
288 static int eexp_probe1(struct device *dev, short ioaddr);
289 static int eexp_open(struct device *dev);
290 static int eexp_send_packet(struct sk_buff *skb, struct device *dev);
291 static void eexp_interrupt(int reg_ptr);
292 static void eexp_rx(struct device *dev);
293 static int eexp_close(struct device *dev);
294 static struct enet_statistics *eexp_get_stats(struct device *dev);
295 #ifdef HAVE_MULTICAST
296 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
297 #endif
298
299 static int read_eeprom(int ioaddr, int location);
300 static void hardware_send_packet(struct device *dev, void *buf, short length);
301 static void init_82586_mem(struct device *dev);
302 static void init_rx_bufs(struct device *dev);
303
304
305
306
307
308
309
310
311 int
312 express_probe(struct device *dev)
313 {
314
315 int *port, ports[] = {0x300, 0x270, 0x320, 0x340, 0};
316 int base_addr = dev->base_addr;
317
318 if (base_addr > 0x1ff)
319 return eexp_probe1(dev, base_addr);
320 else if (base_addr > 0)
321 return ENXIO;
322
323 for (port = &ports[0]; *port; port++) {
324 short id_addr = *port + ID_PORT;
325 unsigned short sum = 0;
326 int i;
327 #ifdef notdef
328 for (i = 16; i > 0; i--)
329 sum += inb(id_addr);
330 printk("EtherExpress ID checksum is %04x.\n", sum);
331 #else
332 for (i = 4; i > 0; i--) {
333 short id_val = inb(id_addr);
334 sum |= (id_val >> 4) << ((id_val & 3) << 2);
335 }
336 #endif
337 if (sum == 0xbaba
338 && eexp_probe1(dev, *port) == 0)
339 return 0;
340 }
341
342 return ENODEV;
343 }
344
345 int eexp_probe1(struct device *dev, short ioaddr)
346 {
347 unsigned short station_addr[3];
348 int i;
349
350 printk("%s: EtherExpress at %#x,", dev->name, ioaddr);
351
352
353
354 station_addr[0] = read_eeprom(ioaddr, 2);
355 station_addr[1] = read_eeprom(ioaddr, 3);
356 station_addr[2] = read_eeprom(ioaddr, 4);
357
358
359 if (station_addr[2] != 0x00aa || (station_addr[1] & 0xff00) != 0x0000) {
360 printk(" rejected (invalid address %04x%04x%04x).\n",
361 station_addr[2], station_addr[1], station_addr[0]);
362 return ENODEV;
363 }
364
365
366 snarf_region(ioaddr, 16);
367 dev->base_addr = ioaddr;
368
369 for (i = 0; i < 6; i++) {
370 dev->dev_addr[i] = ((unsigned char*)station_addr)[5-i];
371 printk(" %02x", dev->dev_addr[i]);
372 }
373
374
375
376 {
377 char irqmap[] = {0, 9, 3, 4, 5, 10, 11, 0};
378 char *ifmap[] = {"AUI", "BNC", "10baseT"};
379 enum iftype {AUI=0, BNC=1, TP=2};
380 unsigned short setupval = read_eeprom(ioaddr, 0);
381
382 dev->irq = irqmap[setupval >> 13];
383 dev->if_port = (setupval & 0x1000) == 0 ? AUI :
384 read_eeprom(ioaddr, 5) & 0x1 ? TP : BNC;
385 printk(", IRQ %d, Interface %s.\n", dev->irq, ifmap[dev->if_port]);
386
387
388 outb(0x00, ioaddr + SET_IRQ);
389 }
390
391
392 outb(ASIC_RESET, ioaddr + EEPROM_Ctrl);
393
394 if ((dev->mem_start & 0xf) > 0)
395 net_debug = dev->mem_start & 7;
396
397 if (net_debug)
398 printk(version);
399
400
401 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
402 memset(dev->priv, 0, sizeof(struct net_local));
403
404 dev->open = eexp_open;
405 dev->stop = eexp_close;
406 dev->hard_start_xmit = eexp_send_packet;
407 dev->get_stats = eexp_get_stats;
408 #ifdef HAVE_MULTICAST
409 dev->set_multicast_list = &set_multicast_list;
410 #endif
411
412
413
414 for (i = 0; i < DEV_NUMBUFFS; i++)
415 dev->buffs[i] = NULL;
416
417 dev->hard_header = eth_header;
418 dev->add_arp = eth_add_arp;
419 dev->queue_xmit = dev_queue_xmit;
420 dev->rebuild_header = eth_rebuild_header;
421 dev->type_trans = eth_type_trans;
422
423 dev->type = ARPHRD_ETHER;
424 dev->hard_header_len = ETH_HLEN;
425 dev->mtu = 1500;
426 dev->addr_len = ETH_ALEN;
427 for (i = 0; i < ETH_ALEN; i++) {
428 dev->broadcast[i]=0xff;
429 }
430
431
432 dev->flags = IFF_BROADCAST;
433 dev->family = AF_INET;
434 dev->pa_addr = 0;
435 dev->pa_brdaddr = 0;
436 dev->pa_mask = 0;
437 dev->pa_alen = sizeof(unsigned long);
438
439 return 0;
440 }
441
442
443
444 static char irqrmap[]={0,0,1,2,3,4,0,0,0,1,5,6,0,0,0,0};
445
446 static int
447 eexp_open(struct device *dev)
448 {
449 int ioaddr = dev->base_addr;
450
451 if (dev->irq == 0 || irqrmap[dev->irq] == 0)
452 return -ENXIO;
453
454 if (irq2dev_map[dev->irq] != 0
455
456 || (irq2dev_map[dev->irq] = dev) == 0
457 || request_irq(dev->irq, &eexp_interrupt)) {
458 return -EAGAIN;
459 }
460
461
462 init_82586_mem(dev);
463
464
465 outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
466
467 dev->tbusy = 0;
468 dev->interrupt = 0;
469 dev->start = 1;
470 return 0;
471 }
472
473 static int
474 eexp_send_packet(struct sk_buff *skb, struct device *dev)
475 {
476 struct net_local *lp = (struct net_local *)dev->priv;
477 int ioaddr = dev->base_addr;
478
479 if (dev->tbusy) {
480
481
482 int tickssofar = jiffies - dev->trans_start;
483 if (tickssofar < 5)
484 return 1;
485 if (net_debug > 1)
486 printk("%s: transmit timed out, %s? ", dev->name,
487 inw(ioaddr+SCB_STATUS) & 0x8000 ? "IRQ conflict" :
488 "network cable problem");
489 lp->stats.tx_errors++;
490
491 if (lp->last_restart == lp->stats.tx_packets) {
492 if (net_debug > 1) printk("Resetting board.\n");
493
494 init_82586_mem(dev);
495 } else {
496
497 if (net_debug > 1) printk("Kicking board.\n");
498 outw(0xf000|CUC_START|RX_START, ioaddr + SCB_CMD);
499 outb(0, ioaddr + SIGNAL_CA);
500 lp->last_restart = lp->stats.tx_packets;
501 }
502 dev->tbusy=0;
503 dev->trans_start = jiffies;
504 }
505
506
507
508
509 if (skb == NULL) {
510 dev_tint(dev);
511 return 0;
512 }
513
514
515
516 if (!skb->arp && dev->rebuild_header(skb->data, dev)) {
517 skb->dev = dev;
518 arp_queue (skb);
519 return 0;
520 }
521 skb->arp=1;
522
523
524 if (set_bit(0, (void*)&dev->tbusy) != 0)
525 printk("%s: Transmitter access conflict.\n", dev->name);
526 else {
527 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
528 unsigned char *buf = skb->data;
529
530
531 outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
532 hardware_send_packet(dev, buf, length);
533 dev->trans_start = jiffies;
534
535 outb(0x08 | irqrmap[dev->irq], ioaddr + SET_IRQ);
536 }
537
538 if (skb->free)
539 kfree_skb (skb, FREE_WRITE);
540
541
542 lp->stats.tx_aborted_errors++;
543
544 return 0;
545 }
546
547
548
549 static void
550 eexp_interrupt(int reg_ptr)
551 {
552 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
553 struct device *dev = (struct device *)(irq2dev_map[irq]);
554 struct net_local *lp;
555 int ioaddr, status, boguscount = 0;
556 short ack_cmd;
557
558 if (dev == NULL) {
559 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
560 return;
561 }
562 dev->interrupt = 1;
563
564 ioaddr = dev->base_addr;
565 lp = (struct net_local *)dev->priv;
566
567 status = inw(ioaddr + SCB_STATUS);
568
569 if (net_debug > 4) {
570 printk("%s: EExp interrupt, status %4.4x.\n", dev->name, status);
571 }
572
573
574 outb(irqrmap[dev->irq], ioaddr + SET_IRQ);
575
576
577 while (lp->tx_reap != lp->tx_head) {
578 unsigned short tx_status;
579 outw(lp->tx_reap, ioaddr + READ_PTR);
580 tx_status = inw(ioaddr);
581 if (tx_status == 0) {
582 if (net_debug > 5) printk("Couldn't reap %#x.\n", lp->tx_reap);
583 break;
584 }
585 if (tx_status & 0x2000) {
586 lp->stats.tx_packets++;
587 lp->stats.collisions += tx_status & 0xf;
588 dev->tbusy = 0;
589 mark_bh(INET_BH);
590 } else {
591 lp->stats.tx_errors++;
592 if (tx_status & 0x0600) lp->stats.tx_carrier_errors++;
593 if (tx_status & 0x0100) lp->stats.tx_fifo_errors++;
594 if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++;
595 if (tx_status & 0x0020) lp->stats.tx_aborted_errors++;
596 }
597 if (net_debug > 5)
598 printk("Reaped %x, Tx status %04x.\n" , lp->tx_reap, tx_status);
599 lp->tx_reap += TX_BUF_SIZE;
600 if (lp->tx_reap > TX_BUF_END - TX_BUF_SIZE)
601 lp->tx_reap = TX_BUF_START;
602 if (++boguscount > 4)
603 break;
604 }
605
606 if (status & 0x4000) {
607 if (net_debug > 5)
608 printk("Received packet, rx_head %04x.\n", lp->rx_head);
609 eexp_rx(dev);
610 }
611
612
613 ack_cmd = status & 0xf000;
614
615 if ((status & 0x0700) != 0x0200 && dev->start) {
616 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
617 if (net_debug > 1)
618 printk("%s: Command unit stopped, status %04x, restarting.\n",
619 dev->name, status);
620
621
622 outw(IDLELOOP, ioaddr + WRITE_PTR);
623 outw(0, ioaddr);
624 outw(CmdNOp, ioaddr);
625 outw(IDLELOOP, ioaddr);
626 outw(IDLELOOP, SCB_CBL);
627 lp->tx_cmd_link = IDLELOOP + 4;
628 lp->tx_head = lp->tx_reap = TX_BUF_START;
629
630 outw(saved_write_ptr, ioaddr + WRITE_PTR);
631 ack_cmd |= CUC_START;
632 }
633
634 if ((status & 0x0070) != 0x0040 && dev->start) {
635 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
636
637
638 lp->stats.rx_errors++;
639 if (net_debug > 1) {
640 int cur_rxbuf = RX_BUF_START;
641 printk("%s: Rx unit stopped status %04x rx head %04x tail %04x.\n",
642 dev->name, status, lp->rx_head, lp->rx_tail);
643 while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE) {
644 int i;
645 printk(" Rx buf at %04x:", cur_rxbuf);
646 outw(cur_rxbuf, ioaddr + READ_PTR);
647 for (i = 0; i < 0x20; i += 2)
648 printk(" %04x", inw(ioaddr));
649 printk(".\n");
650 cur_rxbuf += RX_BUF_SIZE;
651 }
652 }
653 init_rx_bufs(dev);
654 outw(RX_BUF_START, SCB_RFA);
655 outw(saved_write_ptr, ioaddr + WRITE_PTR);
656 ack_cmd |= RX_START;
657 }
658
659 outw(ack_cmd, ioaddr + SCB_CMD);
660 outb(0, ioaddr + SIGNAL_CA);
661
662 if (net_debug > 5) {
663 printk("%s: EExp exiting interrupt, status %4.4x.\n", dev->name,
664 inw(ioaddr + SCB_CMD));
665 }
666
667 outb(irqrmap[dev->irq] | 0x08, ioaddr + SET_IRQ);
668 return;
669 }
670
671 static int
672 eexp_close(struct device *dev)
673 {
674 int ioaddr = dev->base_addr;
675
676 dev->tbusy = 1;
677 dev->start = 0;
678
679
680 outw(RX_SUSPEND | CUC_SUSPEND, ioaddr + SCB_CMD);
681 outb(0, ioaddr + SIGNAL_CA);
682
683
684 outb(0, ioaddr + SET_IRQ);
685
686 free_irq(dev->irq);
687
688 irq2dev_map[dev->irq] = 0;
689
690
691
692 return 0;
693 }
694
695
696
697 static struct enet_statistics *
698 eexp_get_stats(struct device *dev)
699 {
700 struct net_local *lp = (struct net_local *)dev->priv;
701
702
703
704 return &lp->stats;
705 }
706
707 #ifdef HAVE_MULTICAST
708
709
710
711
712
713
714 static void
715 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
716 {
717 short ioaddr = dev->base_addr;
718 if (num_addrs < 0) {
719
720
721 } else if (num_addrs > 0) {
722
723
724 outw(SET_MC_CMD + 6, ioaddr + WRITE_PTR);
725 outw(num_addrs * 6, ioaddr);
726 outsw(ioaddr, addrs, num_addrs*3);
727
728 } else {
729
730
731 outw(99, ioaddr);
732 }
733 }
734 #endif
735
736
737
738
739 #define eeprom_delay() { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
740 #define EE_READ_CMD (6 << 6)
741
742 int
743 read_eeprom(int ioaddr, int location)
744 {
745 int i;
746 unsigned short retval = 0;
747 short ee_addr = ioaddr + EEPROM_Ctrl;
748 int read_cmd = location | EE_READ_CMD;
749 short ctrl_val = EE_CS | _586_RESET;
750
751 outb(ctrl_val, ee_addr);
752
753
754 for (i = 8; i >= 0; i--) {
755 short outval = (read_cmd & (1 << i)) ? ctrl_val | EE_DATA_WRITE
756 : ctrl_val;
757 outb(outval, ee_addr);
758 outb(outval | EE_SHIFT_CLK, ee_addr);
759 eeprom_delay();
760 outb(outval, ee_addr);
761 eeprom_delay();
762 }
763 outb(ctrl_val, ee_addr);
764
765 for (i = 16; i > 0; i--) {
766 outb(ctrl_val | EE_SHIFT_CLK, ee_addr); eeprom_delay();
767 retval = (retval << 1) | ((inb(ee_addr) & EE_DATA_READ) ? 1 : 0);
768 outb(ctrl_val, ee_addr); eeprom_delay();
769 }
770
771
772 ctrl_val &= ~EE_CS;
773 outb(ctrl_val | EE_SHIFT_CLK, ee_addr);
774 eeprom_delay();
775 outb(ctrl_val, ee_addr);
776 eeprom_delay();
777 return retval;
778 }
779
780 static void
781 init_82586_mem(struct device *dev)
782 {
783 struct net_local *lp = (struct net_local *)dev->priv;
784 short ioaddr = dev->base_addr;
785
786
787
788 outb(inb(ioaddr + Config) | 0x02, ioaddr + Config);
789
790
791 outb(_586_RESET, ioaddr + EEPROM_Ctrl);
792
793
794 outw(0xfff6, ioaddr + WRITE_PTR);
795 outsw(ioaddr, init_words, sizeof(init_words)>>1);
796
797
798 outw(SA_OFFSET, ioaddr + WRITE_PTR);
799 outsw(ioaddr, dev->dev_addr, 3);
800
801
802 #ifdef initial_text_tx
803 lp->tx_cmd_link = DUMP_DATA + 4;
804 #else
805 lp->tx_cmd_link = IDLELOOP + 4;
806 #endif
807 lp->tx_head = lp->tx_reap = TX_BUF_START;
808
809 init_rx_bufs(dev);
810
811
812 outb(0x00, ioaddr + EEPROM_Ctrl);
813
814
815
816 outb(0, ioaddr + SIGNAL_CA);
817
818 {
819 int boguscnt = 50;
820 while (inw(ioaddr + SCB_STATUS) == 0)
821 if (--boguscnt == 0) {
822 printk("%s: i82586 initialization timed out with status %04x, cmd %04x.\n",
823 dev->name, inw(ioaddr + SCB_STATUS), inw(ioaddr + SCB_CMD));
824 break;
825 }
826
827 outb(0, ioaddr + SIGNAL_CA);
828 }
829
830
831 outb(inb(ioaddr + Config) & ~0x02, ioaddr + Config);
832 if (net_debug > 4)
833 printk("%s: Initialized 82586, status %04x.\n", dev->name,
834 inw(ioaddr + SCB_STATUS));
835 return;
836 }
837
838
839 static void init_rx_bufs(struct device *dev)
840 {
841 struct net_local *lp = (struct net_local *)dev->priv;
842 short ioaddr = dev->base_addr;
843
844 int cur_rxbuf = lp->rx_head = RX_BUF_START;
845
846
847 do {
848 outw(cur_rxbuf, ioaddr + WRITE_PTR);
849 outw(0x0000, ioaddr);
850 outw(0x0000, ioaddr);
851 outw(cur_rxbuf + RX_BUF_SIZE, ioaddr);
852 outw(cur_rxbuf + 22, ioaddr);
853 outw(0xFeed, ioaddr);
854 outw(0xF00d, ioaddr);
855 outw(0xF001, ioaddr);
856 outw(0x0505, ioaddr);
857 outw(0x2424, ioaddr);
858 outw(0x6565, ioaddr);
859 outw(0xdeaf, ioaddr);
860
861 outw(0x0000, ioaddr);
862 outw(-1, ioaddr);
863 outw(cur_rxbuf + 0x20, ioaddr);
864 outw(0x0000, ioaddr);
865
866 outw(0x8000 + RX_BUF_SIZE-0x20, ioaddr);
867
868 lp->rx_tail = cur_rxbuf;
869 cur_rxbuf += RX_BUF_SIZE;
870 } while (cur_rxbuf <= RX_BUF_END - RX_BUF_SIZE);
871
872
873
874 outw(lp->rx_tail + 2, ioaddr + WRITE_PTR);
875 outw(0xC000, ioaddr);
876 outw(lp->rx_head, ioaddr);
877 }
878
879 static void
880 hardware_send_packet(struct device *dev, void *buf, short length)
881 {
882 struct net_local *lp = (struct net_local *)dev->priv;
883 short ioaddr = dev->base_addr;
884 short tx_block = lp->tx_head;
885
886
887 outw(tx_block, ioaddr + WRITE_PTR);
888 outw(0x0000, ioaddr);
889 outw(CMD_INTR|CmdTx, ioaddr);
890 outw(tx_block+16, ioaddr);
891 outw(tx_block+8, ioaddr);
892
893
894 outw(length | 0x8000, ioaddr);
895 outw(-1, ioaddr);
896 outw(tx_block+22, ioaddr);
897 outw(0x0000, ioaddr);
898
899
900 outw(0x0000, ioaddr);
901 outw(CmdNOp, ioaddr);
902 outw(tx_block+16, ioaddr);
903
904
905
906 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
907
908
909 outw(lp->tx_cmd_link, ioaddr + WRITE_PTR);
910 outw(tx_block, ioaddr);
911 lp->tx_cmd_link = tx_block + 20;
912
913
914 lp->tx_head = tx_block + TX_BUF_SIZE;
915 if (lp->tx_head > TX_BUF_END - TX_BUF_SIZE)
916 lp->tx_head = TX_BUF_START;
917
918 if (net_debug > 4) {
919 printk("%s: EExp @%x send length = %d, tx_block %3x, next %3x, "
920 "reap %4x status %4.4x.\n", dev->name, ioaddr, length,
921 tx_block, lp->tx_head, lp->tx_reap, inw(ioaddr + SCB_STATUS));
922 }
923
924 if (lp->tx_head != lp->tx_reap)
925 dev->tbusy = 0;
926 }
927
928 static void
929 eexp_rx(struct device *dev)
930 {
931 struct net_local *lp = (struct net_local *)dev->priv;
932 short ioaddr = dev->base_addr;
933 short saved_write_ptr = inw(ioaddr + WRITE_PTR);
934 short rx_head = lp->rx_head;
935 short rx_tail = lp->rx_tail;
936 short boguscount = 10;
937 short frame_status;
938
939
940 outw(rx_head, ioaddr + READ_PTR);
941 while ((frame_status = inw(ioaddr)) < 0) {
942 short rfd_cmd = inw(ioaddr);
943 short next_rx_frame = inw(ioaddr);
944 short data_buffer_addr = inw(ioaddr);
945 short pkt_len;
946
947
948 outw(data_buffer_addr, ioaddr + READ_PTR);
949 pkt_len = inw(ioaddr);
950
951 if (rfd_cmd != 0 || data_buffer_addr != rx_head + 22
952 || pkt_len & 0xC000 != 0xC000) {
953 printk("%s: Rx frame at %#x corrupted, status %04x cmd %04x"
954 "next %04x data-buf @%04x %04x.\n", dev->name, rx_head,
955 frame_status, rfd_cmd, next_rx_frame, data_buffer_addr,
956 pkt_len);
957 } else if ((frame_status & 0x2000) == 0) {
958
959 lp->stats.rx_errors++;
960 if (frame_status & 0x0800) lp->stats.rx_crc_errors++;
961 if (frame_status & 0x0400) lp->stats.rx_frame_errors++;
962 if (frame_status & 0x0200) lp->stats.rx_fifo_errors++;
963 if (frame_status & 0x0100) lp->stats.rx_over_errors++;
964 if (frame_status & 0x0080) lp->stats.rx_length_errors++;
965 } else {
966
967 int sksize;
968 struct sk_buff *skb;
969
970 pkt_len &= 0x3fff;
971 sksize = sizeof(struct sk_buff) + pkt_len;
972 skb = alloc_skb(sksize, GFP_ATOMIC);
973 if (skb == NULL) {
974 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
975 lp->stats.rx_dropped++;
976 break;
977 }
978 skb->mem_len = sksize;
979 skb->mem_addr = skb;
980 skb->len = pkt_len;
981 skb->dev = dev;
982
983 outw(data_buffer_addr + 10, ioaddr + READ_PTR);
984
985 insw(ioaddr, skb->data, (pkt_len + 1) >> 1);
986
987 #ifdef HAVE_NETIF_RX
988 netif_rx(skb);
989 #else
990 skb->lock = 0;
991 if (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
992 kfree_s(skb, sksize);
993 lp->stats.rx_dropped++;
994 break;
995 }
996 #endif
997 lp->stats.rx_packets++;
998 }
999
1000
1001 outw(rx_head, ioaddr + WRITE_PTR);
1002 outw(0x0000, ioaddr);
1003 outw(0xC000, ioaddr);
1004 #ifndef final_version
1005 if (next_rx_frame != rx_head + RX_BUF_SIZE
1006 && next_rx_frame != RX_BUF_START) {
1007 printk("%s: Rx next frame at %#x is %#x instead of %#x.\n", dev->name,
1008 rx_head, next_rx_frame, rx_head + RX_BUF_SIZE);
1009 next_rx_frame = rx_head + RX_BUF_SIZE;
1010 if (next_rx_frame >= RX_BUF_END - RX_BUF_SIZE)
1011 next_rx_frame = RX_BUF_START;
1012 }
1013 #endif
1014 outw(rx_tail+2, ioaddr + WRITE_PTR);
1015 outw(0x0000, ioaddr);
1016
1017 #ifndef final_version
1018 outw(rx_tail+4, ioaddr + READ_PTR);
1019 if (inw(ioaddr) != rx_head) {
1020 printk("%s: Rx buf link mismatch, at %04x link %04x instead of %04x.\n",
1021 dev->name, rx_tail, (outw(rx_tail+4, ioaddr + READ_PTR),inw(ioaddr)),
1022 rx_head);
1023 outw(rx_head, ioaddr);
1024 }
1025 #endif
1026
1027 rx_tail = rx_head;
1028 rx_head = next_rx_frame;
1029 if (--boguscount == 0)
1030 break;
1031 outw(rx_head, ioaddr + READ_PTR);
1032 }
1033
1034 lp->rx_head = rx_head;
1035 lp->rx_tail = rx_tail;
1036
1037
1038 outw(saved_write_ptr, ioaddr + WRITE_PTR);
1039 }
1040
1041
1042
1043
1044
1045
1046
1047
1048