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