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
79
80
81
82
83
84
85
86
87
88
89
90#define DRV_NAME "3c523"
91#define DRV_VERSION "17-Nov-2001"
92
93#include <linux/init.h>
94#include <linux/netdevice.h>
95#include <linux/etherdevice.h>
96#include <linux/module.h>
97#include <linux/kernel.h>
98#include <linux/string.h>
99#include <linux/errno.h>
100#include <linux/ioport.h>
101#include <linux/skbuff.h>
102#include <linux/slab.h>
103#include <linux/interrupt.h>
104#include <linux/delay.h>
105#include <linux/mca-legacy.h>
106#include <linux/ethtool.h>
107#include <linux/bitops.h>
108#include <linux/jiffies.h>
109
110#include <asm/uaccess.h>
111#include <asm/processor.h>
112#include <asm/io.h>
113
114#include "3c523.h"
115
116
117#define DEBUG
118#define SYSBUSVAL 0
119#undef ELMC_MULTICAST
120
121#define make32(ptr16) (p->memtop + (short) (ptr16) )
122#define make24(ptr32) ((char *) (ptr32) - p->base)
123#define make16(ptr32) ((unsigned short) ((unsigned long) (ptr32) - (unsigned long) p->memtop ))
124
125
126
127
128
129static int irq_table[] __initdata = {
130 12, 7, 3, 9
131};
132
133static int csr_table[] __initdata = {
134 0x300, 0x1300, 0x2300, 0x3300
135};
136
137static int shm_table[] __initdata = {
138 0x0c0000, 0x0c8000, 0x0d0000, 0x0d8000
139};
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156#define RECV_BUFF_SIZE 1524
157#define XMIT_BUFF_SIZE 1524
158#define NUM_XMIT_BUFFS 1
159#define NUM_RECV_BUFFS_8 4
160#define NUM_RECV_BUFFS_16 9
161
162#if (NUM_XMIT_BUFFS == 1)
163#define NO_NOPCOMMANDS
164#endif
165
166
167
168#define DELAY(x) { mdelay(32 * x); }
169
170
171#define DELAY_16(); { udelay(16) ; }
172
173
174#define WAIT_4_SCB_CMD() { int i; \
175 for(i=0;i<1024;i++) { \
176 if(!p->scb->cmd) break; \
177 DELAY_16(); \
178 if(i == 1023) { \
179 pr_warning("%s:%d: scb_cmd timed out .. resetting i82586\n",\
180 dev->name,__LINE__); \
181 elmc_id_reset586(); } } }
182
183static irqreturn_t elmc_interrupt(int irq, void *dev_id);
184static int elmc_open(struct net_device *dev);
185static int elmc_close(struct net_device *dev);
186static netdev_tx_t elmc_send_packet(struct sk_buff *, struct net_device *);
187static struct net_device_stats *elmc_get_stats(struct net_device *dev);
188static void elmc_timeout(struct net_device *dev);
189#ifdef ELMC_MULTICAST
190static void set_multicast_list(struct net_device *dev);
191#endif
192static const struct ethtool_ops netdev_ethtool_ops;
193
194
195static int init586(struct net_device *dev);
196static int check586(struct net_device *dev, unsigned long where, unsigned size);
197static void alloc586(struct net_device *dev);
198static void startrecv586(struct net_device *dev);
199static void *alloc_rfa(struct net_device *dev, void *ptr);
200static void elmc_rcv_int(struct net_device *dev);
201static void elmc_xmt_int(struct net_device *dev);
202static void elmc_rnr_int(struct net_device *dev);
203
204struct priv {
205 unsigned long base;
206 char *memtop;
207 unsigned long mapped_start;
208 volatile struct rfd_struct *rfd_last, *rfd_top, *rfd_first;
209 volatile struct scp_struct *scp;
210 volatile struct iscp_struct *iscp;
211 volatile struct scb_struct *scb;
212 volatile struct tbd_struct *xmit_buffs[NUM_XMIT_BUFFS];
213#if (NUM_XMIT_BUFFS == 1)
214 volatile struct transmit_cmd_struct *xmit_cmds[2];
215 volatile struct nop_cmd_struct *nop_cmds[2];
216#else
217 volatile struct transmit_cmd_struct *xmit_cmds[NUM_XMIT_BUFFS];
218 volatile struct nop_cmd_struct *nop_cmds[NUM_XMIT_BUFFS];
219#endif
220 volatile int nop_point, num_recv_buffs;
221 volatile char *xmit_cbuffs[NUM_XMIT_BUFFS];
222 volatile int xmit_count, xmit_last;
223 volatile int slot;
224};
225
226#define elmc_attn586() {elmc_do_attn586(dev->base_addr,ELMC_CTRL_INTE);}
227#define elmc_reset586() {elmc_do_reset586(dev->base_addr,ELMC_CTRL_INTE);}
228
229
230
231
232#define elmc_id_attn586() {elmc_do_attn586(dev->base_addr,0);}
233#define elmc_id_reset586() {elmc_do_reset586(dev->base_addr,0);}
234
235
236
237
238
239static void elmc_do_attn586(int ioaddr, int ints)
240{
241
242
243
244
245
246
247
248
249
250 outb(ELMC_CTRL_RST | 0x3 | ELMC_CTRL_CA | ints, ioaddr + ELMC_CTRL);
251 DELAY_16();
252 outb(ELMC_CTRL_RST | 0x3 | ints, ioaddr + ELMC_CTRL);
253}
254
255
256
257
258
259static void elmc_do_reset586(int ioaddr, int ints)
260{
261
262 outb(0x3 | ELMC_CTRL_LBK, ioaddr + ELMC_CTRL);
263 DELAY_16();
264 outb(ELMC_CTRL_RST | ELMC_CTRL_LBK | 0x3, ioaddr + ELMC_CTRL);
265
266 elmc_do_attn586(ioaddr, ints);
267}
268
269
270
271
272
273static int elmc_close(struct net_device *dev)
274{
275 netif_stop_queue(dev);
276 elmc_id_reset586();
277 free_irq(dev->irq, dev);
278 return 0;
279}
280
281
282
283
284
285static int elmc_open(struct net_device *dev)
286{
287 int ret;
288
289 elmc_id_attn586();
290
291 ret = request_irq(dev->irq, &elmc_interrupt, IRQF_SHARED | IRQF_SAMPLE_RANDOM,
292 dev->name, dev);
293 if (ret) {
294 pr_err("%s: couldn't get irq %d\n", dev->name, dev->irq);
295 elmc_id_reset586();
296 return ret;
297 }
298 alloc586(dev);
299 init586(dev);
300 startrecv586(dev);
301 netif_start_queue(dev);
302 return 0;
303}
304
305
306
307
308
309static int __init check586(struct net_device *dev, unsigned long where, unsigned size)
310{
311 struct priv *p = netdev_priv(dev);
312 char *iscp_addrs[2];
313 int i = 0;
314
315 p->base = (unsigned long) isa_bus_to_virt((unsigned long)where) + size - 0x01000000;
316 p->memtop = isa_bus_to_virt((unsigned long)where) + size;
317 p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
318 memset((char *) p->scp, 0, sizeof(struct scp_struct));
319 p->scp->sysbus = SYSBUSVAL;
320
321 iscp_addrs[0] = isa_bus_to_virt((unsigned long)where);
322 iscp_addrs[1] = (char *) p->scp - sizeof(struct iscp_struct);
323
324 for (i = 0; i < 2; i++) {
325 p->iscp = (struct iscp_struct *) iscp_addrs[i];
326 memset((char *) p->iscp, 0, sizeof(struct iscp_struct));
327
328 p->scp->iscp = make24(p->iscp);
329 p->iscp->busy = 1;
330
331 elmc_id_reset586();
332
333
334
335
336 elmc_id_attn586();
337 DELAY(1);
338
339 if (p->iscp->busy) {
340 return 0;
341 }
342 }
343 return 1;
344}
345
346
347
348
349
350static void alloc586(struct net_device *dev)
351{
352 struct priv *p = netdev_priv(dev);
353
354 elmc_id_reset586();
355 DELAY(2);
356
357 p->scp = (struct scp_struct *) (p->base + SCP_DEFAULT_ADDRESS);
358 p->scb = (struct scb_struct *) isa_bus_to_virt(dev->mem_start);
359 p->iscp = (struct iscp_struct *) ((char *) p->scp - sizeof(struct iscp_struct));
360
361 memset((char *) p->iscp, 0, sizeof(struct iscp_struct));
362 memset((char *) p->scp, 0, sizeof(struct scp_struct));
363
364 p->scp->iscp = make24(p->iscp);
365 p->scp->sysbus = SYSBUSVAL;
366 p->iscp->scb_offset = make16(p->scb);
367
368 p->iscp->busy = 1;
369 elmc_id_reset586();
370 elmc_id_attn586();
371
372 DELAY(2);
373
374 if (p->iscp->busy)
375 pr_err("%s: Init-Problems (alloc).\n", dev->name);
376
377 memset((char *) p->scb, 0, sizeof(struct scb_struct));
378}
379
380
381
382static int elmc_getinfo(char *buf, int slot, void *d)
383{
384 int len = 0;
385 struct net_device *dev = d;
386
387 if (dev == NULL)
388 return len;
389
390 len += sprintf(buf + len, "Revision: 0x%x\n",
391 inb(dev->base_addr + ELMC_REVISION) & 0xf);
392 len += sprintf(buf + len, "IRQ: %d\n", dev->irq);
393 len += sprintf(buf + len, "IO Address: %#lx-%#lx\n", dev->base_addr,
394 dev->base_addr + ELMC_IO_EXTENT);
395 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
396 dev->mem_end - 1);
397 len += sprintf(buf + len, "Transceiver: %s\n", dev->if_port ?
398 "External" : "Internal");
399 len += sprintf(buf + len, "Device: %s\n", dev->name);
400 len += sprintf(buf + len, "Hardware Address: %pM\n",
401 dev->dev_addr);
402
403 return len;
404}
405
406static const struct net_device_ops netdev_ops = {
407 .ndo_open = elmc_open,
408 .ndo_stop = elmc_close,
409 .ndo_get_stats = elmc_get_stats,
410 .ndo_start_xmit = elmc_send_packet,
411 .ndo_tx_timeout = elmc_timeout,
412#ifdef ELMC_MULTICAST
413 .ndo_set_multicast_list = set_multicast_list,
414#endif
415 .ndo_change_mtu = eth_change_mtu,
416 .ndo_set_mac_address = eth_mac_addr,
417 .ndo_validate_addr = eth_validate_addr,
418};
419
420
421
422static int __init do_elmc_probe(struct net_device *dev)
423{
424 static int slot;
425 int base_addr = dev->base_addr;
426 int irq = dev->irq;
427 u_char status = 0;
428 u_char revision = 0;
429 int i = 0;
430 unsigned int size = 0;
431 int retval;
432 struct priv *pr = netdev_priv(dev);
433
434 if (MCA_bus == 0) {
435 return -ENODEV;
436 }
437
438 slot = mca_find_adapter(ELMC_MCA_ID, 0);
439 while (slot != -1) {
440 status = mca_read_stored_pos(slot, 2);
441
442 dev->irq=irq_table[(status & ELMC_STATUS_IRQ_SELECT) >> 6];
443 dev->base_addr=csr_table[(status & ELMC_STATUS_CSR_SELECT) >> 1];
444
445
446
447
448
449
450
451 if ((irq && irq != dev->irq) ||
452 (base_addr && base_addr != dev->base_addr)) {
453 slot = mca_find_adapter(ELMC_MCA_ID, slot + 1);
454 continue;
455 }
456 if (!request_region(dev->base_addr, ELMC_IO_EXTENT, DRV_NAME)) {
457 slot = mca_find_adapter(ELMC_MCA_ID, slot + 1);
458 continue;
459 }
460
461
462 break;
463 }
464
465
466 if (slot == MCA_NOTFOUND)
467 return ((base_addr || irq) ? -ENXIO : -ENODEV);
468
469 mca_set_adapter_name(slot, "3Com 3c523 Etherlink/MC");
470 mca_set_adapter_procfn(slot, (MCA_ProcFn) elmc_getinfo, dev);
471
472
473 pr_info("%s: 3c523 adapter found in slot %d\n", dev->name, slot + 1);
474
475
476
477
478
479
480
481
482
483
484
485
486
487 revision = inb(dev->base_addr + ELMC_REVISION) & 0xf;
488
489
490
491
492 switch (dev->irq) {
493 case 3:
494 mca_write_pos(slot, 3, 0x04);
495 break;
496 case 7:
497 mca_write_pos(slot, 3, 0x02);
498 break;
499 case 9:
500 mca_write_pos(slot, 3, 0x08);
501 break;
502 case 12:
503 mca_write_pos(slot, 3, 0x01);
504 break;
505 }
506
507 memset(pr, 0, sizeof(struct priv));
508 pr->slot = slot;
509
510 pr_info("%s: 3Com 3c523 Rev 0x%x at %#lx\n", dev->name, (int) revision,
511 dev->base_addr);
512
513
514
515
516 dev->if_port = (status & ELMC_STATUS_DISABLE_THIN);
517
518
519
520
521
522
523 dev->mem_start = shm_table[(status & ELMC_STATUS_MEMORY_SELECT) >> 3];
524
525
526
527
528 elmc_id_reset586();
529
530 size = 0x4000;
531 if (!check586(dev, dev->mem_start, size)) {
532 pr_err("%s: memprobe, Can't find memory at 0x%lx!\n", dev->name,
533 dev->mem_start);
534 retval = -ENODEV;
535 goto err_out;
536 }
537 dev->mem_end = dev->mem_start + size;
538
539 pr->memtop = isa_bus_to_virt(dev->mem_start) + size;
540 pr->base = (unsigned long) isa_bus_to_virt(dev->mem_start) + size - 0x01000000;
541 alloc586(dev);
542
543 elmc_id_reset586();
544
545
546 pr->num_recv_buffs = NUM_RECV_BUFFS_16;
547
548
549 pr_info("%s: IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->name,
550 dev->irq, dev->if_port ? "ex" : "in",
551 dev->mem_start, dev->mem_end - 1);
552
553
554
555 for (i = 0; i < 6; i++)
556 dev->dev_addr[i] = inb(dev->base_addr + i);
557
558 pr_info("%s: hardware address %pM\n",
559 dev->name, dev->dev_addr);
560
561 dev->netdev_ops = &netdev_ops;
562 dev->watchdog_timeo = HZ;
563 dev->ethtool_ops = &netdev_ethtool_ops;
564
565
566
567
568
569#ifndef ELMC_MULTICAST
570 dev->flags&=~IFF_MULTICAST;
571#endif
572
573 retval = register_netdev(dev);
574 if (retval)
575 goto err_out;
576
577 return 0;
578err_out:
579 mca_set_adapter_procfn(slot, NULL, NULL);
580 release_region(dev->base_addr, ELMC_IO_EXTENT);
581 return retval;
582}
583
584#ifdef MODULE
585static void cleanup_card(struct net_device *dev)
586{
587 mca_set_adapter_procfn(((struct priv *)netdev_priv(dev))->slot,
588 NULL, NULL);
589 release_region(dev->base_addr, ELMC_IO_EXTENT);
590}
591#else
592struct net_device * __init elmc_probe(int unit)
593{
594 struct net_device *dev = alloc_etherdev(sizeof(struct priv));
595 int err;
596
597 if (!dev)
598 return ERR_PTR(-ENOMEM);
599
600 sprintf(dev->name, "eth%d", unit);
601 netdev_boot_setup_check(dev);
602
603 err = do_elmc_probe(dev);
604 if (err)
605 goto out;
606 return dev;
607out:
608 free_netdev(dev);
609 return ERR_PTR(err);
610}
611#endif
612
613
614
615
616
617
618static int init586(struct net_device *dev)
619{
620 void *ptr;
621 unsigned long s;
622 int i, result = 0;
623 struct priv *p = netdev_priv(dev);
624 volatile struct configure_cmd_struct *cfg_cmd;
625 volatile struct iasetup_cmd_struct *ias_cmd;
626 volatile struct tdr_cmd_struct *tdr_cmd;
627 volatile struct mcsetup_cmd_struct *mc_cmd;
628 struct dev_mc_list *dmi = dev->mc_list;
629 int num_addrs = dev->mc_count;
630
631 ptr = (void *) ((char *) p->scb + sizeof(struct scb_struct));
632
633 cfg_cmd = (struct configure_cmd_struct *) ptr;
634 cfg_cmd->cmd_status = 0;
635 cfg_cmd->cmd_cmd = CMD_CONFIGURE | CMD_LAST;
636 cfg_cmd->cmd_link = 0xffff;
637
638 cfg_cmd->byte_cnt = 0x0a;
639 cfg_cmd->fifo = 0x08;
640 cfg_cmd->sav_bf = 0x40;
641 cfg_cmd->adr_len = 0x2e;
642 cfg_cmd->priority = 0x00;
643 cfg_cmd->ifs = 0x60;
644 cfg_cmd->time_low = 0x00;
645 cfg_cmd->time_high = 0xf2;
646 cfg_cmd->promisc = 0;
647 if (dev->flags & (IFF_ALLMULTI | IFF_PROMISC))
648 cfg_cmd->promisc = 1;
649 cfg_cmd->carr_coll = 0x00;
650
651 p->scb->cbl_offset = make16(cfg_cmd);
652
653 p->scb->cmd = CUC_START;
654 elmc_id_attn586();
655
656 s = jiffies;
657 while (!(cfg_cmd->cmd_status & STAT_COMPL)) {
658 if (time_after(jiffies, s + 30*HZ/100))
659 break;
660 }
661
662 if ((cfg_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_COMPL | STAT_OK)) {
663 pr_warning("%s (elmc): configure command failed: %x\n", dev->name, cfg_cmd->cmd_status);
664 return 1;
665 }
666
667
668
669 ias_cmd = (struct iasetup_cmd_struct *) ptr;
670
671 ias_cmd->cmd_status = 0;
672 ias_cmd->cmd_cmd = CMD_IASETUP | CMD_LAST;
673 ias_cmd->cmd_link = 0xffff;
674
675 memcpy((char *) &ias_cmd->iaddr, (char *) dev->dev_addr, ETH_ALEN);
676
677 p->scb->cbl_offset = make16(ias_cmd);
678
679 p->scb->cmd = CUC_START;
680 elmc_id_attn586();
681
682 s = jiffies;
683 while (!(ias_cmd->cmd_status & STAT_COMPL)) {
684 if (time_after(jiffies, s + 30*HZ/100))
685 break;
686 }
687
688 if ((ias_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_OK | STAT_COMPL)) {
689 pr_warning("%s (elmc): individual address setup command failed: %04x\n",
690 dev->name, ias_cmd->cmd_status);
691 return 1;
692 }
693
694
695
696 tdr_cmd = (struct tdr_cmd_struct *) ptr;
697
698 tdr_cmd->cmd_status = 0;
699 tdr_cmd->cmd_cmd = CMD_TDR | CMD_LAST;
700 tdr_cmd->cmd_link = 0xffff;
701 tdr_cmd->status = 0;
702
703 p->scb->cbl_offset = make16(tdr_cmd);
704
705 p->scb->cmd = CUC_START;
706 elmc_attn586();
707
708 s = jiffies;
709 while (!(tdr_cmd->cmd_status & STAT_COMPL)) {
710 if (time_after(jiffies, s + 30*HZ/100)) {
711 pr_warning("%s: %d Problems while running the TDR.\n", dev->name, __LINE__);
712 result = 1;
713 break;
714 }
715 }
716
717 if (!result) {
718 DELAY(2);
719 result = tdr_cmd->status;
720
721 p->scb->cmd = p->scb->status & STAT_MASK;
722 elmc_id_attn586();
723
724 if (result & TDR_LNK_OK) {
725
726 } else if (result & TDR_XCVR_PRB) {
727 pr_warning("%s: TDR: Transceiver problem!\n", dev->name);
728 } else if (result & TDR_ET_OPN) {
729 pr_warning("%s: TDR: No correct termination %d clocks away.\n", dev->name, result & TDR_TIMEMASK);
730 } else if (result & TDR_ET_SRT) {
731 if (result & TDR_TIMEMASK)
732 pr_warning("%s: TDR: Detected a short circuit %d clocks away.\n", dev->name, result & TDR_TIMEMASK);
733 } else {
734 pr_warning("%s: TDR: Unknown status %04x\n", dev->name, result);
735 }
736 }
737
738
739
740 p->scb->cmd = p->scb->status & STAT_MASK;
741 elmc_id_attn586();
742
743
744
745
746#if (NUM_XMIT_BUFFS == 1)
747 for (i = 0; i < 2; i++) {
748 p->nop_cmds[i] = (struct nop_cmd_struct *) ptr;
749 p->nop_cmds[i]->cmd_cmd = CMD_NOP;
750 p->nop_cmds[i]->cmd_status = 0;
751 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
752 ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
753 }
754 p->xmit_cmds[0] = (struct transmit_cmd_struct *) ptr;
755 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
756#else
757 for (i = 0; i < NUM_XMIT_BUFFS; i++) {
758 p->nop_cmds[i] = (struct nop_cmd_struct *) ptr;
759 p->nop_cmds[i]->cmd_cmd = CMD_NOP;
760 p->nop_cmds[i]->cmd_status = 0;
761 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
762 ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
763 p->xmit_cmds[i] = (struct transmit_cmd_struct *) ptr;
764 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
765 }
766#endif
767
768 ptr = alloc_rfa(dev, (void *) ptr);
769
770
771
772
773
774 if (dev->mc_count) {
775
776 int len = ((char *) p->iscp - (char *) ptr - 8) / 6;
777 if (len <= 0) {
778 pr_err("%s: Ooooops, no memory for MC-Setup!\n", dev->name);
779 } else {
780 if (len < num_addrs) {
781 num_addrs = len;
782 pr_warning("%s: Sorry, can only apply %d MC-Address(es).\n",
783 dev->name, num_addrs);
784 }
785 mc_cmd = (struct mcsetup_cmd_struct *) ptr;
786 mc_cmd->cmd_status = 0;
787 mc_cmd->cmd_cmd = CMD_MCSETUP | CMD_LAST;
788 mc_cmd->cmd_link = 0xffff;
789 mc_cmd->mc_cnt = num_addrs * 6;
790 for (i = 0; i < num_addrs; i++) {
791 memcpy((char *) mc_cmd->mc_list[i], dmi->dmi_addr, 6);
792 dmi = dmi->next;
793 }
794 p->scb->cbl_offset = make16(mc_cmd);
795 p->scb->cmd = CUC_START;
796 elmc_id_attn586();
797 s = jiffies;
798 while (!(mc_cmd->cmd_status & STAT_COMPL)) {
799 if (time_after(jiffies, s + 30*HZ/100))
800 break;
801 }
802 if (!(mc_cmd->cmd_status & STAT_COMPL)) {
803 pr_warning("%s: Can't apply multicast-address-list.\n", dev->name);
804 }
805 }
806 }
807
808
809
810 for (i = 0; i < NUM_XMIT_BUFFS; i++) {
811 p->xmit_cbuffs[i] = (char *) ptr;
812 ptr = (char *) ptr + XMIT_BUFF_SIZE;
813 p->xmit_buffs[i] = (struct tbd_struct *) ptr;
814 ptr = (char *) ptr + sizeof(struct tbd_struct);
815 if ((void *) ptr > (void *) p->iscp) {
816 pr_err("%s: not enough shared-mem for your configuration!\n", dev->name);
817 return 1;
818 }
819 memset((char *) (p->xmit_cmds[i]), 0, sizeof(struct transmit_cmd_struct));
820 memset((char *) (p->xmit_buffs[i]), 0, sizeof(struct tbd_struct));
821 p->xmit_cmds[i]->cmd_status = STAT_COMPL;
822 p->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT;
823 p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i]));
824 p->xmit_buffs[i]->next = 0xffff;
825 p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i]));
826 }
827
828 p->xmit_count = 0;
829 p->xmit_last = 0;
830#ifndef NO_NOPCOMMANDS
831 p->nop_point = 0;
832#endif
833
834
835
836
837#ifndef NO_NOPCOMMANDS
838 p->scb->cbl_offset = make16(p->nop_cmds[0]);
839 p->scb->cmd = CUC_START;
840 elmc_id_attn586();
841 WAIT_4_SCB_CMD();
842#else
843 p->xmit_cmds[0]->cmd_link = 0xffff;
844 p->xmit_cmds[0]->cmd_cmd = CMD_XMIT | CMD_LAST | CMD_INT;
845#endif
846
847 return 0;
848}
849
850
851
852
853
854
855static void *alloc_rfa(struct net_device *dev, void *ptr)
856{
857 volatile struct rfd_struct *rfd = (struct rfd_struct *) ptr;
858 volatile struct rbd_struct *rbd;
859 int i;
860 struct priv *p = netdev_priv(dev);
861
862 memset((char *) rfd, 0, sizeof(struct rfd_struct) * p->num_recv_buffs);
863 p->rfd_first = rfd;
864
865 for (i = 0; i < p->num_recv_buffs; i++) {
866 rfd[i].next = make16(rfd + (i + 1) % p->num_recv_buffs);
867 }
868 rfd[p->num_recv_buffs - 1].last = RFD_SUSP;
869
870 ptr = (void *) (rfd + p->num_recv_buffs);
871
872 rbd = (struct rbd_struct *) ptr;
873 ptr = (void *) (rbd + p->num_recv_buffs);
874
875
876 memset((char *) rbd, 0, sizeof(struct rbd_struct) * p->num_recv_buffs);
877
878 for (i = 0; i < p->num_recv_buffs; i++) {
879 rbd[i].next = make16((rbd + (i + 1) % p->num_recv_buffs));
880 rbd[i].size = RECV_BUFF_SIZE;
881 rbd[i].buffer = make24(ptr);
882 ptr = (char *) ptr + RECV_BUFF_SIZE;
883 }
884
885 p->rfd_top = p->rfd_first;
886 p->rfd_last = p->rfd_first + p->num_recv_buffs - 1;
887
888 p->scb->rfa_offset = make16(p->rfd_first);
889 p->rfd_first->rbd_offset = make16(rbd);
890
891 return ptr;
892}
893
894
895
896
897
898
899static irqreturn_t
900elmc_interrupt(int irq, void *dev_id)
901{
902 struct net_device *dev = dev_id;
903 unsigned short stat;
904 struct priv *p;
905
906 if (!netif_running(dev)) {
907
908
909
910
911
912
913 elmc_id_attn586();
914 return IRQ_HANDLED;
915 } else if (!(ELMC_CTRL_INT & inb(dev->base_addr + ELMC_CTRL))) {
916
917 return IRQ_NONE;
918 }
919
920
921 p = netdev_priv(dev);
922
923 while ((stat = p->scb->status & STAT_MASK))
924 {
925 p->scb->cmd = stat;
926 elmc_attn586();
927
928 if (stat & STAT_CX) {
929
930 elmc_xmt_int(dev);
931 }
932 if (stat & STAT_FR) {
933
934 elmc_rcv_int(dev);
935 }
936#ifndef NO_NOPCOMMANDS
937 if (stat & STAT_CNA) {
938
939 if (netif_running(dev)) {
940 pr_warning("%s: oops! CU has left active state. stat: %04x/%04x.\n",
941 dev->name, (int) stat, (int) p->scb->status);
942 }
943 }
944#endif
945
946 if (stat & STAT_RNR) {
947
948
949 if (p->scb->status & RU_SUSPEND) {
950
951
952 WAIT_4_SCB_CMD();
953 p->scb->cmd = RUC_RESUME;
954 elmc_attn586();
955 } else {
956 pr_warning("%s: Receiver-Unit went 'NOT READY': %04x/%04x.\n",
957 dev->name, (int) stat, (int) p->scb->status);
958 elmc_rnr_int(dev);
959 }
960 }
961 WAIT_4_SCB_CMD();
962 if (p->scb->cmd) {
963 break;
964 }
965 }
966 return IRQ_HANDLED;
967}
968
969
970
971
972
973static void elmc_rcv_int(struct net_device *dev)
974{
975 int status;
976 unsigned short totlen;
977 struct sk_buff *skb;
978 struct rbd_struct *rbd;
979 struct priv *p = netdev_priv(dev);
980
981 for (; (status = p->rfd_top->status) & STAT_COMPL;) {
982 rbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset);
983
984 if (status & STAT_OK) {
985 if ((totlen = rbd->status) & RBD_LAST) {
986 totlen &= RBD_MASK;
987 rbd->status = 0;
988 skb = (struct sk_buff *) dev_alloc_skb(totlen + 2);
989 if (skb != NULL) {
990 skb_reserve(skb, 2);
991 skb_put(skb,totlen);
992 skb_copy_to_linear_data(skb, (char *) p->base+(unsigned long) rbd->buffer,totlen);
993 skb->protocol = eth_type_trans(skb, dev);
994 netif_rx(skb);
995 dev->stats.rx_packets++;
996 dev->stats.rx_bytes += totlen;
997 } else {
998 dev->stats.rx_dropped++;
999 }
1000 } else {
1001 pr_warning("%s: received oversized frame.\n", dev->name);
1002 dev->stats.rx_dropped++;
1003 }
1004 } else {
1005 pr_warning("%s: oops! rfd-error-status: %04x\n", dev->name, status);
1006 dev->stats.rx_errors++;
1007 }
1008 p->rfd_top->status = 0;
1009 p->rfd_top->last = RFD_SUSP;
1010 p->rfd_last->last = 0;
1011 p->rfd_last = p->rfd_top;
1012 p->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next);
1013 }
1014}
1015
1016
1017
1018
1019
1020static void elmc_rnr_int(struct net_device *dev)
1021{
1022 struct priv *p = netdev_priv(dev);
1023
1024 dev->stats.rx_errors++;
1025
1026 WAIT_4_SCB_CMD();
1027 p->scb->cmd = RUC_ABORT;
1028 elmc_attn586();
1029 WAIT_4_SCB_CMD();
1030
1031 alloc_rfa(dev, (char *) p->rfd_first);
1032 startrecv586(dev);
1033
1034 pr_warning("%s: Receive-Unit restarted. Status: %04x\n", dev->name, p->scb->status);
1035
1036}
1037
1038
1039
1040
1041
1042static void elmc_xmt_int(struct net_device *dev)
1043{
1044 int status;
1045 struct priv *p = netdev_priv(dev);
1046
1047 status = p->xmit_cmds[p->xmit_last]->cmd_status;
1048 if (!(status & STAT_COMPL)) {
1049 pr_warning("%s: strange .. xmit-int without a 'COMPLETE'\n", dev->name);
1050 }
1051 if (status & STAT_OK) {
1052 dev->stats.tx_packets++;
1053 dev->stats.collisions += (status & TCMD_MAXCOLLMASK);
1054 } else {
1055 dev->stats.tx_errors++;
1056 if (status & TCMD_LATECOLL) {
1057 pr_warning("%s: late collision detected.\n", dev->name);
1058 dev->stats.collisions++;
1059 } else if (status & TCMD_NOCARRIER) {
1060 dev->stats.tx_carrier_errors++;
1061 pr_warning("%s: no carrier detected.\n", dev->name);
1062 } else if (status & TCMD_LOSTCTS) {
1063 pr_warning("%s: loss of CTS detected.\n", dev->name);
1064 } else if (status & TCMD_UNDERRUN) {
1065 dev->stats.tx_fifo_errors++;
1066 pr_warning("%s: DMA underrun detected.\n", dev->name);
1067 } else if (status & TCMD_MAXCOLL) {
1068 pr_warning("%s: Max. collisions exceeded.\n", dev->name);
1069 dev->stats.collisions += 16;
1070 }
1071 }
1072
1073#if (NUM_XMIT_BUFFS != 1)
1074 if ((++p->xmit_last) == NUM_XMIT_BUFFS) {
1075 p->xmit_last = 0;
1076 }
1077#endif
1078
1079 netif_wake_queue(dev);
1080}
1081
1082
1083
1084
1085
1086static void startrecv586(struct net_device *dev)
1087{
1088 struct priv *p = netdev_priv(dev);
1089
1090 p->scb->rfa_offset = make16(p->rfd_first);
1091 p->scb->cmd = RUC_START;
1092 elmc_attn586();
1093 WAIT_4_SCB_CMD();
1094}
1095
1096
1097
1098
1099
1100static void elmc_timeout(struct net_device *dev)
1101{
1102 struct priv *p = netdev_priv(dev);
1103
1104 if (p->scb->status & CU_ACTIVE) {
1105 pr_debug("%s: strange ... timeout with CU active?!?\n", dev->name);
1106 pr_debug("%s: X0: %04x N0: %04x N1: %04x %d\n", dev->name,
1107 (int)p->xmit_cmds[0]->cmd_status,
1108 (int)p->nop_cmds[0]->cmd_status,
1109 (int)p->nop_cmds[1]->cmd_status, (int)p->nop_point);
1110 p->scb->cmd = CUC_ABORT;
1111 elmc_attn586();
1112 WAIT_4_SCB_CMD();
1113 p->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]);
1114 p->scb->cmd = CUC_START;
1115 elmc_attn586();
1116 WAIT_4_SCB_CMD();
1117 netif_wake_queue(dev);
1118 } else {
1119 pr_debug("%s: xmitter timed out, try to restart! stat: %04x\n",
1120 dev->name, p->scb->status);
1121 pr_debug("%s: command-stats: %04x %04x\n", dev->name,
1122 p->xmit_cmds[0]->cmd_status, p->xmit_cmds[1]->cmd_status);
1123 elmc_close(dev);
1124 elmc_open(dev);
1125 }
1126}
1127
1128
1129
1130
1131
1132static netdev_tx_t elmc_send_packet(struct sk_buff *skb, struct net_device *dev)
1133{
1134 int len;
1135 int i;
1136#ifndef NO_NOPCOMMANDS
1137 int next_nop;
1138#endif
1139 struct priv *p = netdev_priv(dev);
1140
1141 netif_stop_queue(dev);
1142
1143 len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
1144
1145 if (len != skb->len)
1146 memset((char *) p->xmit_cbuffs[p->xmit_count], 0, ETH_ZLEN);
1147 skb_copy_from_linear_data(skb, (char *) p->xmit_cbuffs[p->xmit_count], skb->len);
1148
1149#if (NUM_XMIT_BUFFS == 1)
1150#ifdef NO_NOPCOMMANDS
1151 p->xmit_buffs[0]->size = TBD_LAST | len;
1152 for (i = 0; i < 16; i++) {
1153 p->scb->cbl_offset = make16(p->xmit_cmds[0]);
1154 p->scb->cmd = CUC_START;
1155 p->xmit_cmds[0]->cmd_status = 0;
1156 elmc_attn586();
1157 dev->trans_start = jiffies;
1158 if (!i) {
1159 dev_kfree_skb(skb);
1160 }
1161 WAIT_4_SCB_CMD();
1162 if ((p->scb->status & CU_ACTIVE)) {
1163 break;
1164 }
1165 if (p->xmit_cmds[0]->cmd_status) {
1166 break;
1167 }
1168 if (i == 15) {
1169 pr_warning("%s: Can't start transmit-command.\n", dev->name);
1170 }
1171 }
1172#else
1173 next_nop = (p->nop_point + 1) & 0x1;
1174 p->xmit_buffs[0]->size = TBD_LAST | len;
1175
1176 p->xmit_cmds[0]->cmd_link = p->nop_cmds[next_nop]->cmd_link
1177 = make16((p->nop_cmds[next_nop]));
1178 p->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0;
1179
1180 p->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0]));
1181 dev->trans_start = jiffies;
1182 p->nop_point = next_nop;
1183 dev_kfree_skb(skb);
1184#endif
1185#else
1186 p->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
1187 if ((next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS) {
1188 next_nop = 0;
1189 }
1190 p->xmit_cmds[p->xmit_count]->cmd_status = 0;
1191 p->xmit_cmds[p->xmit_count]->cmd_link = p->nop_cmds[next_nop]->cmd_link
1192 = make16((p->nop_cmds[next_nop]));
1193 p->nop_cmds[next_nop]->cmd_status = 0;
1194 p->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count]));
1195 dev->trans_start = jiffies;
1196 p->xmit_count = next_nop;
1197 if (p->xmit_count != p->xmit_last)
1198 netif_wake_queue(dev);
1199 dev_kfree_skb(skb);
1200#endif
1201 return NETDEV_TX_OK;
1202}
1203
1204
1205
1206
1207
1208static struct net_device_stats *elmc_get_stats(struct net_device *dev)
1209{
1210 struct priv *p = netdev_priv(dev);
1211 unsigned short crc, aln, rsc, ovrn;
1212
1213 crc = p->scb->crc_errs;
1214 p->scb->crc_errs -= crc;
1215 aln = p->scb->aln_errs;
1216 p->scb->aln_errs -= aln;
1217 rsc = p->scb->rsc_errs;
1218 p->scb->rsc_errs -= rsc;
1219 ovrn = p->scb->ovrn_errs;
1220 p->scb->ovrn_errs -= ovrn;
1221
1222 dev->stats.rx_crc_errors += crc;
1223 dev->stats.rx_fifo_errors += ovrn;
1224 dev->stats.rx_frame_errors += aln;
1225 dev->stats.rx_dropped += rsc;
1226
1227 return &dev->stats;
1228}
1229
1230
1231
1232
1233
1234#ifdef ELMC_MULTICAST
1235static void set_multicast_list(struct net_device *dev)
1236{
1237 if (!dev->start) {
1238
1239 return;
1240 }
1241 dev->start = 0;
1242 alloc586(dev);
1243 init586(dev);
1244 startrecv586(dev);
1245 dev->start = 1;
1246}
1247#endif
1248
1249static void netdev_get_drvinfo(struct net_device *dev,
1250 struct ethtool_drvinfo *info)
1251{
1252 strcpy(info->driver, DRV_NAME);
1253 strcpy(info->version, DRV_VERSION);
1254 sprintf(info->bus_info, "MCA 0x%lx", dev->base_addr);
1255}
1256
1257static const struct ethtool_ops netdev_ethtool_ops = {
1258 .get_drvinfo = netdev_get_drvinfo,
1259};
1260
1261#ifdef MODULE
1262
1263
1264#define MAX_3C523_CARDS 4
1265
1266static struct net_device *dev_elmc[MAX_3C523_CARDS];
1267static int irq[MAX_3C523_CARDS];
1268static int io[MAX_3C523_CARDS];
1269module_param_array(irq, int, NULL, 0);
1270module_param_array(io, int, NULL, 0);
1271MODULE_PARM_DESC(io, "EtherLink/MC I/O base address(es)");
1272MODULE_PARM_DESC(irq, "EtherLink/MC IRQ number(s)");
1273MODULE_LICENSE("GPL");
1274
1275int __init init_module(void)
1276{
1277 int this_dev,found = 0;
1278
1279
1280 for(this_dev=0; this_dev<MAX_3C523_CARDS; this_dev++) {
1281 struct net_device *dev = alloc_etherdev(sizeof(struct priv));
1282 if (!dev)
1283 break;
1284 dev->irq=irq[this_dev];
1285 dev->base_addr=io[this_dev];
1286 if (do_elmc_probe(dev) == 0) {
1287 dev_elmc[this_dev] = dev;
1288 found++;
1289 continue;
1290 }
1291 free_netdev(dev);
1292 if (io[this_dev]==0)
1293 break;
1294 pr_warning("3c523.c: No 3c523 card found at io=%#x\n",io[this_dev]);
1295 }
1296
1297 if(found==0) {
1298 if (io[0]==0)
1299 pr_notice("3c523.c: No 3c523 cards found\n");
1300 return -ENXIO;
1301 } else return 0;
1302}
1303
1304void __exit cleanup_module(void)
1305{
1306 int this_dev;
1307 for (this_dev=0; this_dev<MAX_3C523_CARDS; this_dev++) {
1308 struct net_device *dev = dev_elmc[this_dev];
1309 if (dev) {
1310 unregister_netdev(dev);
1311 cleanup_card(dev);
1312 free_netdev(dev);
1313 }
1314 }
1315}
1316
1317#endif
1318