blob: e187c88ae1450329a51da2ba64024dd55da2c3e0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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"
Andy Gospodarekd5b20692006-09-11 17:39:18 -0400157#define DRV_VERSION "0.13c"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
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 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 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
310static int eepro_probe1(struct net_device *dev, int autoprobe);
311static int eepro_open(struct net_device *dev);
312static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100313static irqreturn_t eepro_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314static void eepro_rx(struct net_device *dev);
315static void eepro_transmit_interrupt(struct net_device *dev);
316static int eepro_close(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317static void set_multicast_list(struct net_device *dev);
318static void eepro_tx_timeout (struct net_device *dev);
319
320static int read_eeprom(int ioaddr, int location, struct net_device *dev);
321static int hardware_send_packet(struct net_device *dev, void *buf, short length);
322static int eepro_grab_irq(struct net_device *dev);
323
324/*
325 Details of the i82595.
326
327You will need either the datasheet or the user manual to understand what
328is going on here. The 82595 is very different from the 82586, 82593.
329
330The receive algorithm in eepro_rx() is just an implementation of the
331RCV ring structure that the Intel 82595 imposes at the hardware level.
332The receive buffer is set at 24K, and the transmit buffer is 8K. I
333am assuming that the total buffer memory is 32K, which is true for the
334Intel EtherExpress Pro/10. If it is less than that on a generic card,
335the driver will be broken.
336
337The transmit algorithm in the hardware_send_packet() is similar to the
338one in the eepro_rx(). The transmit buffer is a ring linked list.
339I just queue the next available packet to the end of the list. In my
340system, the 82595 is so fast that the list seems to always contain a
341single packet. In other systems with faster computers and more congested
342network traffics, the ring linked list should improve performance by
343allowing up to 8K worth of packets to be queued.
344
345The sizes of the receive and transmit buffers can now be changed via lilo
346or insmod. Lilo uses the appended line "ether=io,irq,debug,rx-buffer,eth0"
347where rx-buffer is in KB unit. Modules uses the parameter mem which is
348also in KB unit, for example "insmod io=io-address irq=0 mem=rx-buffer."
349The receive buffer has to be more than 3K or less than 29K. Otherwise,
350it is reset to the default of 24K, and, hence, 8K for the trasnmit
351buffer (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) { \
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700515 dev->stats.tx_errors++;\
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 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 */
532static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538#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
Jeff Garzikd61780c2005-10-30 15:01:51 -0800551 if (request_region(WakeupPort, 2, "eepro wakeup")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 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 }
Jeff Garzikd61780c2005-10-30 15:01:51 -0800561
562 release_region(WakeupPort, 2);
563 } else
564 printk(KERN_WARNING "PnP wakeup region busy!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 }
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
585struct 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600out:
601 free_netdev(dev);
602 return ERR_PTR(err);
603}
604#endif
605
606static void __init printEEPROMInfo(struct net_device *dev)
607{
Wang Chen4cf16532008-11-12 23:38:14 -0800608 struct eepro_local *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 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));
Harvey Harrison4e5b8642008-04-26 23:44:03 -0700636 printk(KERN_DEBUG " AutoPort: %d\n", !GetBit(Word,ee_AutoPort));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 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 */
666static 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 */
688static 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:
Jeff Garzikd61780c2005-10-30 15:01:51 -0800704 printk("%s: Intel EtherExpress Pro/10+ ISA\n at %#x,",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 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:
Jeff Garzikd61780c2005-10-30 15:01:51 -0800712 printk("%s: Intel 82595-based lan card at %#x,",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 dev->name, (unsigned)dev->base_addr);
Joe Perches0795af52007-10-03 17:59:30 -0700714 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 }
716
Johannes Berge1749612008-10-27 15:59:26 -0700717 printk(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
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]);
Jeff Garzikd61780c2005-10-30 15:01:51 -0800725 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 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
Jeff Garzik7282d492006-09-13 14:30:00 -0400740static const struct ethtool_ops eepro_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742/* This is the real probe routine. Linux has a history of friendly device
743 probes on the ISA bus. A good device probe avoids doing writes, and
744 verifies that the correct device exists and functions. */
745
746static int __init eepro_probe1(struct net_device *dev, int autoprobe)
747{
748 unsigned short station_addr[3], id, counter;
749 int i;
750 struct eepro_local *lp;
751 int ioaddr = dev->base_addr;
b1fc5502005-05-12 20:11:55 -0400752 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
754 /* Grab the region so we can find another board if autoIRQ fails. */
Jeff Garzikd61780c2005-10-30 15:01:51 -0800755 if (!request_region(ioaddr, EEPRO_IO_EXTENT, DRV_NAME)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (!autoprobe)
757 printk(KERN_WARNING "EEPRO: io-port 0x%04x in use \n",
758 ioaddr);
759 return -EBUSY;
760 }
761
762 /* Now, we are going to check for the signature of the
763 ID_REG (register 2 of bank 0) */
764
765 id = inb(ioaddr + ID_REG);
766
767 if ((id & ID_REG_MASK) != ID_REG_SIG)
768 goto exit;
769
770 /* We seem to have the 82595 signature, let's
771 play with its counter (last 2 bits of
772 register 2 of bank 0) to be sure. */
773
774 counter = id & R_ROBIN_BITS;
775
776 if ((inb(ioaddr + ID_REG) & R_ROBIN_BITS) != (counter + 0x40))
777 goto exit;
778
779 lp = netdev_priv(dev);
780 memset(lp, 0, sizeof(struct eepro_local));
781 lp->xmt_bar = XMT_BAR_PRO;
782 lp->xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_PRO;
783 lp->xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_PRO;
784 lp->eeprom_reg = EEPROM_REG_PRO;
785 spin_lock_init(&lp->lock);
786
787 /* Now, get the ethernet hardware address from
788 the EEPROM */
789 station_addr[0] = read_eeprom(ioaddr, 2, dev);
790
791 /* FIXME - find another way to know that we've found
792 * an Etherexpress 10
793 */
794 if (station_addr[0] == 0x0000 || station_addr[0] == 0xffff) {
795 lp->eepro = LAN595FX_10ISA;
796 lp->eeprom_reg = EEPROM_REG_10;
797 lp->xmt_lower_limit_reg = XMT_LOWER_LIMIT_REG_10;
798 lp->xmt_upper_limit_reg = XMT_UPPER_LIMIT_REG_10;
799 lp->xmt_bar = XMT_BAR_10;
800 station_addr[0] = read_eeprom(ioaddr, 2, dev);
801 }
802
803 /* get all words at once. will be used here and for ethtool */
804 for (i = 0; i < 8; i++) {
805 lp->word[i] = read_eeprom(ioaddr, i, dev);
806 }
807 station_addr[1] = lp->word[3];
808 station_addr[2] = lp->word[4];
809
810 if (!lp->eepro) {
811 if (lp->word[7] == ee_FX_INT2IRQ)
812 lp->eepro = 2;
813 else if (station_addr[2] == SA_ADDR1)
814 lp->eepro = 1;
815 }
816
817 /* Fill in the 'dev' fields. */
818 for (i=0; i < 6; i++)
819 dev->dev_addr[i] = ((unsigned char *) station_addr)[5-i];
820
821 /* RX buffer must be more than 3K and less than 29K */
822 if (dev->mem_end < 3072 || dev->mem_end > 29696)
823 lp->rcv_ram = RCV_DEFAULT_RAM;
824
825 /* calculate {xmt,rcv}_{lower,upper}_limit */
826 eepro_recalc(dev);
827
828 if (GetBit(lp->word[5], ee_BNC_TPE))
829 dev->if_port = BNC;
830 else
831 dev->if_port = TPE;
832
833 if (dev->irq < 2 && lp->eepro != 0) {
834 /* Mask off INT number */
835 int count = lp->word[1] & 7;
836 unsigned irqMask = lp->word[7];
Jeff Garzikd61780c2005-10-30 15:01:51 -0800837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 while (count--)
839 irqMask &= irqMask - 1;
Jeff Garzikd61780c2005-10-30 15:01:51 -0800840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 count = ffs(irqMask);
Jeff Garzikd61780c2005-10-30 15:01:51 -0800842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (count)
844 dev->irq = count - 1;
Jeff Garzikd61780c2005-10-30 15:01:51 -0800845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 if (dev->irq < 2) {
847 printk(KERN_ERR " Duh! illegal interrupt vector stored in EEPROM.\n");
848 goto exit;
849 } else if (dev->irq == 2) {
850 dev->irq = 9;
851 }
852 }
Jeff Garzikd61780c2005-10-30 15:01:51 -0800853
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 dev->open = eepro_open;
855 dev->stop = eepro_close;
856 dev->hard_start_xmit = eepro_send_packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 dev->set_multicast_list = &set_multicast_list;
858 dev->tx_timeout = eepro_tx_timeout;
859 dev->watchdog_timeo = TX_TIMEOUT;
860 dev->ethtool_ops = &eepro_ethtool_ops;
Jeff Garzikd61780c2005-10-30 15:01:51 -0800861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 /* print boot time info */
863 eepro_print_info(dev);
864
865 /* reset 82595 */
866 eepro_reset(ioaddr);
b1fc5502005-05-12 20:11:55 -0400867
868 err = register_netdev(dev);
869 if (err)
870 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 return 0;
872exit:
b1fc5502005-05-12 20:11:55 -0400873 err = -ENODEV;
874err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 release_region(dev->base_addr, EEPRO_IO_EXTENT);
b1fc5502005-05-12 20:11:55 -0400876 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
879/* Open/initialize the board. This is called (in the current kernel)
880 sometime after booting when the 'ifconfig' program is run.
881
882 This routine should set everything up anew at each open, even
883 registers that "should" only need to be set once at boot, so that
884 there is non-reboot way to recover if something goes wrong.
885 */
886
887static char irqrmap[] = {-1,-1,0,1,-1,2,-1,-1,-1,0,3,4,-1,-1,-1,-1};
888static char irqrmap2[] = {-1,-1,4,0,1,2,-1,3,-1,4,5,6,7,-1,-1,-1};
889static int eepro_grab_irq(struct net_device *dev)
890{
891 int irqlist[] = { 3, 4, 5, 7, 9, 10, 11, 12, 0 };
892 int *irqp = irqlist, temp_reg, ioaddr = dev->base_addr;
893
894 eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */
895
896 /* Enable the interrupt line. */
897 eepro_en_intline(ioaddr);
898
899 /* be CAREFUL, BANK 0 now */
900 eepro_sw2bank0(ioaddr);
901
902 /* clear all interrupts */
903 eepro_clear_int(ioaddr);
904
905 /* Let EXEC event to interrupt */
906 eepro_en_intexec(ioaddr);
907
908 do {
909 eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */
910
911 temp_reg = inb(ioaddr + INT_NO_REG);
912 outb((temp_reg & 0xf8) | irqrmap[*irqp], ioaddr + INT_NO_REG);
913
914 eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
915
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700916 if (request_irq (*irqp, NULL, IRQF_SHARED, "bogus", dev) != EBUSY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 unsigned long irq_mask;
918 /* Twinkle the interrupt, and check if it's seen */
919 irq_mask = probe_irq_on();
920
921 eepro_diag(ioaddr); /* RESET the 82595 */
922 mdelay(20);
923
924 if (*irqp == probe_irq_off(irq_mask)) /* It's a good IRQ line */
925 break;
926
927 /* clear all interrupts */
928 eepro_clear_int(ioaddr);
929 }
930 } while (*++irqp);
931
932 eepro_sw2bank1(ioaddr); /* Switch back to Bank 1 */
933
934 /* Disable the physical interrupt line. */
935 eepro_dis_intline(ioaddr);
936
937 eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
938
939 /* Mask all the interrupts. */
940 eepro_dis_int(ioaddr);
941
942 /* clear all interrupts */
943 eepro_clear_int(ioaddr);
944
945 return dev->irq;
946}
947
948static int eepro_open(struct net_device *dev)
949{
950 unsigned short temp_reg, old8, old9;
951 int irqMask;
952 int i, ioaddr = dev->base_addr;
953 struct eepro_local *lp = netdev_priv(dev);
954
955 if (net_debug > 3)
956 printk(KERN_DEBUG "%s: entering eepro_open routine.\n", dev->name);
957
958 irqMask = lp->word[7];
959
960 if (lp->eepro == LAN595FX_10ISA) {
961 if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 3;\n");
962 }
963 else if (irqMask == ee_FX_INT2IRQ) /* INT to IRQ Mask */
964 {
965 lp->eepro = 2; /* Yes, an Intel EtherExpress Pro/10+ */
966 if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 2;\n");
967 }
968
969 else if ((dev->dev_addr[0] == SA_ADDR0 &&
970 dev->dev_addr[1] == SA_ADDR1 &&
971 dev->dev_addr[2] == SA_ADDR2))
972 {
973 lp->eepro = 1;
974 if (net_debug > 3) printk(KERN_DEBUG "p->eepro = 1;\n");
975 } /* Yes, an Intel EtherExpress Pro/10 */
976
977 else lp->eepro = 0; /* No, it is a generic 82585 lan card */
978
979 /* Get the interrupt vector for the 82595 */
980 if (dev->irq < 2 && eepro_grab_irq(dev) == 0) {
981 printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
982 return -EAGAIN;
983 }
984
985 if (request_irq(dev->irq , &eepro_interrupt, 0, dev->name, dev)) {
986 printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
987 return -EAGAIN;
988 }
989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 /* Initialize the 82595. */
991
992 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
993 temp_reg = inb(ioaddr + lp->eeprom_reg);
994
995 lp->stepping = temp_reg >> 5; /* Get the stepping number of the 595 */
996
997 if (net_debug > 3)
998 printk(KERN_DEBUG "The stepping of the 82595 is %d\n", lp->stepping);
999
1000 if (temp_reg & 0x10) /* Check the TurnOff Enable bit */
1001 outb(temp_reg & 0xef, ioaddr + lp->eeprom_reg);
1002 for (i=0; i < 6; i++)
1003 outb(dev->dev_addr[i] , ioaddr + I_ADD_REG0 + i);
1004
1005 temp_reg = inb(ioaddr + REG1); /* Setup Transmit Chaining */
1006 outb(temp_reg | XMT_Chain_Int | XMT_Chain_ErrStop /* and discard bad RCV frames */
1007 | RCV_Discard_BadFrame, ioaddr + REG1);
1008
1009 temp_reg = inb(ioaddr + REG2); /* Match broadcast */
1010 outb(temp_reg | 0x14, ioaddr + REG2);
1011
1012 temp_reg = inb(ioaddr + REG3);
1013 outb(temp_reg & 0x3f, ioaddr + REG3); /* clear test mode */
1014
1015 /* Set the receiving mode */
1016 eepro_sw2bank1(ioaddr); /* be CAREFUL, BANK 1 now */
1017
1018 /* Set the interrupt vector */
1019 temp_reg = inb(ioaddr + INT_NO_REG);
1020 if (lp->eepro == LAN595FX || lp->eepro == LAN595FX_10ISA)
1021 outb((temp_reg & 0xf8) | irqrmap2[dev->irq], ioaddr + INT_NO_REG);
1022 else outb((temp_reg & 0xf8) | irqrmap[dev->irq], ioaddr + INT_NO_REG);
1023
1024
1025 temp_reg = inb(ioaddr + INT_NO_REG);
1026 if (lp->eepro == LAN595FX || lp->eepro == LAN595FX_10ISA)
1027 outb((temp_reg & 0xf0) | irqrmap2[dev->irq] | 0x08,ioaddr+INT_NO_REG);
1028 else outb((temp_reg & 0xf8) | irqrmap[dev->irq], ioaddr + INT_NO_REG);
1029
1030 if (net_debug > 3)
1031 printk(KERN_DEBUG "eepro_open: content of INT Reg is %x\n", temp_reg);
1032
1033
1034 /* Initialize the RCV and XMT upper and lower limits */
Jeff Garzikd61780c2005-10-30 15:01:51 -08001035 outb(lp->rcv_lower_limit >> 8, ioaddr + RCV_LOWER_LIMIT_REG);
1036 outb(lp->rcv_upper_limit >> 8, ioaddr + RCV_UPPER_LIMIT_REG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 outb(lp->xmt_lower_limit >> 8, ioaddr + lp->xmt_lower_limit_reg);
1038 outb(lp->xmt_upper_limit >> 8, ioaddr + lp->xmt_upper_limit_reg);
1039
1040 /* Enable the interrupt line. */
1041 eepro_en_intline(ioaddr);
1042
1043 /* Switch back to Bank 0 */
1044 eepro_sw2bank0(ioaddr);
1045
1046 /* Let RX and TX events to interrupt */
1047 eepro_en_int(ioaddr);
1048
1049 /* clear all interrupts */
1050 eepro_clear_int(ioaddr);
1051
1052 /* Initialize RCV */
Jeff Garzikd61780c2005-10-30 15:01:51 -08001053 outw(lp->rcv_lower_limit, ioaddr + RCV_BAR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 lp->rx_start = lp->rcv_lower_limit;
Jeff Garzikd61780c2005-10-30 15:01:51 -08001055 outw(lp->rcv_upper_limit | 0xfe, ioaddr + RCV_STOP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 /* Initialize XMT */
Jeff Garzikd61780c2005-10-30 15:01:51 -08001058 outw(lp->xmt_lower_limit, ioaddr + lp->xmt_bar);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
1060 lp->tx_last = 0;
1061
1062 /* Check for the i82595TX and i82595FX */
1063 old8 = inb(ioaddr + 8);
1064 outb(~old8, ioaddr + 8);
1065
1066 if ((temp_reg = inb(ioaddr + 8)) == old8) {
1067 if (net_debug > 3)
1068 printk(KERN_DEBUG "i82595 detected!\n");
1069 lp->version = LAN595;
1070 }
1071 else {
1072 lp->version = LAN595TX;
1073 outb(old8, ioaddr + 8);
1074 old9 = inb(ioaddr + 9);
1075
1076 if (irqMask==ee_FX_INT2IRQ) {
1077 if (net_debug > 3) {
1078 printk(KERN_DEBUG "IrqMask: %#x\n",irqMask);
1079 printk(KERN_DEBUG "i82595FX detected!\n");
1080 }
1081 lp->version = LAN595FX;
1082 outb(old9, ioaddr + 9);
1083 if (dev->if_port != TPE) { /* Hopefully, this will fix the
1084 problem of using Pentiums and
1085 pro/10 w/ BNC. */
1086 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1087 temp_reg = inb(ioaddr + REG13);
1088 /* disable the full duplex mode since it is not
1089 applicable with the 10Base2 cable. */
1090 outb(temp_reg & ~(FDX | A_N_ENABLE), REG13);
1091 eepro_sw2bank0(ioaddr); /* be CAREFUL, BANK 0 now */
1092 }
1093 }
1094 else if (net_debug > 3) {
1095 printk(KERN_DEBUG "temp_reg: %#x ~old9: %#x\n",temp_reg,((~old9)&0xff));
1096 printk(KERN_DEBUG "i82595TX detected!\n");
1097 }
1098 }
1099
1100 eepro_sel_reset(ioaddr);
1101
1102 netif_start_queue(dev);
1103
1104 if (net_debug > 3)
1105 printk(KERN_DEBUG "%s: exiting eepro_open routine.\n", dev->name);
1106
1107 /* enabling rx */
1108 eepro_en_rx(ioaddr);
1109
1110 return 0;
1111}
1112
1113static void eepro_tx_timeout (struct net_device *dev)
1114{
1115 struct eepro_local *lp = netdev_priv(dev);
1116 int ioaddr = dev->base_addr;
1117
1118 /* if (net_debug > 1) */
1119 printk (KERN_ERR "%s: transmit timed out, %s?\n", dev->name,
1120 "network cable problem");
1121 /* This is not a duplicate. One message for the console,
Michael Opdenacker59c51592007-05-09 08:57:56 +02001122 one for the log file */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 printk (KERN_DEBUG "%s: transmit timed out, %s?\n", dev->name,
1124 "network cable problem");
1125 eepro_complete_selreset(ioaddr);
1126}
1127
1128
1129static int eepro_send_packet(struct sk_buff *skb, struct net_device *dev)
1130{
1131 struct eepro_local *lp = netdev_priv(dev);
1132 unsigned long flags;
1133 int ioaddr = dev->base_addr;
1134 short length = skb->len;
1135
1136 if (net_debug > 5)
1137 printk(KERN_DEBUG "%s: entering eepro_send_packet routine.\n", dev->name);
1138
1139 if (length < ETH_ZLEN) {
Herbert Xu5b057c62006-06-23 02:06:41 -07001140 if (skb_padto(skb, ETH_ZLEN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 return 0;
1142 length = ETH_ZLEN;
1143 }
1144 netif_stop_queue (dev);
1145
1146 eepro_dis_int(ioaddr);
1147 spin_lock_irqsave(&lp->lock, flags);
1148
1149 {
1150 unsigned char *buf = skb->data;
1151
1152 if (hardware_send_packet(dev, buf, length))
1153 /* we won't wake queue here because we're out of space */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001154 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 else {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001156 dev->stats.tx_bytes+=skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 dev->trans_start = jiffies;
1158 netif_wake_queue(dev);
1159 }
1160
1161 }
1162
1163 dev_kfree_skb (skb);
1164
1165 /* You might need to clean up and record Tx statistics here. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001166 /* dev->stats.tx_aborted_errors++; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
1168 if (net_debug > 5)
1169 printk(KERN_DEBUG "%s: exiting eepro_send_packet routine.\n", dev->name);
1170
1171 eepro_en_int(ioaddr);
1172 spin_unlock_irqrestore(&lp->lock, flags);
1173
1174 return 0;
1175}
1176
1177
1178/* The typical workload of the driver:
1179 Handle the network interface interrupts. */
1180
1181static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01001182eepro_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183{
Jeff Garzikc31f28e2006-10-06 14:56:04 -04001184 struct net_device *dev = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 struct eepro_local *lp;
1186 int ioaddr, status, boguscount = 20;
1187 int handled = 0;
1188
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 lp = netdev_priv(dev);
1190
1191 spin_lock(&lp->lock);
1192
1193 if (net_debug > 5)
1194 printk(KERN_DEBUG "%s: entering eepro_interrupt routine.\n", dev->name);
1195
1196 ioaddr = dev->base_addr;
1197
1198 while (((status = inb(ioaddr + STATUS_REG)) & (RX_INT|TX_INT)) && (boguscount--))
1199 {
1200 handled = 1;
1201 if (status & RX_INT) {
1202 if (net_debug > 4)
1203 printk(KERN_DEBUG "%s: packet received interrupt.\n", dev->name);
1204
1205 eepro_dis_int(ioaddr);
1206
1207 /* Get the received packets */
1208 eepro_ack_rx(ioaddr);
1209 eepro_rx(dev);
1210
1211 eepro_en_int(ioaddr);
1212 }
1213 if (status & TX_INT) {
1214 if (net_debug > 4)
1215 printk(KERN_DEBUG "%s: packet transmit interrupt.\n", dev->name);
1216
1217
1218 eepro_dis_int(ioaddr);
1219
1220 /* Process the status of transmitted packets */
1221 eepro_ack_tx(ioaddr);
1222 eepro_transmit_interrupt(dev);
1223
1224 eepro_en_int(ioaddr);
1225 }
1226 }
1227
1228 if (net_debug > 5)
1229 printk(KERN_DEBUG "%s: exiting eepro_interrupt routine.\n", dev->name);
1230
1231 spin_unlock(&lp->lock);
1232 return IRQ_RETVAL(handled);
1233}
1234
1235static int eepro_close(struct net_device *dev)
1236{
1237 struct eepro_local *lp = netdev_priv(dev);
1238 int ioaddr = dev->base_addr;
1239 short temp_reg;
1240
1241 netif_stop_queue(dev);
1242
1243 eepro_sw2bank1(ioaddr); /* Switch back to Bank 1 */
1244
1245 /* Disable the physical interrupt line. */
1246 temp_reg = inb(ioaddr + REG1);
1247 outb(temp_reg & 0x7f, ioaddr + REG1);
1248
1249 eepro_sw2bank0(ioaddr); /* Switch back to Bank 0 */
1250
1251 /* Flush the Tx and disable Rx. */
1252 outb(STOP_RCV_CMD, ioaddr);
1253 lp->tx_start = lp->tx_end = lp->xmt_lower_limit;
1254 lp->tx_last = 0;
1255
1256 /* Mask all the interrupts. */
1257 eepro_dis_int(ioaddr);
1258
1259 /* clear all interrupts */
1260 eepro_clear_int(ioaddr);
1261
1262 /* Reset the 82595 */
1263 eepro_reset(ioaddr);
1264
1265 /* release the interrupt */
1266 free_irq(dev->irq, dev);
1267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 /* Update the statistics here. What statistics? */
1269
1270 return 0;
1271}
1272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273/* Set or clear the multicast filter for this adaptor.
1274 */
1275static void
1276set_multicast_list(struct net_device *dev)
1277{
1278 struct eepro_local *lp = netdev_priv(dev);
1279 short ioaddr = dev->base_addr;
1280 unsigned short mode;
1281 struct dev_mc_list *dmi=dev->mc_list;
1282
1283 if (dev->flags&(IFF_ALLMULTI|IFF_PROMISC) || dev->mc_count > 63)
1284 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1286 mode = inb(ioaddr + REG2);
1287 outb(mode | PRMSC_Mode, ioaddr + REG2);
1288 mode = inb(ioaddr + REG3);
1289 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
1290 eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 }
1292
1293 else if (dev->mc_count==0 )
1294 {
1295 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1296 mode = inb(ioaddr + REG2);
1297 outb(mode & 0xd6, ioaddr + REG2); /* Turn off Multi-IA and PRMSC_Mode bits */
1298 mode = inb(ioaddr + REG3);
1299 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
1300 eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
1301 }
1302
1303 else
1304 {
1305 unsigned short status, *eaddrs;
1306 int i, boguscount = 0;
1307
1308 /* Disable RX and TX interrupts. Necessary to avoid
1309 corruption of the HOST_ADDRESS_REG by interrupt
1310 service routines. */
1311 eepro_dis_int(ioaddr);
1312
1313 eepro_sw2bank2(ioaddr); /* be CAREFUL, BANK 2 now */
1314 mode = inb(ioaddr + REG2);
1315 outb(mode | Multi_IA, ioaddr + REG2);
1316 mode = inb(ioaddr + REG3);
1317 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
1318 eepro_sw2bank0(ioaddr); /* Return to BANK 0 now */
1319 outw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
1320 outw(MC_SETUP, ioaddr + IO_PORT);
1321 outw(0, ioaddr + IO_PORT);
1322 outw(0, ioaddr + IO_PORT);
1323 outw(6*(dev->mc_count + 1), ioaddr + IO_PORT);
1324
1325 for (i = 0; i < dev->mc_count; i++)
1326 {
1327 eaddrs=(unsigned short *)dmi->dmi_addr;
1328 dmi=dmi->next;
1329 outw(*eaddrs++, ioaddr + IO_PORT);
1330 outw(*eaddrs++, ioaddr + IO_PORT);
1331 outw(*eaddrs++, ioaddr + IO_PORT);
1332 }
1333
1334 eaddrs = (unsigned short *) dev->dev_addr;
1335 outw(eaddrs[0], ioaddr + IO_PORT);
1336 outw(eaddrs[1], ioaddr + IO_PORT);
1337 outw(eaddrs[2], ioaddr + IO_PORT);
1338 outw(lp->tx_end, ioaddr + lp->xmt_bar);
1339 outb(MC_SETUP, ioaddr);
1340
1341 /* Update the transmit queue */
1342 i = lp->tx_end + XMT_HEADER + 6*(dev->mc_count + 1);
1343
1344 if (lp->tx_start != lp->tx_end)
1345 {
1346 /* update the next address and the chain bit in the
1347 last packet */
1348 outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
1349 outw(i, ioaddr + IO_PORT);
1350 outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
1351 status = inw(ioaddr + IO_PORT);
1352 outw(status | CHAIN_BIT, ioaddr + IO_PORT);
1353 lp->tx_end = i ;
1354 }
1355 else {
1356 lp->tx_start = lp->tx_end = i ;
1357 }
1358
1359 /* Acknowledge that the MC setup is done */
1360 do { /* We should be doing this in the eepro_interrupt()! */
1361 SLOW_DOWN;
1362 SLOW_DOWN;
1363 if (inb(ioaddr + STATUS_REG) & 0x08)
1364 {
1365 i = inb(ioaddr);
1366 outb(0x08, ioaddr + STATUS_REG);
1367
1368 if (i & 0x20) { /* command ABORTed */
Jeff Garzikd61780c2005-10-30 15:01:51 -08001369 printk(KERN_NOTICE "%s: multicast setup failed.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 dev->name);
1371 break;
1372 } else if ((i & 0x0f) == 0x03) { /* MC-Done */
1373 printk(KERN_DEBUG "%s: set Rx mode to %d address%s.\n",
1374 dev->name, dev->mc_count,
1375 dev->mc_count > 1 ? "es":"");
1376 break;
1377 }
1378 }
1379 } while (++boguscount < 100);
1380
1381 /* Re-enable RX and TX interrupts */
1382 eepro_en_int(ioaddr);
1383 }
1384 if (lp->eepro == LAN595FX_10ISA) {
1385 eepro_complete_selreset(ioaddr);
1386 }
1387 else
1388 eepro_en_rx(ioaddr);
1389}
1390
1391/* The horrible routine to read a word from the serial EEPROM. */
1392/* IMPORTANT - the 82595 will be set to Bank 0 after the eeprom is read */
1393
1394/* The delay between EEPROM clock transitions. */
1395#define eeprom_delay() { udelay(40); }
1396#define EE_READ_CMD (6 << 6)
1397
Hannes Ederdac499f2008-12-25 23:56:45 -08001398static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399read_eeprom(int ioaddr, int location, struct net_device *dev)
1400{
1401 int i;
1402 unsigned short retval = 0;
1403 struct eepro_local *lp = netdev_priv(dev);
1404 short ee_addr = ioaddr + lp->eeprom_reg;
1405 int read_cmd = location | EE_READ_CMD;
1406 short ctrl_val = EECS ;
1407
1408 /* XXXX - black magic */
1409 eepro_sw2bank1(ioaddr);
1410 outb(0x00, ioaddr + STATUS_REG);
1411 /* XXXX - black magic */
1412
1413 eepro_sw2bank2(ioaddr);
1414 outb(ctrl_val, ee_addr);
1415
1416 /* Shift the read command bits out. */
1417 for (i = 8; i >= 0; i--) {
1418 short outval = (read_cmd & (1 << i)) ? ctrl_val | EEDI
1419 : ctrl_val;
1420 outb(outval, ee_addr);
1421 outb(outval | EESK, ee_addr); /* EEPROM clock tick. */
1422 eeprom_delay();
1423 outb(outval, ee_addr); /* Finish EEPROM a clock tick. */
1424 eeprom_delay();
1425 }
1426 outb(ctrl_val, ee_addr);
1427
1428 for (i = 16; i > 0; i--) {
1429 outb(ctrl_val | EESK, ee_addr); eeprom_delay();
1430 retval = (retval << 1) | ((inb(ee_addr) & EEDO) ? 1 : 0);
1431 outb(ctrl_val, ee_addr); eeprom_delay();
1432 }
1433
1434 /* Terminate the EEPROM access. */
1435 ctrl_val &= ~EECS;
1436 outb(ctrl_val | EESK, ee_addr);
1437 eeprom_delay();
1438 outb(ctrl_val, ee_addr);
1439 eeprom_delay();
1440 eepro_sw2bank0(ioaddr);
1441 return retval;
1442}
1443
1444static int
1445hardware_send_packet(struct net_device *dev, void *buf, short length)
1446{
1447 struct eepro_local *lp = netdev_priv(dev);
1448 short ioaddr = dev->base_addr;
1449 unsigned status, tx_available, last, end;
1450
1451 if (net_debug > 5)
1452 printk(KERN_DEBUG "%s: entering hardware_send_packet routine.\n", dev->name);
1453
1454 /* determine how much of the transmit buffer space is available */
1455 if (lp->tx_end > lp->tx_start)
1456 tx_available = lp->xmt_ram - (lp->tx_end - lp->tx_start);
1457 else if (lp->tx_end < lp->tx_start)
1458 tx_available = lp->tx_start - lp->tx_end;
1459 else tx_available = lp->xmt_ram;
1460
1461 if (((((length + 3) >> 1) << 1) + 2*XMT_HEADER) >= tx_available) {
1462 /* No space available ??? */
1463 return 1;
1464 }
1465
1466 last = lp->tx_end;
1467 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
1468
1469 if (end >= lp->xmt_upper_limit + 2) { /* the transmit buffer is wrapped around */
Jeff Garzikd61780c2005-10-30 15:01:51 -08001470 if ((lp->xmt_upper_limit + 2 - last) <= XMT_HEADER) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 /* Arrrr!!!, must keep the xmt header together,
1472 several days were lost to chase this one down. */
1473 last = lp->xmt_lower_limit;
1474 end = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
1475 }
1476 else end = lp->xmt_lower_limit + (end -
1477 lp->xmt_upper_limit + 2);
1478 }
1479
1480 outw(last, ioaddr + HOST_ADDRESS_REG);
1481 outw(XMT_CMD, ioaddr + IO_PORT);
1482 outw(0, ioaddr + IO_PORT);
1483 outw(end, ioaddr + IO_PORT);
1484 outw(length, ioaddr + IO_PORT);
1485
1486 if (lp->version == LAN595)
1487 outsw(ioaddr + IO_PORT, buf, (length + 3) >> 1);
1488 else { /* LAN595TX or LAN595FX, capable of 32-bit I/O processing */
1489 unsigned short temp = inb(ioaddr + INT_MASK_REG);
1490 outb(temp | IO_32_BIT, ioaddr + INT_MASK_REG);
1491 outsl(ioaddr + IO_PORT_32_BIT, buf, (length + 3) >> 2);
1492 outb(temp & ~(IO_32_BIT), ioaddr + INT_MASK_REG);
1493 }
1494
1495 /* A dummy read to flush the DRAM write pipeline */
1496 status = inw(ioaddr + IO_PORT);
1497
1498 if (lp->tx_start == lp->tx_end) {
1499 outw(last, ioaddr + lp->xmt_bar);
1500 outb(XMT_CMD, ioaddr);
1501 lp->tx_start = last; /* I don't like to change tx_start here */
1502 }
1503 else {
1504 /* update the next address and the chain bit in the
1505 last packet */
1506
1507 if (lp->tx_end != last) {
1508 outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
1509 outw(last, ioaddr + IO_PORT);
1510 }
1511
1512 outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
1513 status = inw(ioaddr + IO_PORT);
1514 outw(status | CHAIN_BIT, ioaddr + IO_PORT);
1515
1516 /* Continue the transmit command */
1517 outb(RESUME_XMT_CMD, ioaddr);
1518 }
1519
1520 lp->tx_last = last;
1521 lp->tx_end = end;
1522
1523 if (net_debug > 5)
1524 printk(KERN_DEBUG "%s: exiting hardware_send_packet routine.\n", dev->name);
1525
1526 return 0;
1527}
1528
1529static void
1530eepro_rx(struct net_device *dev)
1531{
1532 struct eepro_local *lp = netdev_priv(dev);
1533 short ioaddr = dev->base_addr;
1534 short boguscount = 20;
1535 short rcv_car = lp->rx_start;
1536 unsigned rcv_event, rcv_status, rcv_next_frame, rcv_size;
1537
1538 if (net_debug > 5)
1539 printk(KERN_DEBUG "%s: entering eepro_rx routine.\n", dev->name);
1540
1541 /* Set the read pointer to the start of the RCV */
1542 outw(rcv_car, ioaddr + HOST_ADDRESS_REG);
1543
1544 rcv_event = inw(ioaddr + IO_PORT);
1545
1546 while (rcv_event == RCV_DONE) {
1547
1548 rcv_status = inw(ioaddr + IO_PORT);
1549 rcv_next_frame = inw(ioaddr + IO_PORT);
1550 rcv_size = inw(ioaddr + IO_PORT);
1551
1552 if ((rcv_status & (RX_OK | RX_ERROR)) == RX_OK) {
1553
1554 /* Malloc up new buffer. */
1555 struct sk_buff *skb;
1556
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001557 dev->stats.rx_bytes+=rcv_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 rcv_size &= 0x3fff;
1559 skb = dev_alloc_skb(rcv_size+5);
1560 if (skb == NULL) {
1561 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001562 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
1564 lp->rx_start = rcv_next_frame;
1565 outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
1566
1567 break;
1568 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 skb_reserve(skb,2);
1570
1571 if (lp->version == LAN595)
1572 insw(ioaddr+IO_PORT, skb_put(skb,rcv_size), (rcv_size + 3) >> 1);
1573 else { /* LAN595TX or LAN595FX, capable of 32-bit I/O processing */
1574 unsigned short temp = inb(ioaddr + INT_MASK_REG);
1575 outb(temp | IO_32_BIT, ioaddr + INT_MASK_REG);
1576 insl(ioaddr+IO_PORT_32_BIT, skb_put(skb,rcv_size),
1577 (rcv_size + 3) >> 2);
1578 outb(temp & ~(IO_32_BIT), ioaddr + INT_MASK_REG);
1579 }
1580
1581 skb->protocol = eth_type_trans(skb,dev);
1582 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001583 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
1585
1586 else { /* Not sure will ever reach here,
1587 I set the 595 to discard bad received frames */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001588 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
1590 if (rcv_status & 0x0100)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001591 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
1593 else if (rcv_status & 0x0400)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001594 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 else if (rcv_status & 0x0800)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001597 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
Jeff Garzikd61780c2005-10-30 15:01:51 -08001599 printk(KERN_DEBUG "%s: event = %#x, status = %#x, next = %#x, size = %#x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
1601 }
1602
1603 if (rcv_status & 0x1000)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001604 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
1606 rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
1607 lp->rx_start = rcv_next_frame;
1608
1609 if (--boguscount == 0)
1610 break;
1611
1612 outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
1613 rcv_event = inw(ioaddr + IO_PORT);
1614
1615 }
1616 if (rcv_car == 0)
1617 rcv_car = lp->rcv_upper_limit | 0xff;
1618
1619 outw(rcv_car - 1, ioaddr + RCV_STOP);
1620
1621 if (net_debug > 5)
1622 printk(KERN_DEBUG "%s: exiting eepro_rx routine.\n", dev->name);
1623}
1624
1625static void
1626eepro_transmit_interrupt(struct net_device *dev)
1627{
1628 struct eepro_local *lp = netdev_priv(dev);
1629 short ioaddr = dev->base_addr;
Jeff Garzikd61780c2005-10-30 15:01:51 -08001630 short boguscount = 25;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 short xmt_status;
1632
Jeff Garzikd61780c2005-10-30 15:01:51 -08001633 while ((lp->tx_start != lp->tx_end) && boguscount--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634
1635 outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
1636 xmt_status = inw(ioaddr+IO_PORT);
1637
1638 if (!(xmt_status & TX_DONE_BIT))
1639 break;
1640
1641 xmt_status = inw(ioaddr+IO_PORT);
1642 lp->tx_start = inw(ioaddr+IO_PORT);
1643
1644 netif_wake_queue (dev);
1645
1646 if (xmt_status & TX_OK)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001647 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 else {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001649 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 if (xmt_status & 0x0400) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001651 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 printk(KERN_DEBUG "%s: carrier error\n",
1653 dev->name);
1654 printk(KERN_DEBUG "%s: XMT status = %#x\n",
1655 dev->name, xmt_status);
1656 }
1657 else {
1658 printk(KERN_DEBUG "%s: XMT status = %#x\n",
1659 dev->name, xmt_status);
1660 printk(KERN_DEBUG "%s: XMT status = %#x\n",
1661 dev->name, xmt_status);
1662 }
1663 }
1664 if (xmt_status & 0x000f) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001665 dev->stats.collisions += (xmt_status & 0x000f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 }
1667
1668 if ((xmt_status & 0x0040) == 0x0) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001669 dev->stats.tx_heartbeat_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 }
1671 }
1672}
1673
1674static int eepro_ethtool_get_settings(struct net_device *dev,
1675 struct ethtool_cmd *cmd)
1676{
Wang Chen4cf16532008-11-12 23:38:14 -08001677 struct eepro_local *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
Jeff Garzikd61780c2005-10-30 15:01:51 -08001679 cmd->supported = SUPPORTED_10baseT_Half |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 SUPPORTED_10baseT_Full |
1681 SUPPORTED_Autoneg;
1682 cmd->advertising = ADVERTISED_10baseT_Half |
1683 ADVERTISED_10baseT_Full |
1684 ADVERTISED_Autoneg;
1685
1686 if (GetBit(lp->word[5], ee_PortTPE)) {
1687 cmd->supported |= SUPPORTED_TP;
1688 cmd->advertising |= ADVERTISED_TP;
1689 }
1690 if (GetBit(lp->word[5], ee_PortBNC)) {
1691 cmd->supported |= SUPPORTED_BNC;
1692 cmd->advertising |= ADVERTISED_BNC;
1693 }
1694 if (GetBit(lp->word[5], ee_PortAUI)) {
1695 cmd->supported |= SUPPORTED_AUI;
1696 cmd->advertising |= ADVERTISED_AUI;
1697 }
1698
1699 cmd->speed = SPEED_10;
1700
1701 if (dev->if_port == TPE && lp->word[1] & ee_Duplex) {
1702 cmd->duplex = DUPLEX_FULL;
1703 }
1704 else {
1705 cmd->duplex = DUPLEX_HALF;
1706 }
1707
1708 cmd->port = dev->if_port;
1709 cmd->phy_address = dev->base_addr;
1710 cmd->transceiver = XCVR_INTERNAL;
1711
1712 if (lp->word[0] & ee_AutoNeg) {
1713 cmd->autoneg = 1;
1714 }
1715
1716 return 0;
1717}
1718
1719static void eepro_ethtool_get_drvinfo(struct net_device *dev,
1720 struct ethtool_drvinfo *drvinfo)
1721{
1722 strcpy(drvinfo->driver, DRV_NAME);
1723 strcpy(drvinfo->version, DRV_VERSION);
1724 sprintf(drvinfo->bus_info, "ISA 0x%lx", dev->base_addr);
1725}
1726
Jeff Garzik7282d492006-09-13 14:30:00 -04001727static const struct ethtool_ops eepro_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 .get_settings = eepro_ethtool_get_settings,
1729 .get_drvinfo = eepro_ethtool_get_drvinfo,
1730};
1731
1732#ifdef MODULE
1733
1734#define MAX_EEPRO 8
1735static struct net_device *dev_eepro[MAX_EEPRO];
1736
1737static int io[MAX_EEPRO] = {
1738 [0 ... MAX_EEPRO-1] = -1
1739};
1740static int irq[MAX_EEPRO];
1741static int mem[MAX_EEPRO] = { /* Size of the rx buffer in KB */
1742 [0 ... MAX_EEPRO-1] = RCV_DEFAULT_RAM/1024
1743};
1744static int autodetect;
1745
1746static int n_eepro;
1747/* For linux 2.1.xx */
1748
1749MODULE_AUTHOR("Pascal Dupuis and others");
1750MODULE_DESCRIPTION("Intel i82595 ISA EtherExpressPro10/10+ driver");
1751MODULE_LICENSE("GPL");
1752
Florin Malitaa1bfcd92005-10-28 15:14:46 -07001753module_param_array(io, int, NULL, 0);
1754module_param_array(irq, int, NULL, 0);
1755module_param_array(mem, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756module_param(autodetect, int, 0);
1757MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)");
1758MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)");
1759MODULE_PARM_DESC(mem, "EtherExpress Pro/10 Rx buffer size(es) in kB (3-29)");
1760MODULE_PARM_DESC(autodetect, "EtherExpress Pro/10 force board(s) detection (0-1)");
1761
Andrew Morton02a32452006-08-14 23:00:01 -07001762int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763{
1764 struct net_device *dev;
1765 int i;
1766 if (io[0] == -1 && autodetect == 0) {
1767 printk(KERN_WARNING "eepro_init_module: Probe is very dangerous in ISA boards!\n");
1768 printk(KERN_WARNING "eepro_init_module: Please add \"autodetect=1\" to force probe\n");
1769 return -ENODEV;
1770 }
1771 else if (autodetect) {
1772 /* if autodetect is set then we must force detection */
1773 for (i = 0; i < MAX_EEPRO; i++) {
1774 io[i] = 0;
1775 }
1776
1777 printk(KERN_INFO "eepro_init_module: Auto-detecting boards (May God protect us...)\n");
1778 }
1779
1780 for (i = 0; io[i] != -1 && i < MAX_EEPRO; i++) {
1781 dev = alloc_etherdev(sizeof(struct eepro_local));
1782 if (!dev)
1783 break;
1784
1785 dev->mem_end = mem[i];
1786 dev->base_addr = io[i];
1787 dev->irq = irq[i];
1788
1789 if (do_eepro_probe(dev) == 0) {
b1fc5502005-05-12 20:11:55 -04001790 dev_eepro[n_eepro++] = dev;
1791 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 }
1793 free_netdev(dev);
1794 break;
1795 }
1796
1797 if (n_eepro)
1798 printk(KERN_INFO "%s", version);
1799
1800 return n_eepro ? 0 : -ENODEV;
1801}
1802
Al Viroafc8eb42006-06-14 18:50:53 -04001803void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804cleanup_module(void)
1805{
1806 int i;
1807
1808 for (i=0; i<n_eepro; i++) {
1809 struct net_device *dev = dev_eepro[i];
1810 unregister_netdev(dev);
1811 release_region(dev->base_addr, EEPRO_IO_EXTENT);
1812 free_netdev(dev);
1813 }
1814}
1815#endif /* MODULE */