This source file includes following definitions.
- el1_probe
- el1_probe1
- el_open
- el_start_xmit
- el_interrupt
- el_receive
- el_reset
- el1_close
- el1_get_stats
- set_multicast_list
- 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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78 static const char *version =
79 "3c501.c: 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov).\n";
80
81
82
83
84
85
86 #include <linux/module.h>
87
88 #include <linux/kernel.h>
89 #include <linux/sched.h>
90 #include <linux/ptrace.h>
91 #include <linux/fcntl.h>
92 #include <linux/ioport.h>
93 #include <linux/interrupt.h>
94 #include <linux/malloc.h>
95 #include <linux/string.h>
96 #include <linux/errno.h>
97 #include <linux/config.h>
98
99 #include <asm/bitops.h>
100 #include <asm/io.h>
101
102 #include <linux/netdevice.h>
103 #include <linux/etherdevice.h>
104 #include <linux/skbuff.h>
105
106 #define BLOCKOUT_2
107
108
109
110 static unsigned int netcard_portlist[] =
111 { 0x280, 0x300, 0};
112
113
114
115
116
117
118 int el1_probe(struct device *dev);
119 static int el1_probe1(struct device *dev, int ioaddr);
120 static int el_open(struct device *dev);
121 static int el_start_xmit(struct sk_buff *skb, struct device *dev);
122 static void el_interrupt(int irq, void *dev_id, struct pt_regs *regs);
123 static void el_receive(struct device *dev);
124 static void el_reset(struct device *dev);
125 static int el1_close(struct device *dev);
126 static struct enet_statistics *el1_get_stats(struct device *dev);
127 static void set_multicast_list(struct device *dev);
128
129 #define EL1_IO_EXTENT 16
130
131 #ifndef EL_DEBUG
132 #define EL_DEBUG 0
133 #endif
134 static int el_debug = EL_DEBUG;
135
136
137
138
139
140 struct net_local
141 {
142 struct enet_statistics stats;
143 int tx_pkt_start;
144 int collisions;
145 int loading;
146 };
147
148
149 #define RX_STATUS (ioaddr + 0x06)
150 #define RX_CMD RX_STATUS
151 #define TX_STATUS (ioaddr + 0x07)
152 #define TX_CMD TX_STATUS
153 #define GP_LOW (ioaddr + 0x08)
154 #define GP_HIGH (ioaddr + 0x09)
155 #define RX_BUF_CLR (ioaddr + 0x0A)
156 #define RX_LOW (ioaddr + 0x0A)
157 #define RX_HIGH (ioaddr + 0x0B)
158 #define SAPROM (ioaddr + 0x0C)
159 #define AX_STATUS (ioaddr + 0x0E)
160 #define AX_CMD AX_STATUS
161 #define DATAPORT (ioaddr + 0x0F)
162 #define TX_RDY 0x08
163
164 #define EL1_DATAPTR 0x08
165 #define EL1_RXPTR 0x0A
166 #define EL1_SAPROM 0x0C
167 #define EL1_DATAPORT 0x0f
168
169
170
171
172
173 #define AX_OFF 0x00
174 #define AX_SYS 0x40
175 #define AX_XMIT 0x44
176 #define AX_RX 0x48
177 #define AX_LOOP 0x0C
178 #define AX_RESET 0x80
179
180
181
182
183
184
185 #define RX_NORM 0xA8
186 #define RX_PROM 0x68
187 #define RX_MULT 0xE8
188 #define TX_NORM 0x0A
189
190
191
192
193
194 #define TX_COLLISION 0x02
195 #define TX_16COLLISIONS 0x04
196 #define TX_READY 0x08
197
198 #define RX_RUNT 0x08
199 #define RX_MISSED 0x01
200 #define RX_GOOD 0x30
201
202
203
204
205
206
207 #ifdef HAVE_DEVLIST
208 struct netdev_entry el1_drv = {"3c501", el1_probe1, EL1_IO_EXTENT, netcard_portlist};
209 #else
210
211 int el1_probe(struct device *dev)
212 {
213 int i;
214 int base_addr = dev ? dev->base_addr : 0;
215
216 if (base_addr > 0x1ff)
217 return el1_probe1(dev, base_addr);
218 else if (base_addr != 0)
219 return ENXIO;
220
221 for (i = 0; netcard_portlist[i]; i++)
222 {
223 int ioaddr = netcard_portlist[i];
224 if (check_region(ioaddr, EL1_IO_EXTENT))
225 continue;
226 if (el1_probe1(dev, ioaddr) == 0)
227 return 0;
228 }
229
230 return ENODEV;
231 }
232 #endif
233
234
235
236
237
238 static int el1_probe1(struct device *dev, int ioaddr)
239 {
240 #ifndef MODULE
241
242 const char *mname;
243 unsigned char station_addr[6];
244 int autoirq = 0;
245 int i;
246
247
248
249
250
251 for (i = 0; i < 6; i++)
252 {
253 outw(i, ioaddr + EL1_DATAPTR);
254 station_addr[i] = inb(ioaddr + EL1_SAPROM);
255 }
256
257
258
259
260
261 if (station_addr[0] == 0x02 && station_addr[1] == 0x60
262 && station_addr[2] == 0x8c)
263 {
264 mname = "3c501";
265 } else if (station_addr[0] == 0x00 && station_addr[1] == 0x80
266 && station_addr[2] == 0xC8)
267 {
268 mname = "NP943";
269 }
270 else
271 return ENODEV;
272
273
274
275
276
277 request_region(ioaddr, EL1_IO_EXTENT,"3c501");
278
279
280
281
282
283
284 if (dev->irq < 2)
285 {
286 autoirq_setup(2);
287 inb(RX_STATUS);
288 inb(TX_STATUS);
289 outb(AX_LOOP + 1, AX_CMD);
290
291 outb(0x00, AX_CMD);
292
293 autoirq = autoirq_report(1);
294
295 if (autoirq == 0)
296 {
297 printk("%s probe at %#x failed to detect IRQ line.\n",
298 mname, ioaddr);
299 return EAGAIN;
300 }
301 }
302
303 outb(AX_RESET+AX_LOOP, AX_CMD);
304 dev->base_addr = ioaddr;
305 memcpy(dev->dev_addr, station_addr, ETH_ALEN);
306
307 if (dev->mem_start & 0xf)
308 el_debug = dev->mem_start & 0x7;
309 if (autoirq)
310 dev->irq = autoirq;
311
312 printk("%s: %s EtherLink at %#lx, using %sIRQ %d.\n", dev->name, mname, dev->base_addr,
313 autoirq ? "auto":"assigned ", dev->irq);
314
315 #ifdef CONFIG_IP_MULTICAST
316 printk("WARNING: Use of the 3c501 in a multicast kernel is NOT recommended.\n");
317 #endif
318
319 if (el_debug)
320 printk("%s", version);
321
322
323
324
325
326 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
327 if (dev->priv == NULL)
328 return -ENOMEM;
329 memset(dev->priv, 0, sizeof(struct net_local));
330
331
332
333
334
335 dev->open = &el_open;
336 dev->hard_start_xmit = &el_start_xmit;
337 dev->stop = &el1_close;
338 dev->get_stats = &el1_get_stats;
339 dev->set_multicast_list = &set_multicast_list;
340
341
342
343
344
345 ether_setup(dev);
346
347 #endif
348
349 return 0;
350 }
351
352
353
354
355
356 static int el_open(struct device *dev)
357 {
358 int ioaddr = dev->base_addr;
359
360 if (el_debug > 2)
361 printk("%s: Doing el_open()...", dev->name);
362
363 if (request_irq(dev->irq, &el_interrupt, 0, "3c501", NULL))
364 return -EAGAIN;
365
366 irq2dev_map[dev->irq] = dev;
367 el_reset(dev);
368
369 dev->start = 1;
370
371 outb(AX_RX, AX_CMD);
372 MOD_INC_USE_COUNT;
373 return 0;
374 }
375
376 static int el_start_xmit(struct sk_buff *skb, struct device *dev)
377 {
378 struct net_local *lp = (struct net_local *)dev->priv;
379 int ioaddr = dev->base_addr;
380 unsigned long flags;
381
382 if(dev->interrupt)
383 return 1;
384
385 if (dev->tbusy)
386 {
387 if (jiffies - dev->trans_start < 20)
388 {
389 if (el_debug > 2)
390 printk(" transmitter busy, deferred.\n");
391 return 1;
392 }
393 if (el_debug)
394 printk ("%s: transmit timed out, txsr %#2x axsr=%02x rxsr=%02x.\n",
395 dev->name, inb(TX_STATUS), inb(AX_STATUS), inb(RX_STATUS));
396 lp->stats.tx_errors++;
397 outb(TX_NORM, TX_CMD);
398 outb(RX_NORM, RX_CMD);
399 outb(AX_OFF, AX_CMD);
400 outb(AX_RX, AX_CMD);
401 dev->tbusy = 0;
402 dev->trans_start = jiffies;
403 }
404
405 if (skb == NULL)
406 {
407 dev_tint(dev);
408 return 0;
409 }
410
411 save_flags(flags);
412
413
414
415
416
417
418
419 cli();
420
421
422
423
424
425 if (set_bit(0, (void*)&dev->tbusy) != 0)
426 {
427 restore_flags(flags);
428 printk("%s: Transmitter access conflict.\n", dev->name);
429 }
430 else
431 {
432 int gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
433 unsigned char *buf = skb->data;
434
435 load_it_again_sam:
436 lp->tx_pkt_start = gp_start;
437 lp->collisions = 0;
438
439
440
441
442
443
444 #ifdef BLOCKOUT_1
445 disable_irq(dev->irq);
446 #endif
447 outb_p(AX_SYS, AX_CMD);
448 inb_p(RX_STATUS);
449 inb_p(TX_STATUS);
450
451 lp->loading=1;
452
453
454
455
456
457
458 restore_flags(flags);
459 outw(0x00, RX_BUF_CLR);
460 outw(gp_start, GP_LOW);
461 outsb(DATAPORT,buf,skb->len);
462 outw(gp_start, GP_LOW);
463 #ifndef BLOCKOUT_1
464 if(lp->loading==2)
465 {
466 if(el_debug>2)
467 printk("%s: burped during tx load.\n", dev->name);
468 goto load_it_again_sam;
469 }
470 #endif
471 outb(AX_XMIT, AX_CMD);
472 lp->loading=0;
473 #ifdef BLOCKOUT_1
474 enable_irq(dev->irq);
475 #endif
476 dev->trans_start = jiffies;
477 }
478
479 if (el_debug > 2)
480 printk(" queued xmit.\n");
481 dev_kfree_skb (skb, FREE_WRITE);
482 return 0;
483 }
484
485
486
487
488
489
490
491 static void el_interrupt(int irq, void *dev_id, struct pt_regs *regs)
492 {
493 struct device *dev = (struct device *)(irq2dev_map[irq]);
494 struct net_local *lp;
495 int ioaddr;
496 int axsr;
497
498 if (dev == NULL || dev->irq != irq)
499 {
500 printk ("3c501 driver: irq %d for unknown device.\n", irq);
501 return;
502 }
503
504 ioaddr = dev->base_addr;
505 lp = (struct net_local *)dev->priv;
506
507
508
509
510
511 axsr = inb(AX_STATUS);
512
513
514
515
516
517 if (el_debug > 3)
518 printk("%s: el_interrupt() aux=%#02x", dev->name, axsr);
519 if (dev->interrupt)
520 printk("%s: Reentering the interrupt driver!\n", dev->name);
521 dev->interrupt = 1;
522 #ifndef BLOCKOUT_1
523 if(lp->loading==1 && !dev->tbusy)
524 printk("%s: Inconsistent state loading while not in tx\n",
525 dev->name);
526 #endif
527 #ifdef BLOCKOUT_3
528 lp->loading=2;
529 #endif
530
531 if (dev->tbusy)
532 {
533
534
535
536
537
538
539 int txsr = inb(TX_STATUS);
540 #ifdef BLOCKOUT_2
541 if(lp->loading==1)
542 {
543 if(el_debug > 2)
544 {
545 printk("%s: Interrupt while loading [", dev->name);
546 printk(" txsr=%02x gp=%04x rp=%04x]\n", txsr, inw(GP_LOW),inw(RX_LOW));
547 }
548 lp->loading=2;
549 dev->interrupt = 0;
550 return;
551 }
552 #endif
553 if (el_debug > 6)
554 printk(" txsr=%02x gp=%04x rp=%04x", txsr, inw(GP_LOW),inw(RX_LOW));
555
556 if ((axsr & 0x80) && (txsr & TX_READY) == 0)
557 {
558
559
560
561
562 printk("%s: Unusual interrupt during Tx, txsr=%02x axsr=%02x"
563 " gp=%03x rp=%03x.\n", dev->name, txsr, axsr,
564 inw(ioaddr + EL1_DATAPTR), inw(ioaddr + EL1_RXPTR));
565 dev->tbusy = 0;
566 mark_bh(NET_BH);
567 }
568 else if (txsr & TX_16COLLISIONS)
569 {
570
571
572
573 if (el_debug)
574 printk("%s: Transmit failed 16 times, ethernet jammed?\n",dev->name);
575 outb(AX_SYS, AX_CMD);
576 lp->stats.tx_aborted_errors++;
577 }
578 else if (txsr & TX_COLLISION)
579 {
580
581
582
583
584 if (el_debug > 6)
585 printk(" retransmitting after a collision.\n");
586
587
588
589
590 outb(AX_SYS, AX_CMD);
591 outw(lp->tx_pkt_start, GP_LOW);
592 outb(AX_XMIT, AX_CMD);
593 lp->stats.collisions++;
594 dev->interrupt = 0;
595 return;
596 }
597 else
598 {
599
600
601
602 lp->stats.tx_packets++;
603 if (el_debug > 6)
604 printk(" Tx succeeded %s\n",
605 (txsr & TX_RDY) ? "." : "but tx is busy!");
606
607
608
609
610 dev->tbusy = 0;
611 mark_bh(NET_BH);
612 }
613 }
614 else
615 {
616
617
618
619
620 int rxsr = inb(RX_STATUS);
621 if (el_debug > 5)
622 printk(" rxsr=%02x txsr=%02x rp=%04x", rxsr, inb(TX_STATUS),inw(RX_LOW));
623
624
625
626 if (rxsr & RX_MISSED)
627 lp->stats.rx_missed_errors++;
628 else if (rxsr & RX_RUNT)
629 {
630 lp->stats.rx_length_errors++;
631 if (el_debug > 5)
632 printk(" runt.\n");
633 }
634 else if (rxsr & RX_GOOD)
635 {
636
637
638
639 el_receive(dev);
640 }
641 else
642 {
643
644
645
646 if (el_debug > 2)
647 printk("%s: No packet seen, rxsr=%02x **resetting 3c501***\n",
648 dev->name, rxsr);
649 el_reset(dev);
650 }
651 if (el_debug > 3)
652 printk(".\n");
653 }
654
655
656
657
658
659 outb(AX_RX, AX_CMD);
660 outw(0x00, RX_BUF_CLR);
661 inb(RX_STATUS);
662 inb(TX_STATUS);
663 dev->interrupt = 0;
664 return;
665 }
666
667
668
669
670
671
672
673 static void el_receive(struct device *dev)
674 {
675 struct net_local *lp = (struct net_local *)dev->priv;
676 int ioaddr = dev->base_addr;
677 int pkt_len;
678 struct sk_buff *skb;
679
680 pkt_len = inw(RX_LOW);
681
682 if (el_debug > 4)
683 printk(" el_receive %d.\n", pkt_len);
684
685 if ((pkt_len < 60) || (pkt_len > 1536))
686 {
687 if (el_debug)
688 printk("%s: bogus packet, length=%d\n", dev->name, pkt_len);
689 lp->stats.rx_over_errors++;
690 return;
691 }
692
693
694
695
696
697 outb(AX_SYS, AX_CMD);
698 skb = dev_alloc_skb(pkt_len+2);
699
700
701
702
703
704 outw(0x00, GP_LOW);
705 if (skb == NULL)
706 {
707 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
708 lp->stats.rx_dropped++;
709 return;
710 }
711 else
712 {
713 skb_reserve(skb,2);
714 skb->dev = dev;
715
716
717
718
719
720 insb(DATAPORT, skb_put(skb,pkt_len), pkt_len);
721 skb->protocol=eth_type_trans(skb,dev);
722 netif_rx(skb);
723 lp->stats.rx_packets++;
724 }
725 return;
726 }
727
728 static void el_reset(struct device *dev)
729 {
730 int ioaddr = dev->base_addr;
731
732 if (el_debug> 2)
733 printk("3c501 reset...");
734 outb(AX_RESET, AX_CMD);
735 outb(AX_LOOP, AX_CMD);
736 {
737 int i;
738 for (i = 0; i < 6; i++)
739 outb(dev->dev_addr[i], ioaddr + i);
740 }
741
742 outw(0, RX_BUF_CLR);
743 cli();
744 outb(TX_NORM, TX_CMD);
745 outb(RX_NORM, RX_CMD);
746 inb(RX_STATUS);
747 inb(TX_STATUS);
748 dev->interrupt = 0;
749 dev->tbusy = 0;
750 sti();
751 }
752
753 static int el1_close(struct device *dev)
754 {
755 int ioaddr = dev->base_addr;
756
757 if (el_debug > 2)
758 printk("%s: Shutting down ethercard at %#x.\n", dev->name, ioaddr);
759
760 dev->tbusy = 1;
761 dev->start = 0;
762
763
764
765
766
767 free_irq(dev->irq, NULL);
768 outb(AX_RESET, AX_CMD);
769 irq2dev_map[dev->irq] = 0;
770
771 MOD_DEC_USE_COUNT;
772 return 0;
773 }
774
775 static struct enet_statistics *el1_get_stats(struct device *dev)
776 {
777 struct net_local *lp = (struct net_local *)dev->priv;
778 return &lp->stats;
779 }
780
781
782
783
784
785
786 static void set_multicast_list(struct device *dev)
787 {
788 int ioaddr = dev->base_addr;
789
790 if(dev->flags&IFF_PROMISC)
791 {
792 outb(RX_PROM, RX_CMD);
793 inb(RX_STATUS);
794 }
795 else if (dev->mc_list || dev->flags&IFF_ALLMULTI)
796 {
797 outb(RX_MULT, RX_CMD);
798 inb(RX_STATUS);
799 }
800 else
801 {
802 outb(RX_NORM, RX_CMD);
803 inb(RX_STATUS);
804 }
805 }
806
807 #ifdef MODULE
808
809 static char devicename[9] = { 0, };
810
811 static struct device dev_3c501 =
812 {
813 devicename,
814 0, 0, 0, 0,
815 0x280, 5,
816 0, 0, 0, NULL, el1_probe
817 };
818
819 static int io=0x280;
820 static int irq=5;
821
822 int init_module(void)
823 {
824 dev_3c501.irq=irq;
825 dev_3c501.base_addr=io;
826 if (register_netdev(&dev_3c501) != 0)
827 return -EIO;
828 return 0;
829 }
830
831 void cleanup_module(void)
832 {
833
834
835
836
837 unregister_netdev(&dev_3c501);
838
839
840
841
842
843 kfree(dev_3c501.priv);
844 dev_3c501.priv = NULL;
845
846
847
848
849 release_region(dev_3c501.base_addr, EL1_IO_EXTENT);
850 }
851
852 #endif
853
854
855
856
857
858
859