This source file includes following definitions.
- ei_open
- ei_start_xmit
- ei_interrupt
- ei_tx_intr
- ei_receive
- ei_rx_overrun
- get_stats
- set_multicast_list
- ethdev_init
- NS8390_init
- NS8390_trigger_send
- init_module
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 static char *version =
21 "8390.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
22
23
24
25
26
27
28
29
30
31
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/fs.h>
35 #include <linux/types.h>
36 #include <linux/ptrace.h>
37 #include <linux/string.h>
38 #include <asm/system.h>
39 #include <asm/segment.h>
40 #include <asm/bitops.h>
41 #include <asm/io.h>
42 #include <linux/errno.h>
43 #include <linux/fcntl.h>
44 #include <linux/in.h>
45 #include <linux/interrupt.h>
46
47 #include <linux/netdevice.h>
48 #include <linux/etherdevice.h>
49 #include <linux/skbuff.h>
50
51 #include "8390.h"
52
53 #ifdef MODULE
54 #include <linux/module.h>
55 #include <linux/version.h>
56 #endif
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74 #define ei_reset_8390 (ei_local->reset_8390)
75 #define ei_block_output (ei_local->block_output)
76 #define ei_block_input (ei_local->block_input)
77
78
79 #ifdef EI_DEBUG
80 int ei_debug = EI_DEBUG;
81 #else
82 int ei_debug = 1;
83 #endif
84
85
86
87 static int high_water_mark = 0;
88
89
90 static void ei_tx_intr(struct device *dev);
91 static void ei_receive(struct device *dev);
92 static void ei_rx_overrun(struct device *dev);
93
94
95 static void NS8390_trigger_send(struct device *dev, unsigned int length,
96 int start_page);
97 #ifdef HAVE_MULTICAST
98 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
99 #endif
100
101
102
103
104
105
106 int ei_open(struct device *dev)
107 {
108 struct ei_device *ei_local = (struct ei_device *) dev->priv;
109
110 if ( ! ei_local) {
111 printk("%s: Opening a non-existent physical device\n", dev->name);
112 return ENXIO;
113 }
114
115 irq2dev_map[dev->irq] = dev;
116 NS8390_init(dev, 1);
117 dev->start = 1;
118 ei_local->irqlock = 0;
119 return 0;
120 }
121
122 static int ei_start_xmit(struct sk_buff *skb, struct device *dev)
123 {
124 int e8390_base = dev->base_addr;
125 struct ei_device *ei_local = (struct ei_device *) dev->priv;
126 int length, send_length;
127
128
129
130
131
132
133 if (dev->tbusy) {
134 int txsr = inb(e8390_base+EN0_TSR), isr;
135 int tickssofar = jiffies - dev->trans_start;
136 if (tickssofar < 10 || (tickssofar < 15 && ! (txsr & ENTSR_PTX))) {
137 return 1;
138 }
139 isr = inb(e8390_base+EN0_ISR);
140 if (dev->start == 0) {
141 printk("%s: xmit on stopped card\n", dev->name);
142 return 1;
143 }
144 printk(KERN_DEBUG "%s: transmit timed out, TX status %#2x, ISR %#2x.\n",
145 dev->name, txsr, isr);
146
147 if (isr)
148 printk(KERN_DEBUG "%s: Possible IRQ conflict on IRQ%d?\n", dev->name, dev->irq);
149 else {
150
151 printk(KERN_DEBUG "%s: Possible network cable problem?\n", dev->name);
152 if(ei_local->stat.tx_packets==0)
153 ei_local->interface_num ^= 1;
154 }
155
156 ei_reset_8390(dev);
157 NS8390_init(dev, 1);
158 dev->trans_start = jiffies;
159 }
160
161
162
163
164 if (skb == NULL) {
165 dev_tint(dev);
166 return 0;
167 }
168
169 length = skb->len;
170 if (skb->len <= 0)
171 return 0;
172
173
174 if (set_bit(0, (void*)&dev->tbusy) != 0) {
175 printk("%s: Transmitter access conflict.\n", dev->name);
176 return 1;
177 }
178
179
180 outb(0x00, e8390_base + EN0_IMR);
181 ei_local->irqlock = 1;
182
183 send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
184
185 if (ei_local->pingpong) {
186 int output_page;
187 if (ei_local->tx1 == 0) {
188 output_page = ei_local->tx_start_page;
189 ei_local->tx1 = send_length;
190 if (ei_debug && ei_local->tx2 > 0)
191 printk("%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
192 dev->name, ei_local->tx2, ei_local->lasttx,
193 ei_local->txing);
194 } else if (ei_local->tx2 == 0) {
195 output_page = ei_local->tx_start_page + 6;
196 ei_local->tx2 = send_length;
197 if (ei_debug && ei_local->tx1 > 0)
198 printk("%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
199 dev->name, ei_local->tx1, ei_local->lasttx,
200 ei_local->txing);
201 } else {
202 if (ei_debug)
203 printk("%s: No packet buffer space for ping-pong use.\n",
204 dev->name);
205 ei_local->irqlock = 0;
206 dev->tbusy = 1;
207 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
208 return 1;
209 }
210 ei_block_output(dev, length, skb->data, output_page);
211 if (! ei_local->txing) {
212 NS8390_trigger_send(dev, send_length, output_page);
213 dev->trans_start = jiffies;
214 if (output_page == ei_local->tx_start_page)
215 ei_local->tx1 = -1, ei_local->lasttx = -1;
216 else
217 ei_local->tx2 = -1, ei_local->lasttx = -2;
218 ei_local->txing = 1;
219 } else
220 ei_local->txqueue++;
221
222 dev->tbusy = (ei_local->tx1 && ei_local->tx2);
223 } else {
224 ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
225 NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
226 dev->trans_start = jiffies;
227 dev->tbusy = 1;
228 }
229
230
231 ei_local->irqlock = 0;
232 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
233
234 dev_kfree_skb (skb, FREE_WRITE);
235
236 return 0;
237 }
238
239
240
241 void ei_interrupt(int reg_ptr)
242 {
243 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
244 struct device *dev = (struct device *)(irq2dev_map[irq]);
245 int e8390_base;
246 int interrupts, boguscount = 0;
247 struct ei_device *ei_local;
248
249 if (dev == NULL) {
250 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
251 return;
252 }
253 e8390_base = dev->base_addr;
254 ei_local = (struct ei_device *) dev->priv;
255 if (dev->interrupt || ei_local->irqlock) {
256
257 sti();
258 printk(ei_local->irqlock
259 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
260 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
261 dev->name, inb_p(e8390_base + EN0_ISR),
262 inb_p(e8390_base + EN0_IMR));
263 return;
264 }
265
266 dev->interrupt = 1;
267 sti();
268
269
270 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
271 if (ei_debug > 3)
272 printk("%s: interrupt(isr=%#2.2x).\n", dev->name,
273 inb_p(e8390_base + EN0_ISR));
274
275
276 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
277 && ++boguscount < 9) {
278 if (dev->start == 0) {
279 printk("%s: interrupt from stopped card\n", dev->name);
280 interrupts = 0;
281 break;
282 }
283 if (interrupts & ENISR_RDC) {
284
285 outb_p(ENISR_RDC, e8390_base + EN0_ISR);
286 }
287 if (interrupts & ENISR_OVER) {
288 ei_rx_overrun(dev);
289 } else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) {
290
291 ei_receive(dev);
292 }
293
294 if (interrupts & ENISR_TX) {
295 ei_tx_intr(dev);
296 } else if (interrupts & ENISR_COUNTERS) {
297 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
298 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
299 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
300 outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR);
301 }
302
303
304 if (interrupts & ENISR_TX_ERR) {
305 outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR);
306 }
307 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
308 }
309
310 if (interrupts && ei_debug) {
311 if (boguscount == 9)
312 printk("%s: Too much work at interrupt, status %#2.2x\n",
313 dev->name, interrupts);
314 else
315 printk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
316 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
317 outb_p(0xff, e8390_base + EN0_ISR);
318 }
319 dev->interrupt = 0;
320 return;
321 }
322
323
324
325 static void ei_tx_intr(struct device *dev)
326 {
327 int e8390_base = dev->base_addr;
328 int status = inb(e8390_base + EN0_TSR);
329 struct ei_device *ei_local = (struct ei_device *) dev->priv;
330
331 outb_p(ENISR_TX, e8390_base + EN0_ISR);
332
333 if (ei_local->pingpong) {
334 ei_local->txqueue--;
335 if (ei_local->tx1 < 0) {
336 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
337 printk("%s: bogus last_tx_buffer %d, tx1=%d.\n",
338 ei_local->name, ei_local->lasttx, ei_local->tx1);
339 ei_local->tx1 = 0;
340 dev->tbusy = 0;
341 if (ei_local->tx2 > 0) {
342 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
343 dev->trans_start = jiffies;
344 ei_local->txing = 1;
345 ei_local->tx2 = -1,
346 ei_local->lasttx = 2;
347 } else
348 ei_local->lasttx = 20, ei_local->txing = 0;
349 } else if (ei_local->tx2 < 0) {
350 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
351 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
352 ei_local->name, ei_local->lasttx, ei_local->tx2);
353 ei_local->tx2 = 0;
354 dev->tbusy = 0;
355 if (ei_local->tx1 > 0) {
356 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
357 dev->trans_start = jiffies;
358 ei_local->txing = 1;
359 ei_local->tx1 = -1;
360 ei_local->lasttx = 1;
361 } else
362 ei_local->lasttx = 10, ei_local->txing = 0;
363 } else
364 printk("%s: unexpected TX-done interrupt, lasttx=%d.\n",
365 dev->name, ei_local->lasttx);
366 } else {
367 ei_local->txing = 0;
368 dev->tbusy = 0;
369 }
370
371
372 if (status & ENTSR_COL) ei_local->stat.collisions++;
373 if (status & ENTSR_PTX)
374 ei_local->stat.tx_packets++;
375 else {
376 ei_local->stat.tx_errors++;
377 if (status & ENTSR_ABT) ei_local->stat.tx_aborted_errors++;
378 if (status & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
379 if (status & ENTSR_FU) ei_local->stat.tx_fifo_errors++;
380 if (status & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
381 if (status & ENTSR_OWC) ei_local->stat.tx_window_errors++;
382 }
383
384 mark_bh (NET_BH);
385 }
386
387
388
389 static void ei_receive(struct device *dev)
390 {
391 int e8390_base = dev->base_addr;
392 struct ei_device *ei_local = (struct ei_device *) dev->priv;
393 int rxing_page, this_frame, next_frame, current_offset;
394 int rx_pkt_count = 0;
395 struct e8390_pkt_hdr rx_frame;
396 int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
397
398 while (++rx_pkt_count < 10) {
399 int pkt_len;
400
401
402 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
403 rxing_page = inb_p(e8390_base + EN1_CURPAG);
404 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
405
406
407 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
408 if (this_frame >= ei_local->stop_page)
409 this_frame = ei_local->rx_start_page;
410
411
412
413 if (ei_debug > 0 && this_frame != ei_local->current_page)
414 printk("%s: mismatched read page pointers %2x vs %2x.\n",
415 dev->name, this_frame, ei_local->current_page);
416
417 if (this_frame == rxing_page)
418 break;
419
420 current_offset = this_frame << 8;
421 ei_block_input(dev, sizeof(rx_frame), (char *)&rx_frame,
422 current_offset);
423
424 pkt_len = rx_frame.count - sizeof(rx_frame);
425
426 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
427
428
429
430
431 if (rx_frame.next != next_frame
432 && rx_frame.next != next_frame + 1
433 && rx_frame.next != next_frame - num_rx_pages
434 && rx_frame.next != next_frame + 1 - num_rx_pages) {
435 ei_local->current_page = rxing_page;
436 outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
437 ei_local->stat.rx_errors++;
438 continue;
439 }
440
441 if (pkt_len < 60 || pkt_len > 1518) {
442 if (ei_debug)
443 printk("%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
444 dev->name, rx_frame.count, rx_frame.status,
445 rx_frame.next);
446 ei_local->stat.rx_errors++;
447 } else if ((rx_frame.status & 0x0F) == ENRSR_RXOK) {
448 struct sk_buff *skb;
449
450 skb = alloc_skb(pkt_len, GFP_ATOMIC);
451 if (skb == NULL) {
452 if (ei_debug > 1)
453 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
454 dev->name, pkt_len);
455 ei_local->stat.rx_dropped++;
456 break;
457 } else {
458 skb->len = pkt_len;
459 skb->dev = dev;
460
461 ei_block_input(dev, pkt_len, (char *) skb->data,
462 current_offset + sizeof(rx_frame));
463 netif_rx(skb);
464 ei_local->stat.rx_packets++;
465 }
466 } else {
467 int errs = rx_frame.status;
468 if (ei_debug)
469 printk("%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
470 dev->name, rx_frame.status, rx_frame.next,
471 rx_frame.count);
472 if (errs & ENRSR_FO)
473 ei_local->stat.rx_fifo_errors++;
474 }
475 next_frame = rx_frame.next;
476
477
478 if (next_frame >= ei_local->stop_page) {
479 printk("%s: next frame inconsistency, %#2x..", dev->name,
480 next_frame);
481 next_frame = ei_local->rx_start_page;
482 }
483 ei_local->current_page = next_frame;
484 outb(next_frame-1, e8390_base+EN0_BOUNDARY);
485 }
486
487
488
489
490
491 if (rx_pkt_count > high_water_mark)
492 high_water_mark = rx_pkt_count;
493
494
495 outb_p(ENISR_RX+ENISR_RX_ERR+ENISR_OVER, e8390_base+EN0_ISR);
496 return;
497 }
498
499
500
501 static void ei_rx_overrun(struct device *dev)
502 {
503 int e8390_base = dev->base_addr;
504 int reset_start_time = jiffies;
505 struct ei_device *ei_local = (struct ei_device *) dev->priv;
506
507
508 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
509
510 if (ei_debug > 1)
511 printk("%s: Receiver overrun.\n", dev->name);
512 ei_local->stat.rx_over_errors++;
513
514
515
516
517
518
519
520
521 while ((inb_p(e8390_base+EN0_ISR) & ENISR_RESET) == 0)
522 if (jiffies - reset_start_time > 1) {
523 printk("%s: reset did not complete at ei_rx_overrun.\n",
524 dev->name);
525 NS8390_init(dev, 1);
526 return;
527 }
528
529
530 ei_receive(dev);
531
532 outb_p(0xff, e8390_base+EN0_ISR);
533
534 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
535 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
536 }
537
538 static struct enet_statistics *get_stats(struct device *dev)
539 {
540 short ioaddr = dev->base_addr;
541 struct ei_device *ei_local = (struct ei_device *) dev->priv;
542
543
544 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
545 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
546 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
547
548 return &ei_local->stat;
549 }
550
551 #ifdef HAVE_MULTICAST
552
553
554
555
556
557
558 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
559 {
560 short ioaddr = dev->base_addr;
561
562 if (num_addrs > 0) {
563
564
565 outb_p(E8390_RXCONFIG | 0x08, ioaddr + EN0_RXCR);
566 } else if (num_addrs < 0)
567 outb_p(E8390_RXCONFIG | 0x18, ioaddr + EN0_RXCR);
568 else
569 outb_p(E8390_RXCONFIG, ioaddr + EN0_RXCR);
570 }
571 #endif
572
573
574 int ethdev_init(struct device *dev)
575 {
576 if (ei_debug > 1)
577 printk(version);
578
579 if (dev->priv == NULL) {
580 struct ei_device *ei_local;
581
582 dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
583 memset(dev->priv, 0, sizeof(struct ei_device));
584 ei_local = (struct ei_device *)dev->priv;
585 #ifndef NO_PINGPONG
586 ei_local->pingpong = 1;
587 #endif
588 }
589
590
591 if (dev->open == NULL)
592 dev->open = &ei_open;
593
594 dev->hard_start_xmit = &ei_start_xmit;
595 dev->get_stats = get_stats;
596 #ifdef HAVE_MULTICAST
597 dev->set_multicast_list = &set_multicast_list;
598 #endif
599
600 ether_setup(dev);
601
602 return 0;
603 }
604
605
606
607
608 void NS8390_init(struct device *dev, int startp)
609 {
610 int e8390_base = dev->base_addr;
611 struct ei_device *ei_local = (struct ei_device *) dev->priv;
612 int i;
613 int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
614
615
616 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base);
617 outb_p(endcfg, e8390_base + EN0_DCFG);
618
619 outb_p(0x00, e8390_base + EN0_RCNTLO);
620 outb_p(0x00, e8390_base + EN0_RCNTHI);
621
622 outb_p(E8390_RXOFF, e8390_base + EN0_RXCR);
623 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
624
625 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
626 ei_local->tx1 = ei_local->tx2 = 0;
627 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
628 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY);
629 ei_local->current_page = ei_local->rx_start_page;
630 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
631
632 outb_p(0xFF, e8390_base + EN0_ISR);
633 outb_p(0x00, e8390_base + EN0_IMR);
634
635
636
637 cli();
638 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base);
639 for(i = 0; i < 6; i++) {
640 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i);
641 }
642
643
644 for(i = 0; i < 8; i++)
645 outb_p(0xff, e8390_base + EN1_MULT + i);
646
647 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
648 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base);
649 sti();
650 dev->tbusy = 0;
651 dev->interrupt = 0;
652 ei_local->tx1 = ei_local->tx2 = 0;
653 ei_local->txing = 0;
654 if (startp) {
655 outb_p(0xff, e8390_base + EN0_ISR);
656 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
657 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base);
658 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
659
660 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
661 }
662 return;
663 }
664
665
666 static void NS8390_trigger_send(struct device *dev, unsigned int length,
667 int start_page)
668 {
669 int e8390_base = dev->base_addr;
670
671 ei_status.txing = 1;
672 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base);
673
674 if (inb_p(e8390_base) & E8390_TRANS) {
675 printk("%s: trigger_send() called with the transmitter busy.\n",
676 dev->name);
677 return;
678 }
679 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
680 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
681 outb_p(start_page, e8390_base + EN0_TPSR);
682 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base);
683 return;
684 }
685
686 #ifdef MODULE
687 char kernel_version[] = UTS_RELEASE;
688
689 int init_module(void)
690 {
691 return 0;
692 }
693
694 void
695 cleanup_module(void)
696 {
697 }
698 #endif
699
700
701
702
703
704
705
706
707
708