blob: 874973f558e92ee1b7ddc4fba185aecdc49f127a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* eth16i.c An ICL EtherTeam 16i and 32 EISA ethernet driver for Linux
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 Written 1994-1999 by Mika Kuoppala
Jeff Garzik6aa20a22006-09-13 13:24:59 -04004
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 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 General Public License, 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040015 - ICL EtherTeam 32 EISA
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 (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.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 Sources:
30 - skeleton.c a sample network driver core for linux,
31 written by Donald Becker <becker@scyld.com>
Jeff Garzik6aa20a22006-09-13 13:24:59 -040032 - at1700.c a driver for Allied Telesis AT1700, written
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 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.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040037
38 Author thanks following persons due to their valueble assistance:
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 Markku Viima (ICL)
Jeff Garzik6aa20a22006-09-13 13:24:59 -040040 Ari Valve (ICL)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 Donald Becker
42 Kurt Huwig <kurt@huwig.de>
43
44 Revision history:
45
46 Version Date Description
Jeff Garzik6aa20a22006-09-13 13:24:59 -040047
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040061 0.06 19.02-95 Rewrote interrupt handling
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 0.10 04.09-95 Fixed receive packet allocation to work
71 with kernels > 1.3.x
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Jeff Garzik6aa20a22006-09-13 13:24:59 -040073 0.20 20.09-95 Added support for EtherTeam32 EISA
74
75 0.21 17.10-95 Removed the unnecessary extern
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 init_etherdev() declaration. Some
77 other cleanups.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040078
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 0.22 22.02-96 Receive buffer was not flushed
80 correctly when faulty packet was
81 received. Now fixed.
82
Jeff Garzik6aa20a22006-09-13 13:24:59 -040083 0.23 26.02-96 Made resetting the adapter
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 more reliable.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040085
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040090 0.26 11.06-96 Sometimes card was not found by
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 check_signature(). Now made more reliable.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040092
93 0.27 23.06-96 Oops. 16 consecutive collisions halted
94 adapter. Now will try to retransmit
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 MAX_COL_16 times before finally giving up.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040096
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400106 to find the card. Suggested by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400111 boot parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400113 0.32 31.08-98 IRQ was never freed if open/close
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 pair wasn't called. Now fixed.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400125 updated in stats.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
127 Bugs:
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400128 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 configuration software for EtherTeam16i and EtherTeam32 cards.
132 This is also true for IRQ setting. You cannot use module
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400133 parameter to configure IRQ of the card (yet).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400145static char *version =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 "eth16i.c: v0.35 01-Jul-1999 Mika Kuoppala (miku@iki.fi)\n";
147
148#include <linux/module.h>
149#include <linux/kernel.h>
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400150#include <linux/types.h>
151#include <linux/fcntl.h>
152#include <linux/interrupt.h>
153#include <linux/ioport.h>
154#include <linux/in.h>
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400155#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156#include <linux/errno.h>
157#include <linux/init.h>
158#include <linux/spinlock.h>
159#include <linux/netdevice.h>
160#include <linux/etherdevice.h>
161#include <linux/skbuff.h>
162#include <linux/bitops.h>
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800163#include <linux/jiffies.h>
Matthew Wilcox53d5ed62006-10-11 01:22:01 -0700164#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400166#include <asm/system.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167#include <asm/dma.h>
168
169
170
171/* Few macros */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400172#define BITSET(ioaddr, bnum) ((outb(((inb(ioaddr)) | (bnum)), ioaddr)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173#define BITCLR(ioaddr, bnum) ((outb(((inb(ioaddr)) & (~(bnum))), ioaddr)))
174
175/* This is the I/O address space for Etherteam 16i adapter. */
176#define ETH16I_IO_EXTENT 32
177
178/* Ticks before deciding that transmit has timed out */
179#define TX_TIMEOUT (400*HZ/1000)
180
181/* Maximum loop count when receiving packets */
182#define MAX_RX_LOOP 20
183
184/* Some interrupt masks */
185#define ETH16I_INTR_ON 0xef8a /* Higher is receive mask */
186#define ETH16I_INTR_OFF 0x0000
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188/* Buffers header status byte meanings */
189#define PKT_GOOD BIT(5)
190#define PKT_GOOD_RMT BIT(4)
191#define PKT_SHORT BIT(3)
192#define PKT_ALIGN_ERR BIT(2)
193#define PKT_CRC_ERR BIT(1)
194#define PKT_RX_BUF_OVERFLOW BIT(0)
195
196/* Transmit status register (DLCR0) */
197#define TX_STATUS_REG 0
198#define TX_DONE BIT(7)
199#define NET_BUSY BIT(6)
200#define TX_PKT_RCD BIT(5)
201#define CR_LOST BIT(4)
202#define TX_JABBER_ERR BIT(3)
203#define COLLISION BIT(2)
204#define COLLISIONS_16 BIT(1)
205
206/* Receive status register (DLCR1) */
207#define RX_STATUS_REG 1
208#define RX_PKT BIT(7) /* Packet received */
209#define BUS_RD_ERR BIT(6)
210#define SHORT_PKT_ERR BIT(3)
211#define ALIGN_ERR BIT(2)
212#define CRC_ERR BIT(1)
213#define RX_BUF_OVERFLOW BIT(0)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215/* Transmit Interrupt Enable Register (DLCR2) */
216#define TX_INTR_REG 2
217#define TX_INTR_DONE BIT(7)
218#define TX_INTR_COL BIT(2)
219#define TX_INTR_16_COL BIT(1)
220
221/* Receive Interrupt Enable Register (DLCR3) */
222#define RX_INTR_REG 3
223#define RX_INTR_RECEIVE BIT(7)
224#define RX_INTR_SHORT_PKT BIT(3)
225#define RX_INTR_CRC_ERR BIT(1)
226#define RX_INTR_BUF_OVERFLOW BIT(0)
227
228/* Transmit Mode Register (DLCR4) */
229#define TRANSMIT_MODE_REG 4
230#define LOOPBACK_CONTROL BIT(1)
231#define CONTROL_OUTPUT BIT(2)
232
233/* Receive Mode Register (DLCR5) */
234#define RECEIVE_MODE_REG 5
235#define RX_BUFFER_EMPTY BIT(6)
236#define ACCEPT_BAD_PACKETS BIT(5)
237#define RECEIVE_SHORT_ADDR BIT(4)
238#define ACCEPT_SHORT_PACKETS BIT(3)
239#define REMOTE_RESET BIT(2)
240
241#define ADDRESS_FILTER_MODE BIT(1) | BIT(0)
242#define REJECT_ALL 0
243#define ACCEPT_ALL 3
244#define MODE_1 1 /* NODE ID, BC, MC, 2-24th bit */
245#define MODE_2 2 /* NODE ID, BC, MC, Hash Table */
246
247/* Configuration Register 0 (DLCR6) */
248#define CONFIG_REG_0 6
249#define DLC_EN BIT(7)
250#define SRAM_CYCLE_TIME_100NS BIT(6)
251#define SYSTEM_BUS_WIDTH_8 BIT(5) /* 1 = 8bit, 0 = 16bit */
252#define BUFFER_WIDTH_8 BIT(4) /* 1 = 8bit, 0 = 16bit */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400253#define TBS1 BIT(3)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254#define TBS0 BIT(2)
255#define SRAM_BS1 BIT(1) /* 00=8kb, 01=16kb */
256#define SRAM_BS0 BIT(0) /* 10=32kb, 11=64kb */
257
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400258#ifndef ETH16I_TX_BUF_SIZE /* 0 = 2kb, 1 = 4kb */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259#define ETH16I_TX_BUF_SIZE 3 /* 2 = 8kb, 3 = 16kb */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400260#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261#define TX_BUF_1x2048 0
262#define TX_BUF_2x2048 1
263#define TX_BUF_2x4098 2
264#define TX_BUF_2x8192 3
265
266/* Configuration Register 1 (DLCR7) */
267#define CONFIG_REG_1 7
268#define POWERUP BIT(5)
269
270/* Transmit start register */
271#define TRANSMIT_START_REG 10
272#define TRANSMIT_START_RB 2
273#define TX_START BIT(7) /* Rest of register bit indicate*/
274 /* number of packets in tx buffer*/
275/* Node ID registers (DLCR8-13) */
276#define NODE_ID_0 8
277#define NODE_ID_RB 0
278
279/* Hash Table registers (HT8-15) */
280#define HASH_TABLE_0 8
281#define HASH_TABLE_RB 1
282
283/* Buffer memory ports */
284#define BUFFER_MEM_PORT_LB 8
285#define DATAPORT BUFFER_MEM_PORT_LB
286#define BUFFER_MEM_PORT_HB 9
287
288/* 16 Collision control register (BMPR11) */
289#define COL_16_REG 11
290#define HALT_ON_16 0x00
291#define RETRANS_AND_HALT_ON_16 0x02
292
293/* Maximum number of attempts to send after 16 concecutive collisions */
294#define MAX_COL_16 10
295
296/* DMA Burst and Transceiver Mode Register (BMPR13) */
297#define TRANSCEIVER_MODE_REG 13
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400298#define TRANSCEIVER_MODE_RB 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299#define IO_BASE_UNLOCK BIT(7)
300#define LOWER_SQUELCH_TRESH BIT(6)
301#define LINK_TEST_DISABLE BIT(5)
302#define AUI_SELECT BIT(4)
303#define DIS_AUTO_PORT_SEL BIT(3)
304
305/* Filter Self Receive Register (BMPR14) */
306#define FILTER_SELF_RX_REG 14
307#define SKIP_RX_PACKET BIT(2)
308#define FILTER_SELF_RECEIVE BIT(0)
309
310/* EEPROM Control Register (BMPR 16) */
311#define EEPROM_CTRL_REG 16
312
313/* EEPROM Data Register (BMPR 17) */
314#define EEPROM_DATA_REG 17
315
316/* NMC93CSx6 EEPROM Control Bits */
317#define CS_0 0x00
318#define CS_1 0x20
319#define SK_0 0x00
320#define SK_1 0x40
321#define DI_0 0x00
322#define DI_1 0x80
323
324/* NMC93CSx6 EEPROM Instructions */
325#define EEPROM_READ 0x80
326
327/* NMC93CSx6 EEPROM Addresses */
328#define E_NODEID_0 0x02
329#define E_NODEID_1 0x03
330#define E_NODEID_2 0x04
331#define E_PORT_SELECT 0x14
332 #define E_PORT_BNC 0x00
333 #define E_PORT_DIX 0x01
334 #define E_PORT_TP 0x02
335 #define E_PORT_AUTO 0x03
336 #define E_PORT_FROM_EPROM 0x04
337#define E_PRODUCT_CFG 0x30
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340/* Macro to slow down io between EEPROM clock transitions */
341#define eeprom_slow_io() do { int _i = 40; while(--_i > 0) { inb(0x80); }}while(0)
342
343/* Jumperless Configuration Register (BMPR19) */
344#define JUMPERLESS_CONFIG 19
345
346/* ID ROM registers, writing to them also resets some parts of chip */
347#define ID_ROM_0 24
348#define ID_ROM_7 31
349#define RESET ID_ROM_0
350
351/* This is the I/O address list to be probed when seeking the card */
352static unsigned int eth16i_portlist[] __initdata = {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400353 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354};
355
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400356static unsigned int eth32i_portlist[] __initdata = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000, 0x8000,
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400358 0x9000, 0xA000, 0xB000, 0xC000, 0xD000, 0xE000, 0xF000, 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359};
360
361/* This is the Interrupt lookup table for Eth16i card */
362static unsigned int eth16i_irqmap[] __initdata = { 9, 10, 5, 15, 0 };
363#define NUM_OF_ISA_IRQS 4
364
365/* This is the Interrupt lookup table for Eth32i card */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400366static unsigned int eth32i_irqmap[] __initdata = { 3, 5, 7, 9, 10, 11, 12, 15, 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367#define EISA_IRQ_REG 0xc89
368#define NUM_OF_EISA_IRQS 8
369
370static unsigned int eth16i_tx_buf_map[] = { 2048, 2048, 4096, 8192 };
371
372/* Use 0 for production, 1 for verification, >2 for debug */
373#ifndef ETH16I_DEBUG
374#define ETH16I_DEBUG 0
375#endif
376static unsigned int eth16i_debug = ETH16I_DEBUG;
377
378/* Information for each board */
379
380struct eth16i_local {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 unsigned char tx_started;
382 unsigned char tx_buf_busy;
383 unsigned short tx_queue; /* Number of packets in transmit buffer */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400384 unsigned short tx_queue_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 unsigned int tx_buf_size;
386 unsigned long open_time;
387 unsigned long tx_buffered_packets;
388 unsigned long tx_buffered_bytes;
389 unsigned long col_16;
390 spinlock_t lock;
391};
392
393/* Function prototypes */
394
395static int eth16i_probe1(struct net_device *dev, int ioaddr);
396static int eth16i_check_signature(int ioaddr);
397static int eth16i_probe_port(int ioaddr);
398static void eth16i_set_port(int ioaddr, int porttype);
399static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l);
400static int eth16i_receive_probe_packet(int ioaddr);
401static int eth16i_get_irq(int ioaddr);
402static int eth16i_read_eeprom(int ioaddr, int offset);
403static int eth16i_read_eeprom_word(int ioaddr);
404static void eth16i_eeprom_cmd(int ioaddr, unsigned char command);
405static int eth16i_open(struct net_device *dev);
406static int eth16i_close(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000407static netdev_tx_t eth16i_tx(struct sk_buff *skb, struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408static void eth16i_rx(struct net_device *dev);
409static void eth16i_timeout(struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100410static irqreturn_t eth16i_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411static void eth16i_reset(struct net_device *dev);
412static void eth16i_timeout(struct net_device *dev);
413static void eth16i_skip_packet(struct net_device *dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400414static void eth16i_multicast(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415static void eth16i_select_regbank(unsigned char regbank, int ioaddr);
416static void eth16i_initialize(struct net_device *dev, int boot);
417
418#if 0
419static int eth16i_set_irq(struct net_device *dev);
420#endif
421
422#ifdef MODULE
423static ushort eth16i_parse_mediatype(const char* s);
424#endif
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426static char cardname[] __initdata = "ICL EtherTeam 16i/32";
427
428static int __init do_eth16i_probe(struct net_device *dev)
429{
430 int i;
431 int ioaddr;
432 int base_addr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400433
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400434 if(eth16i_debug > 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 printk(KERN_DEBUG "Probing started for %s\n", cardname);
436
437 if(base_addr > 0x1ff) /* Check only single location */
438 return eth16i_probe1(dev, base_addr);
439 else if(base_addr != 0) /* Don't probe at all */
440 return -ENXIO;
441
442 /* Seek card from the ISA io address space */
443 for(i = 0; (ioaddr = eth16i_portlist[i]) ; i++)
444 if(eth16i_probe1(dev, ioaddr) == 0)
445 return 0;
446
447 /* Seek card from the EISA io address space */
448 for(i = 0; (ioaddr = eth32i_portlist[i]) ; i++)
449 if(eth16i_probe1(dev, ioaddr) == 0)
450 return 0;
451
452 return -ENODEV;
453}
454
455#ifndef MODULE
456struct net_device * __init eth16i_probe(int unit)
457{
458 struct net_device *dev = alloc_etherdev(sizeof(struct eth16i_local));
459 int err;
460
461 if (!dev)
462 return ERR_PTR(-ENOMEM);
463
464 sprintf(dev->name, "eth%d", unit);
465 netdev_boot_setup_check(dev);
466
467 err = do_eth16i_probe(dev);
468 if (err)
469 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471out:
472 free_netdev(dev);
473 return ERR_PTR(err);
474}
475#endif
476
Stephen Hemminger6d1ec782009-03-26 15:11:44 +0000477static const struct net_device_ops eth16i_netdev_ops = {
478 .ndo_open = eth16i_open,
479 .ndo_stop = eth16i_close,
480 .ndo_start_xmit = eth16i_tx,
481 .ndo_set_multicast_list = eth16i_multicast,
482 .ndo_tx_timeout = eth16i_timeout,
483 .ndo_change_mtu = eth_change_mtu,
484 .ndo_set_mac_address = eth_mac_addr,
485 .ndo_validate_addr = eth_validate_addr,
486};
487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488static int __init eth16i_probe1(struct net_device *dev, int ioaddr)
489{
490 struct eth16i_local *lp = netdev_priv(dev);
491 static unsigned version_printed;
492 int retval;
493
494 /* Let's grab the region */
495 if (!request_region(ioaddr, ETH16I_IO_EXTENT, cardname))
496 return -EBUSY;
497
498 /*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400499 The MB86985 chip has on register which holds information in which
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 io address the chip lies. First read this register and compare
501 it to our current io address and if match then this could
502 be our chip.
503 */
504
505 if(ioaddr < 0x1000) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400506 if(eth16i_portlist[(inb(ioaddr + JUMPERLESS_CONFIG) & 0x07)]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 != ioaddr) {
508 retval = -ENODEV;
509 goto out;
510 }
511 }
512
513 /* Now we will go a bit deeper and try to find the chip's signature */
514
515 if(eth16i_check_signature(ioaddr) != 0) {
516 retval = -ENODEV;
517 goto out;
518 }
519
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400520 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 Now it seems that we have found a ethernet chip in this particular
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400522 ioaddr. The MB86985 chip has this feature, that when you read a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 certain register it will increase it's io base address to next
524 configurable slot. Now when we have found the chip, first thing is
525 to make sure that the chip's ioaddr will hold still here.
526 */
527
528 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
529 outb(0x00, ioaddr + TRANSCEIVER_MODE_REG);
530
531 outb(0x00, ioaddr + RESET); /* Reset some parts of chip */
532 BITSET(ioaddr + CONFIG_REG_0, BIT(7)); /* Disable the data link */
533
534 if( (eth16i_debug & version_printed++) == 0)
535 printk(KERN_INFO "%s", version);
536
537 dev->base_addr = ioaddr;
538 dev->irq = eth16i_get_irq(ioaddr);
539
540 /* Try to obtain interrupt vector */
541
542 if ((retval = request_irq(dev->irq, (void *)&eth16i_interrupt, 0, cardname, dev))) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400543 printk(KERN_WARNING "%s at %#3x, but is unusable due to conflicting IRQ %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 cardname, ioaddr, dev->irq);
545 goto out;
546 }
547
548 printk(KERN_INFO "%s: %s at %#3x, IRQ %d, ",
549 dev->name, cardname, ioaddr, dev->irq);
550
551
552 /* Now we will have to lock the chip's io address */
553 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400554 outb(0x38, ioaddr + TRANSCEIVER_MODE_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556 eth16i_initialize(dev, 1); /* Initialize rest of the chip's registers */
557
558 /* Now let's same some energy by shutting down the chip ;) */
559 BITCLR(ioaddr + CONFIG_REG_1, POWERUP);
560
561 /* Initialize the device structure */
Stephen Hemminger6d1ec782009-03-26 15:11:44 +0000562 dev->netdev_ops = &eth16i_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 dev->watchdog_timeo = TX_TIMEOUT;
564 spin_lock_init(&lp->lock);
b1fc5502005-05-12 20:11:55 -0400565
566 retval = register_netdev(dev);
567 if (retval)
568 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return 0;
b1fc5502005-05-12 20:11:55 -0400570out1:
571 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572out:
573 release_region(ioaddr, ETH16I_IO_EXTENT);
574 return retval;
575}
576
577
578static void eth16i_initialize(struct net_device *dev, int boot)
579{
580 int ioaddr = dev->base_addr;
581 int i, node_w = 0;
582 unsigned char node_byte = 0;
583
584 /* Setup station address */
585 eth16i_select_regbank(NODE_ID_RB, ioaddr);
586 for(i = 0 ; i < 3 ; i++) {
587 unsigned short node_val = eth16i_read_eeprom(ioaddr, E_NODEID_0 + i);
588 ((unsigned short *)dev->dev_addr)[i] = ntohs(node_val);
589 }
590
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400591 for(i = 0; i < 6; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 outb( ((unsigned char *)dev->dev_addr)[i], ioaddr + NODE_ID_0 + i);
593 if(boot) {
594 printk("%02x", inb(ioaddr + NODE_ID_0 + i));
595 if(i != 5)
596 printk(":");
597 }
598 }
599
600 /* Now we will set multicast addresses to accept none */
601 eth16i_select_regbank(HASH_TABLE_RB, ioaddr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400602 for(i = 0; i < 8; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 outb(0x00, ioaddr + HASH_TABLE_0 + i);
604
605 /*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400606 Now let's disable the transmitter and receiver, set the buffer ram
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 cycle time, bus width and buffer data path width. Also we shall
608 set transmit buffer size and total buffer size.
609 */
610
611 eth16i_select_regbank(2, ioaddr);
612
613 node_byte = 0;
614 node_w = eth16i_read_eeprom(ioaddr, E_PRODUCT_CFG);
615
616 if( (node_w & 0xFF00) == 0x0800)
617 node_byte |= BUFFER_WIDTH_8;
618
619 node_byte |= SRAM_BS1;
620
621 if( (node_w & 0x00FF) == 64)
622 node_byte |= SRAM_BS0;
623
624 node_byte |= DLC_EN | SRAM_CYCLE_TIME_100NS | (ETH16I_TX_BUF_SIZE << 2);
625
626 outb(node_byte, ioaddr + CONFIG_REG_0);
627
628 /* We shall halt the transmitting, if 16 collisions are detected */
629 outb(HALT_ON_16, ioaddr + COL_16_REG);
630
631#ifdef MODULE
632 /* if_port already set by init_module() */
633#else
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400634 dev->if_port = (dev->mem_start < E_PORT_FROM_EPROM) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 dev->mem_start : E_PORT_FROM_EPROM;
636#endif
637
638 /* Set interface port type */
639 if(boot) {
640 char *porttype[] = {"BNC", "DIX", "TP", "AUTO", "FROM_EPROM" };
641
642 switch(dev->if_port)
643 {
644
645 case E_PORT_FROM_EPROM:
646 dev->if_port = eth16i_read_eeprom(ioaddr, E_PORT_SELECT);
647 break;
648
649 case E_PORT_AUTO:
650 dev->if_port = eth16i_probe_port(ioaddr);
651 break;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 case E_PORT_BNC:
654 case E_PORT_TP:
655 case E_PORT_DIX:
656 break;
657 }
658
659 printk(" %s interface.\n", porttype[dev->if_port]);
660
661 eth16i_set_port(ioaddr, dev->if_port);
662 }
663
664 /* Set Receive Mode to normal operation */
665 outb(MODE_2, ioaddr + RECEIVE_MODE_REG);
666}
667
668static int eth16i_probe_port(int ioaddr)
669{
670 int i;
671 int retcode;
672 unsigned char dummy_packet[64];
673
674 /* Powerup the chip */
675 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
676
677 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
678
679 eth16i_select_regbank(NODE_ID_RB, ioaddr);
680
681 for(i = 0; i < 6; i++) {
682 dummy_packet[i] = inb(ioaddr + NODE_ID_0 + i);
683 dummy_packet[i+6] = inb(ioaddr + NODE_ID_0 + i);
684 }
685
686 dummy_packet[12] = 0x00;
687 dummy_packet[13] = 0x04;
688 memset(dummy_packet + 14, 0, sizeof(dummy_packet) - 14);
689
690 eth16i_select_regbank(2, ioaddr);
691
692 for(i = 0; i < 3; i++) {
693 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
694 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
695 eth16i_set_port(ioaddr, i);
696
697 if(eth16i_debug > 1)
698 printk(KERN_DEBUG "Set port number %d\n", i);
699
700 retcode = eth16i_send_probe_packet(ioaddr, dummy_packet, 64);
701 if(retcode == 0) {
702 retcode = eth16i_receive_probe_packet(ioaddr);
703 if(retcode != -1) {
704 if(eth16i_debug > 1)
705 printk(KERN_DEBUG "Eth16i interface port found at %d\n", i);
706 return i;
707 }
708 }
709 else {
710 if(eth16i_debug > 1)
711 printk(KERN_DEBUG "TRANSMIT_DONE timeout when probing interface port\n");
712 }
713 }
714
715 if( eth16i_debug > 1)
716 printk(KERN_DEBUG "Using default port\n");
717
718 return E_PORT_BNC;
719}
720
721static void eth16i_set_port(int ioaddr, int porttype)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400722{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 unsigned short temp = 0;
724
725 eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
726 outb(LOOPBACK_CONTROL, ioaddr + TRANSMIT_MODE_REG);
727
728 temp |= DIS_AUTO_PORT_SEL;
729
730 switch(porttype) {
731
732 case E_PORT_BNC :
733 temp |= AUI_SELECT;
734 break;
735
736 case E_PORT_TP :
737 break;
738
739 case E_PORT_DIX :
740 temp |= AUI_SELECT;
741 BITSET(ioaddr + TRANSMIT_MODE_REG, CONTROL_OUTPUT);
742 break;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400743 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
745 outb(temp, ioaddr + TRANSCEIVER_MODE_REG);
746
747 if(eth16i_debug > 1) {
748 printk(KERN_DEBUG "TRANSMIT_MODE_REG = %x\n", inb(ioaddr + TRANSMIT_MODE_REG));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400749 printk(KERN_DEBUG "TRANSCEIVER_MODE_REG = %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 inb(ioaddr+TRANSCEIVER_MODE_REG));
751 }
752}
753
754static int eth16i_send_probe_packet(int ioaddr, unsigned char *b, int l)
755{
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800756 unsigned long starttime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758 outb(0xff, ioaddr + TX_STATUS_REG);
759
760 outw(l, ioaddr + DATAPORT);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400761 outsw(ioaddr + DATAPORT, (unsigned short *)b, (l + 1) >> 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
763 starttime = jiffies;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400764 outb(TX_START | 1, ioaddr + TRANSMIT_START_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 while( (inb(ioaddr + TX_STATUS_REG) & 0x80) == 0) {
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800767 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 return -1;
769 }
770 }
771
772 return 0;
773}
774
775static int eth16i_receive_probe_packet(int ioaddr)
776{
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800777 unsigned long starttime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
779 starttime = jiffies;
780
781 while((inb(ioaddr + TX_STATUS_REG) & 0x20) == 0) {
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800782 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 if(eth16i_debug > 1)
785 printk(KERN_DEBUG "Timeout occurred waiting transmit packet received\n");
786 starttime = jiffies;
787 while((inb(ioaddr + RX_STATUS_REG) & 0x80) == 0) {
Marcelo Feitoza Parisiff5688a2006-01-09 18:37:15 -0800788 if( time_after(jiffies, starttime + TX_TIMEOUT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 if(eth16i_debug > 1)
790 printk(KERN_DEBUG "Timeout occurred waiting receive packet\n");
791 return -1;
792 }
793 }
794
795 if(eth16i_debug > 1)
796 printk(KERN_DEBUG "RECEIVE_PACKET\n");
797 return(0); /* Found receive packet */
798 }
799 }
800
801 if(eth16i_debug > 1) {
802 printk(KERN_DEBUG "TRANSMIT_PACKET_RECEIVED %x\n", inb(ioaddr + TX_STATUS_REG));
803 printk(KERN_DEBUG "RX_STATUS_REG = %x\n", inb(ioaddr + RX_STATUS_REG));
804 }
805
806 return(0); /* Return success */
807}
808
809#if 0
810static int eth16i_set_irq(struct net_device* dev)
811{
812 const int ioaddr = dev->base_addr;
813 const int irq = dev->irq;
814 int i = 0;
815
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400816 if(ioaddr < 0x1000) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 while(eth16i_irqmap[i] && eth16i_irqmap[i] != irq)
818 i++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 if(i < NUM_OF_ISA_IRQS) {
821 u8 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
822 cbyte = (cbyte & 0x3F) | (i << 6);
823 outb(cbyte, ioaddr + JUMPERLESS_CONFIG);
824 return 0;
825 }
826 }
827 else {
828 printk(KERN_NOTICE "%s: EISA Interrupt cannot be set. Use EISA Configuration utility.\n", dev->name);
829 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 return -1;
832
833}
834#endif
835
836static int __init eth16i_get_irq(int ioaddr)
837{
838 unsigned char cbyte;
839
840 if( ioaddr < 0x1000) {
841 cbyte = inb(ioaddr + JUMPERLESS_CONFIG);
842 return( eth16i_irqmap[ ((cbyte & 0xC0) >> 6) ] );
843 } else { /* Oh..the card is EISA so method getting IRQ different */
844 unsigned short index = 0;
845 cbyte = inb(ioaddr + EISA_IRQ_REG);
846 while( (cbyte & 0x01) == 0) {
847 cbyte = cbyte >> 1;
848 index++;
849 }
850 return( eth32i_irqmap[ index ] );
851 }
852}
853
854static int __init eth16i_check_signature(int ioaddr)
855{
856 int i;
857 unsigned char creg[4] = { 0 };
858
859 for(i = 0; i < 4 ; i++) {
860
861 creg[i] = inb(ioaddr + TRANSMIT_MODE_REG + i);
862
863 if(eth16i_debug > 1)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400864 printk("eth16i: read signature byte %x at %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 creg[i],
866 ioaddr + TRANSMIT_MODE_REG + i);
867 }
868
869 creg[0] &= 0x0F; /* Mask collision cnr */
870 creg[2] &= 0x7F; /* Mask DCLEN bit */
871
872#if 0
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400873 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 This was removed because the card was sometimes left to state
875 from which it couldn't be find anymore. If there is need
876 to more strict check still this have to be fixed.
877 */
878 if( ! ((creg[0] == 0x06) && (creg[1] == 0x41)) ) {
879 if(creg[1] != 0x42)
880 return -1;
881 }
882#endif
883
884 if( !((creg[2] == 0x36) && (creg[3] == 0xE0)) ) {
885 creg[2] &= 0x40;
886 creg[3] &= 0x03;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 if( !((creg[2] == 0x40) && (creg[3] == 0x00)) )
889 return -1;
890 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 if(eth16i_read_eeprom(ioaddr, E_NODEID_0) != 0)
893 return -1;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400894
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if((eth16i_read_eeprom(ioaddr, E_NODEID_1) & 0xFF00) != 0x4B00)
896 return -1;
897
898 return 0;
899}
900
901static int eth16i_read_eeprom(int ioaddr, int offset)
902{
903 int data = 0;
904
905 eth16i_eeprom_cmd(ioaddr, EEPROM_READ | offset);
906 outb(CS_1, ioaddr + EEPROM_CTRL_REG);
907 data = eth16i_read_eeprom_word(ioaddr);
908 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
909
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400910 return(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911}
912
913static int eth16i_read_eeprom_word(int ioaddr)
914{
915 int i;
916 int data = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 for(i = 16; i > 0; i--) {
919 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
920 eeprom_slow_io();
921 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
922 eeprom_slow_io();
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400923 data = (data << 1) |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 ((inb(ioaddr + EEPROM_DATA_REG) & DI_1) ? 1 : 0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400925
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 eeprom_slow_io();
927 }
928
929 return(data);
930}
931
932static void eth16i_eeprom_cmd(int ioaddr, unsigned char command)
933{
934 int i;
935
936 outb(CS_0 | SK_0, ioaddr + EEPROM_CTRL_REG);
937 outb(DI_0, ioaddr + EEPROM_DATA_REG);
938 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
939 outb(DI_1, ioaddr + EEPROM_DATA_REG);
940 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
941
942 for(i = 7; i >= 0; i--) {
943 short cmd = ( (command & (1 << i)) ? DI_1 : DI_0 );
944 outb(cmd, ioaddr + EEPROM_DATA_REG);
945 outb(CS_1 | SK_0, ioaddr + EEPROM_CTRL_REG);
946 eeprom_slow_io();
947 outb(CS_1 | SK_1, ioaddr + EEPROM_CTRL_REG);
948 eeprom_slow_io();
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400949 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950}
951
952static int eth16i_open(struct net_device *dev)
953{
954 struct eth16i_local *lp = netdev_priv(dev);
955 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 /* Powerup the chip */
958 outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);
959
960 /* Initialize the chip */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400961 eth16i_initialize(dev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
963 /* Set the transmit buffer size */
964 lp->tx_buf_size = eth16i_tx_buf_map[ETH16I_TX_BUF_SIZE & 0x03];
965
966 if(eth16i_debug > 0)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400967 printk(KERN_DEBUG "%s: transmit buffer size %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 dev->name, lp->tx_buf_size);
969
970 /* Now enable Transmitter and Receiver sections */
971 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
972
973 /* Now switch to register bank 2, for run time operation */
974 eth16i_select_regbank(2, ioaddr);
975
976 lp->open_time = jiffies;
977 lp->tx_started = 0;
978 lp->tx_queue = 0;
979 lp->tx_queue_len = 0;
980
981 /* Turn on interrupts*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400982 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 netif_start_queue(dev);
985 return 0;
986}
987
988static int eth16i_close(struct net_device *dev)
989{
990 struct eth16i_local *lp = netdev_priv(dev);
991 int ioaddr = dev->base_addr;
992
993 eth16i_reset(dev);
994
995 /* Turn off interrupts*/
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400996 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
998 netif_stop_queue(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 lp->open_time = 0;
1001
1002 /* Disable transmit and receive */
1003 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
1004
1005 /* Reset the chip */
1006 /* outb(0xff, ioaddr + RESET); */
1007 /* outw(0xffff, ioaddr + TX_STATUS_REG); */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 outb(0x00, ioaddr + CONFIG_REG_1);
1010
1011 return 0;
1012}
1013
1014static void eth16i_timeout(struct net_device *dev)
1015{
1016 struct eth16i_local *lp = netdev_priv(dev);
1017 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001018 /*
1019 If we get here, some higher level has decided that
1020 we are broken. There should really be a "kick me"
1021 function call instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 */
1023
1024 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001025 printk(KERN_WARNING "%s: transmit timed out with status %04x, %s ?\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 dev->name,
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001027 inw(ioaddr + TX_STATUS_REG), (inb(ioaddr + TX_STATUS_REG) & TX_DONE) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 "IRQ conflict" : "network cable problem");
1029
Eric Dumazet1ae5dc32010-05-10 05:01:31 -07001030 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
1032 /* Let's dump all registers */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001033 if(eth16i_debug > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 printk(KERN_DEBUG "%s: timeout: %02x %02x %02x %02x %02x %02x %02x %02x.\n",
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001035 dev->name, inb(ioaddr + 0),
1036 inb(ioaddr + 1), inb(ioaddr + 2),
1037 inb(ioaddr + 3), inb(ioaddr + 4),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 inb(ioaddr + 5),
1039 inb(ioaddr + 6), inb(ioaddr + 7));
1040
1041 printk(KERN_DEBUG "%s: transmit start reg: %02x. collision reg %02x\n",
1042 dev->name, inb(ioaddr + TRANSMIT_START_REG),
1043 inb(ioaddr + COL_16_REG));
1044 printk(KERN_DEBUG "lp->tx_queue = %d\n", lp->tx_queue);
1045 printk(KERN_DEBUG "lp->tx_queue_len = %d\n", lp->tx_queue_len);
1046 printk(KERN_DEBUG "lp->tx_started = %d\n", lp->tx_started);
1047 }
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001048 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 eth16i_reset(dev);
Eric Dumazet1ae5dc32010-05-10 05:01:31 -07001050 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1052 netif_wake_queue(dev);
1053}
1054
Stephen Hemminger613573252009-08-31 19:50:58 +00001055static netdev_tx_t eth16i_tx(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056{
1057 struct eth16i_local *lp = netdev_priv(dev);
1058 int ioaddr = dev->base_addr;
1059 int status = 0;
1060 ushort length = skb->len;
1061 unsigned char *buf;
1062 unsigned long flags;
1063
1064 if (length < ETH_ZLEN) {
Herbert Xu5b057c62006-06-23 02:06:41 -07001065 if (skb_padto(skb, ETH_ZLEN))
Patrick McHardy6ed10652009-06-23 06:03:08 +00001066 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 length = ETH_ZLEN;
1068 }
1069 buf = skb->data;
1070
1071 netif_stop_queue(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001072
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 /* Turn off TX interrupts */
1074 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 /* We would be better doing the disable_irq tricks the 3c509 does,
1077 that would make this suck a lot less */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001078
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 spin_lock_irqsave(&lp->lock, flags);
1080
1081 if( (length + 2) > (lp->tx_buf_size - lp->tx_queue_len)) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001082 if(eth16i_debug > 0)
1083 printk(KERN_WARNING "%s: Transmit buffer full.\n", dev->name);
1084 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 else {
1086 outw(length, ioaddr + DATAPORT);
1087
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001088 if( ioaddr < 0x1000 )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
1090 else {
1091 unsigned char frag = length % 4;
1092 outsl(ioaddr + DATAPORT, buf, length >> 2);
1093 if( frag != 0 ) {
1094 outsw(ioaddr + DATAPORT, (buf + (length & 0xFFFC)), 1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001095 if( frag == 3 )
1096 outsw(ioaddr + DATAPORT,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 (buf + (length & 0xFFFC) + 2), 1);
1098 }
1099 }
1100 lp->tx_buffered_packets++;
1101 lp->tx_buffered_bytes = length;
1102 lp->tx_queue++;
1103 lp->tx_queue_len += length + 2;
1104 }
1105 lp->tx_buf_busy = 0;
1106
1107 if(lp->tx_started == 0) {
1108 /* If the transmitter is idle..always trigger a transmit */
1109 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1110 lp->tx_queue = 0;
1111 lp->tx_queue_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 lp->tx_started = 1;
1113 netif_wake_queue(dev);
1114 }
1115 else if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1116 /* There is still more room for one more packet in tx buffer */
1117 netif_wake_queue(dev);
1118 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001119
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 spin_unlock_irqrestore(&lp->lock, flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001121
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
1123 /* Turn TX interrupts back on */
1124 /* outb(TX_INTR_DONE | TX_INTR_16_COL, ioaddr + TX_INTR_REG); */
1125 status = 0;
1126 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +00001127 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128}
1129
1130static void eth16i_rx(struct net_device *dev)
1131{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 int ioaddr = dev->base_addr;
1133 int boguscount = MAX_RX_LOOP;
1134
1135 /* Loop until all packets have been read */
1136 while( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) {
1137
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001138 /* Read status byte from receive buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 ushort status = inw(ioaddr + DATAPORT);
1140
1141 /* Get the size of the packet from receive buffer */
1142 ushort pkt_len = inw(ioaddr + DATAPORT);
1143
1144 if(eth16i_debug > 4)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001145 printk(KERN_DEBUG "%s: Receiving packet mode %02x status %04x.\n",
1146 dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 inb(ioaddr + RECEIVE_MODE_REG), status);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001148
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if( !(status & PKT_GOOD) ) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001150 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
1152 if( (pkt_len < ETH_ZLEN) || (pkt_len > ETH_FRAME_LEN) ) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001153 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 eth16i_reset(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001155 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001157 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 eth16i_skip_packet(dev);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001159 dev->stats.rx_dropped++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 }
1162 else { /* Ok so now we should have a good packet */
1163 struct sk_buff *skb;
1164
1165 skb = dev_alloc_skb(pkt_len + 3);
1166 if( skb == NULL ) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001167 printk(KERN_WARNING "%s: Could'n allocate memory for packet (len %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 dev->name, pkt_len);
1169 eth16i_skip_packet(dev);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001170 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 break;
1172 }
1173
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 skb_reserve(skb,2);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001175
1176 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 Now let's get the packet out of buffer.
1178 size is (pkt_len + 1) >> 1, cause we are now reading words
1179 and it have to be even aligned.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001180 */
1181
1182 if(ioaddr < 0x1000)
1183 insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 (pkt_len + 1) >> 1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001185 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 unsigned char *buf = skb_put(skb, pkt_len);
1187 unsigned char frag = pkt_len % 4;
1188
1189 insl(ioaddr + DATAPORT, buf, pkt_len >> 2);
1190
1191 if(frag != 0) {
1192 unsigned short rest[2];
1193 rest[0] = inw( ioaddr + DATAPORT );
1194 if(frag == 3)
1195 rest[1] = inw( ioaddr + DATAPORT );
1196
1197 memcpy(buf + (pkt_len & 0xfffc), (char *)rest, frag);
1198 }
1199 }
1200
1201 skb->protocol=eth_type_trans(skb, dev);
1202
1203 if( eth16i_debug > 5 ) {
1204 int i;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001205 printk(KERN_DEBUG "%s: Received packet of length %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 dev->name, pkt_len);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001207 for(i = 0; i < 14; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 printk(KERN_DEBUG " %02x", skb->data[i]);
1209 printk(KERN_DEBUG ".\n");
1210 }
1211 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001212 dev->stats.rx_packets++;
1213 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 } /* else */
1216
1217 if(--boguscount <= 0)
1218 break;
1219
1220 } /* while */
1221}
1222
David Howells7d12e782006-10-05 14:55:46 +01001223static irqreturn_t eth16i_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224{
1225 struct net_device *dev = dev_id;
1226 struct eth16i_local *lp;
1227 int ioaddr = 0, status;
1228 int handled = 0;
1229
1230 ioaddr = dev->base_addr;
1231 lp = netdev_priv(dev);
1232
1233 /* Turn off all interrupts from adapter */
1234 outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG);
1235
1236 /* eth16i_tx won't be called */
1237 spin_lock(&lp->lock);
1238
1239 status = inw(ioaddr + TX_STATUS_REG); /* Get the status */
1240 outw(status, ioaddr + TX_STATUS_REG); /* Clear status bits */
1241
1242 if (status)
1243 handled = 1;
1244
1245 if(eth16i_debug > 3)
1246 printk(KERN_DEBUG "%s: Interrupt with status %04x.\n", dev->name, status);
1247
1248 if( status & 0x7f00 ) {
1249
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001250 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001252 if(status & (BUS_RD_ERR << 8) )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 printk(KERN_WARNING "%s: Bus read error.\n",dev->name);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001254 if(status & (SHORT_PKT_ERR << 8) ) dev->stats.rx_length_errors++;
1255 if(status & (ALIGN_ERR << 8) ) dev->stats.rx_frame_errors++;
1256 if(status & (CRC_ERR << 8) ) dev->stats.rx_crc_errors++;
1257 if(status & (RX_BUF_OVERFLOW << 8) ) dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 }
1259 if( status & 0x001a) {
1260
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001261 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001263 if(status & CR_LOST) dev->stats.tx_carrier_errors++;
1264 if(status & TX_JABBER_ERR) dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001266#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 if(status & COLLISION) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001268 dev->stats.collisions +=
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 ((inb(ioaddr+TRANSMIT_MODE_REG) & 0xF0) >> 4);
1270 }
1271#endif
1272 if(status & COLLISIONS_16) {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001273 if(lp->col_16 < MAX_COL_16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 lp->col_16++;
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001275 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 /* Resume transmitting, skip failed packet */
1277 outb(0x02, ioaddr + COL_16_REG);
1278 }
1279 else {
1280 printk(KERN_WARNING "%s: bailing out due to many consecutive 16-in-a-row collisions. Network cable problem?\n", dev->name);
1281 }
1282 }
1283 }
1284
1285 if( status & 0x00ff ) { /* Let's check the transmit status reg */
1286
1287 if(status & TX_DONE) { /* The transmit has been done */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001288 dev->stats.tx_packets = lp->tx_buffered_packets;
1289 dev->stats.tx_bytes += lp->tx_buffered_bytes;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001290 lp->col_16 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
1292 if(lp->tx_queue) { /* Is there still packets ? */
1293 /* There was packet(s) so start transmitting and write also
1294 how many packets there is to be sended */
1295 outb(TX_START | lp->tx_queue, ioaddr + TRANSMIT_START_REG);
1296 lp->tx_queue = 0;
1297 lp->tx_queue_len = 0;
1298 lp->tx_started = 1;
1299 }
1300 else {
1301 lp->tx_started = 0;
1302 }
1303 netif_wake_queue(dev);
1304 }
1305 }
1306
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001307 if( ( status & 0x8000 ) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 ( (inb(ioaddr + RECEIVE_MODE_REG) & RX_BUFFER_EMPTY) == 0) ) {
1309 eth16i_rx(dev); /* We have packet in receive buffer */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001310 }
1311
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 /* Turn interrupts back on */
1313 outw(ETH16I_INTR_ON, ioaddr + TX_INTR_REG);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 if(lp->tx_queue_len < lp->tx_buf_size - (ETH_FRAME_LEN + 2)) {
1316 /* There is still more room for one more packet in tx buffer */
1317 netif_wake_queue(dev);
1318 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001319
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 spin_unlock(&lp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001321
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 return IRQ_RETVAL(handled);
1323}
1324
1325static void eth16i_skip_packet(struct net_device *dev)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001326{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 int ioaddr = dev->base_addr;
1328
1329 inw(ioaddr + DATAPORT);
1330 inw(ioaddr + DATAPORT);
1331 inw(ioaddr + DATAPORT);
1332
1333 outb(SKIP_RX_PACKET, ioaddr + FILTER_SELF_RX_REG);
1334 while( inb( ioaddr + FILTER_SELF_RX_REG ) != 0);
1335}
1336
1337static void eth16i_reset(struct net_device *dev)
1338{
1339 struct eth16i_local *lp = netdev_priv(dev);
1340 int ioaddr = dev->base_addr;
1341
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001342 if(eth16i_debug > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 printk(KERN_DEBUG "%s: Resetting device.\n", dev->name);
1344
1345 BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001346 outw(0xffff, ioaddr + TX_STATUS_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 eth16i_select_regbank(2, ioaddr);
1348
1349 lp->tx_started = 0;
1350 lp->tx_buf_busy = 0;
1351 lp->tx_queue = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001352 lp->tx_queue_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
1354}
1355
1356static void eth16i_multicast(struct net_device *dev)
1357{
1358 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001359
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001360 if (!netdev_mc_empty(dev) || dev->flags&(IFF_ALLMULTI|IFF_PROMISC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001362 outb(3, ioaddr + RECEIVE_MODE_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 } else {
1364 outb(2, ioaddr + RECEIVE_MODE_REG);
1365 }
1366}
1367
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368static void eth16i_select_regbank(unsigned char banknbr, int ioaddr)
1369{
1370 unsigned char data;
1371
1372 data = inb(ioaddr + CONFIG_REG_1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001373 outb( ((data & 0xF3) | ( (banknbr & 0x03) << 2)), ioaddr + CONFIG_REG_1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374}
1375
1376#ifdef MODULE
1377
1378static ushort eth16i_parse_mediatype(const char* s)
1379{
1380 if(!s)
1381 return E_PORT_FROM_EPROM;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001382
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 if (!strncmp(s, "bnc", 3))
1384 return E_PORT_BNC;
1385 else if (!strncmp(s, "tp", 2))
1386 return E_PORT_TP;
1387 else if (!strncmp(s, "dix", 3))
1388 return E_PORT_DIX;
1389 else if (!strncmp(s, "auto", 4))
1390 return E_PORT_AUTO;
1391 else
1392 return E_PORT_FROM_EPROM;
1393}
1394
1395#define MAX_ETH16I_CARDS 4 /* Max number of Eth16i cards per module */
1396
1397static struct net_device *dev_eth16i[MAX_ETH16I_CARDS];
1398static int io[MAX_ETH16I_CARDS];
1399#if 0
1400static int irq[MAX_ETH16I_CARDS];
1401#endif
1402static char* mediatype[MAX_ETH16I_CARDS];
1403static int debug = -1;
1404
1405MODULE_AUTHOR("Mika Kuoppala <miku@iki.fi>");
1406MODULE_DESCRIPTION("ICL EtherTeam 16i/32 driver");
1407MODULE_LICENSE("GPL");
1408
1409
1410module_param_array(io, int, NULL, 0);
1411MODULE_PARM_DESC(io, "eth16i I/O base address(es)");
1412
1413#if 0
1414module_param_array(irq, int, NULL, 0);
1415MODULE_PARM_DESC(irq, "eth16i interrupt request number");
1416#endif
1417
1418module_param_array(mediatype, charp, NULL, 0);
1419MODULE_PARM_DESC(mediatype, "eth16i media type of interface(s) (bnc,tp,dix,auto,eprom)");
1420
1421module_param(debug, int, 0);
1422MODULE_PARM_DESC(debug, "eth16i debug level (0-6)");
1423
Andrew Morton58f149f2006-08-14 23:00:03 -07001424int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425{
1426 int this_dev, found = 0;
1427 struct net_device *dev;
1428
1429 for (this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) {
1430 dev = alloc_etherdev(sizeof(struct eth16i_local));
1431 if (!dev)
1432 break;
1433
1434 dev->base_addr = io[this_dev];
1435
1436 if(debug != -1)
1437 eth16i_debug = debug;
1438
1439 if(eth16i_debug > 1)
1440 printk(KERN_NOTICE "eth16i(%d): interface type %s\n", this_dev, mediatype[this_dev] ? mediatype[this_dev] : "none" );
1441
1442 dev->if_port = eth16i_parse_mediatype(mediatype[this_dev]);
1443
1444 if(io[this_dev] == 0) {
1445 if(this_dev != 0) /* Only autoprobe 1st one */
1446 break;
1447
1448 printk(KERN_NOTICE "eth16i.c: Presently autoprobing (not recommended) for a single card.\n");
1449 }
1450
1451 if (do_eth16i_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -04001452 dev_eth16i[found++] = dev;
1453 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 }
1455 printk(KERN_WARNING "eth16i.c No Eth16i card found (i/o = 0x%x).\n",
1456 io[this_dev]);
1457 free_netdev(dev);
1458 break;
1459 }
1460 if (found)
1461 return 0;
1462 return -ENXIO;
1463}
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001464
Al Viroafc8eb42006-06-14 18:50:53 -04001465void __exit cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466{
1467 int this_dev;
1468
1469 for(this_dev = 0; this_dev < MAX_ETH16I_CARDS; this_dev++) {
1470 struct net_device *dev = dev_eth16i[this_dev];
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001471
Wang Chen4cf16532008-11-12 23:38:14 -08001472 if (netdev_priv(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 unregister_netdev(dev);
1474 free_irq(dev->irq, dev);
1475 release_region(dev->base_addr, ETH16I_IO_EXTENT);
1476 free_netdev(dev);
1477 }
1478 }
1479}
1480#endif /* MODULE */