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