1 /* eth16i.c An ICL EtherTeam 16i and 32 EISA ethernet driver for Linux
3 Written 1994-1999 by Mika Kuoppala
5 Copyright (C) 1994-1999 by Mika Kuoppala
6 Based on skeleton.c and heavily on at1700.c by Donald Becker
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 The author may be reached as miku@iki.fi
13 This driver supports following cards :
15 - ICL EtherTeam 32 EISA
16 (Uses true 32 bit transfers rather than 16i compability mode)
19 insmod eth16i.o io=0x2a0 mediatype=bnc
21 mediatype can be one of the following: bnc,tp,dix,auto,eprom
23 'auto' will try to autoprobe mediatype.
24 'eprom' will use whatever type defined in eprom.
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.
30 - skeleton.c a sample network driver core for linux,
31 written by Donald Becker <becker@scyld.com>
32 - at1700.c a driver for Allied Telesis AT1700, written
34 - e16iSRV.asm a Netware 3.X Server Driver for ICL EtherTeam16i
35 written by Markku Viima
36 - The Fujitsu MB86965 databook.
38 Author thanks following persons due to their valueble assistance:
42 Kurt Huwig <kurt@huwig.de>
46 Version Date Description
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
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
65 0.08 23.06-95 Wrote part that tries to probe used interface
66 port if AUTO is selected
68 0.09 01.09-95 Added module support
70 0.10 04.09-95 Fixed receive packet allocation to work
73 0.20 20.09-95 Added support for EtherTeam32 EISA
75 0.21 17.10-95 Removed the unnecessary extern
76 init_etherdev() declaration. Some
79 0.22 22.02-96 Receive buffer was not flushed
80 correctly when faulty packet was
83 0.23 26.02-96 Made resetting the adapter
86 0.24 27.02-96 Rewrote faulty packet handling in eth16i_rx
88 0.25 22.05-96 kfree() was missing from cleanup_module.
90 0.26 11.06-96 Sometimes card was not found by
91 check_signature(). Now made more reliable.
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.
97 0.28 28.10-97 Added dev_id parameter (NULL) for free_irq
99 0.29 29.10-97 Multiple card support for module users
101 0.30 30.10-97 Fixed irq allocation bug.
102 (request_irq moved from probe to open)
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>
109 0.31 28.08-98 Media interface port can now be selected
110 with module parameters or kernel
113 0.32 31.08-98 IRQ was never freed if open/close
114 pair wasn't called. Now fixed.
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
121 0.34 29.06-99 Fixed one bad #ifdef.
122 Changed ioaddr -> io for consistency
124 0.35 01.07-99 transmit,-receive bytes were never
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).
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.
145 static char *version
=
146 "eth16i.c: v0.35 01-Jul-1999 Mika Kuoppala (miku@iki.fi)\n";
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>
167 #include <asm/system.h>
173 #define BITSET(ioaddr, bnum) ((outb(((inb(ioaddr)) | (bnum)), ioaddr)))
174 #define BITCLR(ioaddr, bnum) ((outb(((inb(ioaddr)) & (~(bnum))), ioaddr)))
176 /* This is the I/O address space for Etherteam 16i adapter. */
177 #define ETH16I_IO_EXTENT 32
179 /* Ticks before deciding that transmit has timed out */
180 #define TX_TIMEOUT (400*HZ/1000)
182 /* Maximum loop count when receiving packets */
183 #define MAX_RX_LOOP 20
185 /* Some interrupt masks */
186 #define ETH16I_INTR_ON 0xef8a /* Higher is receive mask */
187 #define ETH16I_INTR_OFF 0x0000
189 /* Buffers header status byte meanings */
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)
197 /* Transmit status register (DLCR0) */
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)
207 /* Receive status register (DLCR1) */
208 #define RX_STATUS_REG 1
209 #define RX_PKT BIT(7) /* Packet received */
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)
216 /* Transmit Interrupt Enable Register (DLCR2) */
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)
222 /* Receive Interrupt Enable Register (DLCR3) */
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)
229 /* Transmit Mode Register (DLCR4) */
230 #define TRANSMIT_MODE_REG 4
231 #define LOOPBACK_CONTROL BIT(1)
232 #define CONTROL_OUTPUT BIT(2)
234 /* Receive Mode Register (DLCR5) */
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)
242 #define ADDRESS_FILTER_MODE BIT(1) | BIT(0)
245 #define MODE_1 1 /* NODE ID, BC, MC, 2-24th bit */
246 #define MODE_2 2 /* NODE ID, BC, MC, Hash Table */
248 /* Configuration Register 0 (DLCR6) */
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) /* 1 = 8bit, 0 = 16bit */
253 #define BUFFER_WIDTH_8 BIT(4) /* 1 = 8bit, 0 = 16bit */
256 #define SRAM_BS1 BIT(1) /* 00=8kb, 01=16kb */
257 #define SRAM_BS0 BIT(0) /* 10=32kb, 11=64kb */
259 #ifndef ETH16I_TX_BUF_SIZE /* 0 = 2kb, 1 = 4kb */
260 #define ETH16I_TX_BUF_SIZE 3 /* 2 = 8kb, 3 = 16kb */
262 #define TX_BUF_1x2048 0
263 #define TX_BUF_2x2048 1
264 #define TX_BUF_2x4098 2
265 #define TX_BUF_2x8192 3
267 /* Configuration Register 1 (DLCR7) */
268 #define CONFIG_REG_1 7
269 #define POWERUP BIT(5)
271 /* Transmit start register */
272 #define TRANSMIT_START_REG 10
273 #define TRANSMIT_START_RB 2
274 #define TX_START BIT(7) /* Rest of register bit indicate*/
275 /* number of packets in tx buffer*/
276 /* Node ID registers (DLCR8-13) */
280 /* Hash Table registers (HT8-15) */
281 #define HASH_TABLE_0 8
282 #define HASH_TABLE_RB 1
284 /* Buffer memory ports */
285 #define BUFFER_MEM_PORT_LB 8
286 #define DATAPORT BUFFER_MEM_PORT_LB
287 #define BUFFER_MEM_PORT_HB 9
289 /* 16 Collision control register (BMPR11) */
290 #define COL_16_REG 11
291 #define HALT_ON_16 0x00
292 #define RETRANS_AND_HALT_ON_16 0x02
294 /* Maximum number of attempts to send after 16 concecutive collisions */
295 #define MAX_COL_16 10
297 /* DMA Burst and Transceiver Mode Register (BMPR13) */
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)
306 /* Filter Self Receive Register (BMPR14) */
307 #define FILTER_SELF_RX_REG 14
308 #define SKIP_RX_PACKET BIT(2)
309 #define FILTER_SELF_RECEIVE BIT(0)
311 /* EEPROM Control Register (BMPR 16) */
312 #define EEPROM_CTRL_REG 16
314 /* EEPROM Data Register (BMPR 17) */
315 #define EEPROM_DATA_REG 17
317 /* NMC93CSx6 EEPROM Control Bits */
325 /* NMC93CSx6 EEPROM Instructions */
326 #define EEPROM_READ 0x80
328 /* NMC93CSx6 EEPROM Addresses */
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
341 /* Macro to slow down io between EEPROM clock transitions */
342 #define eeprom_slow_io() do { int _i = 40; while(--_i > 0) { inb(0x80); }}while(0)
344 /* Jumperless Configuration Register (BMPR19) */
345 #define JUMPERLESS_CONFIG 19
347 /* ID ROM registers, writing to them also resets some parts of chip */
350 #define RESET ID_ROM_0
352 /* This is the I/O address list to be probed when seeking the card */
353 static unsigned int eth16i_portlist
[] __initdata
= {
354 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
357 static unsigned int eth32i_portlist
[] __initdata
= {
358 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 0x8000,
359 0x9000, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0
362 /* This is the Interrupt lookup table for Eth16i card */
363 static unsigned int eth16i_irqmap
[] __initdata
= { 9, 10, 5, 15, 0 };
364 #define NUM_OF_ISA_IRQS 4
366 /* This is the Interrupt lookup table for Eth32i card */
367 static 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
371 static unsigned int eth16i_tx_buf_map
[] = { 2048, 2048, 4096, 8192 };
373 /* Use 0 for production, 1 for verification, >2 for debug */
375 #define ETH16I_DEBUG 0
377 static unsigned int eth16i_debug
= ETH16I_DEBUG
;
379 /* Information for each board */
381 struct eth16i_local
{
382 unsigned char tx_started
;
383 unsigned char tx_buf_busy
;
384 unsigned short tx_queue
; /* Number of packets in transmit buffer */
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
;
394 /* Function prototypes */
396 static int eth16i_probe1(struct net_device
*dev
, int ioaddr
);
397 static int eth16i_check_signature(int ioaddr
);
398 static int eth16i_probe_port(int ioaddr
);
399 static void eth16i_set_port(int ioaddr
, int porttype
);
400 static int eth16i_send_probe_packet(int ioaddr
, unsigned char *b
, int l
);
401 static int eth16i_receive_probe_packet(int ioaddr
);
402 static int eth16i_get_irq(int ioaddr
);
403 static int eth16i_read_eeprom(int ioaddr
, int offset
);
404 static int eth16i_read_eeprom_word(int ioaddr
);
405 static void eth16i_eeprom_cmd(int ioaddr
, unsigned char command
);
406 static int eth16i_open(struct net_device
*dev
);
407 static int eth16i_close(struct net_device
*dev
);
408 static int eth16i_tx(struct sk_buff
*skb
, struct net_device
*dev
);
409 static void eth16i_rx(struct net_device
*dev
);
410 static void eth16i_timeout(struct net_device
*dev
);
411 static irqreturn_t
eth16i_interrupt(int irq
, void *dev_id
);
412 static void eth16i_reset(struct net_device
*dev
);
413 static void eth16i_timeout(struct net_device
*dev
);
414 static void eth16i_skip_packet(struct net_device
*dev
);
415 static void eth16i_multicast(struct net_device
*dev
);
416 static void eth16i_select_regbank(unsigned char regbank
, int ioaddr
);
417 static void eth16i_initialize(struct net_device
*dev
, int boot
);
420 static int eth16i_set_irq(struct net_device
*dev
);
424 static ushort
eth16i_parse_mediatype(const char* s
);
427 static char cardname
[] __initdata
= "ICL EtherTeam 16i/32";
429 static int __init
do_eth16i_probe(struct net_device
*dev
)
433 int base_addr
= dev
->base_addr
;
436 printk(KERN_DEBUG
"Probing started for %s\n", cardname
);
438 if(base_addr
> 0x1ff) /* Check only single location */
439 return eth16i_probe1(dev
, base_addr
);
440 else if(base_addr
!= 0) /* Don't probe at all */
443 /* Seek card from the ISA io address space */
444 for(i
= 0; (ioaddr
= eth16i_portlist
[i
]) ; i
++)
445 if(eth16i_probe1(dev
, ioaddr
) == 0)
448 /* Seek card from the EISA io address space */
449 for(i
= 0; (ioaddr
= eth32i_portlist
[i
]) ; i
++)
450 if(eth16i_probe1(dev
, ioaddr
) == 0)
457 struct net_device
* __init
eth16i_probe(int unit
)
459 struct net_device
*dev
= alloc_etherdev(sizeof(struct eth16i_local
));
463 return ERR_PTR(-ENOMEM
);
465 sprintf(dev
->name
, "eth%d", unit
);
466 netdev_boot_setup_check(dev
);
468 err
= do_eth16i_probe(dev
);
478 static int __init
eth16i_probe1(struct net_device
*dev
, int ioaddr
)
480 struct eth16i_local
*lp
= netdev_priv(dev
);
481 static unsigned version_printed
;
484 /* Let's grab the region */
485 if (!request_region(ioaddr
, ETH16I_IO_EXTENT
, cardname
))
489 The MB86985 chip has on register which holds information in which
490 io address the chip lies. First read this register and compare
491 it to our current io address and if match then this could
495 if(ioaddr
< 0x1000) {
496 if(eth16i_portlist
[(inb(ioaddr
+ JUMPERLESS_CONFIG
) & 0x07)]
503 /* Now we will go a bit deeper and try to find the chip's signature */
505 if(eth16i_check_signature(ioaddr
) != 0) {
511 Now it seems that we have found a ethernet chip in this particular
512 ioaddr. The MB86985 chip has this feature, that when you read a
513 certain register it will increase it's io base address to next
514 configurable slot. Now when we have found the chip, first thing is
515 to make sure that the chip's ioaddr will hold still here.
518 eth16i_select_regbank(TRANSCEIVER_MODE_RB
, ioaddr
);
519 outb(0x00, ioaddr
+ TRANSCEIVER_MODE_REG
);
521 outb(0x00, ioaddr
+ RESET
); /* Reset some parts of chip */
522 BITSET(ioaddr
+ CONFIG_REG_0
, BIT(7)); /* Disable the data link */
524 if( (eth16i_debug
& version_printed
++) == 0)
525 printk(KERN_INFO
"%s", version
);
527 dev
->base_addr
= ioaddr
;
528 dev
->irq
= eth16i_get_irq(ioaddr
);
530 /* Try to obtain interrupt vector */
532 if ((retval
= request_irq(dev
->irq
, (void *)ð16i_interrupt
, 0, cardname
, dev
))) {
533 printk(KERN_WARNING
"%s at %#3x, but is unusable due to conflicting IRQ %d.\n",
534 cardname
, ioaddr
, dev
->irq
);
538 printk(KERN_INFO
"%s: %s at %#3x, IRQ %d, ",
539 dev
->name
, cardname
, ioaddr
, dev
->irq
);
542 /* Now we will have to lock the chip's io address */
543 eth16i_select_regbank(TRANSCEIVER_MODE_RB
, ioaddr
);
544 outb(0x38, ioaddr
+ TRANSCEIVER_MODE_REG
);
546 eth16i_initialize(dev
, 1); /* Initialize rest of the chip's registers */
548 /* Now let's same some energy by shutting down the chip ;) */
549 BITCLR(ioaddr
+ CONFIG_REG_1
, POWERUP
);
551 /* Initialize the device structure */
552 memset(lp
, 0, sizeof(struct eth16i_local
));
553 dev
->open
= eth16i_open
;
554 dev
->stop
= eth16i_close
;
555 dev
->hard_start_xmit
= eth16i_tx
;
556 dev
->set_multicast_list
= eth16i_multicast
;
557 dev
->tx_timeout
= eth16i_timeout
;
558 dev
->watchdog_timeo
= TX_TIMEOUT
;
559 spin_lock_init(&lp
->lock
);
561 retval
= register_netdev(dev
);
566 free_irq(dev
->irq
, dev
);
568 release_region(ioaddr
, ETH16I_IO_EXTENT
);
573 static void eth16i_initialize(struct net_device
*dev
, int boot
)
575 int ioaddr
= dev
->base_addr
;
577 unsigned char node_byte
= 0;
579 /* Setup station address */
580 eth16i_select_regbank(NODE_ID_RB
, ioaddr
);
581 for(i
= 0 ; i
< 3 ; i
++) {
582 unsigned short node_val
= eth16i_read_eeprom(ioaddr
, E_NODEID_0
+ i
);
583 ((unsigned short *)dev
->dev_addr
)[i
] = ntohs(node_val
);
586 for(i
= 0; i
< 6; i
++) {
587 outb( ((unsigned char *)dev
->dev_addr
)[i
], ioaddr
+ NODE_ID_0
+ i
);
589 printk("%02x", inb(ioaddr
+ NODE_ID_0
+ i
));
595 /* Now we will set multicast addresses to accept none */
596 eth16i_select_regbank(HASH_TABLE_RB
, ioaddr
);
597 for(i
= 0; i
< 8; i
++)
598 outb(0x00, ioaddr
+ HASH_TABLE_0
+ i
);
601 Now let's disable the transmitter and receiver, set the buffer ram
602 cycle time, bus width and buffer data path width. Also we shall
603 set transmit buffer size and total buffer size.
606 eth16i_select_regbank(2, ioaddr
);
609 node_w
= eth16i_read_eeprom(ioaddr
, E_PRODUCT_CFG
);
611 if( (node_w
& 0xFF00) == 0x0800)
612 node_byte
|= BUFFER_WIDTH_8
;
614 node_byte
|= SRAM_BS1
;
616 if( (node_w
& 0x00FF) == 64)
617 node_byte
|= SRAM_BS0
;
619 node_byte
|= DLC_EN
| SRAM_CYCLE_TIME_100NS
| (ETH16I_TX_BUF_SIZE
<< 2);
621 outb(node_byte
, ioaddr
+ CONFIG_REG_0
);
623 /* We shall halt the transmitting, if 16 collisions are detected */
624 outb(HALT_ON_16
, ioaddr
+ COL_16_REG
);
627 /* if_port already set by init_module() */
629 dev
->if_port
= (dev
->mem_start
< E_PORT_FROM_EPROM
) ?
630 dev
->mem_start
: E_PORT_FROM_EPROM
;
633 /* Set interface port type */
635 char *porttype
[] = {"BNC", "DIX", "TP", "AUTO", "FROM_EPROM" };
640 case E_PORT_FROM_EPROM
:
641 dev
->if_port
= eth16i_read_eeprom(ioaddr
, E_PORT_SELECT
);
645 dev
->if_port
= eth16i_probe_port(ioaddr
);
654 printk(" %s interface.\n", porttype
[dev
->if_port
]);
656 eth16i_set_port(ioaddr
, dev
->if_port
);
659 /* Set Receive Mode to normal operation */
660 outb(MODE_2
, ioaddr
+ RECEIVE_MODE_REG
);
663 static int eth16i_probe_port(int ioaddr
)
667 unsigned char dummy_packet
[64];
669 /* Powerup the chip */
670 outb(0xc0 | POWERUP
, ioaddr
+ CONFIG_REG_1
);
672 BITSET(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
674 eth16i_select_regbank(NODE_ID_RB
, ioaddr
);
676 for(i
= 0; i
< 6; i
++) {
677 dummy_packet
[i
] = inb(ioaddr
+ NODE_ID_0
+ i
);
678 dummy_packet
[i
+6] = inb(ioaddr
+ NODE_ID_0
+ i
);
681 dummy_packet
[12] = 0x00;
682 dummy_packet
[13] = 0x04;
683 memset(dummy_packet
+ 14, 0, sizeof(dummy_packet
) - 14);
685 eth16i_select_regbank(2, ioaddr
);
687 for(i
= 0; i
< 3; i
++) {
688 BITSET(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
689 BITCLR(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
690 eth16i_set_port(ioaddr
, i
);
693 printk(KERN_DEBUG
"Set port number %d\n", i
);
695 retcode
= eth16i_send_probe_packet(ioaddr
, dummy_packet
, 64);
697 retcode
= eth16i_receive_probe_packet(ioaddr
);
700 printk(KERN_DEBUG
"Eth16i interface port found at %d\n", i
);
706 printk(KERN_DEBUG
"TRANSMIT_DONE timeout when probing interface port\n");
710 if( eth16i_debug
> 1)
711 printk(KERN_DEBUG
"Using default port\n");
716 static void eth16i_set_port(int ioaddr
, int porttype
)
718 unsigned short temp
= 0;
720 eth16i_select_regbank(TRANSCEIVER_MODE_RB
, ioaddr
);
721 outb(LOOPBACK_CONTROL
, ioaddr
+ TRANSMIT_MODE_REG
);
723 temp
|= DIS_AUTO_PORT_SEL
;
736 BITSET(ioaddr
+ TRANSMIT_MODE_REG
, CONTROL_OUTPUT
);
740 outb(temp
, ioaddr
+ TRANSCEIVER_MODE_REG
);
742 if(eth16i_debug
> 1) {
743 printk(KERN_DEBUG
"TRANSMIT_MODE_REG = %x\n", inb(ioaddr
+ TRANSMIT_MODE_REG
));
744 printk(KERN_DEBUG
"TRANSCEIVER_MODE_REG = %x\n",
745 inb(ioaddr
+TRANSCEIVER_MODE_REG
));
749 static int eth16i_send_probe_packet(int ioaddr
, unsigned char *b
, int l
)
751 unsigned long starttime
;
753 outb(0xff, ioaddr
+ TX_STATUS_REG
);
755 outw(l
, ioaddr
+ DATAPORT
);
756 outsw(ioaddr
+ DATAPORT
, (unsigned short *)b
, (l
+ 1) >> 1);
759 outb(TX_START
| 1, ioaddr
+ TRANSMIT_START_REG
);
761 while( (inb(ioaddr
+ TX_STATUS_REG
) & 0x80) == 0) {
762 if( time_after(jiffies
, starttime
+ TX_TIMEOUT
)) {
770 static int eth16i_receive_probe_packet(int ioaddr
)
772 unsigned long starttime
;
776 while((inb(ioaddr
+ TX_STATUS_REG
) & 0x20) == 0) {
777 if( time_after(jiffies
, starttime
+ TX_TIMEOUT
)) {
780 printk(KERN_DEBUG
"Timeout occurred waiting transmit packet received\n");
782 while((inb(ioaddr
+ RX_STATUS_REG
) & 0x80) == 0) {
783 if( time_after(jiffies
, starttime
+ TX_TIMEOUT
)) {
785 printk(KERN_DEBUG
"Timeout occurred waiting receive packet\n");
791 printk(KERN_DEBUG
"RECEIVE_PACKET\n");
792 return(0); /* Found receive packet */
796 if(eth16i_debug
> 1) {
797 printk(KERN_DEBUG
"TRANSMIT_PACKET_RECEIVED %x\n", inb(ioaddr
+ TX_STATUS_REG
));
798 printk(KERN_DEBUG
"RX_STATUS_REG = %x\n", inb(ioaddr
+ RX_STATUS_REG
));
801 return(0); /* Return success */
805 static int eth16i_set_irq(struct net_device
* dev
)
807 const int ioaddr
= dev
->base_addr
;
808 const int irq
= dev
->irq
;
811 if(ioaddr
< 0x1000) {
812 while(eth16i_irqmap
[i
] && eth16i_irqmap
[i
] != irq
)
815 if(i
< NUM_OF_ISA_IRQS
) {
816 u8 cbyte
= inb(ioaddr
+ JUMPERLESS_CONFIG
);
817 cbyte
= (cbyte
& 0x3F) | (i
<< 6);
818 outb(cbyte
, ioaddr
+ JUMPERLESS_CONFIG
);
823 printk(KERN_NOTICE
"%s: EISA Interrupt cannot be set. Use EISA Configuration utility.\n", dev
->name
);
831 static int __init
eth16i_get_irq(int ioaddr
)
835 if( ioaddr
< 0x1000) {
836 cbyte
= inb(ioaddr
+ JUMPERLESS_CONFIG
);
837 return( eth16i_irqmap
[ ((cbyte
& 0xC0) >> 6) ] );
838 } else { /* Oh..the card is EISA so method getting IRQ different */
839 unsigned short index
= 0;
840 cbyte
= inb(ioaddr
+ EISA_IRQ_REG
);
841 while( (cbyte
& 0x01) == 0) {
845 return( eth32i_irqmap
[ index
] );
849 static int __init
eth16i_check_signature(int ioaddr
)
852 unsigned char creg
[4] = { 0 };
854 for(i
= 0; i
< 4 ; i
++) {
856 creg
[i
] = inb(ioaddr
+ TRANSMIT_MODE_REG
+ i
);
859 printk("eth16i: read signature byte %x at %x\n",
861 ioaddr
+ TRANSMIT_MODE_REG
+ i
);
864 creg
[0] &= 0x0F; /* Mask collision cnr */
865 creg
[2] &= 0x7F; /* Mask DCLEN bit */
869 This was removed because the card was sometimes left to state
870 from which it couldn't be find anymore. If there is need
871 to more strict check still this have to be fixed.
873 if( ! ((creg
[0] == 0x06) && (creg
[1] == 0x41)) ) {
879 if( !((creg
[2] == 0x36) && (creg
[3] == 0xE0)) ) {
883 if( !((creg
[2] == 0x40) && (creg
[3] == 0x00)) )
887 if(eth16i_read_eeprom(ioaddr
, E_NODEID_0
) != 0)
890 if((eth16i_read_eeprom(ioaddr
, E_NODEID_1
) & 0xFF00) != 0x4B00)
896 static int eth16i_read_eeprom(int ioaddr
, int offset
)
900 eth16i_eeprom_cmd(ioaddr
, EEPROM_READ
| offset
);
901 outb(CS_1
, ioaddr
+ EEPROM_CTRL_REG
);
902 data
= eth16i_read_eeprom_word(ioaddr
);
903 outb(CS_0
| SK_0
, ioaddr
+ EEPROM_CTRL_REG
);
908 static int eth16i_read_eeprom_word(int ioaddr
)
913 for(i
= 16; i
> 0; i
--) {
914 outb(CS_1
| SK_0
, ioaddr
+ EEPROM_CTRL_REG
);
916 outb(CS_1
| SK_1
, ioaddr
+ EEPROM_CTRL_REG
);
919 ((inb(ioaddr
+ EEPROM_DATA_REG
) & DI_1
) ? 1 : 0);
927 static void eth16i_eeprom_cmd(int ioaddr
, unsigned char command
)
931 outb(CS_0
| SK_0
, ioaddr
+ EEPROM_CTRL_REG
);
932 outb(DI_0
, ioaddr
+ EEPROM_DATA_REG
);
933 outb(CS_1
| SK_0
, ioaddr
+ EEPROM_CTRL_REG
);
934 outb(DI_1
, ioaddr
+ EEPROM_DATA_REG
);
935 outb(CS_1
| SK_1
, ioaddr
+ EEPROM_CTRL_REG
);
937 for(i
= 7; i
>= 0; i
--) {
938 short cmd
= ( (command
& (1 << i
)) ? DI_1
: DI_0
);
939 outb(cmd
, ioaddr
+ EEPROM_DATA_REG
);
940 outb(CS_1
| SK_0
, ioaddr
+ EEPROM_CTRL_REG
);
942 outb(CS_1
| SK_1
, ioaddr
+ EEPROM_CTRL_REG
);
947 static int eth16i_open(struct net_device
*dev
)
949 struct eth16i_local
*lp
= netdev_priv(dev
);
950 int ioaddr
= dev
->base_addr
;
952 /* Powerup the chip */
953 outb(0xc0 | POWERUP
, ioaddr
+ CONFIG_REG_1
);
955 /* Initialize the chip */
956 eth16i_initialize(dev
, 0);
958 /* Set the transmit buffer size */
959 lp
->tx_buf_size
= eth16i_tx_buf_map
[ETH16I_TX_BUF_SIZE
& 0x03];
962 printk(KERN_DEBUG
"%s: transmit buffer size %d\n",
963 dev
->name
, lp
->tx_buf_size
);
965 /* Now enable Transmitter and Receiver sections */
966 BITCLR(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
968 /* Now switch to register bank 2, for run time operation */
969 eth16i_select_regbank(2, ioaddr
);
971 lp
->open_time
= jiffies
;
974 lp
->tx_queue_len
= 0;
976 /* Turn on interrupts*/
977 outw(ETH16I_INTR_ON
, ioaddr
+ TX_INTR_REG
);
979 netif_start_queue(dev
);
983 static int eth16i_close(struct net_device
*dev
)
985 struct eth16i_local
*lp
= netdev_priv(dev
);
986 int ioaddr
= dev
->base_addr
;
990 /* Turn off interrupts*/
991 outw(ETH16I_INTR_OFF
, ioaddr
+ TX_INTR_REG
);
993 netif_stop_queue(dev
);
997 /* Disable transmit and receive */
998 BITSET(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
1000 /* Reset the chip */
1001 /* outb(0xff, ioaddr + RESET); */
1002 /* outw(0xffff, ioaddr + TX_STATUS_REG); */
1004 outb(0x00, ioaddr
+ CONFIG_REG_1
);
1009 static void eth16i_timeout(struct net_device
*dev
)
1011 struct eth16i_local
*lp
= netdev_priv(dev
);
1012 int ioaddr
= dev
->base_addr
;
1014 If we get here, some higher level has decided that
1015 we are broken. There should really be a "kick me"
1016 function call instead.
1019 outw(ETH16I_INTR_OFF
, ioaddr
+ TX_INTR_REG
);
1020 printk(KERN_WARNING
"%s: transmit timed out with status %04x, %s ?\n",
1022 inw(ioaddr
+ TX_STATUS_REG
), (inb(ioaddr
+ TX_STATUS_REG
) & TX_DONE
) ?
1023 "IRQ conflict" : "network cable problem");
1025 dev
->trans_start
= jiffies
;
1027 /* Let's dump all registers */
1028 if(eth16i_debug
> 0) {
1029 printk(KERN_DEBUG
"%s: timeout: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
1030 dev
->name
, inb(ioaddr
+ 0),
1031 inb(ioaddr
+ 1), inb(ioaddr
+ 2),
1032 inb(ioaddr
+ 3), inb(ioaddr
+ 4),
1034 inb(ioaddr
+ 6), inb(ioaddr
+ 7));
1036 printk(KERN_DEBUG
"%s: transmit start reg: %02x. collision reg %02x\n",
1037 dev
->name
, inb(ioaddr
+ TRANSMIT_START_REG
),
1038 inb(ioaddr
+ COL_16_REG
));
1039 printk(KERN_DEBUG
"lp->tx_queue = %d\n", lp
->tx_queue
);
1040 printk(KERN_DEBUG
"lp->tx_queue_len = %d\n", lp
->tx_queue_len
);
1041 printk(KERN_DEBUG
"lp->tx_started = %d\n", lp
->tx_started
);
1043 dev
->stats
.tx_errors
++;
1045 dev
->trans_start
= jiffies
;
1046 outw(ETH16I_INTR_ON
, ioaddr
+ TX_INTR_REG
);
1047 netif_wake_queue(dev
);
1050 static int eth16i_tx(struct sk_buff
*skb
, struct net_device
*dev
)
1052 struct eth16i_local
*lp
= netdev_priv(dev
);
1053 int ioaddr
= dev
->base_addr
;
1055 ushort length
= skb
->len
;
1057 unsigned long flags
;
1059 if (length
< ETH_ZLEN
) {
1060 if (skb_padto(skb
, ETH_ZLEN
))
1066 netif_stop_queue(dev
);
1068 /* Turn off TX interrupts */
1069 outw(ETH16I_INTR_OFF
, ioaddr
+ TX_INTR_REG
);
1071 /* We would be better doing the disable_irq tricks the 3c509 does,
1072 that would make this suck a lot less */
1074 spin_lock_irqsave(&lp
->lock
, flags
);
1076 if( (length
+ 2) > (lp
->tx_buf_size
- lp
->tx_queue_len
)) {
1077 if(eth16i_debug
> 0)
1078 printk(KERN_WARNING
"%s: Transmit buffer full.\n", dev
->name
);
1081 outw(length
, ioaddr
+ DATAPORT
);
1083 if( ioaddr
< 0x1000 )
1084 outsw(ioaddr
+ DATAPORT
, buf
, (length
+ 1) >> 1);
1086 unsigned char frag
= length
% 4;
1087 outsl(ioaddr
+ DATAPORT
, buf
, length
>> 2);
1089 outsw(ioaddr
+ DATAPORT
, (buf
+ (length
& 0xFFFC)), 1);
1091 outsw(ioaddr
+ DATAPORT
,
1092 (buf
+ (length
& 0xFFFC) + 2), 1);
1095 lp
->tx_buffered_packets
++;
1096 lp
->tx_buffered_bytes
= length
;
1098 lp
->tx_queue_len
+= length
+ 2;
1100 lp
->tx_buf_busy
= 0;
1102 if(lp
->tx_started
== 0) {
1103 /* If the transmitter is idle..always trigger a transmit */
1104 outb(TX_START
| lp
->tx_queue
, ioaddr
+ TRANSMIT_START_REG
);
1106 lp
->tx_queue_len
= 0;
1107 dev
->trans_start
= jiffies
;
1109 netif_wake_queue(dev
);
1111 else if(lp
->tx_queue_len
< lp
->tx_buf_size
- (ETH_FRAME_LEN
+ 2)) {
1112 /* There is still more room for one more packet in tx buffer */
1113 netif_wake_queue(dev
);
1116 spin_unlock_irqrestore(&lp
->lock
, flags
);
1118 outw(ETH16I_INTR_ON
, ioaddr
+ TX_INTR_REG
);
1119 /* Turn TX interrupts back on */
1120 /* outb(TX_INTR_DONE | TX_INTR_16_COL, ioaddr + TX_INTR_REG); */
1126 static void eth16i_rx(struct net_device
*dev
)
1128 int ioaddr
= dev
->base_addr
;
1129 int boguscount
= MAX_RX_LOOP
;
1131 /* Loop until all packets have been read */
1132 while( (inb(ioaddr
+ RECEIVE_MODE_REG
) & RX_BUFFER_EMPTY
) == 0) {
1134 /* Read status byte from receive buffer */
1135 ushort status
= inw(ioaddr
+ DATAPORT
);
1137 /* Get the size of the packet from receive buffer */
1138 ushort pkt_len
= inw(ioaddr
+ DATAPORT
);
1140 if(eth16i_debug
> 4)
1141 printk(KERN_DEBUG
"%s: Receiving packet mode %02x status %04x.\n",
1143 inb(ioaddr
+ RECEIVE_MODE_REG
), status
);
1145 if( !(status
& PKT_GOOD
) ) {
1146 dev
->stats
.rx_errors
++;
1148 if( (pkt_len
< ETH_ZLEN
) || (pkt_len
> ETH_FRAME_LEN
) ) {
1149 dev
->stats
.rx_length_errors
++;
1154 eth16i_skip_packet(dev
);
1155 dev
->stats
.rx_dropped
++;
1158 else { /* Ok so now we should have a good packet */
1159 struct sk_buff
*skb
;
1161 skb
= dev_alloc_skb(pkt_len
+ 3);
1163 printk(KERN_WARNING
"%s: Could'n allocate memory for packet (len %d)\n",
1164 dev
->name
, pkt_len
);
1165 eth16i_skip_packet(dev
);
1166 dev
->stats
.rx_dropped
++;
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.
1179 insw(ioaddr
+ DATAPORT
, skb_put(skb
, pkt_len
),
1180 (pkt_len
+ 1) >> 1);
1182 unsigned char *buf
= skb_put(skb
, pkt_len
);
1183 unsigned char frag
= pkt_len
% 4;
1185 insl(ioaddr
+ DATAPORT
, buf
, pkt_len
>> 2);
1188 unsigned short rest
[2];
1189 rest
[0] = inw( ioaddr
+ DATAPORT
);
1191 rest
[1] = inw( ioaddr
+ DATAPORT
);
1193 memcpy(buf
+ (pkt_len
& 0xfffc), (char *)rest
, frag
);
1197 skb
->protocol
=eth_type_trans(skb
, dev
);
1199 if( eth16i_debug
> 5 ) {
1201 printk(KERN_DEBUG
"%s: Received packet of length %d.\n",
1202 dev
->name
, pkt_len
);
1203 for(i
= 0; i
< 14; i
++)
1204 printk(KERN_DEBUG
" %02x", skb
->data
[i
]);
1205 printk(KERN_DEBUG
".\n");
1208 dev
->stats
.rx_packets
++;
1209 dev
->stats
.rx_bytes
+= pkt_len
;
1213 if(--boguscount
<= 0)
1219 static irqreturn_t
eth16i_interrupt(int irq
, void *dev_id
)
1221 struct net_device
*dev
= dev_id
;
1222 struct eth16i_local
*lp
;
1223 int ioaddr
= 0, status
;
1226 ioaddr
= dev
->base_addr
;
1227 lp
= netdev_priv(dev
);
1229 /* Turn off all interrupts from adapter */
1230 outw(ETH16I_INTR_OFF
, ioaddr
+ TX_INTR_REG
);
1232 /* eth16i_tx won't be called */
1233 spin_lock(&lp
->lock
);
1235 status
= inw(ioaddr
+ TX_STATUS_REG
); /* Get the status */
1236 outw(status
, ioaddr
+ TX_STATUS_REG
); /* Clear status bits */
1241 if(eth16i_debug
> 3)
1242 printk(KERN_DEBUG
"%s: Interrupt with status %04x.\n", dev
->name
, status
);
1244 if( status
& 0x7f00 ) {
1246 dev
->stats
.rx_errors
++;
1248 if(status
& (BUS_RD_ERR
<< 8) )
1249 printk(KERN_WARNING
"%s: Bus read error.\n",dev
->name
);
1250 if(status
& (SHORT_PKT_ERR
<< 8) ) dev
->stats
.rx_length_errors
++;
1251 if(status
& (ALIGN_ERR
<< 8) ) dev
->stats
.rx_frame_errors
++;
1252 if(status
& (CRC_ERR
<< 8) ) dev
->stats
.rx_crc_errors
++;
1253 if(status
& (RX_BUF_OVERFLOW
<< 8) ) dev
->stats
.rx_over_errors
++;
1255 if( status
& 0x001a) {
1257 dev
->stats
.tx_errors
++;
1259 if(status
& CR_LOST
) dev
->stats
.tx_carrier_errors
++;
1260 if(status
& TX_JABBER_ERR
) dev
->stats
.tx_window_errors
++;
1263 if(status
& COLLISION
) {
1264 dev
->stats
.collisions
+=
1265 ((inb(ioaddr
+TRANSMIT_MODE_REG
) & 0xF0) >> 4);
1268 if(status
& COLLISIONS_16
) {
1269 if(lp
->col_16
< MAX_COL_16
) {
1271 dev
->stats
.collisions
++;
1272 /* Resume transmitting, skip failed packet */
1273 outb(0x02, ioaddr
+ COL_16_REG
);
1276 printk(KERN_WARNING
"%s: bailing out due to many consecutive 16-in-a-row collisions. Network cable problem?\n", dev
->name
);
1281 if( status
& 0x00ff ) { /* Let's check the transmit status reg */
1283 if(status
& TX_DONE
) { /* The transmit has been done */
1284 dev
->stats
.tx_packets
= lp
->tx_buffered_packets
;
1285 dev
->stats
.tx_bytes
+= lp
->tx_buffered_bytes
;
1288 if(lp
->tx_queue
) { /* Is there still packets ? */
1289 /* There was packet(s) so start transmitting and write also
1290 how many packets there is to be sended */
1291 outb(TX_START
| lp
->tx_queue
, ioaddr
+ TRANSMIT_START_REG
);
1293 lp
->tx_queue_len
= 0;
1299 netif_wake_queue(dev
);
1303 if( ( status
& 0x8000 ) ||
1304 ( (inb(ioaddr
+ RECEIVE_MODE_REG
) & RX_BUFFER_EMPTY
) == 0) ) {
1305 eth16i_rx(dev
); /* We have packet in receive buffer */
1308 /* Turn interrupts back on */
1309 outw(ETH16I_INTR_ON
, ioaddr
+ TX_INTR_REG
);
1311 if(lp
->tx_queue_len
< lp
->tx_buf_size
- (ETH_FRAME_LEN
+ 2)) {
1312 /* There is still more room for one more packet in tx buffer */
1313 netif_wake_queue(dev
);
1316 spin_unlock(&lp
->lock
);
1318 return IRQ_RETVAL(handled
);
1321 static void eth16i_skip_packet(struct net_device
*dev
)
1323 int ioaddr
= dev
->base_addr
;
1325 inw(ioaddr
+ DATAPORT
);
1326 inw(ioaddr
+ DATAPORT
);
1327 inw(ioaddr
+ DATAPORT
);
1329 outb(SKIP_RX_PACKET
, ioaddr
+ FILTER_SELF_RX_REG
);
1330 while( inb( ioaddr
+ FILTER_SELF_RX_REG
) != 0);
1333 static void eth16i_reset(struct net_device
*dev
)
1335 struct eth16i_local
*lp
= netdev_priv(dev
);
1336 int ioaddr
= dev
->base_addr
;
1338 if(eth16i_debug
> 1)
1339 printk(KERN_DEBUG
"%s: Resetting device.\n", dev
->name
);
1341 BITSET(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
1342 outw(0xffff, ioaddr
+ TX_STATUS_REG
);
1343 eth16i_select_regbank(2, ioaddr
);
1346 lp
->tx_buf_busy
= 0;
1348 lp
->tx_queue_len
= 0;
1349 BITCLR(ioaddr
+ CONFIG_REG_0
, DLC_EN
);
1352 static void eth16i_multicast(struct net_device
*dev
)
1354 int ioaddr
= dev
->base_addr
;
1356 if(dev
->mc_count
|| dev
->flags
&(IFF_ALLMULTI
|IFF_PROMISC
))
1358 outb(3, ioaddr
+ RECEIVE_MODE_REG
);
1360 outb(2, ioaddr
+ RECEIVE_MODE_REG
);
1364 static void eth16i_select_regbank(unsigned char banknbr
, int ioaddr
)
1368 data
= inb(ioaddr
+ CONFIG_REG_1
);
1369 outb( ((data
& 0xF3) | ( (banknbr
& 0x03) << 2)), ioaddr
+ CONFIG_REG_1
);
1374 static ushort
eth16i_parse_mediatype(const char* s
)
1377 return E_PORT_FROM_EPROM
;
1379 if (!strncmp(s
, "bnc", 3))
1381 else if (!strncmp(s
, "tp", 2))
1383 else if (!strncmp(s
, "dix", 3))
1385 else if (!strncmp(s
, "auto", 4))
1388 return E_PORT_FROM_EPROM
;
1391 #define MAX_ETH16I_CARDS 4 /* Max number of Eth16i cards per module */
1393 static struct net_device
*dev_eth16i
[MAX_ETH16I_CARDS
];
1394 static int io
[MAX_ETH16I_CARDS
];
1396 static int irq
[MAX_ETH16I_CARDS
];
1398 static char* mediatype
[MAX_ETH16I_CARDS
];
1399 static int debug
= -1;
1401 MODULE_AUTHOR("Mika Kuoppala <miku@iki.fi>");
1402 MODULE_DESCRIPTION("ICL EtherTeam 16i/32 driver");
1403 MODULE_LICENSE("GPL");
1406 module_param_array(io
, int, NULL
, 0);
1407 MODULE_PARM_DESC(io
, "eth16i I/O base address(es)");
1410 module_param_array(irq
, int, NULL
, 0);
1411 MODULE_PARM_DESC(irq
, "eth16i interrupt request number");
1414 module_param_array(mediatype
, charp
, NULL
, 0);
1415 MODULE_PARM_DESC(mediatype
, "eth16i media type of interface(s) (bnc,tp,dix,auto,eprom)");
1417 module_param(debug
, int, 0);
1418 MODULE_PARM_DESC(debug
, "eth16i debug level (0-6)");
1420 int __init
init_module(void)
1422 int this_dev
, found
= 0;
1423 struct net_device
*dev
;
1425 for (this_dev
= 0; this_dev
< MAX_ETH16I_CARDS
; this_dev
++) {
1426 dev
= alloc_etherdev(sizeof(struct eth16i_local
));
1430 dev
->base_addr
= io
[this_dev
];
1433 eth16i_debug
= debug
;
1435 if(eth16i_debug
> 1)
1436 printk(KERN_NOTICE
"eth16i(%d): interface type %s\n", this_dev
, mediatype
[this_dev
] ? mediatype
[this_dev
] : "none" );
1438 dev
->if_port
= eth16i_parse_mediatype(mediatype
[this_dev
]);
1440 if(io
[this_dev
] == 0) {
1441 if(this_dev
!= 0) /* Only autoprobe 1st one */
1444 printk(KERN_NOTICE
"eth16i.c: Presently autoprobing (not recommended) for a single card.\n");
1447 if (do_eth16i_probe(dev
) == 0) {
1448 dev_eth16i
[found
++] = dev
;
1451 printk(KERN_WARNING
"eth16i.c No Eth16i card found (i/o = 0x%x).\n",
1461 void __exit
cleanup_module(void)
1465 for(this_dev
= 0; this_dev
< MAX_ETH16I_CARDS
; this_dev
++) {
1466 struct net_device
*dev
= dev_eth16i
[this_dev
];
1468 if (netdev_priv(dev
)) {
1469 unregister_netdev(dev
);
1470 free_irq(dev
->irq
, dev
);
1471 release_region(dev
->base_addr
, ETH16I_IO_EXTENT
);
This page took 0.060698 seconds and 5 git commands to generate.