Kernel

Kernel Git Source Tree

Root/drivers/net/eepro.c

1	/* eepro.c: Intel EtherExpress Pro/10 device driver for Linux. */
2	/*
3	Written 1994, 1995,1996 by Bao C. Ha.
4
5	Copyright (C) 1994, 1995,1996 by Bao C. Ha.
6
7	This software may be used and distributed
8	according to the terms of the GNU General Public License,
9	incorporated herein by reference.
10
11	The author may be reached at bao.ha@srs.gov
12	or 418 Hastings Place, Martinez, GA 30907.
13
14	Things remaining to do:
15	Better record keeping of errors.
16	Eliminate transmit interrupt to reduce overhead.
17	Implement "concurrent processing". I won't be doing it!
18
19	Bugs:
20
21	If you have a problem of not detecting the 82595 during a
22	reboot (warm reset), disable the FLASH memory should fix it.
23	This is a compatibility hardware problem.
24
25	Versions:
26	0.13b basic ethtool support (aris, 09/13/2004)
27	0.13a in memory shortage, drop packets also in board
28	(Michael Westermann <mw@microdata-pos.de>, 07/30/2002)
29	0.13 irq sharing, rewrote probe function, fixed a nasty bug in
30	hardware_send_packet and a major cleanup (aris, 11/08/2001)
31	0.12d fixing a problem with single card detected as eight eth devices
32	fixing a problem with sudden drop in card performance
33	(chris (asdn@go2.pl), 10/29/2001)
34	0.12c fixing some problems with old cards (aris, 01/08/2001)
35	0.12b misc fixes (aris, 06/26/2000)
36	0.12a port of version 0.12a of 2.2.x kernels to 2.3.x
37	(aris (aris@conectiva.com.br), 05/19/2000)
38	0.11e some tweaks about multiple cards support (PdP, jul/aug 1999)
39	0.11d added __initdata, __init stuff; call spin_lock_init
40	in eepro_probe1. Replaced "eepro" by dev->name. Augmented
41	the code protected by spin_lock in interrupt routine
42	(PdP, 12/12/1998)
43	0.11c minor cleanup (PdP, RMC, 09/12/1998)
44	0.11b Pascal Dupuis (dupuis@lei.ucl.ac.be): works as a module
45	under 2.1.xx. Debug messages are flagged as KERN_DEBUG to
46	avoid console flooding. Added locking at critical parts. Now
47	the dawn thing is SMP safe.
48	0.11a Attempt to get 2.1.xx support up (RMC)
49	0.11 Brian Candler added support for multiple cards. Tested as
50	a module, no idea if it works when compiled into kernel.
51
52	0.10e Rick Bressler notified me that ifconfig up;ifconfig down fails
53	because the irq is lost somewhere. Fixed that by moving
54	request_irq and free_irq to eepro_open and eepro_close respectively.
55	0.10d Ugh! Now Wakeup works. Was seriously broken in my first attempt.
56	I'll need to find a way to specify an ioport other than
57	the default one in the PnP case. PnP definitively sucks.
58	And, yes, this is not the only reason.
59	0.10c PnP Wakeup Test for 595FX. uncomment #define PnPWakeup;
60	to use.
61	0.10b Should work now with (some) Pro/10+. At least for
62	me (and my two cards) it does. _No_ guarantee for
63	function with non-Pro/10+ cards! (don't have any)
64	(RMC, 9/11/96)
65
66	0.10 Added support for the Etherexpress Pro/10+. The
67	IRQ map was changed significantly from the old
68	pro/10. The new interrupt map was provided by
69	Rainer M. Canavan (Canavan@Zeus.cs.bonn.edu).
70	(BCH, 9/3/96)
71
72	0.09 Fixed a race condition in the transmit algorithm,
73	which causes crashes under heavy load with fast
74	pentium computers. The performance should also
75	improve a bit. The size of RX buffer, and hence
76	TX buffer, can also be changed via lilo or insmod.
77	(BCH, 7/31/96)
78
79	0.08 Implement 32-bit I/O for the 82595TX and 82595FX
80	based lan cards. Disable full-duplex mode if TPE
81	is not used. (BCH, 4/8/96)
82
83	0.07a Fix a stat report which counts every packet as a
84	heart-beat failure. (BCH, 6/3/95)
85
86	0.07 Modified to support all other 82595-based lan cards.
87	The IRQ vector of the EtherExpress Pro will be set
88	according to the value saved in the EEPROM. For other
89	cards, I will do autoirq_request() to grab the next
90	available interrupt vector. (BCH, 3/17/95)
91
92	0.06a,b Interim released. Minor changes in the comments and
93	print out format. (BCH, 3/9/95 and 3/14/95)
94
95	0.06 First stable release that I am comfortable with. (BCH,
96	3/2/95)
97
98	0.05 Complete testing of multicast. (BCH, 2/23/95)
99
100	0.04 Adding multicast support. (BCH, 2/14/95)
101
102	0.03 First widely alpha release for public testing.
103	(BCH, 2/14/95)
104
105	*/
106
107	static const char version[] =
108	"eepro.c: v0.13b 09/13/2004 aris@cathedrallabs.org\n";
109
110	#include <linux/module.h>
111
112	/*
113	Sources:
114
115	This driver wouldn't have been written without the availability
116	of the Crynwr's Lan595 driver source code. It helps me to
117	familiarize with the 82595 chipset while waiting for the Intel
118	documentation. I also learned how to detect the 82595 using
119	the packet driver's technique.
120
121	This driver is written by cutting and pasting the skeleton.c driver
122	provided by Donald Becker. I also borrowed the EEPROM routine from
123	Donald Becker's 82586 driver.
124
125	Datasheet for the Intel 82595 (including the TX and FX version). It
126	provides just enough info that the casual reader might think that it
127	documents the i82595.
128
129	The User Manual for the 82595. It provides a lot of the missing
130	information.
131
132	*/
133
134	#include <linux/kernel.h>
135	#include <linux/types.h>
136	#include <linux/fcntl.h>
137	#include <linux/interrupt.h>
138	#include <linux/ioport.h>
139	#include <linux/in.h>
140	#include <linux/slab.h>
141	#include <linux/string.h>
142	#include <linux/errno.h>
143	#include <linux/netdevice.h>
144	#include <linux/etherdevice.h>
145	#include <linux/skbuff.h>
146	#include <linux/spinlock.h>
147	#include <linux/init.h>
148	#include <linux/delay.h>
149	#include <linux/bitops.h>
150	#include <linux/ethtool.h>
151
152	#include <asm/system.h>
153	#include <asm/io.h>
154	#include <asm/dma.h>
155
156	#define DRV_NAME "eepro"
157	#define DRV_VERSION "0.13c"
158
159	#define compat_dev_kfree_skb( skb, mode ) dev_kfree_skb( (skb) )
160	/* I had reports of looong delays with SLOW_DOWN defined as udelay(2) */
161	#define SLOW_DOWN inb(0x80)
162	/* udelay(2) */
163	#define compat_init_data __initdata
164	enum iftype { AUI=0, BNC=1, TPE=2 };
165
166	/* First, a few definitions that the brave might change. */
167	/* A zero-terminated list of I/O addresses to be probed. */
168	static unsigned int eepro_portlist[] compat_init_data =
169	{ 0x300, 0x210, 0x240, 0x280, 0x2C0, 0x200, 0x320, 0x340, 0x360, 0};
170	/* note: 0x300 is default, the 595FX supports ALL IO Ports
171	from 0x000 to 0x3F0, some of which are reserved in PCs */
172
173	/* To try the (not-really PnP Wakeup: */
174	/*
175	#define PnPWakeup
176	*/
177
178	/* use 0 for production, 1 for verification, >2 for debug */
179	#ifndef NET_DEBUG
180	#define NET_DEBUG 0
181	#endif
182	static unsigned int net_debug = NET_DEBUG;
183
184	/* The number of low I/O ports used by the ethercard. */
185	#define EEPRO_IO_EXTENT 16
186
187	/* Different 82595 chips */
188	#define LAN595 0
189	#define LAN595TX 1
190	#define LAN595FX 2
191	#define LAN595FX_10ISA 3
192
193	/* Information that need to be kept for each board. */
194	struct eepro_local {
195	unsigned rx_start;
196	unsigned tx_start; /* start of the transmit chain */
197	int tx_last; /* pointer to last packet in the transmit chain */
198	unsigned tx_end; /* end of the transmit chain (plus 1) */
199	int eepro; /* 1 for the EtherExpress Pro/10,
200	2 for the EtherExpress Pro/10+,
201	3 for the EtherExpress 10 (blue cards),
202	0 for other 82595-based lan cards. */
203	int version; /* a flag to indicate if this is a TX or FX
204	version of the 82595 chip. */
205	int stepping;
206
207	spinlock_t lock; /* Serializing lock */
208
209	unsigned rcv_ram; /* pre-calculated space for rx */
210	unsigned xmt_ram; /* pre-calculated space for tx */
211	unsigned char xmt_bar;
212	unsigned char xmt_lower_limit_reg;
213	unsigned char xmt_upper_limit_reg;
214	short xmt_lower_limit;
215	short xmt_upper_limit;
216	short rcv_lower_limit;
217	short rcv_upper_limit;
218	unsigned char eeprom_reg;
219	unsigned short word[8];
220	};
221
222	/* The station (ethernet) address prefix, used for IDing the board. */
223	#define SA_ADDR0 0x00 /* Etherexpress Pro/10 */
224	#define SA_ADDR1 0xaa
225	#define SA_ADDR2 0x00
226
227	#define GetBit(x,y) ((x & (1<<y))>>y)
228
229	/* EEPROM Word 0: */
230	#define ee_PnP 0 /* Plug 'n Play enable bit */
231	#define ee_Word1 1 /* Word 1? */
232	#define ee_BusWidth 2 /* 8/16 bit */
233	#define ee_FlashAddr 3 /* Flash Address */
234	#define ee_FlashMask 0x7 /* Mask */
235	#define ee_AutoIO 6 /* */
236	#define ee_reserved0 7 /* =0! */
237	#define ee_Flash 8 /* Flash there? */
238	#define ee_AutoNeg 9 /* Auto Negotiation enabled? */
239	#define ee_IO0 10 /* IO Address LSB */
240	#define ee_IO0Mask 0x /.../
241	#define ee_IO1 15 /* IO MSB */
242
243	/* EEPROM Word 1: */
244	#define ee_IntSel 0 /* Interrupt */
245	#define ee_IntMask 0x7
246	#define ee_LI 3 /* Link Integrity 0= enabled */
247	#define ee_PC 4 /* Polarity Correction 0= enabled */
248	#define ee_TPE_AUI 5 /* PortSelection 1=TPE */
249	#define ee_Jabber 6 /* Jabber prevention 0= enabled */
250	#define ee_AutoPort 7 /* Auto Port Selection 1= Disabled */
251	#define ee_SMOUT 8 /* SMout Pin Control 0= Input */
252	#define ee_PROM 9 /* Flash EPROM / PROM 0=Flash */
253	#define ee_reserved1 10 /* .. 12 =0! */
254	#define ee_AltReady 13 /* Alternate Ready, 0=normal */
255	#define ee_reserved2 14 /* =0! */
256	#define ee_Duplex 15
257
258	/* Word2,3,4: */
259	#define ee_IA5 0 /bit start for individual Addr Byte 5 /
260	#define ee_IA4 8 /bit start for individual Addr Byte 5 /
261	#define ee_IA3 0 /bit start for individual Addr Byte 5 /
262	#define ee_IA2 8 /bit start for individual Addr Byte 5 /
263	#define ee_IA1 0 /bit start for individual Addr Byte 5 /
264	#define ee_IA0 8 /bit start for individual Addr Byte 5 /
265
266	/* Word 5: */
267	#define ee_BNC_TPE 0 /* 0=TPE */
268	#define ee_BootType 1 /* 00=None, 01=IPX, 10=ODI, 11=NDIS */
269	#define ee_BootTypeMask 0x3
270	#define ee_NumConn 3 /* Number of Connections 0= One or Two */
271	#define ee_FlashSock 4 /* Presence of Flash Socket 0= Present */
272	#define ee_PortTPE 5
273	#define ee_PortBNC 6
274	#define ee_PortAUI 7
275	#define ee_PowerMgt 10 /* 0= disabled */
276	#define ee_CP 13 /* Concurrent Processing */
277	#define ee_CPMask 0x7
278
279	/* Word 6: */
280	#define ee_Stepping 0 /* Stepping info */
281	#define ee_StepMask 0x0F
282	#define ee_BoardID 4 /* Manucaturer Board ID, reserved */
283	#define ee_BoardMask 0x0FFF
284
285	/* Word 7: */
286	#define ee_INT_TO_IRQ 0 /* int to IRQ Mapping = 0x1EB8 for Pro/10+ */
287	#define ee_FX_INT2IRQ 0x1EB8 /* the _only_ mapping allowed for FX chips */
288
289	/../
290	#define ee_SIZE 0x40 /* total EEprom Size */
291	#define ee_Checksum 0xBABA /* initial and final value for adding checksum */
292
293
294	/* Card identification via EEprom: */
295	#define ee_addr_vendor 0x10 /* Word offset for EISA Vendor ID */
296	#define ee_addr_id 0x11 /* Word offset for Card ID */
297	#define ee_addr_SN 0x12 /* Serial Number */
298	#define ee_addr_CRC_8 0x14 /* CRC over last thee Bytes */
299
300
301	#define ee_vendor_intel0 0x25 /* Vendor ID Intel */
302	#define ee_vendor_intel1 0xD4
303	#define ee_id_eepro10p0 0x10 /* ID for eepro/10+ */
304	#define ee_id_eepro10p1 0x31
305
306	#define TX_TIMEOUT 40
307
308	/* Index to functions, as function prototypes. */
309
310	static int eepro_probe1(struct net_device *dev, int autoprobe);
311	static int eepro_open(struct net_device *dev);
312	static int eepro_send_packet(struct sk_buff skb, struct net_device dev);
313	static irqreturn_t eepro_interrupt(int irq, void *dev_id);
314	static void eepro_rx(struct net_device *dev);
315	static void eepro_transmit_interrupt(struct net_device *dev);
316	static int eepro_close(struct net_device *dev);
317	static void set_multicast_list(struct net_device *dev);
318	static void eepro_tx_timeout (struct net_device *dev);
319
320	static int read_eeprom(int ioaddr, int location, struct net_device *dev);
321	static int hardware_send_packet(struct net_device dev, void buf, short length);
322	static int eepro_grab_irq(struct net_device *dev);
323
324	/*
325	Details of the i82595.
326
327	You will need either the datasheet or the user manual to understand what
328	is going on here. The 82595 is very different from the 82586, 82593.
329
330	The receive algorithm in eepro_rx() is just an implementation of the
331	RCV ring structure that the Intel 82595 imposes at the hardware level.
332	The receive buffer is set at 24K, and the transmit buffer is 8K. I
333	am assuming that the total buffer memory is 32K, which is true for the
334	Intel EtherExpress Pro/10. If it is less than that on a generic card,
335	the driver will be broken.
336
337	The transmit algorithm in the hardware_send_packet() is similar to the
338	one in the eepro_rx(). The transmit buffer is a ring linked list.
339	I just queue the next available packet to the end of the list. In my
340	system, the 82595 is so fast that the list seems to always contain a
341	single packet. In other systems with faster computers and more congested
342	network traffics, the ring linked list should improve performance by
343	allowing up to 8K worth of packets to be queued.
344
345	The sizes of the receive and transmit buffers can now be changed via lilo
346	or insmod. Lilo uses the appended line "ether=io,irq,debug,rx-buffer,eth0"
347	where rx-buffer is in KB unit. Modules uses the parameter mem which is
348	also in KB unit, for example "insmod io=io-address irq=0 mem=rx-buffer."
349	The receive buffer has to be more than 3K or less than 29K. Otherwise,
350	it is reset to the default of 24K, and, hence, 8K for the trasnmit
351	buffer (transmit-buffer = 32K - receive-buffer).
352
353	*/
354	#define RAM_SIZE 0x8000
355
356	#define RCV_HEADER 8
357	#define RCV_DEFAULT_RAM 0x6000
358
359	#define XMT_HEADER 8
360	#define XMT_DEFAULT_RAM (RAM_SIZE - RCV_DEFAULT_RAM)
361
362	#define XMT_START_PRO RCV_DEFAULT_RAM
363	#define XMT_START_10 0x0000
364	#define RCV_START_PRO 0x0000
365	#define RCV_START_10 XMT_DEFAULT_RAM
366
367	#define RCV_DONE 0x0008
368	#define RX_OK 0x2000
369	#define RX_ERROR 0x0d81
370
371	#define TX_DONE_BIT 0x0080
372	#define TX_OK 0x2000
373	#define CHAIN_BIT 0x8000
374	#define XMT_STATUS 0x02
375	#define XMT_CHAIN 0x04
376	#define XMT_COUNT 0x06
377
378	#define BANK0_SELECT 0x00
379	#define BANK1_SELECT 0x40
380	#define BANK2_SELECT 0x80
381
382	/* Bank 0 registers */
383	#define COMMAND_REG 0x00 /* Register 0 */
384	#define MC_SETUP 0x03
385	#define XMT_CMD 0x04
386	#define DIAGNOSE_CMD 0x07
387	#define RCV_ENABLE_CMD 0x08
388	#define RCV_DISABLE_CMD 0x0a
389	#define STOP_RCV_CMD 0x0b
390	#define RESET_CMD 0x0e
391	#define POWER_DOWN_CMD 0x18
392	#define RESUME_XMT_CMD 0x1c
393	#define SEL_RESET_CMD 0x1e
394	#define STATUS_REG 0x01 /* Register 1 */
395	#define RX_INT 0x02
396	#define TX_INT 0x04
397	#define EXEC_STATUS 0x30
398	#define ID_REG 0x02 /* Register 2 */
399	#define R_ROBIN_BITS 0xc0 /* round robin counter */
400	#define ID_REG_MASK 0x2c
401	#define ID_REG_SIG 0x24
402	#define AUTO_ENABLE 0x10
403	#define INT_MASK_REG 0x03 /* Register 3 */
404	#define RX_STOP_MASK 0x01
405	#define RX_MASK 0x02
406	#define TX_MASK 0x04
407	#define EXEC_MASK 0x08
408	#define ALL_MASK 0x0f
409	#define IO_32_BIT 0x10
410	#define RCV_BAR 0x04 /* The following are word (16-bit) registers */
411	#define RCV_STOP 0x06
412
413	#define XMT_BAR_PRO 0x0a
414	#define XMT_BAR_10 0x0b
415
416	#define HOST_ADDRESS_REG 0x0c
417	#define IO_PORT 0x0e
418	#define IO_PORT_32_BIT 0x0c
419
420	/* Bank 1 registers */
421	#define REG1 0x01
422	#define WORD_WIDTH 0x02
423	#define INT_ENABLE 0x80
424	#define INT_NO_REG 0x02
425	#define RCV_LOWER_LIMIT_REG 0x08
426	#define RCV_UPPER_LIMIT_REG 0x09
427
428	#define XMT_LOWER_LIMIT_REG_PRO 0x0a
429	#define XMT_UPPER_LIMIT_REG_PRO 0x0b
430	#define XMT_LOWER_LIMIT_REG_10 0x0b
431	#define XMT_UPPER_LIMIT_REG_10 0x0a
432
433	/* Bank 2 registers */
434	#define XMT_Chain_Int 0x20 /* Interrupt at the end of the transmit chain */
435	#define XMT_Chain_ErrStop 0x40 /* Interrupt at the end of the chain even if there are errors */
436	#define RCV_Discard_BadFrame 0x80 /* Throw bad frames away, and continue to receive others */
437	#define REG2 0x02
438	#define PRMSC_Mode 0x01
439	#define Multi_IA 0x20
440	#define REG3 0x03
441	#define TPE_BIT 0x04
442	#define BNC_BIT 0x20
443	#define REG13 0x0d
444	#define FDX 0x00
445	#define A_N_ENABLE 0x02
446
447	#define I_ADD_REG0 0x04
448	#define I_ADD_REG1 0x05
449	#define I_ADD_REG2 0x06
450	#define I_ADD_REG3 0x07
451	#define I_ADD_REG4 0x08
452	#define I_ADD_REG5 0x09
453
454	#define EEPROM_REG_PRO 0x0a
455	#define EEPROM_REG_10 0x0b
456
457	#define EESK 0x01
458	#define EECS 0x02
459	#define EEDI 0x04
460	#define EEDO 0x08
461
462	/* do a full reset */
463	#define eepro_reset(ioaddr) outb(RESET_CMD, ioaddr)
464
465	/* do a nice reset */
466	#define eepro_sel_reset(ioaddr) { \
467	outb(SEL_RESET_CMD, ioaddr); \
468	SLOW_DOWN; \
469	SLOW_DOWN; \
470	}
471
472	/* disable all interrupts */
473	#define eepro_dis_int(ioaddr) outb(ALL_MASK, ioaddr + INT_MASK_REG)
474
475	/* clear all interrupts */
476	#define eepro_clear_int(ioaddr) outb(ALL_MASK, ioaddr + STATUS_REG)
477
478	/* enable tx/rx */
479	#define eepro_en_int(ioaddr) outb(ALL_MASK & ~(RX_MASK \| TX_MASK), \
480	ioaddr + INT_MASK_REG)
481
482	/* enable exec event interrupt */
483	#define eepro_en_intexec(ioaddr) outb(ALL_MASK & ~(EXEC_MASK), ioaddr + INT_MASK_REG)
484
485	/* enable rx */
486	#define eepro_en_rx(ioaddr) outb(RCV_ENABLE_CMD, ioaddr)
487
488	/* disable rx */
489	#define eepro_dis_rx(ioaddr) outb(RCV_DISABLE_CMD, ioaddr)
490
491	/* switch bank */
492	#define eepro_sw2bank0(ioaddr) outb(BANK0_SELECT, ioaddr)
493	#define eepro_sw2bank1(ioaddr) outb(BANK1_SELECT, ioaddr)
494	#define eepro_sw2bank2(ioaddr) outb(BANK2_SELECT, ioaddr)
495
496	/* enable interrupt line */
497	#define eepro_en_intline(ioaddr) outb(inb(ioaddr + REG1) \| INT_ENABLE,\
498	ioaddr + REG1)
499
500	/* disable interrupt line */
501	#define eepro_dis_intline(ioaddr) outb(inb(ioaddr + REG1) & 0x7f, \
502	ioaddr + REG1);
503
504	/* set diagnose flag */
505	#define eepro_diag(ioaddr) outb(DIAGNOSE_CMD, ioaddr)
506
507	/* ack for rx int */
508	#define eepro_ack_rx(ioaddr) outb (RX_INT, ioaddr + STATUS_REG)
509
510	/* ack for tx int */
511	#define eepro_ack_tx(ioaddr) outb (TX_INT, ioaddr + STATUS_REG)
512
513	/* a complete sel reset */
514	#define eepro_complete_selreset(ioaddr) { \
515	dev->stats.tx_errors++;\
516	eepro_sel_reset(ioaddr);\
517	lp->tx_end = \
518	lp->xmt_lower_limit;\
519	lp->tx_start = lp->tx_end;\
520	lp->tx_last = 0;\
521	dev->trans_start = jiffies;\
522	netif_wake_queue(dev);\
523	eepro_en_rx(ioaddr);\
524	}
525
526	/* Check for a network adaptor of this type, and return '0' if one exists.
527	If dev->base_addr == 0, probe all likely locations.
528	If dev->base_addr == 1, always return failure.
529	If dev->base_addr == 2, allocate space for the device and return success
530	(detachable devices only).
531	*/
532	static int __init do_eepro_probe(struct net_device *dev)
533	{
534	int i;
535	int base_addr = dev->base_addr;
536	int irq = dev->irq;
537
538	#ifdef PnPWakeup
539	/* XXXX for multiple cards should this only be run once? */
540
541	/* Wakeup: */
542	#define WakeupPort 0x279
543	#define WakeupSeq {0x6A, 0xB5, 0xDA, 0xED, 0xF6, 0xFB, 0x7D, 0xBE,\
544	0xDF, 0x6F, 0x37, 0x1B, 0x0D, 0x86, 0xC3, 0x61,\
545	0xB0, 0x58, 0x2C, 0x16, 0x8B, 0x45, 0xA2, 0xD1,\
546	0xE8, 0x74, 0x3A, 0x9D, 0xCE, 0xE7, 0x73, 0x43}
547
548	{
549	unsigned short int WS[32]=WakeupSeq;
550
551	if (request_region(WakeupPort, 2, "eepro wakeup")) {
552	if (net_debug>5)
553	printk(KERN_DEBUG "Waking UP\n");
554
555	outb_p(0,WakeupPort);
556	outb_p(0,WakeupPort);
557	for (i=0; i<32; i++) {
558	outb_p(WS[i],WakeupPort);
559	if (net_debug>5) printk(KERN_DEBUG ": %#x ",WS[i]);
560	}
561
562	release_region(WakeupPort, 2);
563	} else
564	printk(KERN_WARNING "PnP wakeup region busy!\n");
565	}
566	#endif
567
568	if (base_addr > 0x1ff) /* Check a single specified location. */
569	return eepro_probe1(dev, 0);
570
571	else if (base_addr != 0) /* Don't probe at all. */
572	return -ENXIO;
573
574	for (i = 0; eepro_portlist[i]; i++) {
575	dev->base_addr = eepro_portlist[i];
576	dev->irq = irq;
577	if (eepro_probe1(dev, 1) == 0)
578	return 0;
579	}
580
581	return -ENODEV;
582	}
583
584	#ifndef MODULE
585	struct net_device * __init eepro_probe(int unit)
586	{
587	struct net_device *dev = alloc_etherdev(sizeof(struct eepro_local));
588	int err;
589
590	if (!dev)
591	return ERR_PTR(-ENODEV);
592
593	sprintf(dev->name, "eth%d", unit);
594	netdev_boot_setup_check(dev);
595
596	err = do_eepro_probe(dev);
597	if (err)
598	goto out;
599	return dev;
600	out:
601	free_netdev(dev);
602	return ERR_PTR(err);
603	}
604	#endif
605
606	static void __init printEEPROMInfo(struct net_device *dev)
607	{
608	struct eepro_local *lp = netdev_priv(dev);
609	int ioaddr = dev->base_addr;
610	unsigned short Word;
611	int i,j;
612
613	j = ee_Checksum;
614	for (i = 0; i < 8; i++)
615	j += lp->word[i];
616	for ( ; i < ee_SIZE; i++)
617	j += read_eeprom(ioaddr, i, dev);
618
619	printk(KERN_DEBUG "Checksum: %#x\n",j&0xffff);
620
621	Word = lp->word[0];
622	printk(KERN_DEBUG "Word0:\n");
623	printk(KERN_DEBUG " Plug 'n Pray: %d\n",GetBit(Word,ee_PnP));
624	printk(KERN_DEBUG " Buswidth: %d\n",(GetBit(Word,ee_BusWidth)+1)*8 );
625	printk(KERN_DEBUG " AutoNegotiation: %d\n",GetBit(Word,ee_AutoNeg));
626	printk(KERN_DEBUG " IO Address: %#x\n", (Word>>ee_IO0)<<4);
627
628	if (net_debug>4) {
629	Word = lp->word[1];
630	printk(KERN_DEBUG "Word1:\n");
631	printk(KERN_DEBUG " INT: %d\n", Word & ee_IntMask);
632	printk(KERN_DEBUG " LI: %d\n", GetBit(Word,ee_LI));
633	printk(KERN_DEBUG " PC: %d\n", GetBit(Word,ee_PC));
634	printk(KERN_DEBUG " TPE/AUI: %d\n", GetBit(Word,ee_TPE_AUI));
635	printk(KERN_DEBUG " Jabber: %d\n", GetBit(Word,ee_Jabber));
636	printk(KERN_DEBUG " AutoPort: %d\n", !GetBit(Word,ee_AutoPort));
637	printk(KERN_DEBUG " Duplex: %d\n", GetBit(Word,ee_Duplex));
638	}
639
640	Word = lp->word[5];
641	printk(KERN_DEBUG "Word5:\n");
642	printk(KERN_DEBUG " BNC: %d\n",GetBit(Word,ee_BNC_TPE));
643	printk(KERN_DEBUG " NumConnectors: %d\n",GetBit(Word,ee_NumConn));
644	printk(KERN_DEBUG " Has ");
645	if (GetBit(Word,ee_PortTPE)) printk(KERN_DEBUG "TPE ");
646	if (GetBit(Word,ee_PortBNC)) printk(KERN_DEBUG "BNC ");
647	if (GetBit(Word,ee_PortAUI)) printk(KERN_DEBUG "AUI ");
648	printk(KERN_DEBUG "port(s) \n");
649
650	Word = lp->word[6];
651	printk(KERN_DEBUG "Word6:\n");
652	printk(KERN_DEBUG " Stepping: %d\n",Word & ee_StepMask);
653	printk(KERN_DEBUG " BoardID: %d\n",Word>>ee_BoardID);
654
655	Word = lp->word[7];
656	printk(KERN_DEBUG "Word7:\n");
657	printk(KERN_DEBUG " INT to IRQ:\n");
658
659	for (i=0, j=0; i<15; i++)
660	if (GetBit(Word,i)) printk(KERN_DEBUG " INT%d -> IRQ %d;",j++,i);
661
662	printk(KERN_DEBUG "\n");
663	}
664
665	/* function to recalculate the limits of buffer based on rcv_ram */
666	static void eepro_recalc (struct net_device *dev)
667	{
668	struct eepro_local * lp;
669
670	lp = netdev_priv(dev);
671	lp->xmt_ram = RAM_SIZE - lp->rcv_ram;
672
673	if (lp->eepro == LAN595FX_10ISA) {
674	lp->xmt_lower_limit = XMT_START_10;
675	lp->xmt_upper_limit = (lp->xmt_ram - 2);
676	lp->rcv_lower_limit = lp->xmt_ram;
677	lp->rcv_upper_limit = (RAM_SIZE - 2);
678	}
679	else {
680	lp->rcv_lower_limit = RCV_START_PRO;
681	lp->rcv_upper_limit = (lp->rcv_ram - 2);
682	lp->xmt_lower_limit = lp->rcv_ram;
683	lp->xmt_upper_limit = (RAM_SIZE - 2);
684	}
685	}
686
687	/* prints boot-time info */
688	static void __init eepro_print_info (struct net_device *dev)
689	{
690	struct eepro_local * lp = netdev_priv(dev);
691	int i;
692	const char * ifmap[] = {"AUI", "10Base2", "10BaseT"};
693
694	i = inb(dev->base_addr + ID_REG);
695	printk(KERN_DEBUG " id: %#x ",i);
696	printk(" io: %#x ", (unsigned)dev->base_addr);
697
698	switch (lp->eepro) {
699	case LAN595FX_10ISA:
700	printk("%s: Intel EtherExpress 10 ISA\n at %#x,",
701	dev->name, (unsigned)dev->base_addr);
702	break;
703	case LAN595FX:
704	printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,",
705	dev->name, (unsigned)dev->base_addr);
706	break;
707	case LAN595TX:
708	printk("%s: Intel EtherExpress Pro/10 ISA at %#x,",
709	dev->name, (unsigned)dev->base_addr);
710	break;
711	case LAN595:
712	printk("%s: Intel 82595-based lan card at %#x,",
713	dev->name, (unsigned)dev->base_addr);
714	break;
715	}
716
717	printk(" %pM", dev->dev_addr);
718
719	if (net_debug > 3)
720	printk(KERN_DEBUG ", %dK RCV buffer",
721	(int)(lp->rcv_ram)/1024);
722
723	if (dev->irq > 2)
724	printk(", IRQ %d, %s.\n", dev->irq, ifmap[dev->if_port]);
725	else
726	printk(", %s.\n", ifmap[dev->if_port]);
727
728	if (net_debug > 3) {
729	i = lp->word[5];
730	if (i & 0x2000) /* bit 13 of EEPROM word 5 */
731	printk(KERN_DEBUG "%s: Concurrent Processing is "
732	"enabled but not used!\n", dev->name);
733	}
734
735	/* Check the station address for the manufacturer's code */
736	if (net_debug>3)
737	printEEPROMInfo(dev);
738	}
739
740	static const struct ethtool_ops eepro_ethtool_ops;
741
742	static const struct net_device_ops eepro_netdev_ops = {
743	.ndo_open = eepro_open,
744	.ndo_stop = eepro_close,
745	.ndo_start_xmit = eepro_send_packet,
746	.ndo_set_multicast_list = set_multicast_list,
747	.ndo_tx_timeout = eepro_tx_timeout,
748	.ndo_change_mtu = eth_change_mtu,
749	.ndo_set_mac_address = eth_mac_addr,
750	.ndo_validate_addr = eth_validate_addr,
751	};
752
753	/* This is the real probe routine. Linux has a history of friendly device
754	probes on the ISA bus. A good device probe avoids doing writes, and
755	verifies that the correct device exists and functions. */
756
757	static int __init eepro_probe1(struct net_device *dev, int autoprobe)
758	{
759	unsigned short station_addr[3], id, counter;
760	int i;
761	struct eepro_local *lp;
762	int ioaddr = dev->base_addr;
763	int err;
764
765	/* Grab the region so we can find another board if autoIRQ fails. */
766	if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) {
767	if (!autoprobe)
768	printk(KERN_WARNING "EEPRO: io-port 0x%04x in use \n",
769	ioaddr);
770	return -EBUSY;
771	}
772
773	/* Now, we are going to check for the signature of the
774	ID_REG (register 2 of bank 0) */
775
776	id = inb(ioaddr + ID_REG);
777
778	if ((id & ID_REG_MASK) != ID_REG_SIG)
779	goto exit;
780
781	/* We seem to have the 82595 signature, let's
782	play with its counter (last 2 bits of
783	register 2 of bank 0) to be sure. */
784
785	counter = id & R_ROBIN_BITS;
786
787	if ((inb(ioaddr + ID_REG) & R_ROBIN_BITS) != (counter + 0x40))
788	goto exit;
789
790	lp = netdev_priv(dev);
791	memset(lp, 0, sizeof(struct eepro_local));
792	lp->xmt_bar = XMT_BAR_PRO;
793	lp->xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_PRO;
794	lp->xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_PRO;
795	lp->eeprom_reg = EEPROM_REG_PRO;
796	spin_lock_init(&lp->lock);
797
798	/* Now, get the ethernet hardware address from
799	the EEPROM */
800	station_addr[0] = read_eeprom(ioaddr, 2, dev);
801
802	/* FIXME - find another way to know that we've found
803	* an Etherexpress 10
804	*/
805	if (station_addr[0] == 0x0000 \|\| station_addr[0] == 0xffff) {
806	lp->eepro = LAN595FX_10ISA;
807	lp->eeprom_reg = EEPROM_REG_10;
808	lp->xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_10;
809	lp->xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_10;
810	lp->xmt_bar = XMT_BAR_10;
811	station_addr[0] = read_eeprom(ioaddr, 2, dev);
812	}
813
814	/* get all words at once. will be used here and for ethtool */
815	for (i = 0; i < 8; i++) {
816	lp->word[i] = read_eeprom(ioaddr, i, dev);
817	}
818	station_addr[1] = lp->word[3];
819	station_addr[2] = lp->word[4];
820
821	if (!lp->eepro) {
822	if (lp->word[7] == ee_FX_INT2IRQ)
823	lp->eepro = 2;
824	else if (station_addr[2] == SA_ADDR1)
825	lp->eepro = 1;
826	}
827
828	/* Fill in the 'dev' fields. */
829	for (i=0; i < 6; i++)
830	dev->dev_addr[i] = ((unsigned char *) station_addr)[5-i];
831
832	/* RX buffer must be more than 3K and less than 29K */
833	if (dev->mem_end < 3072 \|\| dev->mem_end > 29696)
834	lp->rcv_ram = RCV_DEFAULT_RAM;
835
836	/* calculate {xmt,rcv}_{lower,upper}_limit */
837	eepro_recalc(dev);
838
839	if (GetBit(lp->word[5], ee_BNC_TPE))
840	dev->if_port = BNC;
841	else
842	dev->if_port = TPE;
843
844	if (dev->irq < 2 && lp->eepro != 0) {
845	/* Mask off INT number */
846	int count = lp->word[1] & 7;
847	unsigned irqMask = lp->word[7];
848
849	while (count--)
850	irqMask &= irqMask - 1;
851
852	count = ffs(irqMask);
853
854	if (count)
855	dev->irq = count - 1;
856
857	if (dev->irq < 2) {
858	printk(KERN_ERR " Duh! illegal interrupt vector stored in EEPROM.\n");
859	goto exit;
860	} else if (dev->irq == 2) {
861	dev->irq = 9;
862	}
863	}
864
865	dev->netdev_ops = &eepro_netdev_ops;
866	dev->watchdog_timeo = TX_TIMEOUT;
867	dev->ethtool_ops = &eepro_ethtool_ops;
868
869	/* print boot time info */
870	eepro_print_info(dev);
871
872	/* reset 82595 */
873	eepro_reset(ioaddr);
874
875	err = register_netdev(dev);
876	if (err)
877	goto err;
878	return 0;
879	exit:
880	err = -ENODEV;
881	err:
882	release_region(dev->base_addr, EEPRO_IO_EXTENT);
883	return err;
884	}
885
886	/* Open/initialize the board. This is called (in the current kernel)
887	sometime after booting when the 'ifconfig' program is run.
888
889	This routine should set everything up anew at each open, even
890	registers that "should" only need to be set once at boot, so that
891	there is non-reboot way to recover if something goes wrong.
892	*/
893
894	static char irqrmap[] = {-1,-1,0,1,-1,2,-1,-1,-1,0,3,4,-1,-1,-1,-1};
895	static char irqrmap2[] = {-1,-1,4,0,1,2,-1,3,-1,4,5,6,7,-1,-1,-1};
896	static int eepro_grab_irq(struct net_device *dev)
897	{
898	int irqlist[] = { 3, 4, 5, 7, 9, 10, 11, 12, 0 };
899	int *irqp = irqlist, temp_reg, ioaddr = dev->base_addr;
900
901	eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */
902
903	/* Enable the interrupt line. */
904	eepro_en_intline(ioaddr);
905
906	/* be CAREFUL, BANK 0 now */
907	eepro_sw2bank0(ioaddr);
908
909	/* clear all interrupts */
910	eepro_clear_int(ioaddr);
911
912	/* Let EXEC event to interrupt */
913	eepro_en_intexec(ioaddr);
914
915	do {
916	eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */
917
918	temp_reg = inb(ioaddr + INT_NO_REG);
919	outb((temp_reg & 0xf8) \| irqrmap[*irqp], ioaddr + INT_NO_REG);
920
921	eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
922
923	if (request_irq (*irqp, NULL, IRQF_SHARED, "bogus", dev) != EBUSY) {
924	unsigned long irq_mask;
925	/* Twinkle the interrupt, and check if it's seen */
926	irq_mask = probe_irq_on();
927
928	eepro_diag(ioaddr); /* RESET the 82595 */
929	mdelay(20);
930
931	if (irqp == probe_irq_off(irq_mask)) / It's a good IRQ line */
932	break;
933
934	/* clear all interrupts */
935	eepro_clear_int(ioaddr);
936	}
937	} while (*++irqp);
938
939	eepro_sw2bank1(ioaddr); /* Switch back to Bank 1 */
940
941	/* Disable the physical interrupt line. */
942	eepro_dis_intline(ioaddr);
943
944	eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
945
946	/* Mask all the interrupts. */
947	eepro_dis_int(ioaddr);
948
949	/* clear all interrupts */
950	eepro_clear_int(ioaddr);
951
952	return dev->irq;
953	}
954
955	static int eepro_open(struct net_device *dev)
956	{
957	unsigned short temp_reg, old8, old9;
958	int irqMask;
959	int i, ioaddr = dev->base_addr;
960	struct eepro_local *lp = netdev_priv(dev);
961
962	if (net_debug > 3)
963	printk(KERN_DEBUG "%s: entering eepro_open routine.\n", dev->name);
964
965	irqMask = lp->word[7];
966
967	if (lp->eepro == LAN595FX_10ISA) {
968	if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 3;\n");
969	}
970	else if (irqMask == ee_FX_INT2IRQ) /* INT to IRQ Mask */
971	{
972	lp->eepro = 2; /* Yes, an Intel EtherExpress Pro/10+ */
973	if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 2;\n");
974	}
975
976	else if ((dev->dev_addr[0] == SA_ADDR0 &&
977	dev->dev_addr[1] == SA_ADDR1 &&
978	dev->dev_addr[2] == SA_ADDR2))
979	{
980	lp->eepro = 1;
981	if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 1;\n");
982	} /* Yes, an Intel EtherExpress Pro/10 */
983
984	else lp->eepro = 0; /* No, it is a generic 82585 lan card */
985
986	/* Get the interrupt vector for the 82595 */
987	if (dev->irq < 2 && eepro_grab_irq(dev) == 0) {
988	printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
989	return -EAGAIN;
990	}
991
992	if (request_irq(dev->irq , &eepro_interrupt, 0, dev->name, dev)) {
993	printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
994	return -EAGAIN;
995	}
996
997	/* Initialize the 82595. */
998
999	eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1000	temp_reg = inb(ioaddr + lp->eeprom_reg);
1001
1002	lp->stepping = temp_reg >> 5; /* Get the stepping number of the 595 */
1003
1004	if (net_debug > 3)
1005	printk(KERN_DEBUG "The stepping of the 82595 is %d\n", lp->stepping);
1006
1007	if (temp_reg & 0x10) /* Check the TurnOff Enable bit */
1008	outb(temp_reg & 0xef, ioaddr + lp->eeprom_reg);
1009	for (i=0; i < 6; i++)
1010	outb(dev->dev_addr[i] , ioaddr + I_ADD_REG0 + i);
1011
1012	temp_reg = inb(ioaddr + REG1); /* Setup Transmit Chaining */
1013	outb(temp_reg \| XMT_Chain_Int \| XMT_Chain_ErrStop /* and discard bad RCV frames */
1014	\| RCV_Discard_BadFrame, ioaddr + REG1);
1015
1016	temp_reg = inb(ioaddr + REG2); /* Match broadcast */
1017	outb(temp_reg \| 0x14, ioaddr + REG2);
1018
1019	temp_reg = inb(ioaddr + REG3);
1020	outb(temp_reg & 0x3f, ioaddr + REG3); /* clear test mode */
1021
1022	/* Set the receiving mode */
1023	eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */
1024
1025	/* Set the interrupt vector */
1026	temp_reg = inb(ioaddr + INT_NO_REG);
1027	if (lp->eepro == LAN595FX \|\| lp->eepro == LAN595FX_10ISA)
1028	outb((temp_reg & 0xf8) \| irqrmap2[dev->irq], ioaddr + INT_NO_REG);
1029	else outb((temp_reg & 0xf8) \| irqrmap[dev->irq], ioaddr + INT_NO_REG);
1030
1031
1032	temp_reg = inb(ioaddr + INT_NO_REG);
1033	if (lp->eepro == LAN595FX \|\| lp->eepro == LAN595FX_10ISA)
1034	outb((temp_reg & 0xf0) \| irqrmap2[dev->irq] \| 0x08,ioaddr+INT_NO_REG);
1035	else outb((temp_reg & 0xf8) \| irqrmap[dev->irq], ioaddr + INT_NO_REG);
1036
1037	if (net_debug > 3)
1038	printk(KERN_DEBUG "eepro_open: content of INT Reg is %x\n", temp_reg);
1039
1040
1041	/* Initialize the RCV and XMT upper and lower limits */
1042	outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG);
1043	outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG);
1044	outb(lp->xmt_lower_limit >> 8, ioaddr + lp->xmt_lower_limit_reg);
1045	outb(lp->xmt_upper_limit >> 8, ioaddr + lp->xmt_upper_limit_reg);
1046
1047	/* Enable the interrupt line. */
1048	eepro_en_intline(ioaddr);
1049
1050	/* Switch back to Bank 0 */
1051	eepro_sw2bank0(ioaddr);
1052
1053	/* Let RX and TX events to interrupt */
1054	eepro_en_int(ioaddr);
1055
1056	/* clear all interrupts */
1057	eepro_clear_int(ioaddr);
1058
1059	/* Initialize RCV */
1060	outw(lp->rcv_lower_limit, ioaddr + RCV_BAR);
1061	lp->rx_start = lp->rcv_lower_limit;
1062	outw(lp->rcv_upper_limit \| 0xfe, ioaddr + RCV_STOP);
1063
1064	/* Initialize XMT */
1065	outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar);
1066	lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
1067	lp->tx_last = 0;
1068
1069	/* Check for the i82595TX and i82595FX */
1070	old8 = inb(ioaddr + 8);
1071	outb(~old8, ioaddr + 8);
1072
1073	if ((temp_reg = inb(ioaddr + 8)) == old8) {
1074	if (net_debug > 3)
1075	printk(KERN_DEBUG "i82595 detected!\n");
1076	lp->version = LAN595;
1077	}
1078	else {
1079	lp->version = LAN595TX;
1080	outb(old8, ioaddr + 8);
1081	old9 = inb(ioaddr + 9);
1082
1083	if (irqMask==ee_FX_INT2IRQ) {
1084	if (net_debug > 3) {
1085	printk(KERN_DEBUG "IrqMask: %#x\n",irqMask);
1086	printk(KERN_DEBUG "i82595FX detected!\n");
1087	}
1088	lp->version = LAN595FX;
1089	outb(old9, ioaddr + 9);
1090	if (dev->if_port != TPE) { /* Hopefully, this will fix the
1091	problem of using Pentiums and
1092	pro/10 w/ BNC. */
1093	eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1094	temp_reg = inb(ioaddr + REG13);
1095	/* disable the full duplex mode since it is not
1096	applicable with the 10Base2 cable. */
1097	outb(temp_reg & ~(FDX \| A_N_ENABLE), REG13);
1098	eepro_sw2bank0(ioaddr); /* be CAREFUL, BANK 0 now */
1099	}
1100	}
1101	else if (net_debug > 3) {
1102	printk(KERN_DEBUG "temp_reg: %#x ~old9: %#x\n",temp_reg,((~old9)&0xff));
1103	printk(KERN_DEBUG "i82595TX detected!\n");
1104	}
1105	}
1106
1107	eepro_sel_reset(ioaddr);
1108
1109	netif_start_queue(dev);
1110
1111	if (net_debug > 3)
1112	printk(KERN_DEBUG "%s: exiting eepro_open routine.\n", dev->name);
1113
1114	/* enabling rx */
1115	eepro_en_rx(ioaddr);
1116
1117	return 0;
1118	}
1119
1120	static void eepro_tx_timeout (struct net_device *dev)
1121	{
1122	struct eepro_local *lp = netdev_priv(dev);
1123	int ioaddr = dev->base_addr;
1124
1125	/* if (net_debug > 1) */
1126	printk (KERN_ERR "%s: transmit timed out, %s?\n", dev->name,
1127	"network cable problem");
1128	/* This is not a duplicate. One message for the console,
1129	one for the log file */
1130	printk (KERN_DEBUG "%s: transmit timed out, %s?\n", dev->name,
1131	"network cable problem");
1132	eepro_complete_selreset(ioaddr);
1133	}
1134
1135
1136	static int eepro_send_packet(struct sk_buff skb, struct net_device dev)
1137	{
1138	struct eepro_local *lp = netdev_priv(dev);
1139	unsigned long flags;
1140	int ioaddr = dev->base_addr;
1141	short length = skb->len;
1142
1143	if (net_debug > 5)
1144	printk(KERN_DEBUG "%s: entering eepro_send_packet routine.\n", dev->name);
1145
1146	if (length < ETH_ZLEN) {
1147	if (skb_padto(skb, ETH_ZLEN))
1148	return 0;
1149	length = ETH_ZLEN;
1150	}
1151	netif_stop_queue (dev);
1152
1153	eepro_dis_int(ioaddr);
1154	spin_lock_irqsave(&lp->lock, flags);
1155
1156	{
1157	unsigned char *buf = skb->data;
1158
1159	if (hardware_send_packet(dev, buf, length))
1160	/* we won't wake queue here because we're out of space */
1161	dev->stats.tx_dropped++;
1162	else {
1163	dev->stats.tx_bytes+=skb->len;
1164	dev->trans_start = jiffies;
1165	netif_wake_queue(dev);
1166	}
1167
1168	}
1169
1170	dev_kfree_skb (skb);
1171
1172	/* You might need to clean up and record Tx statistics here. */
1173	/* dev->stats.tx_aborted_errors++; */
1174
1175	if (net_debug > 5)
1176	printk(KERN_DEBUG "%s: exiting eepro_send_packet routine.\n", dev->name);
1177
1178	eepro_en_int(ioaddr);
1179	spin_unlock_irqrestore(&lp->lock, flags);
1180
1181	return 0;
1182	}
1183
1184
1185	/* The typical workload of the driver:
1186	Handle the network interface interrupts. */
1187
1188	static irqreturn_t
1189	eepro_interrupt(int irq, void *dev_id)
1190	{
1191	struct net_device *dev = dev_id;
1192	struct eepro_local *lp;
1193	int ioaddr, status, boguscount = 20;
1194	int handled = 0;
1195
1196	lp = netdev_priv(dev);
1197
1198	spin_lock(&lp->lock);
1199
1200	if (net_debug > 5)
1201	printk(KERN_DEBUG "%s: entering eepro_interrupt routine.\n", dev->name);
1202
1203	ioaddr = dev->base_addr;
1204
1205	while (((status = inb(ioaddr + STATUS_REG)) & (RX_INT\|TX_INT)) && (boguscount--))
1206	{
1207	handled = 1;
1208	if (status & RX_INT) {
1209	if (net_debug > 4)
1210	printk(KERN_DEBUG "%s: packet received interrupt.\n", dev->name);
1211
1212	eepro_dis_int(ioaddr);
1213
1214	/* Get the received packets */
1215	eepro_ack_rx(ioaddr);
1216	eepro_rx(dev);
1217
1218	eepro_en_int(ioaddr);
1219	}
1220	if (status & TX_INT) {
1221	if (net_debug > 4)
1222	printk(KERN_DEBUG "%s: packet transmit interrupt.\n", dev->name);
1223
1224
1225	eepro_dis_int(ioaddr);
1226
1227	/* Process the status of transmitted packets */
1228	eepro_ack_tx(ioaddr);
1229	eepro_transmit_interrupt(dev);
1230
1231	eepro_en_int(ioaddr);
1232	}
1233	}
1234
1235	if (net_debug > 5)
1236	printk(KERN_DEBUG "%s: exiting eepro_interrupt routine.\n", dev->name);
1237
1238	spin_unlock(&lp->lock);
1239	return IRQ_RETVAL(handled);
1240	}
1241
1242	static int eepro_close(struct net_device *dev)
1243	{
1244	struct eepro_local *lp = netdev_priv(dev);
1245	int ioaddr = dev->base_addr;
1246	short temp_reg;
1247
1248	netif_stop_queue(dev);
1249
1250	eepro_sw2bank1(ioaddr); /* Switch back to Bank 1 */
1251
1252	/* Disable the physical interrupt line. */
1253	temp_reg = inb(ioaddr + REG1);
1254	outb(temp_reg & 0x7f, ioaddr + REG1);
1255
1256	eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
1257
1258	/* Flush the Tx and disable Rx. */
1259	outb(STOP_RCV_CMD, ioaddr);
1260	lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
1261	lp->tx_last = 0;
1262
1263	/* Mask all the interrupts. */
1264	eepro_dis_int(ioaddr);
1265
1266	/* clear all interrupts */
1267	eepro_clear_int(ioaddr);
1268
1269	/* Reset the 82595 */
1270	eepro_reset(ioaddr);
1271
1272	/* release the interrupt */
1273	free_irq(dev->irq, dev);
1274
1275	/* Update the statistics here. What statistics? */
1276
1277	return 0;
1278	}
1279
1280	/* Set or clear the multicast filter for this adaptor.
1281	*/
1282	static void
1283	set_multicast_list(struct net_device *dev)
1284	{
1285	struct eepro_local *lp = netdev_priv(dev);
1286	short ioaddr = dev->base_addr;
1287	unsigned short mode;
1288	struct dev_mc_list *dmi=dev->mc_list;
1289
1290	if (dev->flags&(IFF_ALLMULTI\|IFF_PROMISC) \|\| dev->mc_count > 63)
1291	{
1292	eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1293	mode = inb(ioaddr + REG2);
1294	outb(mode \| PRMSC_Mode, ioaddr + REG2);
1295	mode = inb(ioaddr + REG3);
1296	outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
1297	eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
1298	}
1299
1300	else if (dev->mc_count==0 )
1301	{
1302	eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1303	mode = inb(ioaddr + REG2);
1304	outb(mode & 0xd6, ioaddr + REG2); /* Turn off Multi-IA and PRMSC_Mode bits */
1305	mode = inb(ioaddr + REG3);
1306	outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
1307	eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
1308	}
1309
1310	else
1311	{
1312	unsigned short status, *eaddrs;
1313	int i, boguscount = 0;
1314
1315	/* Disable RX and TX interrupts. Necessary to avoid
1316	corruption of the HOST_ADDRESS_REG by interrupt
1317	service routines. */
1318	eepro_dis_int(ioaddr);
1319
1320	eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1321	mode = inb(ioaddr + REG2);
1322	outb(mode \| Multi_IA, ioaddr + REG2);
1323	mode = inb(ioaddr + REG3);
1324	outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
1325	eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
1326	outw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
1327	outw(MC_SETUP, ioaddr + IO_PORT);
1328	outw(0, ioaddr + IO_PORT);
1329	outw(0, ioaddr + IO_PORT);
1330	outw(6*(dev->mc_count + 1), ioaddr + IO_PORT);
1331
1332	for (i = 0; i < dev->mc_count; i++)
1333	{
1334	eaddrs=(unsigned short *)dmi->dmi_addr;
1335	dmi=dmi->next;
1336	outw(*eaddrs++, ioaddr + IO_PORT);
1337	outw(*eaddrs++, ioaddr + IO_PORT);
1338	outw(*eaddrs++, ioaddr + IO_PORT);
1339	}
1340
1341	eaddrs = (unsigned short *) dev->dev_addr;
1342	outw(eaddrs[0], ioaddr + IO_PORT);
1343	outw(eaddrs[1], ioaddr + IO_PORT);
1344	outw(eaddrs[2], ioaddr + IO_PORT);
1345	outw(lp->tx_end, ioaddr + lp->xmt_bar);
1346	outb(MC_SETUP, ioaddr);
1347
1348	/* Update the transmit queue */
1349	i = lp->tx_end + XMT_HEADER + 6*(dev->mc_count + 1);
1350
1351	if (lp->tx_start != lp->tx_end)
1352	{
1353	/* update the next address and the chain bit in the
1354	last packet */
1355	outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
1356	outw(i, ioaddr + IO_PORT);
1357	outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
1358	status = inw(ioaddr + IO_PORT);
1359	outw(status \| CHAIN_BIT, ioaddr + IO_PORT);
1360	lp->tx_end = i ;
1361	}
1362	else {
1363	lp->tx_start = lp->tx_end = i ;
1364	}
1365
1366	/* Acknowledge that the MC setup is done */
1367	do { /* We should be doing this in the eepro_interrupt()! */
1368	SLOW_DOWN;
1369	SLOW_DOWN;
1370	if (inb(ioaddr + STATUS_REG) & 0x08)
1371	{
1372	i = inb(ioaddr);
1373	outb(0x08, ioaddr + STATUS_REG);
1374
1375	if (i & 0x20) { /* command ABORTed */
1376	printk(KERN_NOTICE "%s: multicast setup failed.\n",
1377	dev->name);
1378	break;
1379	} else if ((i & 0x0f) == 0x03) { /* MC-Done */
1380	printk(KERN_DEBUG "%s: set Rx mode to %d address%s.\n",
1381	dev->name, dev->mc_count,
1382	dev->mc_count > 1 ? "es":"");
1383	break;
1384	}
1385	}
1386	} while (++boguscount < 100);
1387
1388	/* Re-enable RX and TX interrupts */
1389	eepro_en_int(ioaddr);
1390	}
1391	if (lp->eepro == LAN595FX_10ISA) {
1392	eepro_complete_selreset(ioaddr);
1393	}
1394	else
1395	eepro_en_rx(ioaddr);
1396	}
1397
1398	/* The horrible routine to read a word from the serial EEPROM. */
1399	/* IMPORTANT - the 82595 will be set to Bank 0 after the eeprom is read */
1400
1401	/* The delay between EEPROM clock transitions. */
1402	#define eeprom_delay() { udelay(40); }
1403	#define EE_READ_CMD (6 << 6)
1404
1405	static int
1406	read_eeprom(int ioaddr, int location, struct net_device *dev)
1407	{
1408	int i;
1409	unsigned short retval = 0;
1410	struct eepro_local *lp = netdev_priv(dev);
1411	short ee_addr = ioaddr + lp->eeprom_reg;
1412	int read_cmd = location \| EE_READ_CMD;
1413	short ctrl_val = EECS ;
1414
1415	/* XXXX - black magic */
1416	eepro_sw2bank1(ioaddr);
1417	outb(0x00, ioaddr + STATUS_REG);
1418	/* XXXX - black magic */
1419
1420	eepro_sw2bank2(ioaddr);
1421	outb(ctrl_val, ee_addr);
1422
1423	/* Shift the read command bits out. */
1424	for (i = 8; i >= 0; i--) {
1425	short outval = (read_cmd & (1 << i)) ? ctrl_val \| EEDI
1426	: ctrl_val;
1427	outb(outval, ee_addr);
1428	outb(outval \| EESK, ee_addr); /* EEPROM clock tick. */
1429	eeprom_delay();
1430	outb(outval, ee_addr); /* Finish EEPROM a clock tick. */
1431	eeprom_delay();
1432	}
1433	outb(ctrl_val, ee_addr);
1434
1435	for (i = 16; i > 0; i--) {
1436	outb(ctrl_val \| EESK, ee_addr); eeprom_delay();
1437	retval = (retval << 1) \| ((inb(ee_addr) & EEDO) ? 1 : 0);
1438	outb(ctrl_val, ee_addr); eeprom_delay();
1439	}
1440
1441	/* Terminate the EEPROM access. */
1442	ctrl_val &= ~EECS;
1443	outb(ctrl_val \| EESK, ee_addr);
1444	eeprom_delay();
1445	outb(ctrl_val, ee_addr);
1446	eeprom_delay();
1447	eepro_sw2bank0(ioaddr);
1448	return retval;
1449	}
1450
1451	static int
1452	hardware_send_packet(struct net_device dev, void buf, short length)
1453	{
1454	struct eepro_local *lp = netdev_priv(dev);
1455	short ioaddr = dev->base_addr;
1456	unsigned status, tx_available, last, end;
1457
1458	if (net_debug > 5)
1459	printk(KERN_DEBUG "%s: entering hardware_send_packet routine.\n", dev->name);
1460
1461	/* determine how much of the transmit buffer space is available */
1462	if (lp->tx_end > lp->tx_start)
1463	tx_available = lp->xmt_ram - (lp->tx_end - lp->tx_start);
1464	else if (lp->tx_end < lp->tx_start)
1465	tx_available = lp->tx_start - lp->tx_end;
1466	else tx_available = lp->xmt_ram;
1467
1468	if (((((length + 3) >> 1) << 1) + 2*XMT_HEADER) >= tx_available) {
1469	/* No space available ??? */
1470	return 1;
1471	}
1472
1473	last = lp->tx_end;
1474	end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
1475
1476	if (end >= lp->xmt_upper_limit + 2) { /* the transmit buffer is wrapped around */
1477	if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {
1478	/* Arrrr!!!, must keep the xmt header together,
1479	several days were lost to chase this one down. */
1480	last = lp->xmt_lower_limit;
1481	end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
1482	}
1483	else end = lp->xmt_lower_limit + (end -
1484	lp->xmt_upper_limit + 2);
1485	}
1486
1487	outw(last, ioaddr + HOST_ADDRESS_REG);
1488	outw(XMT_CMD, ioaddr + IO_PORT);
1489	outw(0, ioaddr + IO_PORT);
1490	outw(end, ioaddr + IO_PORT);
1491	outw(length, ioaddr + IO_PORT);
1492
1493	if (lp->version == LAN595)
1494	outsw(ioaddr + IO_PORT, buf, (length + 3) >> 1);
1495	else { /* LAN595TX or LAN595FX, capable of 32-bit I/O processing */
1496	unsigned short temp = inb(ioaddr + INT_MASK_REG);
1497	outb(temp \| IO_32_BIT, ioaddr + INT_MASK_REG);
1498	outsl(ioaddr + IO_PORT_32_BIT, buf, (length + 3) >> 2);
1499	outb(temp & ~(IO_32_BIT), ioaddr + INT_MASK_REG);
1500	}
1501
1502	/* A dummy read to flush the DRAM write pipeline */
1503	status = inw(ioaddr + IO_PORT);
1504
1505	if (lp->tx_start == lp->tx_end) {
1506	outw(last, ioaddr + lp->xmt_bar);
1507	outb(XMT_CMD, ioaddr);
1508	lp->tx_start = last; /* I don't like to change tx_start here */
1509	}
1510	else {
1511	/* update the next address and the chain bit in the
1512	last packet */
1513
1514	if (lp->tx_end != last) {
1515	outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
1516	outw(last, ioaddr + IO_PORT);
1517	}
1518
1519	outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
1520	status = inw(ioaddr + IO_PORT);
1521	outw(status \| CHAIN_BIT, ioaddr + IO_PORT);
1522
1523	/* Continue the transmit command */
1524	outb(RESUME_XMT_CMD, ioaddr);
1525	}
1526
1527	lp->tx_last = last;
1528	lp->tx_end = end;
1529
1530	if (net_debug > 5)
1531	printk(KERN_DEBUG "%s: exiting hardware_send_packet routine.\n", dev->name);
1532
1533	return 0;
1534	}
1535
1536	static void
1537	eepro_rx(struct net_device *dev)
1538	{
1539	struct eepro_local *lp = netdev_priv(dev);
1540	short ioaddr = dev->base_addr;
1541	short boguscount = 20;
1542	short rcv_car = lp->rx_start;
1543	unsigned rcv_event, rcv_status, rcv_next_frame, rcv_size;
1544
1545	if (net_debug > 5)
1546	printk(KERN_DEBUG "%s: entering eepro_rx routine.\n", dev->name);
1547
1548	/* Set the read pointer to the start of the RCV */
1549	outw(rcv_car, ioaddr + HOST_ADDRESS_REG);
1550
1551	rcv_event = inw(ioaddr + IO_PORT);
1552
1553	while (rcv_event == RCV_DONE) {
1554
1555	rcv_status = inw(ioaddr + IO_PORT);
1556	rcv_next_frame = inw(ioaddr + IO_PORT);
1557	rcv_size = inw(ioaddr + IO_PORT);
1558
1559	if ((rcv_status & (RX_OK \| RX_ERROR)) == RX_OK) {
1560
1561	/* Malloc up new buffer. */
1562	struct sk_buff *skb;
1563
1564	dev->stats.rx_bytes+=rcv_size;
1565	rcv_size &= 0x3fff;
1566	skb = dev_alloc_skb(rcv_size+5);
1567	if (skb == NULL) {
1568	printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
1569	dev->stats.rx_dropped++;
1570	rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
1571	lp->rx_start = rcv_next_frame;
1572	outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
1573
1574	break;
1575	}
1576	skb_reserve(skb,2);
1577
1578	if (lp->version == LAN595)
1579	insw(ioaddr+IO_PORT, skb_put(skb,rcv_size), (rcv_size + 3) >> 1);
1580	else { /* LAN595TX or LAN595FX, capable of 32-bit I/O processing */
1581	unsigned short temp = inb(ioaddr + INT_MASK_REG);
1582	outb(temp \| IO_32_BIT, ioaddr + INT_MASK_REG);
1583	insl(ioaddr+IO_PORT_32_BIT, skb_put(skb,rcv_size),
1584	(rcv_size + 3) >> 2);
1585	outb(temp & ~(IO_32_BIT), ioaddr + INT_MASK_REG);
1586	}
1587
1588	skb->protocol = eth_type_trans(skb,dev);
1589	netif_rx(skb);
1590	dev->stats.rx_packets++;
1591	}
1592
1593	else { /* Not sure will ever reach here,
1594	I set the 595 to discard bad received frames */
1595	dev->stats.rx_errors++;
1596
1597	if (rcv_status & 0x0100)
1598	dev->stats.rx_over_errors++;
1599
1600	else if (rcv_status & 0x0400)
1601	dev->stats.rx_frame_errors++;
1602
1603	else if (rcv_status & 0x0800)
1604	dev->stats.rx_crc_errors++;
1605
1606	printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n",
1607	dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
1608	}
1609
1610	if (rcv_status & 0x1000)
1611	dev->stats.rx_length_errors++;
1612
1613	rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
1614	lp->rx_start = rcv_next_frame;
1615
1616	if (--boguscount == 0)
1617	break;
1618
1619	outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
1620	rcv_event = inw(ioaddr + IO_PORT);
1621
1622	}
1623	if (rcv_car == 0)
1624	rcv_car = lp->rcv_upper_limit \| 0xff;
1625
1626	outw(rcv_car - 1, ioaddr + RCV_STOP);
1627
1628	if (net_debug > 5)
1629	printk(KERN_DEBUG "%s: exiting eepro_rx routine.\n", dev->name);
1630	}
1631
1632	static void
1633	eepro_transmit_interrupt(struct net_device *dev)
1634	{
1635	struct eepro_local *lp = netdev_priv(dev);
1636	short ioaddr = dev->base_addr;
1637	short boguscount = 25;
1638	short xmt_status;
1639
1640	while ((lp->tx_start != lp->tx_end) && boguscount--) {
1641
1642	outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
1643	xmt_status = inw(ioaddr+IO_PORT);
1644
1645	if (!(xmt_status & TX_DONE_BIT))
1646	break;
1647
1648	xmt_status = inw(ioaddr+IO_PORT);
1649	lp->tx_start = inw(ioaddr+IO_PORT);
1650
1651	netif_wake_queue (dev);
1652
1653	if (xmt_status & TX_OK)
1654	dev->stats.tx_packets++;
1655	else {
1656	dev->stats.tx_errors++;
1657	if (xmt_status & 0x0400) {
1658	dev->stats.tx_carrier_errors++;
1659	printk(KERN_DEBUG "%s: carrier error\n",
1660	dev->name);
1661	printk(KERN_DEBUG "%s: XMT status = %#x\n",
1662	dev->name, xmt_status);
1663	}
1664	else {
1665	printk(KERN_DEBUG "%s: XMT status = %#x\n",
1666	dev->name, xmt_status);
1667	printk(KERN_DEBUG "%s: XMT status = %#x\n",
1668	dev->name, xmt_status);
1669	}
1670	}
1671	if (xmt_status & 0x000f) {
1672	dev->stats.collisions += (xmt_status & 0x000f);
1673	}
1674
1675	if ((xmt_status & 0x0040) == 0x0) {
1676	dev->stats.tx_heartbeat_errors++;
1677	}
1678	}
1679	}
1680
1681	static int eepro_ethtool_get_settings(struct net_device *dev,
1682	struct ethtool_cmd *cmd)
1683	{
1684	struct eepro_local *lp = netdev_priv(dev);
1685
1686	cmd->supported = SUPPORTED_10baseT_Half \|
1687	SUPPORTED_10baseT_Full \|
1688	SUPPORTED_Autoneg;
1689	cmd->advertising = ADVERTISED_10baseT_Half \|
1690	ADVERTISED_10baseT_Full \|
1691	ADVERTISED_Autoneg;
1692
1693	if (GetBit(lp->word[5], ee_PortTPE)) {
1694	cmd->supported \|= SUPPORTED_TP;
1695	cmd->advertising \|= ADVERTISED_TP;
1696	}
1697	if (GetBit(lp->word[5], ee_PortBNC)) {
1698	cmd->supported \|= SUPPORTED_BNC;
1699	cmd->advertising \|= ADVERTISED_BNC;
1700	}
1701	if (GetBit(lp->word[5], ee_PortAUI)) {
1702	cmd->supported \|= SUPPORTED_AUI;
1703	cmd->advertising \|= ADVERTISED_AUI;
1704	}
1705
1706	cmd->speed = SPEED_10;
1707
1708	if (dev->if_port == TPE && lp->word[1] & ee_Duplex) {
1709	cmd->duplex = DUPLEX_FULL;
1710	}
1711	else {
1712	cmd->duplex = DUPLEX_HALF;
1713	}
1714
1715	cmd->port = dev->if_port;
1716	cmd->phy_address = dev->base_addr;
1717	cmd->transceiver = XCVR_INTERNAL;
1718
1719	if (lp->word[0] & ee_AutoNeg) {
1720	cmd->autoneg = 1;
1721	}
1722
1723	return 0;
1724	}
1725
1726	static void eepro_ethtool_get_drvinfo(struct net_device *dev,
1727	struct ethtool_drvinfo *drvinfo)
1728	{
1729	strcpy(drvinfo->driver, DRV_NAME);
1730	strcpy(drvinfo->version, DRV_VERSION);
1731	sprintf(drvinfo->bus_info, "ISA 0x%lx", dev->base_addr);
1732	}
1733
1734	static const struct ethtool_ops eepro_ethtool_ops = {
1735	.get_settings = eepro_ethtool_get_settings,
1736	.get_drvinfo = eepro_ethtool_get_drvinfo,
1737	};
1738
1739	#ifdef MODULE
1740
1741	#define MAX_EEPRO 8
1742	static struct net_device *dev_eepro[MAX_EEPRO];
1743
1744	static int io[MAX_EEPRO] = {
1745	[0 ... MAX_EEPRO-1] = -1
1746	};
1747	static int irq[MAX_EEPRO];
1748	static int mem[MAX_EEPRO] = { /* Size of the rx buffer in KB */
1749	[0 ... MAX_EEPRO-1] = RCV_DEFAULT_RAM/1024
1750	};
1751	static int autodetect;
1752
1753	static int n_eepro;
1754	/* For linux 2.1.xx */
1755
1756	MODULE_AUTHOR("Pascal Dupuis and others");
1757	MODULE_DESCRIPTION("Intel i82595 ISA EtherExpressPro10/10+ driver");
1758	MODULE_LICENSE("GPL");
1759
1760	module_param_array(io, int, NULL, 0);
1761	module_param_array(irq, int, NULL, 0);
1762	module_param_array(mem, int, NULL, 0);
1763	module_param(autodetect, int, 0);
1764	MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)");
1765	MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)");
1766	MODULE_PARM_DESC(mem, "EtherExpress Pro/10 Rx buffer size(es) in kB (3-29)");
1767	MODULE_PARM_DESC(autodetect, "EtherExpress Pro/10 force board(s) detection (0-1)");
1768
1769	int __init init_module(void)
1770	{
1771	struct net_device *dev;
1772	int i;
1773	if (io[0] == -1 && autodetect == 0) {
1774	printk(KERN_WARNING "eepro_init_module: Probe is very dangerous in ISA boards!\n");
1775	printk(KERN_WARNING "eepro_init_module: Please add \"autodetect=1\" to force probe\n");
1776	return -ENODEV;
1777	}
1778	else if (autodetect) {
1779	/* if autodetect is set then we must force detection */
1780	for (i = 0; i < MAX_EEPRO; i++) {
1781	io[i] = 0;
1782	}
1783
1784	printk(KERN_INFO "eepro_init_module: Auto-detecting boards (May God protect us...)\n");
1785	}
1786
1787	for (i = 0; i < MAX_EEPRO && io[i] != -1; i++) {
1788	dev = alloc_etherdev(sizeof(struct eepro_local));
1789	if (!dev)
1790	break;
1791
1792	dev->mem_end = mem[i];
1793	dev->base_addr = io[i];
1794	dev->irq = irq[i];
1795
1796	if (do_eepro_probe(dev) == 0) {
1797	dev_eepro[n_eepro++] = dev;
1798	continue;
1799	}
1800	free_netdev(dev);
1801	break;
1802	}
1803
1804	if (n_eepro)
1805	printk(KERN_INFO "%s", version);
1806
1807	return n_eepro ? 0 : -ENODEV;
1808	}
1809
1810	void __exit
1811	cleanup_module(void)
1812	{
1813	int i;
1814
1815	for (i=0; i<n_eepro; i++) {
1816	struct net_device *dev = dev_eepro[i];
1817	unregister_netdev(dev);
1818	release_region(dev->base_addr, EEPRO_IO_EXTENT);
1819	free_netdev(dev);
1820	}
1821	}
1822	#endif /* MODULE */
1823

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7

Kernel

Kernel Git Source Tree

Root/drivers/net/eepro.c

interactive