1 /* eth16i.c An ICL EtherTeam 16i and 32 EISA ethernet driver for Linux
2
3 Written 1994-1999 by Mika Kuoppala
4
5 Copyright (C) 1994-1999 by Mika Kuoppala
6 Based on skeleton.c and heavily on at1700.c by Donald Becker
7
8 This software may be used and distributed according to the terms
9 of the GNU Public Licence, incorporated herein by reference.
10
11 The author may be reached as miku@iki.fi
12
13 This driver supports following cards :
14 - ICL EtherTeam 16i
15 - ICL EtherTeam 32 EISA
16 (Uses true 32 bit transfers rather than 16i compability mode)
17
18 Example Module usage:
19 insmod eth16i.o io=0x2a0 mediatype=bnc
20
21 mediatype can be one of the following: bnc,tp,dix,auto,eprom
22
23 'auto' will try to autoprobe mediatype.
24 'eprom' will use whatever type defined in eprom.
25
26 I have benchmarked driver with PII/300Mhz as a ftp client
27 and 486/33Mhz as a ftp server. Top speed was 1128.37 kilobytes/sec.
28
29 Sources:
30 - skeleton.c a sample network driver core for linux,
31 written by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
32 - at1700.c a driver for Allied Telesis AT1700, written
33 by Donald Becker.
34 - e16iSRV.asm a Netware 3.X Server Driver for ICL EtherTeam16i
35 written by Markku Viima
36 - The Fujitsu MB86965 databook.
37
38 Author thanks following persons due to their valueble assistance:
39 Markku Viima (ICL)
40 Ari Valve (ICL)
41 Donald Becker
42 Kurt Huwig <kurt@huwig.de>
43
44 Revision history:
45
46 Version Date Description
47
48 0.01 15.12-94 Initial version (card detection)
49 0.02 23.01-95 Interrupt is now hooked correctly
50 0.03 01.02-95 Rewrote initialization part
51 0.04 07.02-95 Base skeleton done...
52 Made a few changes to signature checking
53 to make it a bit reliable.
54 - fixed bug in tx_buf mapping
55 - fixed bug in initialization (DLC_EN
56 wasn't enabled when initialization
57 was done.)
58 0.05 08.02-95 If there were more than one packet to send,
59 transmit was jammed due to invalid
60 register write...now fixed
61 0.06 19.02-95 Rewrote interrupt handling
62 0.07 13.04-95 Wrote EEPROM read routines
63 Card configuration now set according to
64 data read from EEPROM
65 0.08 23.06-95 Wrote part that tries to probe used interface
66 port if AUTO is selected
67
68 0.09 01.09-95 Added module support
69
70 0.10 04.09-95 Fixed receive packet allocation to work
71 with kernels > 1.3.x
72
73 0.20 20.09-95 Added support for EtherTeam32 EISA
74
75 0.21 17.10-95 Removed the unnecessary extern
76 init_etherdev() declaration. Some
77 other cleanups.
78
79 0.22 22.02-96 Receive buffer was not flushed
80 correctly when faulty packet was
81 received. Now fixed.
82
83 0.23 26.02-96 Made resetting the adapter
84 more reliable.
85
86 0.24 27.02-96 Rewrote faulty packet handling in eth16i_rx
87
88 0.25 22.05-96 kfree() was missing from cleanup_module.
89
90 0.26 11.06-96 Sometimes card was not found by
91 check_signature(). Now made more reliable.
92
93 0.27 23.06-96 Oops. 16 consecutive collisions halted
94 adapter. Now will try to retransmit
95 MAX_COL_16 times before finally giving up.
96
97 0.28 28.10-97 Added dev_id parameter (NULL) for free_irq
98
99 0.29 29.10-97 Multiple card support for module users
100
101 0.30 30.10-97 Fixed irq allocation bug.
102 (request_irq moved from probe to open)
103
104 0.30a 21.08-98 Card detection made more relaxed. Driver
105 had problems with some TCP/IP-PROM boots
106 to find the card. Suggested by
107 Kurt Huwig <kurt@huwig.de>
108
109 0.31 28.08-98 Media interface port can now be selected
110 with module parameters or kernel
111 boot parameters.
112
113 0.32 31.08-98 IRQ was never freed if open/close
114 pair wasn't called. Now fixed.
115
116 0.33 10.09-98 When eth16i_open() was called after
117 eth16i_close() chip never recovered.
118 Now more shallow reset is made on
119 close.
120
121 0.34 29.06-99 Fixed one bad #ifdef.
122 Changed ioaddr -> io for consistency
123
124 0.35 01.07-99 transmit,-receive bytes were never
125 updated in stats.
126
127 Bugs:
128 In some cases the media interface autoprobing code doesn't find
129 the correct interface type. In this case you can
130 manually choose the interface type in DOS with E16IC.EXE which is
131 configuration software for EtherTeam16i and EtherTeam32 cards.
132 This is also true for IRQ setting. You cannot use module
133 parameter to configure IRQ of the card (yet).
134
135 To do:
136 - Real multicast support
137 - Rewrite the media interface autoprobing code. Its _horrible_ !
138 - Possibly merge all the MB86965 specific code to external
139 module for use by eth16.c and Donald's at1700.c
140 - IRQ configuration with module parameter. I will do
141 this when i will get enough info about setting
142 irq without configuration utility.
143 */
144
145 static char *version =
146 "eth16i.c: v0.35 01-Jul-1999 Mika Kuoppala (miku@iki.fi)\n";
147
148 #include <linux/module.h>
149
150 #include <linux/kernel.h>
151 #include <linux/sched.h>
152 #include <linux/types.h>
153 #include <linux/fcntl.h>
154 #include <linux/interrupt.h>
155 #include <linux/ptrace.h>
156 #include <linux/ioport.h>
157 #include <linux/in.h>
158 #include <linux/malloc.h>
159 #include <linux/string.h>
160 #include <linux/errno.h>
161 #include <linux/init.h>
162 #include <linux/spinlock.h>
163
164 #include <linux/netdevice.h>
165 #include <linux/etherdevice.h>
166 #include <linux/skbuff.h>
167
168 #include <asm/system.h>
169 #include <asm/bitops.h>
170 #include <asm/io.h>
171 #include <asm/dma.h>
172
173
174
175 /* Few macros */
176 #define BIT(a) ( (1 << (a)) )
177 #define BITSET(ioaddr, bnum) ((outb(((inb(ioaddr)) | (bnum)), ioaddr)))
178 #define BITCLR(ioaddr, bnum) ((outb(((inb(ioaddr)) & (~(bnum))), ioaddr)))
179
180 /* This is the I/O address space for Etherteam 16i adapter. */
181 #define ETH16I_IO_EXTENT 32
182
183 /* Ticks before deciding that transmit has timed out */
184 #define TX_TIMEOUT (400*HZ/1000)
185
186 /* Maximum loop count when receiving packets */
187 #define MAX_RX_LOOP 20
188
189 /* Some interrupt masks */
190 #define ETH16I_INTR_ON 0xef8a /* Higher is receive mask */
191 #define ETH16I_INTR_OFF 0x0000
192
193 /* Buffers header status byte meanings */
194 #define PKT_GOOD BIT(5)
195 #define PKT_GOOD_RMT BIT(4)
196 #define PKT_SHORT BIT(3)
197 #define PKT_ALIGN_ERR BIT(2)
198 #define PKT_CRC_ERR BIT(1)
199 #define PKT_RX_BUF_OVERFLOW BIT(0)
200
201 /* Transmit status register (DLCR0) */
202 #define TX_STATUS_REG 0
203 #define TX_DONE BIT(7)
204 #define NET_BUSY BIT(6)
205 #define TX_PKT_RCD BIT(5)
206 #define CR_LOST BIT(4)
207 #define TX_JABBER_ERR BIT(3)
208 #define COLLISION BIT(2)
209 #define COLLISIONS_16 BIT(1)
210
211 /* Receive status register (DLCR1) */
212 #define RX_STATUS_REG 1
213 #define RX_PKT BIT(7) /* Packet received */
214 #define BUS_RD_ERR BIT(6)
215 #define SHORT_PKT_ERR BIT(3)
216 #define ALIGN_ERR BIT(2)
217 #define CRC_ERR BIT(1)
218 #define RX_BUF_OVERFLOW BIT(0)
219
220 /* Transmit Interrupt Enable Register (DLCR2) */
221 #define TX_INTR_REG 2
222 #define TX_INTR_DONE BIT(7)
223 #define TX_INTR_COL BIT(2)
224 #define TX_INTR_16_COL BIT(1)
225
226 /* Receive Interrupt Enable Register (DLCR3) */
227 #define RX_INTR_REG 3
228 #define RX_INTR_RECEIVE BIT(7)
229 #define RX_INTR_SHORT_PKT BIT(3)
230 #define RX_INTR_CRC_ERR BIT(1)
231 #define RX_INTR_BUF_OVERFLOW BIT(0)
232
233 /* Transmit Mode Register (DLCR4) */
234 #define TRANSMIT_MODE_REG 4
235 #define LOOPBACK_CONTROL BIT(1)
236 #define CONTROL_OUTPUT BIT(2)
237
238 /* Receive Mode Register (DLCR5) */
239 #define RECEIVE_MODE_REG 5
240 #define RX_BUFFER_EMPTY BIT(6)
241 #define ACCEPT_BAD_PACKETS BIT(5)
242 #define RECEIVE_SHORT_ADDR BIT(4)
243 #define ACCEPT_SHORT_PACKETS BIT(3)
244 #define REMOTE_RESET BIT(2)
245
246 #define ADDRESS_FILTER_MODE BIT(1) | BIT(0)
247 #define REJECT_ALL 0
248 #define ACCEPT_ALL 3
249 #define MODE_1 1 /* NODE ID, BC, MC, 2-24th bit */
250 #define MODE_2 2 /* NODE ID, BC, MC, Hash Table */
251
252 /* Configuration Register 0 (DLCR6) */
253 #define CONFIG_REG_0 6
254 #define DLC_EN BIT(7)
255 #define SRAM_CYCLE_TIME_100NS BIT(6)
256 #define SYSTEM_BUS_WIDTH_8 BIT(5) /* 1 = 8bit, 0 = 16bit */
257 #define BUFFER_WIDTH_8 BIT(4) /* 1 = 8bit, 0 = 16bit */
258 #define TBS1 BIT(3)
259 #define TBS0 BIT(2)
260 #define SRAM_BS1 BIT(1) /* 00=8kb, 01=16kb */
261 #define SRAM_BS0 BIT(0) /* 10=32kb, 11=64kb */
262
263 #ifndef ETH16I_TX_BUF_SIZE /* 0 = 2kb, 1 = 4kb */
264 #define ETH16I_TX_BUF_SIZE 3 /* 2 = 8kb, 3 = 16kb */
265 #endif
266 #define TX_BUF_1x2048 0
267 #define TX_BUF_2x2048 1
268 #define TX_BUF_2x4098 2
269 #define TX_BUF_2x8192 3
270
271 /* Configuration Register 1 (DLCR7) */
272 #define CONFIG_REG_1 7
273 #define POWERUP BIT(5)
274
275 /* Transmit start register */
276 #define TRANSMIT_START_REG 10
277 #define TRANSMIT_START_RB 2
278 #define TX_START BIT(7) /* Rest of register bit indicate*/
279 /* number of packets in tx buffer*/
280 /* Node ID registers (DLCR8-13) */
281 #define NODE_ID_0 8
282 #define NODE_ID_RB 0
283
284 /* Hash Table registers (HT8-15) */
285 #define HASH_TABLE_0 8
286 #define HASH_TABLE_RB 1
287
288 /* Buffer memory ports */
289 #define BUFFER_MEM_PORT_LB 8
290 #define DATAPORT BUFFER_MEM_PORT_LB
291 #define BUFFER_MEM_PORT_HB 9
292
293 /* 16 Collision control register (BMPR11) */
294 #define COL_16_REG 11
295 #define HALT_ON_16 0x00
296 #define RETRANS_AND_HALT_ON_16 0x02
297
298 /* Maximum number of attempts to send after 16 concecutive collisions */
299 #define MAX_COL_16 10
300
301 /* DMA Burst and Transceiver Mode Register (BMPR13) */
302 #define TRANSCEIVER_MODE_REG 13
303 #define TRANSCEIVER_MODE_RB 2
304 #define IO_BASE_UNLOCK BIT(7)
305 #define LOWER_SQUELCH_TRESH BIT(6)
306 #define LINK_TEST_DISABLE BIT(5)
307 #define AUI_SELECT BIT(4)
308 #define DIS_AUTO_PORT_SEL BIT(3)
309
310 /* Filter Self Receive Register (BMPR14) */
311 #define FILTER_SELF_RX_REG 14
312 #define SKIP_RX_PACKET BIT(2)
313 #define FILTER_SELF_RECEIVE BIT(0)
314
315 /* EEPROM Control Register (BMPR 16) */
316 #define EEPROM_CTRL_REG 16
317
318 /* EEPROM Data Register (BMPR 17) */
319 #define EEPROM_DATA_REG 17
320
321 /* NMC93CSx6 EEPROM Control Bits */
322 #define CS_0 0x00
323 #define CS_1 0x20
324 #define SK_0 0x00
325 #define SK_1 0x40
326 #define DI_0 0x00
327 #define DI_1 0x80
328
329 /* NMC93CSx6 EEPROM Instructions */
330 #define EEPROM_READ 0x80
331
332 /* NMC93CSx6 EEPROM Addresses */
333 #define E_NODEID_0 0x02
334 #define E_NODEID_1 0x03
335 #define E_NODEID_2 0x04
336 #define E_PORT_SELECT 0x14
337 #define E_PORT_BNC 0x00
338 #define E_PORT_DIX 0x01
339 #define E_PORT_TP 0x02
340 #define E_PORT_AUTO 0x03
341 #define E_PORT_FROM_EPROM 0x04
342 #define E_PRODUCT_CFG 0x30
343
344
345 /* Macro to slow down io between EEPROM clock transitions */
346 #define eeprom_slow_io() do { int _i = 40; while(--_i > 0) { inb(0x80); }}while(0)
347
348 /* Jumperless Configuration Register (BMPR19) */
349 #define JUMPERLESS_CONFIG 19
350
351 /* ID ROM registers, writing to them also resets some parts of chip */
352 #define ID_ROM_0 24
353 #define ID_ROM_7 31
354 #define RESET ID_ROM_0
355
356 /* This is the I/O address list to be probed when seeking the card */
357 static unsigned int eth16i_portlist[] = {
358 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
359 };
360
361 static unsigned int eth32i_portlist[] = {
362 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 0x8000,
363 0x9000, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0
364 };
365
366 /* This is the Interrupt lookup table for Eth16i card */
367 static unsigned int eth16i_irqmap[] = { 9, 10, 5, 15, 0 };
368 #define NUM_OF_ISA_IRQS 4
369
370 /* This is the Interrupt lookup table for Eth32i card */
371 static unsigned int eth32i_irqmap[] = { 3, 5, 7, 9, 10, 11, 12, 15, 0 };
372 #define EISA_IRQ_REG 0xc89
373 #define NUM_OF_EISA_IRQS 8
374
375 static unsigned int eth16i_tx_buf_map[] = { 2048, 2048, 4096, 8192 };
376 static unsigned int boot = 1;
377
378 /* Use 0 for production, 1 for verification, >2 for debug */
379 #ifndef ETH16I_DEBUG
380 #define ETH16I_DEBUG 0
381 #endif
382 static unsigned int eth16i_debug = ETH16I_DEBUG;
383
384 /* Information for each board */
385
386 struct eth16i_local {
387 struct net_device_stats stats;
388 unsigned char tx_started;
389 unsigned char tx_buf_busy;
390 unsigned short tx_queue; /* Number of packets in transmit buffer */
391 unsigned short tx_queue_len;
392 unsigned int tx_buf_size;
393 unsigned long open_time;
394 unsigned long tx_buffered_packets;
395 unsigned long tx_buffered_bytes;
396 unsigned long col_16;
397 spinlock_t lock;
398 };
399
400 /* Function prototypes */
401
402 extern int eth16i_probe(struct net_device *dev);
403
404 static int eth16i_probe1(struct net_device *dev, int ioaddr);
405 static int eth16i_check_signature(int ioaddr);
406 static int eth16i_probe_port(int ioaddr);
407 static void eth16i_set_port(int ioaddr, int porttype);
408 static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l);
409 static int eth16i_receive_probe_packet(int ioaddr);
410 static int eth16i_get_irq(int ioaddr);
411 static int eth16i_read_eeprom(int ioaddr, int offset);
412 static int eth16i_read_eeprom_word(int ioaddr);
413 static void eth16i_eeprom_cmd(int ioaddr, unsigned char command);
414 static int eth16i_open(struct net_device *dev);
415 static int eth16i_close(struct net_device *dev);
416 static int eth16i_tx(struct sk_buff *skb, struct net_device *dev);
417 static void eth16i_rx(struct net_device *dev);
418 static void eth16i_timeout(struct net_device *dev);
419 static void eth16i_interrupt(int irq, void *dev_id, struct pt_regs *regs);
420 static void eth16i_reset(struct net_device *dev);
421 static void eth16i_timeout(struct net_device *dev);
422 static void eth16i_skip_packet(struct net_device *dev);
423 static void eth16i_multicast(struct net_device *dev);
424 static void eth16i_select_regbank(unsigned char regbank, int ioaddr);
425 static void eth16i_initialize(struct net_device *dev);
426
427 #if 0
428 static int eth16i_set_irq(struct net_device *dev);
429 #endif
430
431 #ifdef MODULE
432 static ushort eth16i_parse_mediatype(const char* s);
433 #endif
434
435 static struct net_device_stats *eth16i_get_stats(struct net_device *dev);
436
437 static char *cardname = "ICL EtherTeam 16i/32";
438
439 int __init eth16i_probe(struct net_device *dev)
440 {
441 int i;
442 int ioaddr;
443 int base_addr = dev->base_addr;
444
445 SET_MODULE_OWNER(dev);
446
447 if(eth16i_debug > 4)
448 printk(KERN_DEBUG "Probing started for %s\n", cardname);
449
450 if(base_addr > 0x1ff) /* Check only single location */
451 return eth16i_probe1(dev, base_addr);
452 else if(base_addr != 0) /* Don't probe at all */
453 return -ENXIO;
454
455 /* Seek card from the ISA io address space */
456 for(i = 0; (ioaddr = eth16i_portlist[i]) ; i++)
457 if(eth16i_probe1(dev, ioaddr) == 0)
458 return 0;
459
460 /* Seek card from the EISA io address space */
461 for(i = 0; (ioaddr = eth32i_portlist[i]) ; i++)
462 if(eth16i_probe1(dev, ioaddr) == 0)
463 return 0;
464
465 return -ENODEV;
466 }
467
468 static int __init eth16i_probe1(struct net_device *dev, int ioaddr)
469 {
470 struct eth16i_local *lp;
471 static unsigned version_printed;
472 int retval;
473
474 boot = 1; /* To inform initilization that we are in boot probe */
475
476 /* Let's grab the region */
477 if (!request_region(ioaddr, ETH16I_IO_EXTENT, dev->name))
478 return -EBUSY;
479
480 /*
481 The MB86985 chip has on register which holds information in which
482 io address the chip lies. First read this register and compare
483 it to our current io address and if match then this could
484 be our chip.
485 */
486
487 if(ioaddr < 0x1000) {
488 if(eth16i_portlist[(inb(ioaddr + JUMPERLESS_CONFIG) & 0x07)]
489 != ioaddr) {
490 retval = -ENODEV;
491 goto out;
492 }
493 }
494
495 /* Now we will go a bit deeper and try to find the chip's signature */
496
497 if(eth16i_check_signature(ioaddr) != 0) {
498 retval = -ENODEV;
499 goto out;
500 }
501
502 /*
503 Now it seems that we have found a ethernet chip in this particular
504 ioaddr. The MB86985 chip has this feature, that when you read a
505 certain register it will increase it's io base address to next
506 configurable slot. Now when we have found the chip, first thing is
507 to make sure that the chip's ioaddr will hold still here.
508 */
509
510 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
511 outb(0x00, ioaddr + TRANSCEIVER_MODE_REG);
512
513 outb(0x00, ioaddr + RESET); /* Reset some parts of chip */
514 BITSET(ioaddr + CONFIG_REG_0, BIT(7)); /* Disable the data link */
515
516 if( (eth16i_debug & version_printed++) == 0)
517 printk(KERN_INFO "%s", version);
518
519 dev->base_addr = ioaddr;
520 dev->irq = eth16i_get_irq(ioaddr);
521
522 /* Try to obtain interrupt vector */
523
524 if ((retval = request_irq(dev->irq, (void *)ð16i_interrupt, 0, dev->name, dev))) {
525 printk(KERN_WARNING "%s: %s at %#3x, but is unusable due conflicting IRQ %d.\n",
526 dev->name, cardname, ioaddr, dev->irq);
527 goto out;
528 }
529
530 printk(KERN_INFO "%s: %s at %#3x, IRQ %d, ",
531 dev->name, cardname, ioaddr, dev->irq);
532
533
534 /* Now we will have to lock the chip's io address */
535 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
536 outb(0x38, ioaddr + TRANSCEIVER_MODE_REG);
537
538 eth16i_initialize(dev); /* Initialize rest of the chip's registers */
539
540 /* Now let's same some energy by shutting down the chip ;) */
541 BITCLR(ioaddr + CONFIG_REG_1, POWERUP);
542
543 /* Initialize the device structure */
544 if(dev->priv == NULL) {
545 dev->priv = kmalloc(sizeof(struct eth16i_local), GFP_KERNEL);
546 if(dev->priv == NULL) {
547 free_irq(dev->irq, dev);
548 retval = -ENOMEM;
549 goto out;
550 }
551 }
552
553 memset(dev->priv, 0, sizeof(struct eth16i_local));
554 dev->open = eth16i_open;
555 dev->stop = eth16i_close;
556 dev->hard_start_xmit = eth16i_tx;
557 dev->get_stats = eth16i_get_stats;
558 dev->set_multicast_list = eth16i_multicast;
559 dev->tx_timeout = eth16i_timeout;
560 dev->watchdog_timeo = TX_TIMEOUT;
561
562 lp = (struct eth16i_local *)dev->priv;
563 spin_lock_init(&lp->lock);
564
565 /* Fill in the fields of the device structure with ethernet values. */
566 ether_setup(dev);
567
568 boot = 0;
569
570 return 0;
571 out:
572 release_region(ioaddr, ETH16I_IO_EXTENT);
573 return retval;
574 }
575
576
577 static void eth16i_initialize(struct net_device *dev)
578 {
579 int ioaddr = dev->base_addr;
580 int i, node_w = 0;
581 unsigned char node_byte = 0;
582
583 /* Setup station address */
584 eth16i_select_regbank(NODE_ID_RB, ioaddr);
585 for(i = 0 ; i < 3 ; i++) {
586 unsigned short node_val = eth16i_read_eeprom(ioaddr, E_NODEID_0 + i);
587 ((unsigned short *)dev->dev_addr)[i] = ntohs(node_val);
588 }
589
590 for(i = 0; i < 6; i++) {
591 outb( ((unsigned char *)dev->dev_addr)[i], ioaddr + NODE_ID_0 + i);
592 if(boot) {
593 printk("%02x", inb(ioaddr + NODE_ID_0 + i));
594 if(i != 5)
595 printk(":");
596 }
597 }
598
599 /* Now we will set multicast addresses to accept none */
600 eth16i_select_regbank(HASH_TABLE_RB, ioaddr);
601 for(i = 0; i < 8; i++)
602 outb(0x00, ioaddr + HASH_TABLE_0 + i);
603
604 /*
605 Now let's disable the transmitter and receiver, set the buffer ram
606 cycle time, bus width and buffer data path width. Also we shall
607 set transmit buffer size and total buffer size.
608 */
609
610 eth16i_select_regbank(2, ioaddr);
611
612 node_byte = 0;
613 node_w = eth16i_read_eeprom(ioaddr, E_PRODUCT_CFG);
614
615 if( (node_w & 0xFF00) == 0x0800)
616 node_byte |= BUFFER_WIDTH_8;
617
618 node_byte |= SRAM_BS1;
619
620 if( (node_w & 0x00FF) == 64)
621 node_byte |= SRAM_BS0;
622
623 node_byte |= DLC_EN | SRAM_CYCLE_TIME_100NS | (ETH16I_TX_BUF_SIZE << 2);
624
625 outb(node_byte, ioaddr + CONFIG_REG_0);
626
627 /* We shall halt the transmitting, if 16 collisions are detected */
628 outb(HALT_ON_16, ioaddr + COL_16_REG);
629
630 #ifdef MODULE
631 /* if_port already set by init_module() */
632 #else
633 dev->if_port = (dev->mem_start < E_PORT_FROM_EPROM) ?
634 dev->mem_start : E_PORT_FROM_EPROM;
635 #endif
636
637 /* Set interface port type */
638 if(boot) {
639 char *porttype[] = {"BNC", "DIX", "TP", "AUTO", "FROM_EPROM" };
640
641 switch(dev->if_port)
642 {
643
644 case E_PORT_FROM_EPROM:
645 dev->if_port = eth16i_read_eeprom(ioaddr, E_PORT_SELECT);
646 break;
647
648 case E_PORT_AUTO:
649 dev->if_port = eth16i_probe_port(ioaddr);
650 break;
651
652 case E_PORT_BNC:
653 case E_PORT_TP:
654 case E_PORT_DIX:
655 break;
656 }
657
658 printk(" %s interface.\n", porttype[dev->if_port]);
659
660 eth16i_set_port(ioaddr, dev->if_port);
661 }
662
663 /* Set Receive Mode to normal operation */
664 outb(MODE_2, ioaddr + RECEIVE_MODE_REG);
665 }
666
667 static int eth16i_probe_port(int ioaddr)
668 {
669 int i;
670 int retcode;
671 unsigned char dummy_packet[64];
672
673 /* Powerup the chip */
674 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
675
676 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
677
678 eth16i_select_regbank(NODE_ID_RB, ioaddr);
679
680 for(i = 0; i < 6; i++) {
681 dummy_packet[i] = inb(ioaddr + NODE_ID_0 + i);
682 dummy_packet[i+6] = inb(ioaddr + NODE_ID_0 + i);
683 }
684
685 dummy_packet[12] = 0x00;
686 dummy_packet[13] = 0x04;
687 memset(dummy_packet + 14, 0, sizeof(dummy_packet) - 14);
688
689 eth16i_select_regbank(2, ioaddr);
690
691 for(i = 0; i < 3; i++) {
692 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
693 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
694 eth16i_set_port(ioaddr, i);
695
696 if(eth16i_debug > 1)
697 printk(KERN_DEBUG "Set port number %d\n", i);
698
699 retcode = eth16i_send_probe_packet(ioaddr, dummy_packet, 64);
700 if(retcode == 0) {
701 retcode = eth16i_receive_probe_packet(ioaddr);
702 if(retcode != -1) {
703 if(eth16i_debug > 1)
704 printk(KERN_DEBUG "Eth16i interface port found at %d\n", i);
705 return i;
706 }
707 }
708 else {
709 if(eth16i_debug > 1)
710 printk(KERN_DEBUG "TRANSMIT_DONE timeout when probing interface port\n");
711 }
712 }
713
714 if( eth16i_debug > 1)
715 printk(KERN_DEBUG "Using default port\n");
716
717 return E_PORT_BNC;
718 }
719
720 static void eth16i_set_port(int ioaddr, int porttype)
721 {
722 unsigned short temp = 0;
723
724 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
725 outb(LOOPBACK_CONTROL, ioaddr + TRANSMIT_MODE_REG);
726
727 temp |= DIS_AUTO_PORT_SEL;
728
729 switch(porttype) {
730
731 case E_PORT_BNC :
732 temp |= AUI_SELECT;
733 break;
734
735 case E_PORT_TP :
736 break;
737
738 case E_PORT_DIX :
739 temp |= AUI_SELECT;
740 BITSET(ioaddr + TRANSMIT_MODE_REG, CONTROL_OUTPUT);
741 break;
742 }
743
744 outb(temp, ioaddr + TRANSCEIVER_MODE_REG);
745
746 if(eth16i_debug > 1) {
747 printk(KERN_DEBUG "TRANSMIT_MODE_REG = %x\n", inb(ioaddr + TRANSMIT_MODE_REG));
748 printk(KERN_DEBUG "TRANSCEIVER_MODE_REG = %x\n",
749 inb(ioaddr+TRANSCEIVER_MODE_REG));
750 }
751 }
752
753 static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l)
754 {
755 int starttime;
756
757 outb(0xff, ioaddr + TX_STATUS_REG);
758
759 outw(l, ioaddr + DATAPORT);
760 outsw(ioaddr + DATAPORT, (unsigned short *)b, (l + 1) >> 1);
761
762 starttime = jiffies;
763 outb(TX_START | 1, ioaddr + TRANSMIT_START_REG);
764
765 while( (inb(ioaddr + TX_STATUS_REG) & 0x80) == 0) {
766 if( (jiffies - starttime) > TX_TIMEOUT) {
767 return -1;
768 }
769 }
770
771 return 0;
772 }
773
774 static int eth16i_receive_probe_packet(int ioaddr)
775 {
776 int starttime;
777
778 starttime = jiffies;
779
780 while((inb(ioaddr + TX_STATUS_REG) & 0x20) == 0) {
781 if( (jiffies - starttime) > TX_TIMEOUT) {
782
783 if(eth16i_debug > 1)
784 printk(KERN_DEBUG "Timeout occurred waiting transmit packet received\n");
785 starttime = jiffies;
786 while((inb(ioaddr + RX_STATUS_REG) & 0x80) == 0) {
787 if( (jiffies - starttime) > TX_TIMEOUT) {
788 if(eth16i_debug > 1)
789 printk(KERN_DEBUG "Timeout occurred waiting receive packet\n");
790 return -1;
791 }
792 }
793
794 if(eth16i_debug > 1)
795 printk(KERN_DEBUG "RECEIVE_PACKET\n");
796 return(0); /* Found receive packet */
797 }
798 }
799
800 if(eth16i_debug > 1) {
801 printk(KERN_DEBUG "TRANSMIT_PACKET_RECEIVED %x\n", inb(ioaddr + TX_STATUS_REG));
802 printk(KERN_DEBUG "RX_STATUS_REG = %x\n", inb(ioaddr + RX_STATUS_REG));
803 }
804
805 return(0); /* Return success */
806 }
807
808 #if 0
809 static int eth16i_set_irq(struct net_device* dev)
810 {
811 const int ioaddr = dev->base_addr;
812 const int irq = dev->irq;
813 int i = 0;
814
815 if(ioaddr < 0x1000) {
816 while(eth16i_irqmap[i] && eth16i_irqmap[i] != irq)
817 i++;
818
819 if(i < NUM_OF_ISA_IRQS) {
820 u8 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
821 cbyte = (cbyte & 0x3F) | (i << 6);
822 outb(cbyte, ioaddr + JUMPERLESS_CONFIG);
823 return 0;
824 }
825 }
826 else {
827 printk(KERN_NOTICE "%s: EISA Interrupt cannot be set. Use EISA Configuration utility.\n", dev->name);
828 }
829
830 return -1;
831
832 }
833 #endif
834
835 static int eth16i_get_irq(int ioaddr)
836 {
837 unsigned char cbyte;
838
839 if( ioaddr < 0x1000) {
840 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
841 return( eth16i_irqmap[ ((cbyte & 0xC0) >> 6) ] );
842 } else { /* Oh..the card is EISA so method getting IRQ different */
843 unsigned short index = 0;
844 cbyte = inb(ioaddr + EISA_IRQ_REG);
845 while( (cbyte & 0x01) == 0) {
846 cbyte = cbyte >> 1;
847 index++;
848 }
849 return( eth32i_irqmap[ index ] );
850 }
851 }
852
853 static int eth16i_check_signature(int ioaddr)
854 {
855 int i;
856 unsigned char creg[4] = { 0 };
857
858 for(i = 0; i < 4 ; i++) {
859
860 creg[i] = inb(ioaddr + TRANSMIT_MODE_REG + i);
861
862 if(eth16i_debug > 1)
863 printk("eth16i: read signature byte %x at %x\n",
864 creg[i],
865 ioaddr + TRANSMIT_MODE_REG + i);
866 }
867
868 creg[0] &= 0x0F; /* Mask collision cnr */
869 creg[2] &= 0x7F; /* Mask DCLEN bit */
870
871 #if 0
872 /*
873 This was removed because the card was sometimes left to state
874 from which it couldn't be find anymore. If there is need
875 to more strict check still this have to be fixed.
876 */
877 if( ! ((creg[0] == 0x06) && (creg[1] == 0x41)) ) {
878 if(creg[1] != 0x42)
879 return -1;
880 }
881 #endif
882
883 if( !((creg[2] == 0x36) && (creg[3] == 0xE0)) ) {
884 creg[2] &= 0x40;
885 creg[3] &= 0x03;
886
887 if( !((creg[2] == 0x40) && (creg[3] == 0x00)) )
888 return -1;
889 }
890
891 if(eth16i_read_eeprom(ioaddr, E_NODEID_0) != 0)
892 return -1;
893
894 if((eth16i_read_eeprom(ioaddr, E_NODEID_1) & 0xFF00) != 0x4B00)
895 return -1;
896
897 return 0;
898 }
899
900 static int eth16i_read_eeprom(int ioaddr, int offset)
901 {
902 int data = 0;
903
904 eth16i_eeprom_cmd(ioaddr, EEPROM_READ | offset);
905 outb(CS_1, ioaddr + EEPROM_CTRL_REG);
906 data = eth16i_read_eeprom_word(ioaddr);
907 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
908
909 return(data);
910 }
911
912 static int eth16i_read_eeprom_word(int ioaddr)
913 {
914 int i;
915 int data = 0;
916
917 for(i = 16; i > 0; i--) {
918 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
919 eeprom_slow_io();
920 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
921 eeprom_slow_io();
922 data = (data << 1) |
923 ((inb(ioaddr + EEPROM_DATA_REG) & DI_1) ? 1 : 0);
924
925 eeprom_slow_io();
926 }
927
928 return(data);
929 }
930
931 static void eth16i_eeprom_cmd(int ioaddr, unsigned char command)
932 {
933 int i;
934
935 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
936 outb(DI_0, ioaddr + EEPROM_DATA_REG);
937 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
938 outb(DI_1, ioaddr + EEPROM_DATA_REG);
939 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
940
941 for(i = 7; i >= 0; i--) {
942 short cmd = ( (command & (1 << i)) ? DI_1 : DI_0 );
943 outb(cmd, ioaddr + EEPROM_DATA_REG);
944 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
945 eeprom_slow_io();
946 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
947 eeprom_slow_io();
948 }
949 }
950
951 static int eth16i_open(struct net_device *dev)
952 {
953 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
954 int ioaddr = dev->base_addr;
955
956 /* Powerup the chip */
957 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
958
959 /* Initialize the chip */
960 eth16i_initialize(dev);
961
962 /* Set the transmit buffer size */
963 lp->tx_buf_size = eth16i_tx_buf_map[ETH16I_TX_BUF_SIZE & 0x03];
964
965 if(eth16i_debug > 0)
966 printk(KERN_DEBUG "%s: transmit buffer size %d\n",
967 dev->name, lp->tx_buf_size);
968
969 /* Now enable Transmitter and Receiver sections */
970 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
971
972 /* Now switch to register bank 2, for run time operation */
973 eth16i_select_regbank(2, ioaddr);
974
975 lp->open_time = jiffies;
976 lp->tx_started = 0;
977 lp->tx_queue = 0;
978 lp->tx_queue_len = 0;
979
980 /* Turn on interrupts*/
981 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
982
983 netif_start_queue(dev);
984 return 0;
985 }
986
987 static int eth16i_close(struct net_device *dev)
988 {
989 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
990 int ioaddr = dev->base_addr;
991
992 eth16i_reset(dev);
993
994 /* Turn off interrupts*/
995 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
996
997 netif_stop_queue(dev);
998
999 lp->open_time = 0;
1000
1001 /* Disable transmit and receive */
1002 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1003
1004 /* Reset the chip */
1005 /* outb(0xff, ioaddr + RESET); */
1006 /* outw(0xffff, ioaddr + TX_STATUS_REG); */
1007
1008 outb(0x00, ioaddr + CONFIG_REG_1);
1009
1010 return 0;
1011 }
1012
1013 static void eth16i_timeout(struct net_device *dev)
1014 {
1015 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
1016 int ioaddr = dev->base_addr;
1017 /*
1018 If we get here, some higher level has decided that
1019 we are broken. There should really be a "kick me"
1020 function call instead.
1021 */
1022
1023 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1024 printk(KERN_WARNING "%s: transmit timed out with status %04x, %s ?\n",
1025 dev->name,
1026 inw(ioaddr + TX_STATUS_REG), (inb(ioaddr + TX_STATUS_REG) & TX_DONE) ?
1027 "IRQ conflict" : "network cable problem");
1028
1029 dev->trans_start = jiffies;
1030
1031 /* Let's dump all registers */
1032 if(eth16i_debug > 0) {
1033 printk(KERN_DEBUG "%s: timeout: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
1034 dev->name, inb(ioaddr + 0),
1035 inb(ioaddr + 1), inb(ioaddr + 2),
1036 inb(ioaddr + 3), inb(ioaddr + 4),
1037 inb(ioaddr + 5),
1038 inb(ioaddr + 6), inb(ioaddr + 7));
1039
1040 printk(KERN_DEBUG "%s: transmit start reg: %02x. collision reg %02x\n",
1041 dev->name, inb(ioaddr + TRANSMIT_START_REG),
1042 inb(ioaddr + COL_16_REG));
1043 printk(KERN_DEBUG "lp->tx_queue = %d\n", lp->tx_queue);
1044 printk(KERN_DEBUG "lp->tx_queue_len = %d\n", lp->tx_queue_len);
1045 printk(KERN_DEBUG "lp->tx_started = %d\n", lp->tx_started);
1046 }
1047 lp->stats.tx_errors++;
1048 eth16i_reset(dev);
1049 dev->trans_start = jiffies;
1050 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1051 netif_wake_queue(dev);
1052 }
1053
1054 static int eth16i_tx(struct sk_buff *skb, struct net_device *dev)
1055 {
1056 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
1057 int ioaddr = dev->base_addr;
1058 int status = 0;
1059 ushort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1060 unsigned char *buf = skb->data;
1061 unsigned long flags;
1062
1063
1064 netif_stop_queue(dev);
1065
1066 /* Turn off TX interrupts */
1067 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1068
1069 /* We would be better doing the disable_irq tricks the 3c509 does,
1070 that would make this suck a lot less */
1071
1072 spin_lock_irqsave(&lp->lock, flags);
1073
1074 if( (length + 2) > (lp->tx_buf_size - lp->tx_queue_len)) {
1075 if(eth16i_debug > 0)
1076 printk(KERN_WARNING "%s: Transmit buffer full.\n", dev->name);
1077 }
1078 else {
1079 outw(length, ioaddr + DATAPORT);
1080
1081 if( ioaddr < 0x1000 )
1082 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
1083 else {
1084 unsigned char frag = length % 4;
1085 outsl(ioaddr + DATAPORT, buf, length >> 2);
1086 if( frag != 0 ) {
1087 outsw(ioaddr + DATAPORT, (buf + (length & 0xFFFC)), 1);
1088 if( frag == 3 )
1089 outsw(ioaddr + DATAPORT,
1090 (buf + (length & 0xFFFC) + 2), 1);
1091 }
1092 }
1093 lp->tx_buffered_packets++;
1094 lp->tx_buffered_bytes = length;
1095 lp->tx_queue++;
1096 lp->tx_queue_len += length + 2;
1097 }
1098 lp->tx_buf_busy = 0;
1099
1100 if(lp->tx_started == 0) {
1101 /* If the transmitter is idle..always trigger a transmit */
1102 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1103 lp->tx_queue = 0;
1104 lp->tx_queue_len = 0;
1105 dev->trans_start = jiffies;
1106 lp->tx_started = 1;
1107 netif_wake_queue(dev);
1108 }
1109 else if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1110 /* There is still more room for one more packet in tx buffer */
1111 netif_wake_queue(dev);
1112 }
1113
1114 spin_unlock_irqrestore(&lp->lock, flags);
1115
1116 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1117 /* Turn TX interrupts back on */
1118 /* outb(TX_INTR_DONE | TX_INTR_16_COL, ioaddr + TX_INTR_REG); */
1119 status = 0;
1120 dev_kfree_skb(skb);
1121 return 0;
1122 }
1123
1124 static void eth16i_rx(struct net_device *dev)
1125 {
1126 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
1127 int ioaddr = dev->base_addr;
1128 int boguscount = MAX_RX_LOOP;
1129
1130 /* Loop until all packets have been read */
1131 while( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) {
1132
1133 /* Read status byte from receive buffer */
1134 ushort status = inw(ioaddr + DATAPORT);
1135
1136 /* Get the size of the packet from receive buffer */
1137 ushort pkt_len = inw(ioaddr + DATAPORT);
1138
1139 if(eth16i_debug > 4)
1140 printk(KERN_DEBUG "%s: Receiving packet mode %02x status %04x.\n",
1141 dev->name,
1142 inb(ioaddr + RECEIVE_MODE_REG), status);
1143
1144 if( !(status & PKT_GOOD) ) {
1145 lp->stats.rx_errors++;
1146
1147 if( (pkt_len < ETH_ZLEN) || (pkt_len > ETH_FRAME_LEN) ) {
1148 lp->stats.rx_length_errors++;
1149 eth16i_reset(dev);
1150 return;
1151 }
1152 else {
1153 eth16i_skip_packet(dev);
1154 lp->stats.rx_dropped++;
1155 }
1156 }
1157 else { /* Ok so now we should have a good packet */
1158 struct sk_buff *skb;
1159
1160 skb = dev_alloc_skb(pkt_len + 3);
1161 if( skb == NULL ) {
1162 printk(KERN_WARNING "%s: Could'n allocate memory for packet (len %d)\n",
1163 dev->name, pkt_len);
1164 eth16i_skip_packet(dev);
1165 lp->stats.rx_dropped++;
1166 break;
1167 }
1168
1169 skb->dev = dev;
1170 skb_reserve(skb,2);
1171
1172 /*
1173 Now let's get the packet out of buffer.
1174 size is (pkt_len + 1) >> 1, cause we are now reading words
1175 and it have to be even aligned.
1176 */
1177
1178 if(ioaddr < 0x1000)
1179 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1180 (pkt_len + 1) >> 1);
1181 else {
1182 unsigned char *buf = skb_put(skb, pkt_len);
1183 unsigned char frag = pkt_len % 4;
1184
1185 insl(ioaddr + DATAPORT, buf, pkt_len >> 2);
1186
1187 if(frag != 0) {
1188 unsigned short rest[2];
1189 rest[0] = inw( ioaddr + DATAPORT );
1190 if(frag == 3)
1191 rest[1] = inw( ioaddr + DATAPORT );
1192
1193 memcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag);
1194 }
1195 }
1196
1197 skb->protocol=eth_type_trans(skb, dev);
1198 netif_rx(skb);
1199 lp->stats.rx_packets++;
1200 lp->stats.rx_bytes += pkt_len;
1201
1202 if( eth16i_debug > 5 ) {
1203 int i;
1204 printk(KERN_DEBUG "%s: Received packet of length %d.\n",
1205 dev->name, pkt_len);
1206 for(i = 0; i < 14; i++)
1207 printk(KERN_DEBUG " %02x", skb->data[i]);
1208 printk(KERN_DEBUG ".\n");
1209 }
1210
1211 } /* else */
1212
1213 if(--boguscount <= 0)
1214 break;
1215
1216 } /* while */
1217 }
1218
1219 static void eth16i_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1220 {
1221 struct net_device *dev = dev_id;
1222 struct eth16i_local *lp;
1223 int ioaddr = 0, status;
1224
1225 ioaddr = dev->base_addr;
1226 lp = (struct eth16i_local *)dev->priv;
1227
1228 /* Turn off all interrupts from adapter */
1229 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1230
1231 /* eth16i_tx wont be called */
1232 spin_lock(&lp->lock);
1233
1234 status = inw(ioaddr + TX_STATUS_REG); /* Get the status */
1235 outw(status, ioaddr + TX_STATUS_REG); /* Clear status bits */
1236
1237 if(eth16i_debug > 3)
1238 printk(KERN_DEBUG "%s: Interrupt with status %04x.\n", dev->name, status);
1239
1240 if( status & 0x7f00 ) {
1241
1242 lp->stats.rx_errors++;
1243
1244 if(status & (BUS_RD_ERR << 8) )
1245 printk(KERN_WARNING "%s: Bus read error.\n",dev->name);
1246 if(status & (SHORT_PKT_ERR << 8) ) lp->stats.rx_length_errors++;
1247 if(status & (ALIGN_ERR << 8) ) lp->stats.rx_frame_errors++;
1248 if(status & (CRC_ERR << 8) ) lp->stats.rx_crc_errors++;
1249 if(status & (RX_BUF_OVERFLOW << 8) ) lp->stats.rx_over_errors++;
1250 }
1251 if( status & 0x001a) {
1252
1253 lp->stats.tx_errors++;
1254
1255 if(status & CR_LOST) lp->stats.tx_carrier_errors++;
1256 if(status & TX_JABBER_ERR) lp->stats.tx_window_errors++;
1257
1258 #if 0
1259 if(status & COLLISION) {
1260 lp->stats.collisions +=
1261 ((inb(ioaddr+TRANSMIT_MODE_REG) & 0xF0) >> 4);
1262 }
1263 #endif
1264 if(status & COLLISIONS_16) {
1265 if(lp->col_16 < MAX_COL_16) {
1266 lp->col_16++;
1267 lp->stats.collisions++;
1268 /* Resume transmitting, skip failed packet */
1269 outb(0x02, ioaddr + COL_16_REG);
1270 }
1271 else {
1272 printk(KERN_WARNING "%s: bailing out due to many consecutive 16-in-a-row collisions. Network cable problem?\n", dev->name);
1273 }
1274 }
1275 }
1276
1277 if( status & 0x00ff ) { /* Let's check the transmit status reg */
1278
1279 if(status & TX_DONE) { /* The transmit has been done */
1280 lp->stats.tx_packets = lp->tx_buffered_packets;
1281 lp->stats.tx_bytes += lp->tx_buffered_bytes;
1282 lp->col_16 = 0;
1283
1284 if(lp->tx_queue) { /* Is there still packets ? */
1285 /* There was packet(s) so start transmitting and write also
1286 how many packets there is to be sended */
1287 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1288 lp->tx_queue = 0;
1289 lp->tx_queue_len = 0;
1290 lp->tx_started = 1;
1291 }
1292 else {
1293 lp->tx_started = 0;
1294 }
1295 netif_wake_queue(dev);
1296 }
1297 }
1298
1299 if( ( status & 0x8000 ) ||
1300 ( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) ) {
1301 eth16i_rx(dev); /* We have packet in receive buffer */
1302 }
1303
1304 /* Turn interrupts back on */
1305 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1306
1307 if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1308 /* There is still more room for one more packet in tx buffer */
1309 netif_wake_queue(dev);
1310 }
1311
1312 spin_unlock(&lp->lock);
1313
1314 return;
1315 }
1316
1317 static void eth16i_skip_packet(struct net_device *dev)
1318 {
1319 int ioaddr = dev->base_addr;
1320
1321 inw(ioaddr + DATAPORT);
1322 inw(ioaddr + DATAPORT);
1323 inw(ioaddr + DATAPORT);
1324
1325 outb(SKIP_RX_PACKET, ioaddr + FILTER_SELF_RX_REG);
1326 while( inb( ioaddr + FILTER_SELF_RX_REG ) != 0);
1327 }
1328
1329 static void eth16i_reset(struct net_device *dev)
1330 {
1331 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
1332 int ioaddr = dev->base_addr;
1333
1334 if(eth16i_debug > 1)
1335 printk(KERN_DEBUG "%s: Resetting device.\n", dev->name);
1336
1337 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1338 outw(0xffff, ioaddr + TX_STATUS_REG);
1339 eth16i_select_regbank(2, ioaddr);
1340
1341 lp->tx_started = 0;
1342 lp->tx_buf_busy = 0;
1343 lp->tx_queue = 0;
1344 lp->tx_queue_len = 0;
1345 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
1346 }
1347
1348 static void eth16i_multicast(struct net_device *dev)
1349 {
1350 int ioaddr = dev->base_addr;
1351
1352 if(dev->mc_count || dev->flags&(IFF_ALLMULTI|IFF_PROMISC))
1353 {
1354 dev->flags|=IFF_PROMISC; /* Must do this */
1355 outb(3, ioaddr + RECEIVE_MODE_REG);
1356 } else {
1357 outb(2, ioaddr + RECEIVE_MODE_REG);
1358 }
1359 }
1360
1361 static struct net_device_stats *eth16i_get_stats(struct net_device *dev)
1362 {
1363 struct eth16i_local *lp = (struct eth16i_local *)dev->priv;
1364 return &lp->stats;
1365 }
1366
1367 static void eth16i_select_regbank(unsigned char banknbr, int ioaddr)
1368 {
1369 unsigned char data;
1370
1371 data = inb(ioaddr + CONFIG_REG_1);
1372 outb( ((data & 0xF3) | ( (banknbr & 0x03) << 2)), ioaddr + CONFIG_REG_1);
1373 }
1374
1375 #ifdef MODULE
1376
1377 static ushort eth16i_parse_mediatype(const char* s)
1378 {
1379 if(!s)
1380 return E_PORT_FROM_EPROM;
1381
1382 if (!strncmp(s, "bnc", 3))
1383 return E_PORT_BNC;
1384 else if (!strncmp(s, "tp", 2))
1385 return E_PORT_TP;
1386 else if (!strncmp(s, "dix", 3))
1387 return E_PORT_DIX;
1388 else if (!strncmp(s, "auto", 4))
1389 return E_PORT_AUTO;
1390 else
1391 return E_PORT_FROM_EPROM;
1392 }
1393
1394 #define MAX_ETH16I_CARDS 4 /* Max number of Eth16i cards per module */
1395
1396 static struct net_device dev_eth16i[MAX_ETH16I_CARDS];
1397 static int io[MAX_ETH16I_CARDS];
1398 #if 0
1399 static int irq[MAX_ETH16I_CARDS];
1400 #endif
1401 static char* mediatype[MAX_ETH16I_CARDS];
1402 static int debug = -1;
1403
1404 #if (LINUX_VERSION_CODE >= 0x20115)
1405 MODULE_AUTHOR("Mika Kuoppala <miku@iki.fi>");
1406 MODULE_DESCRIPTION("ICL EtherTeam 16i/32 driver");
1407
1408 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_ETH16I_CARDS) "i");
1409 MODULE_PARM_DESC(io, "eth16i io base address");
1410
1411 #if 0
1412 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_ETH16I_CARDS) "i");
1413 MODULE_PARM_DESC(irq, "eth16i interrupt request number");
1414 #endif
1415
1416 MODULE_PARM(mediatype, "1-" __MODULE_STRING(MAX_ETH16I_CARDS) "s");
1417 MODULE_PARM_DESC(mediatype, "eth16i interfaceport mediatype");
1418
1419 MODULE_PARM(debug, "i");
1420 MODULE_PARM_DESC(debug, "eth16i debug level (0-4)");
1421 #endif
1422
1423 int init_module(void)
1424 {
1425 int this_dev, found = 0;
1426
1427 for(this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++)
1428 {
1429 struct net_device *dev = &dev_eth16i[this_dev];
1430
1431 dev->irq = 0; /* irq[this_dev]; */
1432 dev->base_addr = io[this_dev];
1433 dev->init = eth16i_probe;
1434
1435 if(debug != -1)
1436 eth16i_debug = debug;
1437
1438 if(eth16i_debug > 1)
1439 printk(KERN_NOTICE "eth16i(%d): interface type %s\n", this_dev, mediatype[this_dev] ? mediatype[this_dev] : "none" );
1440
1441 dev->if_port = eth16i_parse_mediatype(mediatype[this_dev]);
1442
1443 if(io[this_dev] == 0)
1444 {
1445 if(this_dev != 0) break; /* Only autoprobe 1st one */
1446
1447 printk(KERN_NOTICE "eth16i.c: Presently autoprobing (not recommended) for a single card.\n");
1448 }
1449
1450 if(register_netdev(dev) != 0)
1451 {
1452 printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n",
1453 io[this_dev]);
1454
1455 if(found != 0) return 0;
1456 return -ENXIO;
1457 }
1458
1459 found++;
1460 }
1461 return 0;
1462 }
1463
1464 void cleanup_module(void)
1465 {
1466 int this_dev;
1467
1468 for(this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++)
1469 {
1470 struct net_device* dev = &dev_eth16i[this_dev];
1471
1472 if(dev->priv != NULL)
1473 {
1474 unregister_netdev(dev);
1475 kfree(dev->priv);
1476 dev->priv = NULL;
1477
1478 free_irq(dev->irq, dev);
1479 release_region(dev->base_addr, ETH16I_IO_EXTENT);
1480
1481 }
1482 }
1483 }
1484 #endif /* MODULE */
1485
1486 /*
1487 * Local variables:
1488 * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c eth16i.c"
1489 * alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict -prototypes -O6 -c eth16i.c"
1490 * tab-width: 8
1491 * c-basic-offset: 8
1492 * c-indent-level: 8
1493 * End:
1494 */
1495
1496 /* End of file eth16i.c */
1497
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.