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