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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145static char *version =
146 "eth16i.c: v0.35 01-Jul-1999 Mika Kuoppala (miku@iki.fi)\n";
147
148#include <linux/module.h>
149#include <linux/kernel.h>
150#include <linux/types.h>
151#include <linux/fcntl.h>
152#include <linux/interrupt.h>
153#include <linux/ioport.h>
154#include <linux/in.h>
155#include <linux/slab.h>
156#include <linux/string.h>
157#include <linux/errno.h>
158#include <linux/init.h>
159#include <linux/spinlock.h>
160#include <linux/netdevice.h>
161#include <linux/etherdevice.h>
162#include <linux/skbuff.h>
163#include <linux/bitops.h>
164#include <linux/jiffies.h>
165#include <linux/io.h>
166
167#include <asm/system.h>
168#include <asm/dma.h>
169
170
171
172
173#define BITSET(ioaddr, bnum) ((outb(((inb(ioaddr)) | (bnum)), ioaddr)))
174#define BITCLR(ioaddr, bnum) ((outb(((inb(ioaddr)) & (~(bnum))), ioaddr)))
175
176
177#define ETH16I_IO_EXTENT 32
178
179
180#define TX_TIMEOUT (400*HZ/1000)
181
182
183#define MAX_RX_LOOP 20
184
185
186#define ETH16I_INTR_ON 0xef8a
187#define ETH16I_INTR_OFF 0x0000
188
189
190#define PKT_GOOD BIT(5)
191#define PKT_GOOD_RMT BIT(4)
192#define PKT_SHORT BIT(3)
193#define PKT_ALIGN_ERR BIT(2)
194#define PKT_CRC_ERR BIT(1)
195#define PKT_RX_BUF_OVERFLOW BIT(0)
196
197
198#define TX_STATUS_REG 0
199#define TX_DONE BIT(7)
200#define NET_BUSY BIT(6)
201#define TX_PKT_RCD BIT(5)
202#define CR_LOST BIT(4)
203#define TX_JABBER_ERR BIT(3)
204#define COLLISION BIT(2)
205#define COLLISIONS_16 BIT(1)
206
207
208#define RX_STATUS_REG 1
209#define RX_PKT BIT(7)
210#define BUS_RD_ERR BIT(6)
211#define SHORT_PKT_ERR BIT(3)
212#define ALIGN_ERR BIT(2)
213#define CRC_ERR BIT(1)
214#define RX_BUF_OVERFLOW BIT(0)
215
216
217#define TX_INTR_REG 2
218#define TX_INTR_DONE BIT(7)
219#define TX_INTR_COL BIT(2)
220#define TX_INTR_16_COL BIT(1)
221
222
223#define RX_INTR_REG 3
224#define RX_INTR_RECEIVE BIT(7)
225#define RX_INTR_SHORT_PKT BIT(3)
226#define RX_INTR_CRC_ERR BIT(1)
227#define RX_INTR_BUF_OVERFLOW BIT(0)
228
229
230#define TRANSMIT_MODE_REG 4
231#define LOOPBACK_CONTROL BIT(1)
232#define CONTROL_OUTPUT BIT(2)
233
234
235#define RECEIVE_MODE_REG 5
236#define RX_BUFFER_EMPTY BIT(6)
237#define ACCEPT_BAD_PACKETS BIT(5)
238#define RECEIVE_SHORT_ADDR BIT(4)
239#define ACCEPT_SHORT_PACKETS BIT(3)
240#define REMOTE_RESET BIT(2)
241
242#define ADDRESS_FILTER_MODE BIT(1) | BIT(0)
243#define REJECT_ALL 0
244#define ACCEPT_ALL 3
245#define MODE_1 1
246#define MODE_2 2
247
248
249#define CONFIG_REG_0 6
250#define DLC_EN BIT(7)
251#define SRAM_CYCLE_TIME_100NS BIT(6)
252#define SYSTEM_BUS_WIDTH_8 BIT(5)
253#define BUFFER_WIDTH_8 BIT(4)
254#define TBS1 BIT(3)
255#define TBS0 BIT(2)
256#define SRAM_BS1 BIT(1)
257#define SRAM_BS0 BIT(0)
258
259#ifndef ETH16I_TX_BUF_SIZE
260#define ETH16I_TX_BUF_SIZE 3
261#endif
262#define TX_BUF_1x2048 0
263#define TX_BUF_2x2048 1
264#define TX_BUF_2x4098 2
265#define TX_BUF_2x8192 3
266
267
268#define CONFIG_REG_1 7
269#define POWERUP BIT(5)
270
271
272#define TRANSMIT_START_REG 10
273#define TRANSMIT_START_RB 2
274#define TX_START BIT(7)
275
276
277#define NODE_ID_0 8
278#define NODE_ID_RB 0
279
280
281#define HASH_TABLE_0 8
282#define HASH_TABLE_RB 1
283
284
285#define BUFFER_MEM_PORT_LB 8
286#define DATAPORT BUFFER_MEM_PORT_LB
287#define BUFFER_MEM_PORT_HB 9
288
289
290#define COL_16_REG 11
291#define HALT_ON_16 0x00
292#define RETRANS_AND_HALT_ON_16 0x02
293
294
295#define MAX_COL_16 10
296
297
298#define TRANSCEIVER_MODE_REG 13
299#define TRANSCEIVER_MODE_RB 2
300#define IO_BASE_UNLOCK BIT(7)
301#define LOWER_SQUELCH_TRESH BIT(6)
302#define LINK_TEST_DISABLE BIT(5)
303#define AUI_SELECT BIT(4)
304#define DIS_AUTO_PORT_SEL BIT(3)
305
306
307#define FILTER_SELF_RX_REG 14
308#define SKIP_RX_PACKET BIT(2)
309#define FILTER_SELF_RECEIVE BIT(0)
310
311
312#define EEPROM_CTRL_REG 16
313
314
315#define EEPROM_DATA_REG 17
316
317
318#define CS_0 0x00
319#define CS_1 0x20
320#define SK_0 0x00
321#define SK_1 0x40
322#define DI_0 0x00
323#define DI_1 0x80
324
325
326#define EEPROM_READ 0x80
327
328
329#define E_NODEID_0 0x02
330#define E_NODEID_1 0x03
331#define E_NODEID_2 0x04
332#define E_PORT_SELECT 0x14
333 #define E_PORT_BNC 0x00
334 #define E_PORT_DIX 0x01
335 #define E_PORT_TP 0x02
336 #define E_PORT_AUTO 0x03
337 #define E_PORT_FROM_EPROM 0x04
338#define E_PRODUCT_CFG 0x30
339
340
341
342#define eeprom_slow_io() do { int _i = 40; while(--_i > 0) { inb(0x80); }}while(0)
343
344
345#define JUMPERLESS_CONFIG 19
346
347
348#define ID_ROM_0 24
349#define ID_ROM_7 31
350#define RESET ID_ROM_0
351
352
353static unsigned int eth16i_portlist[] __initdata = {
354 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
355};
356
357static unsigned int eth32i_portlist[] __initdata = {
358 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 0x8000,
359 0x9000, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0
360};
361
362
363static unsigned int eth16i_irqmap[] __initdata = { 9, 10, 5, 15, 0 };
364#define NUM_OF_ISA_IRQS 4
365
366
367static unsigned int eth32i_irqmap[] __initdata = { 3, 5, 7, 9, 10, 11, 12, 15, 0 };
368#define EISA_IRQ_REG 0xc89
369#define NUM_OF_EISA_IRQS 8
370
371static unsigned int eth16i_tx_buf_map[] = { 2048, 2048, 4096, 8192 };
372
373
374#ifndef ETH16I_DEBUG
375#define ETH16I_DEBUG 0
376#endif
377static unsigned int eth16i_debug = ETH16I_DEBUG;
378
379
380
381struct eth16i_local {
382 unsigned char tx_started;
383 unsigned char tx_buf_busy;
384 unsigned short tx_queue;
385 unsigned short tx_queue_len;
386 unsigned int tx_buf_size;
387 unsigned long open_time;
388 unsigned long tx_buffered_packets;
389 unsigned long tx_buffered_bytes;
390 unsigned long col_16;
391 spinlock_t lock;
392};
393
394
395
396static int eth16i_probe1(struct net_device *dev, int ioaddr);
397static int eth16i_check_signature(int ioaddr);
398static int eth16i_probe_port(int ioaddr);
399static void eth16i_set_port(int ioaddr, int porttype);
400static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l);
401static int eth16i_receive_probe_packet(int ioaddr);
402static int eth16i_get_irq(int ioaddr);
403static int eth16i_read_eeprom(int ioaddr, int offset);
404static int eth16i_read_eeprom_word(int ioaddr);
405static void eth16i_eeprom_cmd(int ioaddr, unsigned char command);
406static int eth16i_open(struct net_device *dev);
407static int eth16i_close(struct net_device *dev);
408static netdev_tx_t eth16i_tx(struct sk_buff *skb, struct net_device *dev);
409static void eth16i_rx(struct net_device *dev);
410static void eth16i_timeout(struct net_device *dev);
411static irqreturn_t eth16i_interrupt(int irq, void *dev_id);
412static void eth16i_reset(struct net_device *dev);
413static void eth16i_timeout(struct net_device *dev);
414static void eth16i_skip_packet(struct net_device *dev);
415static void eth16i_multicast(struct net_device *dev);
416static void eth16i_select_regbank(unsigned char regbank, int ioaddr);
417static void eth16i_initialize(struct net_device *dev, int boot);
418
419#if 0
420static int eth16i_set_irq(struct net_device *dev);
421#endif
422
423#ifdef MODULE
424static ushort eth16i_parse_mediatype(const char* s);
425#endif
426
427static char cardname[] __initdata = "ICL EtherTeam 16i/32";
428
429static int __init do_eth16i_probe(struct net_device *dev)
430{
431 int i;
432 int ioaddr;
433 int base_addr = dev->base_addr;
434
435 if(eth16i_debug > 4)
436 printk(KERN_DEBUG "Probing started for %s\n", cardname);
437
438 if(base_addr > 0x1ff)
439 return eth16i_probe1(dev, base_addr);
440 else if(base_addr != 0)
441 return -ENXIO;
442
443
444 for(i = 0; (ioaddr = eth16i_portlist[i]) ; i++)
445 if(eth16i_probe1(dev, ioaddr) == 0)
446 return 0;
447
448
449 for(i = 0; (ioaddr = eth32i_portlist[i]) ; i++)
450 if(eth16i_probe1(dev, ioaddr) == 0)
451 return 0;
452
453 return -ENODEV;
454}
455
456#ifndef MODULE
457struct net_device * __init eth16i_probe(int unit)
458{
459 struct net_device *dev = alloc_etherdev(sizeof(struct eth16i_local));
460 int err;
461
462 if (!dev)
463 return ERR_PTR(-ENOMEM);
464
465 sprintf(dev->name, "eth%d", unit);
466 netdev_boot_setup_check(dev);
467
468 err = do_eth16i_probe(dev);
469 if (err)
470 goto out;
471 return dev;
472out:
473 free_netdev(dev);
474 return ERR_PTR(err);
475}
476#endif
477
478static const struct net_device_ops eth16i_netdev_ops = {
479 .ndo_open = eth16i_open,
480 .ndo_stop = eth16i_close,
481 .ndo_start_xmit = eth16i_tx,
482 .ndo_set_multicast_list = eth16i_multicast,
483 .ndo_tx_timeout = eth16i_timeout,
484 .ndo_change_mtu = eth_change_mtu,
485 .ndo_set_mac_address = eth_mac_addr,
486 .ndo_validate_addr = eth_validate_addr,
487};
488
489static int __init eth16i_probe1(struct net_device *dev, int ioaddr)
490{
491 struct eth16i_local *lp = netdev_priv(dev);
492 static unsigned version_printed;
493 int retval;
494
495
496 if (!request_region(ioaddr, ETH16I_IO_EXTENT, cardname))
497 return -EBUSY;
498
499
500
501
502
503
504
505
506 if(ioaddr < 0x1000) {
507 if(eth16i_portlist[(inb(ioaddr + JUMPERLESS_CONFIG) & 0x07)]
508 != ioaddr) {
509 retval = -ENODEV;
510 goto out;
511 }
512 }
513
514
515
516 if(eth16i_check_signature(ioaddr) != 0) {
517 retval = -ENODEV;
518 goto out;
519 }
520
521
522
523
524
525
526
527
528
529 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
530 outb(0x00, ioaddr + TRANSCEIVER_MODE_REG);
531
532 outb(0x00, ioaddr + RESET);
533 BITSET(ioaddr + CONFIG_REG_0, BIT(7));
534
535 if( (eth16i_debug & version_printed++) == 0)
536 printk(KERN_INFO "%s", version);
537
538 dev->base_addr = ioaddr;
539 dev->irq = eth16i_get_irq(ioaddr);
540
541
542
543 if ((retval = request_irq(dev->irq, (void *)ð16i_interrupt, 0, cardname, dev))) {
544 printk(KERN_WARNING "%s at %#3x, but is unusable due to conflicting IRQ %d.\n",
545 cardname, ioaddr, dev->irq);
546 goto out;
547 }
548
549 printk(KERN_INFO "%s: %s at %#3x, IRQ %d, ",
550 dev->name, cardname, ioaddr, dev->irq);
551
552
553
554 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
555 outb(0x38, ioaddr + TRANSCEIVER_MODE_REG);
556
557 eth16i_initialize(dev, 1);
558
559
560 BITCLR(ioaddr + CONFIG_REG_1, POWERUP);
561
562
563 dev->netdev_ops = ð16i_netdev_ops;
564 dev->watchdog_timeo = TX_TIMEOUT;
565 spin_lock_init(&lp->lock);
566
567 retval = register_netdev(dev);
568 if (retval)
569 goto out1;
570 return 0;
571out1:
572 free_irq(dev->irq, dev);
573out:
574 release_region(ioaddr, ETH16I_IO_EXTENT);
575 return retval;
576}
577
578
579static void eth16i_initialize(struct net_device *dev, int boot)
580{
581 int ioaddr = dev->base_addr;
582 int i, node_w = 0;
583 unsigned char node_byte = 0;
584
585
586 eth16i_select_regbank(NODE_ID_RB, ioaddr);
587 for(i = 0 ; i < 3 ; i++) {
588 unsigned short node_val = eth16i_read_eeprom(ioaddr, E_NODEID_0 + i);
589 ((unsigned short *)dev->dev_addr)[i] = ntohs(node_val);
590 }
591
592 for(i = 0; i < 6; i++) {
593 outb( ((unsigned char *)dev->dev_addr)[i], ioaddr + NODE_ID_0 + i);
594 if(boot) {
595 printk("%02x", inb(ioaddr + NODE_ID_0 + i));
596 if(i != 5)
597 printk(":");
598 }
599 }
600
601
602 eth16i_select_regbank(HASH_TABLE_RB, ioaddr);
603 for(i = 0; i < 8; i++)
604 outb(0x00, ioaddr + HASH_TABLE_0 + i);
605
606
607
608
609
610
611
612 eth16i_select_regbank(2, ioaddr);
613
614 node_byte = 0;
615 node_w = eth16i_read_eeprom(ioaddr, E_PRODUCT_CFG);
616
617 if( (node_w & 0xFF00) == 0x0800)
618 node_byte |= BUFFER_WIDTH_8;
619
620 node_byte |= SRAM_BS1;
621
622 if( (node_w & 0x00FF) == 64)
623 node_byte |= SRAM_BS0;
624
625 node_byte |= DLC_EN | SRAM_CYCLE_TIME_100NS | (ETH16I_TX_BUF_SIZE << 2);
626
627 outb(node_byte, ioaddr + CONFIG_REG_0);
628
629
630 outb(HALT_ON_16, ioaddr + COL_16_REG);
631
632#ifdef MODULE
633
634#else
635 dev->if_port = (dev->mem_start < E_PORT_FROM_EPROM) ?
636 dev->mem_start : E_PORT_FROM_EPROM;
637#endif
638
639
640 if(boot) {
641 char *porttype[] = {"BNC", "DIX", "TP", "AUTO", "FROM_EPROM" };
642
643 switch(dev->if_port)
644 {
645
646 case E_PORT_FROM_EPROM:
647 dev->if_port = eth16i_read_eeprom(ioaddr, E_PORT_SELECT);
648 break;
649
650 case E_PORT_AUTO:
651 dev->if_port = eth16i_probe_port(ioaddr);
652 break;
653
654 case E_PORT_BNC:
655 case E_PORT_TP:
656 case E_PORT_DIX:
657 break;
658 }
659
660 printk(" %s interface.\n", porttype[dev->if_port]);
661
662 eth16i_set_port(ioaddr, dev->if_port);
663 }
664
665
666 outb(MODE_2, ioaddr + RECEIVE_MODE_REG);
667}
668
669static int eth16i_probe_port(int ioaddr)
670{
671 int i;
672 int retcode;
673 unsigned char dummy_packet[64];
674
675
676 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
677
678 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
679
680 eth16i_select_regbank(NODE_ID_RB, ioaddr);
681
682 for(i = 0; i < 6; i++) {
683 dummy_packet[i] = inb(ioaddr + NODE_ID_0 + i);
684 dummy_packet[i+6] = inb(ioaddr + NODE_ID_0 + i);
685 }
686
687 dummy_packet[12] = 0x00;
688 dummy_packet[13] = 0x04;
689 memset(dummy_packet + 14, 0, sizeof(dummy_packet) - 14);
690
691 eth16i_select_regbank(2, ioaddr);
692
693 for(i = 0; i < 3; i++) {
694 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
695 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
696 eth16i_set_port(ioaddr, i);
697
698 if(eth16i_debug > 1)
699 printk(KERN_DEBUG "Set port number %d\n", i);
700
701 retcode = eth16i_send_probe_packet(ioaddr, dummy_packet, 64);
702 if(retcode == 0) {
703 retcode = eth16i_receive_probe_packet(ioaddr);
704 if(retcode != -1) {
705 if(eth16i_debug > 1)
706 printk(KERN_DEBUG "Eth16i interface port found at %d\n", i);
707 return i;
708 }
709 }
710 else {
711 if(eth16i_debug > 1)
712 printk(KERN_DEBUG "TRANSMIT_DONE timeout when probing interface port\n");
713 }
714 }
715
716 if( eth16i_debug > 1)
717 printk(KERN_DEBUG "Using default port\n");
718
719 return E_PORT_BNC;
720}
721
722static void eth16i_set_port(int ioaddr, int porttype)
723{
724 unsigned short temp = 0;
725
726 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
727 outb(LOOPBACK_CONTROL, ioaddr + TRANSMIT_MODE_REG);
728
729 temp |= DIS_AUTO_PORT_SEL;
730
731 switch(porttype) {
732
733 case E_PORT_BNC :
734 temp |= AUI_SELECT;
735 break;
736
737 case E_PORT_TP :
738 break;
739
740 case E_PORT_DIX :
741 temp |= AUI_SELECT;
742 BITSET(ioaddr + TRANSMIT_MODE_REG, CONTROL_OUTPUT);
743 break;
744 }
745
746 outb(temp, ioaddr + TRANSCEIVER_MODE_REG);
747
748 if(eth16i_debug > 1) {
749 printk(KERN_DEBUG "TRANSMIT_MODE_REG = %x\n", inb(ioaddr + TRANSMIT_MODE_REG));
750 printk(KERN_DEBUG "TRANSCEIVER_MODE_REG = %x\n",
751 inb(ioaddr+TRANSCEIVER_MODE_REG));
752 }
753}
754
755static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l)
756{
757 unsigned long starttime;
758
759 outb(0xff, ioaddr + TX_STATUS_REG);
760
761 outw(l, ioaddr + DATAPORT);
762 outsw(ioaddr + DATAPORT, (unsigned short *)b, (l + 1) >> 1);
763
764 starttime = jiffies;
765 outb(TX_START | 1, ioaddr + TRANSMIT_START_REG);
766
767 while( (inb(ioaddr + TX_STATUS_REG) & 0x80) == 0) {
768 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
769 return -1;
770 }
771 }
772
773 return 0;
774}
775
776static int eth16i_receive_probe_packet(int ioaddr)
777{
778 unsigned long starttime;
779
780 starttime = jiffies;
781
782 while((inb(ioaddr + TX_STATUS_REG) & 0x20) == 0) {
783 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
784
785 if(eth16i_debug > 1)
786 printk(KERN_DEBUG "Timeout occurred waiting transmit packet received\n");
787 starttime = jiffies;
788 while((inb(ioaddr + RX_STATUS_REG) & 0x80) == 0) {
789 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
790 if(eth16i_debug > 1)
791 printk(KERN_DEBUG "Timeout occurred waiting receive packet\n");
792 return -1;
793 }
794 }
795
796 if(eth16i_debug > 1)
797 printk(KERN_DEBUG "RECEIVE_PACKET\n");
798 return(0);
799 }
800 }
801
802 if(eth16i_debug > 1) {
803 printk(KERN_DEBUG "TRANSMIT_PACKET_RECEIVED %x\n", inb(ioaddr + TX_STATUS_REG));
804 printk(KERN_DEBUG "RX_STATUS_REG = %x\n", inb(ioaddr + RX_STATUS_REG));
805 }
806
807 return(0);
808}
809
810#if 0
811static int eth16i_set_irq(struct net_device* dev)
812{
813 const int ioaddr = dev->base_addr;
814 const int irq = dev->irq;
815 int i = 0;
816
817 if(ioaddr < 0x1000) {
818 while(eth16i_irqmap[i] && eth16i_irqmap[i] != irq)
819 i++;
820
821 if(i < NUM_OF_ISA_IRQS) {
822 u8 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
823 cbyte = (cbyte & 0x3F) | (i << 6);
824 outb(cbyte, ioaddr + JUMPERLESS_CONFIG);
825 return 0;
826 }
827 }
828 else {
829 printk(KERN_NOTICE "%s: EISA Interrupt cannot be set. Use EISA Configuration utility.\n", dev->name);
830 }
831
832 return -1;
833
834}
835#endif
836
837static int __init eth16i_get_irq(int ioaddr)
838{
839 unsigned char cbyte;
840
841 if( ioaddr < 0x1000) {
842 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
843 return( eth16i_irqmap[ ((cbyte & 0xC0) >> 6) ] );
844 } else {
845 unsigned short index = 0;
846 cbyte = inb(ioaddr + EISA_IRQ_REG);
847 while( (cbyte & 0x01) == 0) {
848 cbyte = cbyte >> 1;
849 index++;
850 }
851 return( eth32i_irqmap[ index ] );
852 }
853}
854
855static int __init eth16i_check_signature(int ioaddr)
856{
857 int i;
858 unsigned char creg[4] = { 0 };
859
860 for(i = 0; i < 4 ; i++) {
861
862 creg[i] = inb(ioaddr + TRANSMIT_MODE_REG + i);
863
864 if(eth16i_debug > 1)
865 printk("eth16i: read signature byte %x at %x\n",
866 creg[i],
867 ioaddr + TRANSMIT_MODE_REG + i);
868 }
869
870 creg[0] &= 0x0F;
871 creg[2] &= 0x7F;
872
873#if 0
874
875
876
877
878
879 if( ! ((creg[0] == 0x06) && (creg[1] == 0x41)) ) {
880 if(creg[1] != 0x42)
881 return -1;
882 }
883#endif
884
885 if( !((creg[2] == 0x36) && (creg[3] == 0xE0)) ) {
886 creg[2] &= 0x40;
887 creg[3] &= 0x03;
888
889 if( !((creg[2] == 0x40) && (creg[3] == 0x00)) )
890 return -1;
891 }
892
893 if(eth16i_read_eeprom(ioaddr, E_NODEID_0) != 0)
894 return -1;
895
896 if((eth16i_read_eeprom(ioaddr, E_NODEID_1) & 0xFF00) != 0x4B00)
897 return -1;
898
899 return 0;
900}
901
902static int eth16i_read_eeprom(int ioaddr, int offset)
903{
904 int data = 0;
905
906 eth16i_eeprom_cmd(ioaddr, EEPROM_READ | offset);
907 outb(CS_1, ioaddr + EEPROM_CTRL_REG);
908 data = eth16i_read_eeprom_word(ioaddr);
909 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
910
911 return(data);
912}
913
914static int eth16i_read_eeprom_word(int ioaddr)
915{
916 int i;
917 int data = 0;
918
919 for(i = 16; i > 0; i--) {
920 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
921 eeprom_slow_io();
922 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
923 eeprom_slow_io();
924 data = (data << 1) |
925 ((inb(ioaddr + EEPROM_DATA_REG) & DI_1) ? 1 : 0);
926
927 eeprom_slow_io();
928 }
929
930 return(data);
931}
932
933static void eth16i_eeprom_cmd(int ioaddr, unsigned char command)
934{
935 int i;
936
937 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
938 outb(DI_0, ioaddr + EEPROM_DATA_REG);
939 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
940 outb(DI_1, ioaddr + EEPROM_DATA_REG);
941 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
942
943 for(i = 7; i >= 0; i--) {
944 short cmd = ( (command & (1 << i)) ? DI_1 : DI_0 );
945 outb(cmd, ioaddr + EEPROM_DATA_REG);
946 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
947 eeprom_slow_io();
948 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
949 eeprom_slow_io();
950 }
951}
952
953static int eth16i_open(struct net_device *dev)
954{
955 struct eth16i_local *lp = netdev_priv(dev);
956 int ioaddr = dev->base_addr;
957
958
959 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
960
961
962 eth16i_initialize(dev, 0);
963
964
965 lp->tx_buf_size = eth16i_tx_buf_map[ETH16I_TX_BUF_SIZE & 0x03];
966
967 if(eth16i_debug > 0)
968 printk(KERN_DEBUG "%s: transmit buffer size %d\n",
969 dev->name, lp->tx_buf_size);
970
971
972 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
973
974
975 eth16i_select_regbank(2, ioaddr);
976
977 lp->open_time = jiffies;
978 lp->tx_started = 0;
979 lp->tx_queue = 0;
980 lp->tx_queue_len = 0;
981
982
983 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
984
985 netif_start_queue(dev);
986 return 0;
987}
988
989static int eth16i_close(struct net_device *dev)
990{
991 struct eth16i_local *lp = netdev_priv(dev);
992 int ioaddr = dev->base_addr;
993
994 eth16i_reset(dev);
995
996
997 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
998
999 netif_stop_queue(dev);
1000
1001 lp->open_time = 0;
1002
1003
1004 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1005
1006
1007
1008
1009
1010 outb(0x00, ioaddr + CONFIG_REG_1);
1011
1012 return 0;
1013}
1014
1015static void eth16i_timeout(struct net_device *dev)
1016{
1017 struct eth16i_local *lp = netdev_priv(dev);
1018 int ioaddr = dev->base_addr;
1019
1020
1021
1022
1023
1024
1025 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1026 printk(KERN_WARNING "%s: transmit timed out with status %04x, %s ?\n",
1027 dev->name,
1028 inw(ioaddr + TX_STATUS_REG), (inb(ioaddr + TX_STATUS_REG) & TX_DONE) ?
1029 "IRQ conflict" : "network cable problem");
1030
1031 dev->trans_start = jiffies;
1032
1033
1034 if(eth16i_debug > 0) {
1035 printk(KERN_DEBUG "%s: timeout: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
1036 dev->name, inb(ioaddr + 0),
1037 inb(ioaddr + 1), inb(ioaddr + 2),
1038 inb(ioaddr + 3), inb(ioaddr + 4),
1039 inb(ioaddr + 5),
1040 inb(ioaddr + 6), inb(ioaddr + 7));
1041
1042 printk(KERN_DEBUG "%s: transmit start reg: %02x. collision reg %02x\n",
1043 dev->name, inb(ioaddr + TRANSMIT_START_REG),
1044 inb(ioaddr + COL_16_REG));
1045 printk(KERN_DEBUG "lp->tx_queue = %d\n", lp->tx_queue);
1046 printk(KERN_DEBUG "lp->tx_queue_len = %d\n", lp->tx_queue_len);
1047 printk(KERN_DEBUG "lp->tx_started = %d\n", lp->tx_started);
1048 }
1049 dev->stats.tx_errors++;
1050 eth16i_reset(dev);
1051 dev->trans_start = jiffies;
1052 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1053 netif_wake_queue(dev);
1054}
1055
1056static netdev_tx_t eth16i_tx(struct sk_buff *skb, struct net_device *dev)
1057{
1058 struct eth16i_local *lp = netdev_priv(dev);
1059 int ioaddr = dev->base_addr;
1060 int status = 0;
1061 ushort length = skb->len;
1062 unsigned char *buf;
1063 unsigned long flags;
1064
1065 if (length < ETH_ZLEN) {
1066 if (skb_padto(skb, ETH_ZLEN))
1067 return NETDEV_TX_OK;
1068 length = ETH_ZLEN;
1069 }
1070 buf = skb->data;
1071
1072 netif_stop_queue(dev);
1073
1074
1075 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1076
1077
1078
1079
1080 spin_lock_irqsave(&lp->lock, flags);
1081
1082 if( (length + 2) > (lp->tx_buf_size - lp->tx_queue_len)) {
1083 if(eth16i_debug > 0)
1084 printk(KERN_WARNING "%s: Transmit buffer full.\n", dev->name);
1085 }
1086 else {
1087 outw(length, ioaddr + DATAPORT);
1088
1089 if( ioaddr < 0x1000 )
1090 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
1091 else {
1092 unsigned char frag = length % 4;
1093 outsl(ioaddr + DATAPORT, buf, length >> 2);
1094 if( frag != 0 ) {
1095 outsw(ioaddr + DATAPORT, (buf + (length & 0xFFFC)), 1);
1096 if( frag == 3 )
1097 outsw(ioaddr + DATAPORT,
1098 (buf + (length & 0xFFFC) + 2), 1);
1099 }
1100 }
1101 lp->tx_buffered_packets++;
1102 lp->tx_buffered_bytes = length;
1103 lp->tx_queue++;
1104 lp->tx_queue_len += length + 2;
1105 }
1106 lp->tx_buf_busy = 0;
1107
1108 if(lp->tx_started == 0) {
1109
1110 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1111 lp->tx_queue = 0;
1112 lp->tx_queue_len = 0;
1113 dev->trans_start = jiffies;
1114 lp->tx_started = 1;
1115 netif_wake_queue(dev);
1116 }
1117 else if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1118
1119 netif_wake_queue(dev);
1120 }
1121
1122 spin_unlock_irqrestore(&lp->lock, flags);
1123
1124 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1125
1126
1127 status = 0;
1128 dev_kfree_skb(skb);
1129 return NETDEV_TX_OK;
1130}
1131
1132static void eth16i_rx(struct net_device *dev)
1133{
1134 int ioaddr = dev->base_addr;
1135 int boguscount = MAX_RX_LOOP;
1136
1137
1138 while( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) {
1139
1140
1141 ushort status = inw(ioaddr + DATAPORT);
1142
1143
1144 ushort pkt_len = inw(ioaddr + DATAPORT);
1145
1146 if(eth16i_debug > 4)
1147 printk(KERN_DEBUG "%s: Receiving packet mode %02x status %04x.\n",
1148 dev->name,
1149 inb(ioaddr + RECEIVE_MODE_REG), status);
1150
1151 if( !(status & PKT_GOOD) ) {
1152 dev->stats.rx_errors++;
1153
1154 if( (pkt_len < ETH_ZLEN) || (pkt_len > ETH_FRAME_LEN) ) {
1155 dev->stats.rx_length_errors++;
1156 eth16i_reset(dev);
1157 return;
1158 }
1159 else {
1160 eth16i_skip_packet(dev);
1161 dev->stats.rx_dropped++;
1162 }
1163 }
1164 else {
1165 struct sk_buff *skb;
1166
1167 skb = dev_alloc_skb(pkt_len + 3);
1168 if( skb == NULL ) {
1169 printk(KERN_WARNING "%s: Could'n allocate memory for packet (len %d)\n",
1170 dev->name, pkt_len);
1171 eth16i_skip_packet(dev);
1172 dev->stats.rx_dropped++;
1173 break;
1174 }
1175
1176 skb_reserve(skb,2);
1177
1178
1179
1180
1181
1182
1183
1184 if(ioaddr < 0x1000)
1185 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1186 (pkt_len + 1) >> 1);
1187 else {
1188 unsigned char *buf = skb_put(skb, pkt_len);
1189 unsigned char frag = pkt_len % 4;
1190
1191 insl(ioaddr + DATAPORT, buf, pkt_len >> 2);
1192
1193 if(frag != 0) {
1194 unsigned short rest[2];
1195 rest[0] = inw( ioaddr + DATAPORT );
1196 if(frag == 3)
1197 rest[1] = inw( ioaddr + DATAPORT );
1198
1199 memcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag);
1200 }
1201 }
1202
1203 skb->protocol=eth_type_trans(skb, dev);
1204
1205 if( eth16i_debug > 5 ) {
1206 int i;
1207 printk(KERN_DEBUG "%s: Received packet of length %d.\n",
1208 dev->name, pkt_len);
1209 for(i = 0; i < 14; i++)
1210 printk(KERN_DEBUG " %02x", skb->data[i]);
1211 printk(KERN_DEBUG ".\n");
1212 }
1213 netif_rx(skb);
1214 dev->stats.rx_packets++;
1215 dev->stats.rx_bytes += pkt_len;
1216
1217 }
1218
1219 if(--boguscount <= 0)
1220 break;
1221
1222 }
1223}
1224
1225static irqreturn_t eth16i_interrupt(int irq, void *dev_id)
1226{
1227 struct net_device *dev = dev_id;
1228 struct eth16i_local *lp;
1229 int ioaddr = 0, status;
1230 int handled = 0;
1231
1232 ioaddr = dev->base_addr;
1233 lp = netdev_priv(dev);
1234
1235
1236 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1237
1238
1239 spin_lock(&lp->lock);
1240
1241 status = inw(ioaddr + TX_STATUS_REG);
1242 outw(status, ioaddr + TX_STATUS_REG);
1243
1244 if (status)
1245 handled = 1;
1246
1247 if(eth16i_debug > 3)
1248 printk(KERN_DEBUG "%s: Interrupt with status %04x.\n", dev->name, status);
1249
1250 if( status & 0x7f00 ) {
1251
1252 dev->stats.rx_errors++;
1253
1254 if(status & (BUS_RD_ERR << 8) )
1255 printk(KERN_WARNING "%s: Bus read error.\n",dev->name);
1256 if(status & (SHORT_PKT_ERR << 8) ) dev->stats.rx_length_errors++;
1257 if(status & (ALIGN_ERR << 8) ) dev->stats.rx_frame_errors++;
1258 if(status & (CRC_ERR << 8) ) dev->stats.rx_crc_errors++;
1259 if(status & (RX_BUF_OVERFLOW << 8) ) dev->stats.rx_over_errors++;
1260 }
1261 if( status & 0x001a) {
1262
1263 dev->stats.tx_errors++;
1264
1265 if(status & CR_LOST) dev->stats.tx_carrier_errors++;
1266 if(status & TX_JABBER_ERR) dev->stats.tx_window_errors++;
1267
1268#if 0
1269 if(status & COLLISION) {
1270 dev->stats.collisions +=
1271 ((inb(ioaddr+TRANSMIT_MODE_REG) & 0xF0) >> 4);
1272 }
1273#endif
1274 if(status & COLLISIONS_16) {
1275 if(lp->col_16 < MAX_COL_16) {
1276 lp->col_16++;
1277 dev->stats.collisions++;
1278
1279 outb(0x02, ioaddr + COL_16_REG);
1280 }
1281 else {
1282 printk(KERN_WARNING "%s: bailing out due to many consecutive 16-in-a-row collisions. Network cable problem?\n", dev->name);
1283 }
1284 }
1285 }
1286
1287 if( status & 0x00ff ) {
1288
1289 if(status & TX_DONE) {
1290 dev->stats.tx_packets = lp->tx_buffered_packets;
1291 dev->stats.tx_bytes += lp->tx_buffered_bytes;
1292 lp->col_16 = 0;
1293
1294 if(lp->tx_queue) {
1295
1296
1297 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1298 lp->tx_queue = 0;
1299 lp->tx_queue_len = 0;
1300 lp->tx_started = 1;
1301 }
1302 else {
1303 lp->tx_started = 0;
1304 }
1305 netif_wake_queue(dev);
1306 }
1307 }
1308
1309 if( ( status & 0x8000 ) ||
1310 ( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) ) {
1311 eth16i_rx(dev);
1312 }
1313
1314
1315 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1316
1317 if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1318
1319 netif_wake_queue(dev);
1320 }
1321
1322 spin_unlock(&lp->lock);
1323
1324 return IRQ_RETVAL(handled);
1325}
1326
1327static void eth16i_skip_packet(struct net_device *dev)
1328{
1329 int ioaddr = dev->base_addr;
1330
1331 inw(ioaddr + DATAPORT);
1332 inw(ioaddr + DATAPORT);
1333 inw(ioaddr + DATAPORT);
1334
1335 outb(SKIP_RX_PACKET, ioaddr + FILTER_SELF_RX_REG);
1336 while( inb( ioaddr + FILTER_SELF_RX_REG ) != 0);
1337}
1338
1339static void eth16i_reset(struct net_device *dev)
1340{
1341 struct eth16i_local *lp = netdev_priv(dev);
1342 int ioaddr = dev->base_addr;
1343
1344 if(eth16i_debug > 1)
1345 printk(KERN_DEBUG "%s: Resetting device.\n", dev->name);
1346
1347 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1348 outw(0xffff, ioaddr + TX_STATUS_REG);
1349 eth16i_select_regbank(2, ioaddr);
1350
1351 lp->tx_started = 0;
1352 lp->tx_buf_busy = 0;
1353 lp->tx_queue = 0;
1354 lp->tx_queue_len = 0;
1355 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
1356}
1357
1358static void eth16i_multicast(struct net_device *dev)
1359{
1360 int ioaddr = dev->base_addr;
1361
1362 if(dev->mc_count || dev->flags&(IFF_ALLMULTI|IFF_PROMISC))
1363 {
1364 outb(3, ioaddr + RECEIVE_MODE_REG);
1365 } else {
1366 outb(2, ioaddr + RECEIVE_MODE_REG);
1367 }
1368}
1369
1370static void eth16i_select_regbank(unsigned char banknbr, int ioaddr)
1371{
1372 unsigned char data;
1373
1374 data = inb(ioaddr + CONFIG_REG_1);
1375 outb( ((data & 0xF3) | ( (banknbr & 0x03) << 2)), ioaddr + CONFIG_REG_1);
1376}
1377
1378#ifdef MODULE
1379
1380static ushort eth16i_parse_mediatype(const char* s)
1381{
1382 if(!s)
1383 return E_PORT_FROM_EPROM;
1384
1385 if (!strncmp(s, "bnc", 3))
1386 return E_PORT_BNC;
1387 else if (!strncmp(s, "tp", 2))
1388 return E_PORT_TP;
1389 else if (!strncmp(s, "dix", 3))
1390 return E_PORT_DIX;
1391 else if (!strncmp(s, "auto", 4))
1392 return E_PORT_AUTO;
1393 else
1394 return E_PORT_FROM_EPROM;
1395}
1396
1397#define MAX_ETH16I_CARDS 4
1398
1399static struct net_device *dev_eth16i[MAX_ETH16I_CARDS];
1400static int io[MAX_ETH16I_CARDS];
1401#if 0
1402static int irq[MAX_ETH16I_CARDS];
1403#endif
1404static char* mediatype[MAX_ETH16I_CARDS];
1405static int debug = -1;
1406
1407MODULE_AUTHOR("Mika Kuoppala <miku@iki.fi>");
1408MODULE_DESCRIPTION("ICL EtherTeam 16i/32 driver");
1409MODULE_LICENSE("GPL");
1410
1411
1412module_param_array(io, int, NULL, 0);
1413MODULE_PARM_DESC(io, "eth16i I/O base address(es)");
1414
1415#if 0
1416module_param_array(irq, int, NULL, 0);
1417MODULE_PARM_DESC(irq, "eth16i interrupt request number");
1418#endif
1419
1420module_param_array(mediatype, charp, NULL, 0);
1421MODULE_PARM_DESC(mediatype, "eth16i media type of interface(s) (bnc,tp,dix,auto,eprom)");
1422
1423module_param(debug, int, 0);
1424MODULE_PARM_DESC(debug, "eth16i debug level (0-6)");
1425
1426int __init init_module(void)
1427{
1428 int this_dev, found = 0;
1429 struct net_device *dev;
1430
1431 for (this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) {
1432 dev = alloc_etherdev(sizeof(struct eth16i_local));
1433 if (!dev)
1434 break;
1435
1436 dev->base_addr = io[this_dev];
1437
1438 if(debug != -1)
1439 eth16i_debug = debug;
1440
1441 if(eth16i_debug > 1)
1442 printk(KERN_NOTICE "eth16i(%d): interface type %s\n", this_dev, mediatype[this_dev] ? mediatype[this_dev] : "none" );
1443
1444 dev->if_port = eth16i_parse_mediatype(mediatype[this_dev]);
1445
1446 if(io[this_dev] == 0) {
1447 if(this_dev != 0)
1448 break;
1449
1450 printk(KERN_NOTICE "eth16i.c: Presently autoprobing (not recommended) for a single card.\n");
1451 }
1452
1453 if (do_eth16i_probe(dev) == 0) {
1454 dev_eth16i[found++] = dev;
1455 continue;
1456 }
1457 printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n",
1458 io[this_dev]);
1459 free_netdev(dev);
1460 break;
1461 }
1462 if (found)
1463 return 0;
1464 return -ENXIO;
1465}
1466
1467void __exit cleanup_module(void)
1468{
1469 int this_dev;
1470
1471 for(this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) {
1472 struct net_device *dev = dev_eth16i[this_dev];
1473
1474 if (netdev_priv(dev)) {
1475 unregister_netdev(dev);
1476 free_irq(dev->irq, dev);
1477 release_region(dev->base_addr, ETH16I_IO_EXTENT);
1478 free_netdev(dev);
1479 }
1480 }
1481}
1482#endif
1483