This source file includes following definitions.
- ewrk3_probe
- ewrk3_hw_init
- ewrk3_open
- ewrk3_init
- ewrk3_queue_pkt
- ewrk3_interrupt
- ewrk3_rx
- ewrk3_tx
- ewrk3_close
- ewrk3_get_stats
- set_multicast_list
- SetMulticastFilter
- isa_probe
- eisa_probe
- alloc_device
- Read_EEPROM
- Write_EEPROM
- EthwrkSignature
- DevicePresent
- aprom_crc
- ewrk3_ioctl
- asc2hex
- 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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126 static char *version = "ewrk3.c:v0.31 12/5/94 davies@wanton.lkg.dec.com\n";
127
128 #include <stdarg.h>
129 #include <linux/config.h>
130 #include <linux/kernel.h>
131 #include <linux/sched.h>
132 #include <linux/string.h>
133 #include <linux/ptrace.h>
134 #include <linux/errno.h>
135 #include <linux/ioport.h>
136 #include <linux/malloc.h>
137 #include <linux/interrupt.h>
138 #include <asm/bitops.h>
139 #include <asm/io.h>
140 #include <asm/dma.h>
141 #include <asm/segment.h>
142
143 #include <linux/netdevice.h>
144 #include <linux/etherdevice.h>
145 #include <linux/skbuff.h>
146
147 #include <linux/time.h>
148 #include <linux/types.h>
149 #include <linux/unistd.h>
150
151 #ifdef MODULE
152 #include <linux/module.h>
153 #include <linux/version.h>
154 #endif
155
156 #include "ewrk3.h"
157
158 #ifdef EWRK3_DEBUG
159 static int ewrk3_debug = EWRK3_DEBUG;
160 #else
161 static int ewrk3_debug = 1;
162 #endif
163
164 #ifndef PROBE_LENGTH
165 #define PROBE_LENGTH 32
166 #endif
167
168 #ifndef PROBE_SEQUENCE
169 #define PROBE_SEQUENCE "FF0055AAFF0055AA"
170 #endif
171
172 #ifndef EWRK3_SIGNATURE
173 #define EWRK3_SIGNATURE {"DE203","DE204","DE205",""}
174 #define EWRK3_NAME_LENGTH 8
175 #endif
176
177 #ifndef EWRK3_RAM_BASE_ADDRESSES
178 #define EWRK3_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0x00000}
179 #endif
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195 #define EWRK3_IO_BASE 0x100
196 #define EWRK3_IOP_INC 0x20
197 #define EWRK3_IO_SEARCH 0x007dff7f
198 static long mem_chkd = EWRK3_IO_SEARCH;
199
200
201 #ifndef MAX_NUM_EWRK3S
202 #define MAX_NUM_EWRK3S 21
203 #endif
204
205 #ifndef EWRK3_EISA_IO_PORTS
206 #define EWRK3_EISA_IO_PORTS 0x0c00
207 #endif
208
209 #ifndef MAX_EISA_SLOTS
210 #define MAX_EISA_SLOTS 8
211 #define EISA_SLOT_INC 0x1000
212 #endif
213
214 #ifndef CRC_POLYNOMIAL
215 #define CRC_POLYNOMIAL 0x04c11db7
216 #endif
217
218
219
220
221 #define IO_ONLY 0x00
222 #define SHMEM_2K 0x800
223 #define SHMEM_32K 0x8000
224 #define SHMEM_64K 0x10000
225
226
227
228
229 static unsigned char irq_mask = TNEM|TXDM|RNEM|RXDM;
230
231 #define ENABLE_IRQs \
232 icr |= irq_mask;\
233 outb(icr, EWRK3_ICR)
234
235 #define DISABLE_IRQs \
236 icr = inb(EWRK3_ICR);\
237 icr &= ~irq_mask;\
238 outb(icr, EWRK3_ICR)
239
240
241
242
243 #define START_EWRK3 \
244 csr = inb(EWRK3_CSR);\
245 csr &= ~(TXD|RXD);\
246 outb(csr, EWRK3_CSR)
247
248 #define STOP_EWRK3 \
249 csr = (TXD|RXD);\
250 outb(csr, EWRK3_CSR)
251
252
253
254
255 #define EWRK3_PKT_STAT_SZ 16
256 #define EWRK3_PKT_BIN_SZ 128
257
258
259 struct ewrk3_private {
260 long shmem_base;
261 long shmem_length;
262 struct enet_statistics stats;
263 struct {
264 unsigned long bins[EWRK3_PKT_STAT_SZ];
265 unsigned long unicast;
266 unsigned long multicast;
267 unsigned long broadcast;
268 unsigned long excessive_collisions;
269 unsigned long tx_underruns;
270 unsigned long excessive_underruns;
271 } pktStats;
272 short mPage;
273 unsigned char lemac;
274 unsigned char hard_strapped;
275 unsigned char lock;
276 unsigned char txc;
277 };
278
279
280
281
282 #define FORCE_2K_MODE \
283 shmem_length = SHMEM_2K;\
284 outb(((mem_start - 0x80000) >> 11), EWRK3_MBR)
285
286
287
288
289 static int ewrk3_open(struct device *dev);
290 static int ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
291 static void ewrk3_interrupt(int reg_ptr);
292 static int ewrk3_close(struct device *dev);
293 static struct enet_statistics *ewrk3_get_stats(struct device *dev);
294 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
295 static int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
296
297
298
299
300 static int ewrk3_hw_init(struct device *dev, short iobase);
301 static void ewrk3_init(struct device *dev);
302 static int ewrk3_rx(struct device *dev);
303 static int ewrk3_tx(struct device *dev);
304
305 static void EthwrkSignature(char * name, char *eeprom_image);
306 static int DevicePresent(short iobase);
307 static void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table);
308
309 static int Read_EEPROM(short iobase, unsigned char eaddr);
310 static int Write_EEPROM(short data, short iobase, unsigned char eaddr);
311 static unsigned char aprom_crc (struct device *dev, unsigned char *eeprom_image, char chipType);
312
313 #ifndef MODULE
314 static struct device *isa_probe(struct device *dev);
315 static struct device *eisa_probe(struct device *dev);
316 static struct device *alloc_device(struct device *dev, int iobase);
317
318 static int num_ewrk3s = 0, num_eth = 0;
319 static unsigned char irq[] = {5,0,10,3,11,9,15,12};
320
321 #else
322 int init_module(void);
323 void cleanup_module(void);
324
325 #endif
326
327 static int autoprobed = 0;
328
329
330
331
332 #define INIT_EWRK3 {\
333 int i;\
334 outb(EEPROM_INIT, EWRK3_IOPR);\
335 for (i=0;i<5000;i++) inb(EWRK3_CSR);\
336 }
337
338
339
340
341 int ewrk3_probe(struct device *dev)
342 {
343 int base_addr = dev->base_addr;
344 int status = -ENODEV;
345 #ifndef MODULE
346 struct device *eth0;
347 #endif
348
349 if (base_addr > 0x0ff) {
350 if (!autoprobed) {
351 if (!check_region(base_addr, EWRK3_IOP_INC)) {
352 if (((mem_chkd >> ((base_addr - EWRK3_IO_BASE)/ EWRK3_IOP_INC))&0x01)==1) {
353 if (DevicePresent(base_addr) == 0) {
354 snarf_region(base_addr, EWRK3_IOP_INC);
355 status = ewrk3_hw_init(dev, base_addr);
356 } else {
357 printk("ewrk3_probe(): No device found\n");
358 mem_chkd &= ~(0x01 << ((base_addr - EWRK3_IO_BASE)/EWRK3_IOP_INC));
359 }
360 }
361 } else {
362 printk("%s: ewrk3_probe(): Detected a device already registered at 0x%02x\n", dev->name, base_addr);
363 mem_chkd &= ~(0x01 << ((base_addr - EWRK3_IO_BASE)/EWRK3_IOP_INC));
364 }
365 } else {
366 status = ewrk3_hw_init(dev, base_addr);
367 }
368 } else if (base_addr > 0) {
369 status = -ENXIO;
370
371 #ifdef MODULE
372 } else {
373 printk("Autoprobing is not supported when loading a module based driver.\n");
374 status = -EIO;
375 #else
376 } else if (!autoprobed) {
377
378 eth0=isa_probe(dev);
379 eth0=eisa_probe(eth0);
380 if (dev->priv) status=0;
381 autoprobed = 1;
382 } else {
383 status = -ENXIO;
384 #endif
385
386 }
387
388 if (status) dev->base_addr = base_addr;
389
390 return status;
391 }
392
393 static int
394 ewrk3_hw_init(struct device *dev, short iobase)
395 {
396 struct ewrk3_private *lp;
397 int i, status=0;
398 unsigned long mem_start, shmem_length;
399 char name[EWRK3_NAME_LENGTH + 1];
400 unsigned char cr, cmr, icr, nicsr, lemac, hard_strapped = 0;
401 unsigned char eeprom_image[EEPROM_MAX], chksum, eisa_cr = 0;
402
403
404
405
406
407 if (iobase > 0x400) eisa_cr = inb(EISA_CR);
408 INIT_EWRK3;
409
410 nicsr = inb(EWRK3_CSR);
411
412
413
414
415 DISABLE_IRQs;
416
417 if (nicsr == TXD|RXD) {
418
419
420
421
422 for (chksum=0, i=0; i<EEPROM_MAX; i+=2) {
423 union {
424 short val;
425 char c[2];
426 } tmp;
427
428 tmp.val = (short)Read_EEPROM(iobase, (i>>1));
429 eeprom_image[i] = tmp.c[0];
430 eeprom_image[i+1] = tmp.c[1];
431
432 chksum += eeprom_image[i] + eeprom_image[i+1];
433 }
434
435 if (chksum != 0) {
436 printk("%s: Device has a bad on-board EEPROM.\n", dev->name);
437 status = -ENXIO;
438 } else {
439
440
441
442 EthwrkSignature(name, eeprom_image);
443
444 if (*name != '\0') {
445 dev->base_addr = iobase;
446
447 if (iobase > 0x400) {
448 outb(eisa_cr, EISA_CR);
449 }
450
451 lemac = eeprom_image[EEPROM_CHIPVER];
452 cmr = inb(EWRK3_CMR);
453
454 if (((lemac == LeMAC) && ((cmr & NO_EEPROM) != NO_EEPROM)) ||
455 ((lemac == LeMAC2) && !(cmr & HS))) {
456 printk("%s: %s at %#3x", dev->name, name, iobase);
457 hard_strapped = 1;
458 } else if ((iobase&0x0fff)==EWRK3_EISA_IO_PORTS) {
459
460 printk("%s: %s at %#3x (EISA slot %d)",
461 dev->name, name, iobase, ((iobase>>12)&0x0f));
462 } else {
463 printk("%s: %s at %#3x", dev->name, name, iobase);
464 }
465
466 if (!status) {
467 printk(", h/w address ");
468 if (lemac == LeMAC2) {
469 for (i = 0;i < ETH_ALEN - 1;i++) {
470 printk("%2.2x:", dev->dev_addr[i] =
471 eeprom_image[EEPROM_PADDR0 + i]);
472 outb(eeprom_image[EEPROM_PADDR0 + i], EWRK3_PAR0 + i);
473 }
474 printk("%2.2x,\n",dev->dev_addr[i] = eeprom_image[EEPROM_PADDR0 + i]);
475 outb(eeprom_image[EEPROM_PADDR0 + i], EWRK3_PAR0 + i);
476 } else {
477 DevicePresent(iobase);
478 for (i = 0; i < ETH_ALEN - 1; i++) {
479 printk("%2.2x:", dev->dev_addr[i] = inb(EWRK3_APROM));
480 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
481 }
482 printk("%2.2x,\n", dev->dev_addr[i] = inb(EWRK3_APROM));
483 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
484 }
485
486 if (aprom_crc(dev, eeprom_image, lemac)) {
487 printk(" which has an EEPROM CRC error.\n");
488 status = -ENXIO;
489 } else {
490 if (lemac == LeMAC2) {
491 cmr &= ~(RA | WB | LINK | POLARITY | _0WS);
492 if (eeprom_image[EEPROM_MISC0] & READ_AHEAD) cmr |= RA;
493 if (eeprom_image[EEPROM_MISC0] & WRITE_BEHIND) cmr |= WB;
494 if (eeprom_image[EEPROM_NETMAN0] & NETMAN_POL) cmr |= POLARITY;
495 if (eeprom_image[EEPROM_NETMAN0] & NETMAN_LINK) cmr |= LINK;
496 if (eeprom_image[EEPROM_MISC0] & _0WS_ENA) cmr |= _0WS;
497 }
498 if (eeprom_image[EEPROM_SETUP] & SETUP_DRAM) cmr |= DRAM;
499 outb(cmr, EWRK3_CMR);
500
501 cr = inb(EWRK3_CR);
502 cr |= eeprom_image[EEPROM_SETUP] & SETUP_APD;
503 if (cr & SETUP_APD) cr |= eeprom_image[EEPROM_SETUP] & SETUP_PS;
504 cr |= eeprom_image[EEPROM_MISC0] & FAST_BUS;
505 cr |= eeprom_image[EEPROM_MISC0] & ENA_16;
506 outb(cr, EWRK3_CR);
507
508
509
510
511
512 mem_start = inb(EWRK3_MBR);
513 shmem_length = 0;
514 if (mem_start != 0) {
515 if ((mem_start >= 0x0a) && (mem_start <= 0x0f)) {
516 mem_start *= SHMEM_64K;
517 shmem_length = SHMEM_64K;
518 } else if ((mem_start >= 0x14) && (mem_start <= 0x1f)) {
519 mem_start *= SHMEM_32K;
520 shmem_length = SHMEM_32K;
521 } else if ((mem_start >= 0x40) && (mem_start <= 0xff)) {
522 mem_start = mem_start * SHMEM_2K + 0x80000;
523 shmem_length = SHMEM_2K;
524 } else {
525 status = -ENXIO;
526 }
527 }
528
529
530
531
532
533
534
535 if (!status) {
536 if (hard_strapped) {
537 printk(" is hard strapped.\n");
538 } else if (mem_start) {
539 printk(" has a %dk RAM window", (int)(shmem_length >> 10));
540 printk(" at 0x%.5lx", mem_start);
541 } else {
542 printk(" is in I/O only mode");
543 }
544
545
546 dev->priv = (void *) kmalloc(sizeof(struct ewrk3_private),
547 GFP_KERNEL);
548 lp = (struct ewrk3_private *)dev->priv;
549 memset(dev->priv, 0, sizeof(struct ewrk3_private));
550 lp->shmem_base = mem_start;
551 lp->shmem_length = shmem_length;
552 lp->lemac = lemac;
553 lp->hard_strapped = hard_strapped;
554
555 lp->mPage = 64;
556 if (cmr & DRAM) lp->mPage <<= 1 ;
557
558 if (!hard_strapped) {
559
560
561
562 icr |= IE;
563 outb(icr, EWRK3_ICR);
564
565
566 dev->dma = 0;
567
568
569
570 if (dev->irq < 2) {
571 #ifndef MODULE
572 unsigned char irqnum;
573
574 autoirq_setup(0);
575
576
577
578
579 icr |=TNEM;
580 outb(1,EWRK3_TDQ);
581 outb(icr, EWRK3_ICR);
582
583 irqnum = irq[((icr & IRQ_SEL) >> 4)];
584
585 dev->irq = autoirq_report(1);
586 if ((dev->irq) && (irqnum == dev->irq)) {
587 printk(" and uses IRQ%d.\n", dev->irq);
588 } else {
589 if (!dev->irq) {
590 printk(" and failed to detect IRQ line.\n");
591 } else if ((irqnum == 1) && (lemac == LeMAC2)) {
592 printk(" and an illegal IRQ line detected.\n");
593 } else {
594 printk(", but incorrect IRQ line detected.\n");
595 }
596 status = -ENXIO;
597 }
598
599 DISABLE_IRQs;
600
601 #endif
602 } else {
603 printk(" and requires IRQ%d.\n", dev->irq);
604 }
605 }
606 } else {
607 status = -ENXIO;
608 }
609 }
610 }
611 } else {
612 status = -ENXIO;
613 }
614 }
615
616 if (!status) {
617 if (ewrk3_debug > 0) {
618 printk(version);
619 }
620
621
622 dev->open = &ewrk3_open;
623 dev->hard_start_xmit = &ewrk3_queue_pkt;
624 dev->stop = &ewrk3_close;
625 dev->get_stats = &ewrk3_get_stats;
626 #ifdef HAVE_MULTICAST
627 dev->set_multicast_list = &set_multicast_list;
628 #endif
629 dev->do_ioctl = &ewrk3_ioctl;
630
631 dev->mem_start = 0;
632
633
634 ether_setup(dev);
635 }
636 } else {
637 status = -ENXIO;
638 }
639
640 return status;
641 }
642
643
644 static int
645 ewrk3_open(struct device *dev)
646 {
647 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
648 int i, iobase = dev->base_addr;
649 int status = 0;
650 unsigned char icr, csr;
651
652
653
654
655 STOP_EWRK3;
656
657 if (!lp->hard_strapped) {
658 if (request_irq(dev->irq, &ewrk3_interrupt, 0, "ewrk3")) {
659 printk("ewrk3_open(): Requested IRQ%d is busy\n",dev->irq);
660 status = -EAGAIN;
661 } else {
662
663 irq2dev_map[dev->irq] = dev;
664
665
666
667
668 ewrk3_init(dev);
669
670 if (ewrk3_debug > 1){
671 printk("%s: ewrk3 open with irq %d\n",dev->name,dev->irq);
672 printk("\tphysical address: ");
673 for (i=0;i<6;i++){
674 printk("%2.2x:",(short)dev->dev_addr[i]);
675 }
676 printk("\n");
677 printk("\tchecked memory: 0x%08lx\n",mem_chkd);
678 if (lp->shmem_length == 0) {
679 printk("\tno shared memory, I/O only mode\n");
680 } else {
681 printk("\tstart of shared memory: 0x%08lx\n",lp->shmem_base);
682 printk("\twindow length: 0x%04lx\n",lp->shmem_length);
683 }
684 printk("\t# of DRAMS: %d\n",((inb(EWRK3_CMR) & 0x02) ? 2 : 1));
685 printk("\tcsr: 0x%02x\n", inb(EWRK3_CSR));
686 printk("\tcr: 0x%02x\n", inb(EWRK3_CR));
687 printk("\ticr: 0x%02x\n", inb(EWRK3_ICR));
688 printk("\tcmr: 0x%02x\n", inb(EWRK3_CMR));
689 printk("\tfmqc: 0x%02x\n", inb(EWRK3_FMQC));
690 }
691
692 dev->tbusy = 0;
693 dev->start = 1;
694 dev->interrupt = UNMASK_INTERRUPTS;
695
696
697
698
699 icr = inb(EWRK3_ICR);
700 ENABLE_IRQs;
701
702 }
703 } else {
704 dev->start = 0;
705 dev->tbusy = 1;
706 printk("%s: ewrk3 available for hard strapped set up only.\n", dev->name);
707 printk(" Run the 'ewrk3setup' utility or remove the hard straps.\n");
708 }
709
710 #ifdef MODULE
711 MOD_INC_USE_COUNT;
712 #endif
713
714
715 return status;
716 }
717
718
719
720
721 static void
722 ewrk3_init(struct device *dev)
723 {
724 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
725 char csr, page;
726 short iobase = dev->base_addr;
727
728
729
730
731 set_multicast_list(dev, HASH_TABLE_LEN, NULL);
732
733
734
735
736 while (inb(EWRK3_TQ));
737 while (inb(EWRK3_TDQ));
738 while (inb(EWRK3_RQ));
739 while (inb(EWRK3_FMQ));
740
741
742
743
744 for (page=1;page<lp->mPage;page++) {
745 outb(page, EWRK3_FMQ);
746 }
747
748 lp->lock = 0;
749
750 START_EWRK3;
751 }
752
753
754
755
756 static int
757 ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
758 {
759 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
760 int iobase = dev->base_addr;
761 int status = 0;
762 unsigned char icr, csr;
763
764
765 if (dev->tbusy || lp->lock) {
766 int tickssofar = jiffies - dev->trans_start;
767 if (tickssofar < 10) {
768 status = -1;
769 } else if (!lp->hard_strapped) {
770 printk("%s: transmit timed/locked out, status %04x, resetting.\n",
771 dev->name, inb(EWRK3_CSR));
772
773
774
775
776 DISABLE_IRQs;
777
778
779
780
781 STOP_EWRK3;
782
783 ewrk3_init(dev);
784
785
786
787
788 ENABLE_IRQs;
789
790 dev->tbusy=0;
791 dev->trans_start = jiffies;
792 }
793 } else if (skb == NULL) {
794 dev_tint(dev);
795 } else if (skb->len > 0) {
796
797
798
799
800
801 if (set_bit(0, (void*)&dev->tbusy) != 0)
802 printk("%s: Transmitter access conflict.\n", dev->name);
803
804 DISABLE_IRQs;
805
806
807
808
809 if (inb(EWRK3_FMQC) > 0) {
810 unsigned char *buf;
811 unsigned char page;
812
813 if ((page = inb(EWRK3_FMQ)) < lp->mPage) {
814 buf = NULL;
815
816
817
818
819 while (set_bit(0, (void *)&lp->lock) != 0);
820 if (lp->shmem_length == IO_ONLY) {
821 outb(page, EWRK3_IOPR);
822 } else if (lp->shmem_length == SHMEM_2K) {
823 buf = (char *) lp->shmem_base;
824 outb(page, EWRK3_MPR);
825 } else if (lp->shmem_length == SHMEM_32K) {
826 buf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
827 outb((page >> 4), EWRK3_MPR);
828 } else if (lp->shmem_length == SHMEM_64K) {
829 buf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
830 outb((page >> 5), EWRK3_MPR);
831 } else {
832 status = -1;
833 printk("%s: Oops - your private data area is hosed!\n",dev->name);
834 }
835
836 if (!status) {
837
838
839
840
841
842
843 if (lp->shmem_length == IO_ONLY) {
844 int i;
845 unsigned char *p = skb->data;
846
847 outb((char)(QMODE | PAD | IFC), EWRK3_DATA);
848 outb((char)(skb->len & 0xff), EWRK3_DATA);
849 outb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
850 outb((char)0x04, EWRK3_DATA);
851 for (i=0; i<skb->len; i++) {
852 outb(*p++, EWRK3_DATA);
853 }
854 outb(page, EWRK3_TQ);
855 } else {
856 *buf++ = (char)(QMODE | PAD | IFC);
857 *buf++ = (char)(skb->len & 0xff);
858 if (lp->txc) {
859 *buf++ = (char)(((skb->len >> 8) & 0xff) | XCT);
860 *buf++ = 0x04;
861 *(buf + skb->len) = 0x00;
862 memcpy(buf, skb->data, PRELOAD);
863 outb(page, EWRK3_TQ);
864 memcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
865 *(buf + skb->len) = 0xff;
866 } else {
867 *buf++ = (char)((skb->len >> 8) & 0xff);
868 *buf++ = 0x04;
869 memcpy(buf, skb->data, skb->len);
870 outb(page, EWRK3_TQ);
871 }
872 }
873
874 dev->trans_start = jiffies;
875
876 dev_kfree_skb (skb, FREE_WRITE);
877
878 } else {
879 outb(page, EWRK3_FMQ);
880 }
881 lp->lock = 0;
882 } else {
883 printk("ewrk3_queue_pkt(): Invalid free memory page (%d).\n",
884 (unsigned char) page);
885 }
886 } else {
887 printk("ewrk3_queue_pkt(): No free resources...\n");
888 printk("ewrk3_queue_pkt(): CSR: %02x ICR: %02x FMQC: %02x\n",inb(EWRK3_CSR),inb(EWRK3_ICR),inb(EWRK3_FMQC));
889 }
890
891
892 if (inb(EWRK3_FMQC) > 0) {
893 dev->tbusy = 0;
894 }
895
896 ENABLE_IRQs;
897 }
898
899 return status;
900 }
901
902
903
904
905 static void
906 ewrk3_interrupt(int reg_ptr)
907 {
908 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
909 struct device *dev = (struct device *)(irq2dev_map[irq]);
910 struct ewrk3_private *lp;
911 int iobase;
912 unsigned char icr, cr, csr;
913
914 if (dev == NULL) {
915 printk ("ewrk3_interrupt(): irq %d for unknown device.\n", irq);
916 } else {
917 lp = (struct ewrk3_private *)dev->priv;
918 iobase = dev->base_addr;
919
920 if (dev->interrupt)
921 printk("%s: Re-entering the interrupt handler.\n", dev->name);
922
923 dev->interrupt = MASK_INTERRUPTS;
924
925
926 csr = inb(EWRK3_CSR);
927
928
929
930
931 DISABLE_IRQs;
932
933 cr = inb(EWRK3_CR);
934 cr |= LED;
935 outb(cr, EWRK3_CR);
936
937 if (csr & RNE)
938 ewrk3_rx(dev);
939
940 if (csr & TNE)
941 ewrk3_tx(dev);
942
943
944
945
946
947
948
949 if (inb(EWRK3_FMQC)) {
950 irq_mask |= TXDM|RXDM;
951 csr &= ~(TXD|RXD);
952 outb(csr, EWRK3_CSR);
953 dev->tbusy = 0;
954 mark_bh(NET_BH);
955 } else {
956 irq_mask &= ~(TXDM|RXDM);
957 }
958
959
960 cr &= ~LED;
961 outb(cr, EWRK3_CR);
962
963 dev->interrupt = UNMASK_INTERRUPTS;
964
965 ENABLE_IRQs;
966 }
967
968 return;
969 }
970
971 static int
972 ewrk3_rx(struct device *dev)
973 {
974 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
975 int i, iobase = dev->base_addr;
976 unsigned char page, tmpPage = 0, tmpLock = 0, *buf;
977 int status = 0;
978
979 while (inb(EWRK3_RQC) && !status) {
980 if ((page = inb(EWRK3_RQ)) < lp->mPage) {
981 buf = NULL;
982
983
984
985
986
987 if ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {
988 if (lp->shmem_length == IO_ONLY) {
989 tmpPage = inb(EWRK3_IOPR);
990 } else {
991 tmpPage = inb(EWRK3_MPR);
992 }
993 }
994
995
996
997
998 if (lp->shmem_length == IO_ONLY) {
999 outb(page, EWRK3_IOPR);
1000 } else if (lp->shmem_length == SHMEM_2K) {
1001 buf = (char *) lp->shmem_base;
1002 outb(page, EWRK3_MPR);
1003 } else if (lp->shmem_length == SHMEM_32K) {
1004 buf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
1005 outb((page >> 4), EWRK3_MPR);
1006 } else if (lp->shmem_length == SHMEM_64K) {
1007 buf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
1008 outb((page >> 5), EWRK3_MPR);
1009 } else {
1010 status = -1;
1011 printk("%s: Oops - your private data area is hosed!\n",dev->name);
1012 }
1013
1014 if (!status) {
1015 char rx_status;
1016 int pkt_len;
1017
1018 if (lp->shmem_length == IO_ONLY) {
1019 rx_status = inb(EWRK3_DATA);
1020 pkt_len = inb(EWRK3_DATA);
1021 pkt_len |= ((unsigned short)inb(EWRK3_DATA) << 8);
1022 } else {
1023 rx_status = (char)(*buf++);
1024 pkt_len = (short)(*buf+((*(buf+1))<<8));
1025 buf+=3;
1026 }
1027
1028 if (!(rx_status & ROK)) {
1029 lp->stats.rx_errors++;
1030 if (rx_status & DBE) lp->stats.rx_frame_errors++;
1031 if (rx_status & CRC) lp->stats.rx_crc_errors++;
1032 if (rx_status & PLL) lp->stats.rx_fifo_errors++;
1033 } else {
1034 struct sk_buff *skb;
1035
1036 if ((skb = alloc_skb(pkt_len, GFP_ATOMIC)) != NULL) {
1037 skb->len = pkt_len;
1038 skb->dev = dev;
1039
1040 if (lp->shmem_length == IO_ONLY) {
1041 unsigned char *p = skb->data;
1042
1043 *p = inb(EWRK3_DATA);
1044 for (i=0; i<skb->len; i++) {
1045 *p++ = inb(EWRK3_DATA);
1046 }
1047 } else {
1048 memcpy(skb->data, buf, pkt_len);
1049 }
1050
1051
1052
1053
1054
1055 netif_rx(skb);
1056
1057
1058
1059
1060 lp->stats.rx_packets++;
1061 for (i=1; i<EWRK3_PKT_STAT_SZ-1; i++) {
1062 if (pkt_len < i*EWRK3_PKT_BIN_SZ) {
1063 lp->pktStats.bins[i]++;
1064 i = EWRK3_PKT_STAT_SZ;
1065 }
1066 }
1067 buf = skb->data;
1068 if (buf[0] & 0x01) {
1069 if ((*(long *)&buf[0] == -1) && (*(short *)&buf[4] == -1)) {
1070 lp->pktStats.broadcast++;
1071 } else {
1072 lp->pktStats.multicast++;
1073 }
1074 } else if ((*(long *)&buf[0] == *(long *)&dev->dev_addr[0]) &&
1075 (*(short *)&buf[4] == *(short *)&dev->dev_addr[4])) {
1076 lp->pktStats.unicast++;
1077 }
1078
1079 lp->pktStats.bins[0]++;
1080 if (lp->pktStats.bins[0] == 0) {
1081 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1082 }
1083 } else {
1084 printk("%s: Insufficient memory; nuking packet.\n", dev->name);
1085 lp->stats.rx_dropped++;
1086 break;
1087 }
1088 }
1089 }
1090
1091
1092
1093 outb(page, EWRK3_FMQ);
1094
1095 if (tmpLock) {
1096 if (lp->shmem_length == IO_ONLY) {
1097 outb(tmpPage, EWRK3_IOPR);
1098 } else {
1099 outb(tmpPage, EWRK3_MPR);
1100 }
1101 }
1102 lp->lock = 0;
1103 } else {
1104 printk("ewrk3_rx(): Illegal page number, page %d\n",page);
1105 printk("ewrk3_rx(): CSR: %02x ICR: %02x FMQC: %02x\n",inb(EWRK3_CSR),inb(EWRK3_ICR),inb(EWRK3_FMQC));
1106 }
1107 }
1108 return status;
1109 }
1110
1111
1112
1113
1114 static int
1115 ewrk3_tx(struct device *dev)
1116 {
1117 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1118 int iobase = dev->base_addr;
1119 unsigned char tx_status;
1120
1121 while ((tx_status = inb(EWRK3_TDQ)) > 0) {
1122 if (tx_status & VSTS) {
1123 if (tx_status & MAC_TXE) {
1124 lp->stats.tx_errors++;
1125 if (tx_status & MAC_NCL) lp->stats.tx_carrier_errors++;
1126 if (tx_status & MAC_LCL) lp->stats.tx_window_errors++;
1127 if (tx_status & MAC_CTU) {
1128 if ((tx_status & MAC_COLL) ^ MAC_XUR) {
1129 lp->pktStats.tx_underruns++;
1130 } else {
1131 lp->pktStats.excessive_underruns++;
1132 }
1133 } else if (tx_status & MAC_COLL) {
1134 if ((tx_status & MAC_COLL) ^ MAC_XCOLL) {
1135 lp->stats.collisions++;
1136 } else {
1137 lp->pktStats.excessive_collisions++;
1138 }
1139 }
1140 } else {
1141 lp->stats.tx_packets++;
1142 }
1143 }
1144 }
1145
1146 return 0;
1147 }
1148
1149 static int
1150 ewrk3_close(struct device *dev)
1151 {
1152 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1153 int iobase = dev->base_addr;
1154 unsigned char icr, csr;
1155
1156 dev->start = 0;
1157 dev->tbusy = 1;
1158
1159 if (ewrk3_debug > 1) {
1160 printk("%s: Shutting down ethercard, status was %2.2x.\n",
1161 dev->name, inb(EWRK3_CSR));
1162 }
1163
1164
1165
1166
1167 DISABLE_IRQs;
1168
1169 STOP_EWRK3;
1170
1171
1172
1173
1174
1175
1176
1177 while (inb(EWRK3_TQ));
1178 while (inb(EWRK3_TDQ));
1179 while (inb(EWRK3_RQ));
1180
1181 if (!lp->hard_strapped) {
1182 free_irq(dev->irq);
1183
1184 irq2dev_map[dev->irq] = 0;
1185 }
1186
1187 #ifdef MODULE
1188 MOD_DEC_USE_COUNT;
1189 #endif
1190
1191 return 0;
1192 }
1193
1194 static struct enet_statistics *
1195 ewrk3_get_stats(struct device *dev)
1196 {
1197 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1198
1199
1200
1201 return &lp->stats;
1202 }
1203
1204
1205
1206
1207
1208
1209
1210
1211 static void
1212 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
1213 {
1214 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1215 int iobase = dev->base_addr;
1216 char *multicast_table;
1217 unsigned char csr;
1218
1219 csr = inb(EWRK3_CSR);
1220
1221 if (lp->shmem_length == IO_ONLY) {
1222 multicast_table = (char *) PAGE0_HTE;
1223 } else {
1224 multicast_table = (char *)(lp->shmem_base + PAGE0_HTE);
1225 }
1226
1227 if (num_addrs >= 0) {
1228 SetMulticastFilter(dev, num_addrs, (char *)addrs, multicast_table);
1229 csr &= ~PME;
1230 csr |= MCE;
1231 outb(csr, EWRK3_CSR);
1232 } else {
1233 csr |= PME;
1234 csr &= ~MCE;
1235 outb(csr, EWRK3_CSR);
1236 }
1237 }
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247 static void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table)
1248 {
1249 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1250 int iobase = dev->base_addr;
1251 char j, ctrl, bit, octet;
1252 short *p = (short *) multicast_table;
1253 unsigned short hashcode;
1254 int i;
1255 long int crc, poly = (long int) CRC_POLYNOMIAL;
1256
1257 while (set_bit(0, (void *)&lp->lock) != 0);
1258
1259 if (lp->shmem_length == IO_ONLY) {
1260 outb(0, EWRK3_IOPR);
1261 outw((short)((long)multicast_table), EWRK3_PIR1);
1262 } else {
1263 outb(0, EWRK3_MPR);
1264 }
1265
1266 if (num_addrs == HASH_TABLE_LEN) {
1267 for (i=0; i<(HASH_TABLE_LEN >> 3); i++) {
1268 if (lp->shmem_length == IO_ONLY) {
1269 outb(0xff, EWRK3_DATA);
1270 } else {
1271 *p++ = 0xffff;
1272 i++;
1273 }
1274 }
1275 } else if (num_addrs == 0) {
1276 if (lp->shmem_length == IO_ONLY) {
1277 for (i=0; i<(HASH_TABLE_LEN >> 3); i++) {
1278 outb(0x00, EWRK3_DATA);
1279 }
1280 } else {
1281 memset(multicast_table, 0, (HASH_TABLE_LEN >> 3));
1282 }
1283 } else {
1284 for (i=0;i<num_addrs;i++) {
1285 if (((char) *(addrs+ETH_ALEN*i) & 0x01) == 1) {
1286 crc = (long int) 0xffffffff;
1287 for (octet=0;octet<ETH_ALEN;octet++) {
1288 for(j=0;j<8;j++) {
1289 bit = (((char)* (addrs+ETH_ALEN*i+octet)) >> j) & 0x01;
1290 ctrl = ((crc < 0) ? 1 : 0);
1291 crc <<= 1;
1292 if (bit ^ ctrl) {
1293 crc ^= poly;
1294 }
1295 }
1296 }
1297 hashcode = ((crc >>= 23) & 0x01);
1298 for (j=0;j<8;j++) {
1299 hashcode <<= 1;
1300 crc >>= 1;
1301 hashcode |= (crc & 0x01);
1302 }
1303
1304 octet = hashcode >> 3;
1305
1306 if (lp->shmem_length == IO_ONLY) {
1307 unsigned char tmp;
1308
1309 outw((short)((long)multicast_table) + octet, EWRK3_PIR1);
1310 tmp = inb(EWRK3_DATA);
1311 tmp |= (1 << (hashcode & 0x07));
1312 outw((short)((long)multicast_table) + octet, EWRK3_PIR1);
1313 outb(tmp, EWRK3_DATA);
1314 } else {
1315 multicast_table[octet] |= (1 << (hashcode & 0x07));
1316 }
1317 }
1318 }
1319 }
1320
1321 lp->lock = 0;
1322
1323 return;
1324 }
1325
1326 #ifndef MODULE
1327
1328
1329
1330 static struct device *isa_probe(struct device *dev)
1331 {
1332 int i, iobase, status;
1333 unsigned long int tmp = mem_chkd;
1334
1335 for (status = -ENODEV, iobase = EWRK3_IO_BASE,i = 0;
1336 i < 24;
1337 iobase += EWRK3_IOP_INC, i++) {
1338 if (tmp & 0x01) {
1339
1340 if (!check_region(iobase, EWRK3_IOP_INC)) {
1341 if (DevicePresent(iobase) == 0) {
1342
1343
1344
1345
1346 snarf_region(iobase, EWRK3_IOP_INC);
1347 if (num_ewrk3s > 0) {
1348 dev = alloc_device(dev, iobase);
1349 } else {
1350 if ((status = ewrk3_hw_init(dev, iobase)) == 0) {
1351 num_ewrk3s++;
1352 }
1353 }
1354 num_eth++;
1355 } else {
1356 mem_chkd &= ~(0x01 << ((iobase - EWRK3_IO_BASE)/EWRK3_IOP_INC));
1357 }
1358 } else {
1359 printk("%s: ewrk3_probe(): Detected a device already registered at 0x%02x\n", dev->name, iobase);
1360 mem_chkd &= ~(0x01 << ((iobase - EWRK3_IO_BASE)/EWRK3_IOP_INC));
1361 }
1362 }
1363 tmp >>= 1;
1364 }
1365
1366 return dev;
1367 }
1368
1369
1370
1371
1372
1373 static struct device *eisa_probe(struct device *dev)
1374 {
1375 int i, iobase = EWRK3_EISA_IO_PORTS;
1376 int status;
1377
1378 iobase+=EISA_SLOT_INC;
1379 for (status = -ENODEV, i=1; i<MAX_EISA_SLOTS; i++, iobase+=EISA_SLOT_INC) {
1380
1381
1382 if (!check_region(iobase, EWRK3_IOP_INC)) {
1383 if (DevicePresent(iobase) == 0) {
1384
1385
1386
1387
1388 mem_chkd |= (0x01 << (i + 24));
1389 snarf_region(iobase, EWRK3_IOP_INC);
1390 if (num_ewrk3s > 0) {
1391 dev = alloc_device(dev, iobase);
1392 } else {
1393 if ((status = ewrk3_hw_init(dev, iobase)) == 0) {
1394 num_ewrk3s++;
1395 }
1396 }
1397 num_eth++;
1398 }
1399 }
1400 }
1401 return dev;
1402 }
1403
1404
1405
1406
1407
1408 static struct device *alloc_device(struct device *dev, int iobase)
1409 {
1410
1411
1412
1413 while (dev->next != NULL) {
1414 if (dev->next->base_addr == 0xffe0) break;
1415 dev = dev->next;
1416 num_eth++;
1417 }
1418
1419
1420
1421
1422
1423 if (dev->next == NULL) {
1424 dev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
1425 GFP_KERNEL);
1426 if (dev->next == NULL) {
1427 printk("eth%d: Device not initialised, insufficient memory\n",
1428 num_eth);
1429 }
1430 }
1431
1432
1433
1434
1435
1436
1437 if ((dev->next != NULL) &&
1438 (num_eth > 0) && (num_eth < 9999)) {
1439 dev = dev->next;
1440 dev->name = (char *)(dev + sizeof(struct device));
1441 sprintf(dev->name,"eth%d", num_eth);
1442 dev->base_addr = iobase;
1443 dev->next = NULL;
1444 dev->init = &ewrk3_probe;
1445 num_ewrk3s++;
1446 }
1447
1448 return dev;
1449 }
1450 #endif
1451
1452
1453
1454
1455 static int Read_EEPROM(short iobase, unsigned char eaddr)
1456 {
1457 int i;
1458
1459 outb((eaddr & 0x3f), EWRK3_PIR1);
1460 outb(EEPROM_RD, EWRK3_IOPR);
1461 for (i=0;i<5000;i++) inb(EWRK3_CSR);
1462
1463 return inw(EWRK3_EPROM1);
1464 }
1465
1466
1467
1468
1469 static int Write_EEPROM(short data, short iobase, unsigned char eaddr)
1470 {
1471 int i;
1472
1473 outb(EEPROM_WR_EN, EWRK3_IOPR);
1474 for (i=0;i<5000;i++) inb(EWRK3_CSR);
1475 outw(data, EWRK3_EPROM1);
1476 outb((eaddr & 0x3f), EWRK3_PIR1);
1477 outb(EEPROM_WR, EWRK3_IOPR);
1478 for (i=0;i<75000;i++) inb(EWRK3_CSR);
1479 outb(EEPROM_WR_DIS, EWRK3_IOPR);
1480 for (i=0;i<5000;i++) inb(EWRK3_CSR);
1481
1482 return 0;
1483 }
1484
1485
1486
1487
1488 static void EthwrkSignature(char *name, char *eeprom_image)
1489 {
1490 unsigned long i,j,k;
1491 char signatures[][EWRK3_NAME_LENGTH] = EWRK3_SIGNATURE;
1492
1493 strcpy(name, "");
1494 for (i=0;*signatures[i] != '\0' && *name == '\0';i++) {
1495 for (j=EEPROM_PNAME7,k=0;j<=EEPROM_PNAME0 && k<strlen(signatures[i]);j++) {
1496 if (signatures[i][k] == eeprom_image[j]) {
1497 k++;
1498 } else {
1499 k=0;
1500 }
1501 }
1502 if (k == strlen(signatures[i])) {
1503 for (k=0; k<EWRK3_NAME_LENGTH; k++) {
1504 name[k] = eeprom_image[EEPROM_PNAME7 + k];
1505 name[EWRK3_NAME_LENGTH] = '\0';
1506 }
1507 }
1508 }
1509
1510 return;
1511 }
1512
1513
1514
1515
1516
1517
1518 static int DevicePresent(short iobase)
1519 {
1520 static short fp=1,sigLength=0;
1521 static char devSig[] = PROBE_SEQUENCE;
1522 char data;
1523 int i, j, status = 0;
1524 static char asc2hex(char value);
1525
1526
1527
1528
1529 if (fp) {
1530 for (i=0,j=0;devSig[i] != '\0' && !status;i+=2,j++) {
1531 if ((devSig[i]=asc2hex(devSig[i]))>=0) {
1532 devSig[i]<<=4;
1533 if((devSig[i+1]=asc2hex(devSig[i+1]))>=0){
1534 devSig[j]=devSig[i]+devSig[i+1];
1535 } else {
1536 status= -1;
1537 }
1538 } else {
1539 status= -1;
1540 }
1541 }
1542 sigLength=j;
1543 fp = 0;
1544 }
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554 if (!status) {
1555 for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
1556 data = inb(EWRK3_APROM);
1557 if (devSig[j] == data) {
1558 j++;
1559 } else {
1560 j=0;
1561 }
1562 }
1563
1564 if (j!=sigLength) {
1565 status = -ENODEV;
1566 }
1567 }
1568
1569 return status;
1570 }
1571
1572 static unsigned char aprom_crc(struct device *dev, unsigned char *eeprom_image, char chipType)
1573 {
1574 long k;
1575 unsigned short j,chksum;
1576 unsigned char crc, lfsr, sd, status = 0;
1577 int iobase = dev->base_addr;
1578
1579 if (chipType == LeMAC2) {
1580 for (crc=0x6a, j=0; j<ETH_ALEN; j++) {
1581 for (sd=inb(EWRK3_PAR0+j), k=0; k<8; k++, sd >>= 1) {
1582 lfsr = ((((crc & 0x02) >> 1) ^ (crc & 0x01)) ^ (sd & 0x01)) << 7;
1583 crc = (crc >> 1) + lfsr;
1584 }
1585 }
1586 if (crc != eeprom_image[EEPROM_PA_CRC]) status = -1;
1587 } else {
1588 for (k=0,j=0;j<3;j++) {
1589 k <<= 1 ;
1590 if (k > 0xffff) k-=0xffff;
1591 k += inw(EWRK3_PAR0 + (j<<1));
1592 if (k > 0xffff) k-=0xffff;
1593 }
1594 if (k == 0xffff) k=0;
1595 chksum = inb(EWRK3_APROM);
1596 chksum |= (inb(EWRK3_APROM)<<8);
1597 if (k != chksum) status = -1;
1598 }
1599
1600 return status;
1601 }
1602
1603
1604
1605
1606
1607 static int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
1608 {
1609 struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1610 struct ewrk3_ioctl *ioc = (struct ewrk3_ioctl *) &rq->ifr_data;
1611 int i, j, iobase = dev->base_addr, status = 0;
1612 unsigned char csr;
1613 union {
1614 unsigned char addr[HASH_TABLE_LEN * ETH_ALEN];
1615 unsigned short val[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1616 } tmp;
1617
1618 switch(ioc->cmd) {
1619 case EWRK3_GET_HWADDR:
1620 for (i=0; i<ETH_ALEN; i++) {
1621 tmp.addr[i] = dev->dev_addr[i];
1622 }
1623 ioc->len = ETH_ALEN;
1624 memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1625
1626 break;
1627 case EWRK3_SET_HWADDR:
1628 if (suser()) {
1629 csr = inb(EWRK3_CSR);
1630 csr |= (TXD|RXD);
1631 outb(csr, EWRK3_CSR);
1632
1633 memcpy_fromfs(tmp.addr,ioc->data,ETH_ALEN);
1634 for (i=0; i<ETH_ALEN; i++) {
1635 dev->dev_addr[i] = tmp.addr[i];
1636 outb(tmp.addr[i], EWRK3_PAR0 + i);
1637 }
1638
1639 csr &= ~(TXD|RXD);
1640 outb(csr, EWRK3_CSR);
1641 } else {
1642 status = -EPERM;
1643 }
1644
1645 break;
1646 case EWRK3_SET_PROM:
1647 if (suser()) {
1648 csr = inb(EWRK3_CSR);
1649 csr |= PME;
1650 csr &= ~MCE;
1651 outb(csr, EWRK3_CSR);
1652 } else {
1653 status = -EPERM;
1654 }
1655
1656 break;
1657 case EWRK3_CLR_PROM:
1658 if (suser()) {
1659 csr = inb(EWRK3_CSR);
1660 csr &= ~PME;
1661 outb(csr, EWRK3_CSR);
1662 } else {
1663 status = -EPERM;
1664 }
1665
1666 break;
1667 case EWRK3_SAY_BOO:
1668 printk("%s: Boo!\n", dev->name);
1669
1670 break;
1671 case EWRK3_GET_MCA:
1672 while (set_bit(0, (void *)&lp->lock) != 0);
1673 if (lp->shmem_length == IO_ONLY) {
1674 outb(0, EWRK3_IOPR);
1675 outw(PAGE0_HTE, EWRK3_PIR1);
1676 for (i=0; i<(HASH_TABLE_LEN >> 3); i++) {
1677 tmp.addr[i] = inb(EWRK3_DATA);
1678 }
1679 } else {
1680 outb(0, EWRK3_MPR);
1681 memcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
1682 }
1683 ioc->len = (HASH_TABLE_LEN >> 3);
1684 memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1685 lp->lock = 0;
1686
1687 break;
1688 case EWRK3_SET_MCA:
1689 if (suser()) {
1690 if (ioc->len != HASH_TABLE_LEN) {
1691 memcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
1692 }
1693 set_multicast_list(dev, ioc->len, tmp.addr);
1694 } else {
1695 status = -EPERM;
1696 }
1697
1698 break;
1699 case EWRK3_CLR_MCA:
1700 if (suser()) {
1701 set_multicast_list(dev, 0, NULL);
1702 } else {
1703 status = -EPERM;
1704 }
1705
1706 break;
1707 case EWRK3_MCA_EN:
1708 if (suser()) {
1709 csr = inb(EWRK3_CSR);
1710 csr |= MCE;
1711 csr &= ~PME;
1712 outb(csr, EWRK3_CSR);
1713 } else {
1714 status = -EPERM;
1715 }
1716
1717 break;
1718 case EWRK3_GET_STATS:
1719 cli();
1720 memcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats));
1721 ioc->len = EWRK3_PKT_STAT_SZ;
1722 sti();
1723
1724 break;
1725 case EWRK3_CLR_STATS:
1726 if (suser()) {
1727 cli();
1728 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1729 sti();
1730 } else {
1731 status = -EPERM;
1732 }
1733
1734 break;
1735 case EWRK3_GET_CSR:
1736 tmp.addr[0] = inb(EWRK3_CSR);
1737 memcpy_tofs(ioc->data, tmp.addr, 1);
1738
1739 break;
1740 case EWRK3_SET_CSR:
1741 if (suser()) {
1742 memcpy_fromfs(tmp.addr, ioc->data, 1);
1743 outb(tmp.addr[0], EWRK3_CSR);
1744 } else {
1745 status = -EPERM;
1746 }
1747
1748 break;
1749 case EWRK3_GET_EEPROM:
1750 if (suser()) {
1751 for (i=0; i<(EEPROM_MAX>>1); i++) {
1752 tmp.val[i] = (short)Read_EEPROM(iobase, i);
1753 }
1754 i = EEPROM_MAX;
1755 tmp.addr[i++] = inb(EWRK3_CMR);
1756 for (j=0;j<ETH_ALEN;j++) {
1757 tmp.addr[i++] = inb(EWRK3_PAR0 + j);
1758 }
1759 ioc->len = EEPROM_MAX + 1 + ETH_ALEN;
1760 memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1761 } else {
1762 status = -EPERM;
1763 }
1764
1765 break;
1766 case EWRK3_SET_EEPROM:
1767 if (suser()) {
1768 memcpy_fromfs(tmp.addr, ioc->data, EEPROM_MAX);
1769 for (i=0; i<(EEPROM_MAX>>1); i++) {
1770 Write_EEPROM(tmp.val[i], iobase, i);
1771 }
1772 } else {
1773 status = -EPERM;
1774 }
1775
1776 break;
1777 case EWRK3_GET_CMR:
1778 tmp.addr[0] = inb(EWRK3_CMR);
1779 memcpy_tofs(ioc->data, tmp.addr, 1);
1780
1781 break;
1782 case EWRK3_SET_TX_CUT_THRU:
1783 if (suser()) {
1784 lp->txc = 1;
1785 } else {
1786 status = -EPERM;
1787 }
1788
1789 break;
1790 case EWRK3_CLR_TX_CUT_THRU:
1791 if (suser()) {
1792 lp->txc = 0;
1793 } else {
1794 status = -EPERM;
1795 }
1796
1797 break;
1798 default:
1799 status = -EOPNOTSUPP;
1800 }
1801
1802 return status;
1803 }
1804
1805 static char asc2hex(char value)
1806 {
1807 value -= 0x30;
1808 if (value >= 0) {
1809 if (value > 9) {
1810 value &= 0x1f;
1811 value -= 0x07;
1812 if ((value < 0x0a) || (value > 0x0f)) {
1813 value = -1;
1814 }
1815 }
1816 } else {
1817 value = -1;
1818 }
1819 return value;
1820 }
1821
1822 #ifdef MODULE
1823 char kernel_version[] = UTS_RELEASE;
1824 static struct device thisEthwrk = {
1825 " ",
1826 0, 0, 0, 0,
1827 0x300, 5,
1828 0, 0, 0, NULL, ewrk3_probe };
1829
1830 int
1831 init_module(void)
1832 {
1833 if (register_netdev(&thisEthwrk) != 0)
1834 return -EIO;
1835 return 0;
1836 }
1837
1838 void
1839 cleanup_module(void)
1840 {
1841 if (MOD_IN_USE) {
1842 printk("%s: device busy, remove delayed\n",thisEthwrk.name);
1843 } else {
1844 unregister_netdev(&thisEthwrk);
1845 }
1846 }
1847 #endif
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859