diff options
author | Paul Gortmaker <paul.gortmaker@windriver.com> | 2013-01-08 22:11:54 -0500 |
---|---|---|
committer | Paul Gortmaker <paul.gortmaker@windriver.com> | 2013-01-22 10:39:48 -0500 |
commit | 5205939d0f15803cc402e32ac5b886dbb7c50b99 (patch) | |
tree | 7e902bda6b39ae1763ce2e8d46542f6272fa52ac /drivers | |
parent | 6e07ba3e6ad939c89befc2588e72bf37038f7f53 (diff) |
drivers/net: delete intel 486 panther onboard ethernet support
This driver was specific to a "professional workstation" line
of products from around 1993 that used the i82596 ethernet chip
as an on-board ethernet solution.
With a 486 processor, and the premium top of the line model maxing
out at a clock speed of 50MHz, we can safely retire this support.
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/net/ethernet/i825xx/Kconfig | 8 | ||||
-rw-r--r-- | drivers/net/ethernet/i825xx/Makefile | 1 | ||||
-rw-r--r-- | drivers/net/ethernet/i825xx/lp486e.c | 1337 |
3 files changed, 0 insertions, 1346 deletions
diff --git a/drivers/net/ethernet/i825xx/Kconfig b/drivers/net/ethernet/i825xx/Kconfig index c39698ae9801..46edb81bbedb 100644 --- a/drivers/net/ethernet/i825xx/Kconfig +++ b/drivers/net/ethernet/i825xx/Kconfig | |||
@@ -93,14 +93,6 @@ config LASI_82596 | |||
93 | Say Y here to support the builtin Intel 82596 ethernet controller | 93 | Say Y here to support the builtin Intel 82596 ethernet controller |
94 | found in Hewlett-Packard PA-RISC machines with 10Mbit ethernet. | 94 | found in Hewlett-Packard PA-RISC machines with 10Mbit ethernet. |
95 | 95 | ||
96 | config LP486E | ||
97 | tristate "LP486E on board Ethernet" | ||
98 | depends on ISA | ||
99 | ---help--- | ||
100 | Say Y here to support the 82596-based on-board Ethernet controller | ||
101 | for the Panther motherboard, which is one of the two shipped in the | ||
102 | Intel Professional Workstation. | ||
103 | |||
104 | config MVME16x_NET | 96 | config MVME16x_NET |
105 | tristate "MVME16x Ethernet support" | 97 | tristate "MVME16x Ethernet support" |
106 | depends on MVME16x | 98 | depends on MVME16x |
diff --git a/drivers/net/ethernet/i825xx/Makefile b/drivers/net/ethernet/i825xx/Makefile index e5ab9d04a180..4f01584bd897 100644 --- a/drivers/net/ethernet/i825xx/Makefile +++ b/drivers/net/ethernet/i825xx/Makefile | |||
@@ -7,7 +7,6 @@ obj-$(CONFIG_EEXPRESS) += eexpress.o | |||
7 | obj-$(CONFIG_EEXPRESS_PRO) += eepro.o | 7 | obj-$(CONFIG_EEXPRESS_PRO) += eepro.o |
8 | obj-$(CONFIG_ELPLUS) += 3c505.o | 8 | obj-$(CONFIG_ELPLUS) += 3c505.o |
9 | obj-$(CONFIG_EL16) += 3c507.o | 9 | obj-$(CONFIG_EL16) += 3c507.o |
10 | obj-$(CONFIG_LP486E) += lp486e.o | ||
11 | obj-$(CONFIG_NI52) += ni52.o | 10 | obj-$(CONFIG_NI52) += ni52.o |
12 | obj-$(CONFIG_SUN3_82586) += sun3_82586.o | 11 | obj-$(CONFIG_SUN3_82586) += sun3_82586.o |
13 | obj-$(CONFIG_ZNET) += znet.o | 12 | obj-$(CONFIG_ZNET) += znet.o |
diff --git a/drivers/net/ethernet/i825xx/lp486e.c b/drivers/net/ethernet/i825xx/lp486e.c deleted file mode 100644 index 3735bfa53600..000000000000 --- a/drivers/net/ethernet/i825xx/lp486e.c +++ /dev/null | |||
@@ -1,1337 +0,0 @@ | |||
1 | /* Intel Professional Workstation/panther ethernet driver */ | ||
2 | /* lp486e.c: A panther 82596 ethernet driver for linux. */ | ||
3 | /* | ||
4 | History and copyrights: | ||
5 | |||
6 | Driver skeleton | ||
7 | Written 1993 by Donald Becker. | ||
8 | Copyright 1993 United States Government as represented by the Director, | ||
9 | National Security Agency. This software may only be used and | ||
10 | distributed according to the terms of the GNU General Public License | ||
11 | as modified by SRC, incorporated herein by reference. | ||
12 | |||
13 | The author may be reached as becker@scyld.com, or C/O | ||
14 | Scyld Computing Corporation | ||
15 | 410 Severn Ave., Suite 210 | ||
16 | Annapolis MD 21403 | ||
17 | |||
18 | Apricot | ||
19 | Written 1994 by Mark Evans. | ||
20 | This driver is for the Apricot 82596 bus-master interface | ||
21 | |||
22 | Modularised 12/94 Mark Evans | ||
23 | |||
24 | Professional Workstation | ||
25 | Derived from apricot.c by Ard van Breemen | ||
26 | <ard@murphy.nl>|<ard@cstmel.hobby.nl>|<ard@cstmel.nl.eu.org> | ||
27 | |||
28 | Credits: | ||
29 | Thanks to Murphy Software BV for letting me write this in their time. | ||
30 | Well, actually, I get paid doing this... | ||
31 | (Also: see http://www.murphy.nl for murphy, and my homepage ~ard for | ||
32 | more information on the Professional Workstation) | ||
33 | |||
34 | Present version | ||
35 | aeb@cwi.nl | ||
36 | */ | ||
37 | /* | ||
38 | There are currently two motherboards that I know of in the | ||
39 | professional workstation. The only one that I know is the | ||
40 | intel panther motherboard. -- ard | ||
41 | */ | ||
42 | /* | ||
43 | The pws is equipped with an intel 82596. This is a very intelligent controller | ||
44 | which runs its own micro-code. Communication with the hostprocessor is done | ||
45 | through linked lists of commands and buffers in the hostprocessors memory. | ||
46 | A complete description of the 82596 is available from intel. Search for | ||
47 | a file called "29021806.pdf". It is a complete description of the chip itself. | ||
48 | To use it for the pws some additions are needed regarding generation of | ||
49 | the PORT and CA signal, and the interrupt glue needed for a pc. | ||
50 | I/O map: | ||
51 | PORT SIZE ACTION MEANING | ||
52 | 0xCB0 2 WRITE Lower 16 bits for PORT command | ||
53 | 0xCB2 2 WRITE Upper 16 bits for PORT command, and issue of PORT command | ||
54 | 0xCB4 1 WRITE Generation of CA signal | ||
55 | 0xCB8 1 WRITE Clear interrupt glue | ||
56 | All other communication is through memory! | ||
57 | */ | ||
58 | |||
59 | #include <linux/module.h> | ||
60 | #include <linux/init.h> | ||
61 | #include <linux/delay.h> | ||
62 | #include <linux/kernel.h> | ||
63 | #include <linux/string.h> | ||
64 | #include <linux/errno.h> | ||
65 | #include <linux/ioport.h> | ||
66 | #include <linux/slab.h> | ||
67 | #include <linux/interrupt.h> | ||
68 | #include <linux/netdevice.h> | ||
69 | #include <linux/etherdevice.h> | ||
70 | #include <linux/skbuff.h> | ||
71 | #include <linux/bitops.h> | ||
72 | |||
73 | #include <asm/io.h> | ||
74 | #include <asm/dma.h> | ||
75 | |||
76 | #define DRV_NAME "lp486e" | ||
77 | |||
78 | /* debug print flags */ | ||
79 | #define LOG_SRCDST 0x80000000 | ||
80 | #define LOG_STATINT 0x40000000 | ||
81 | #define LOG_STARTINT 0x20000000 | ||
82 | |||
83 | #define i596_debug debug | ||
84 | |||
85 | static int i596_debug = 0; | ||
86 | |||
87 | static const char * const medianame[] = { | ||
88 | "10baseT", "AUI", | ||
89 | "10baseT-FD", "AUI-FD", | ||
90 | }; | ||
91 | |||
92 | #define LP486E_TOTAL_SIZE 16 | ||
93 | |||
94 | #define I596_NULL (0xffffffff) | ||
95 | |||
96 | #define CMD_EOL 0x8000 /* The last command of the list, stop. */ | ||
97 | #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */ | ||
98 | #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */ | ||
99 | |||
100 | #define CMD_FLEX 0x0008 /* Enable flexible memory model */ | ||
101 | |||
102 | enum commands { | ||
103 | CmdNOP = 0, | ||
104 | CmdIASetup = 1, | ||
105 | CmdConfigure = 2, | ||
106 | CmdMulticastList = 3, | ||
107 | CmdTx = 4, | ||
108 | CmdTDR = 5, | ||
109 | CmdDump = 6, | ||
110 | CmdDiagnose = 7 | ||
111 | }; | ||
112 | |||
113 | #if 0 | ||
114 | static const char *CUcmdnames[8] = { "NOP", "IASetup", "Configure", "MulticastList", | ||
115 | "Tx", "TDR", "Dump", "Diagnose" }; | ||
116 | #endif | ||
117 | |||
118 | /* Status word bits */ | ||
119 | #define STAT_CX 0x8000 /* The CU finished executing a command | ||
120 | with the Interrupt bit set */ | ||
121 | #define STAT_FR 0x4000 /* The RU finished receiving a frame */ | ||
122 | #define STAT_CNA 0x2000 /* The CU left the active state */ | ||
123 | #define STAT_RNR 0x1000 /* The RU left the active state */ | ||
124 | #define STAT_ACK (STAT_CX | STAT_FR | STAT_CNA | STAT_RNR) | ||
125 | #define STAT_CUS 0x0700 /* Status of CU: 0: idle, 1: suspended, | ||
126 | 2: active, 3-7: unused */ | ||
127 | #define STAT_RUS 0x00f0 /* Status of RU: 0: idle, 1: suspended, | ||
128 | 2: no resources, 4: ready, | ||
129 | 10: no resources due to no more RBDs, | ||
130 | 12: no more RBDs, other: unused */ | ||
131 | #define STAT_T 0x0008 /* Bus throttle timers loaded */ | ||
132 | #define STAT_ZERO 0x0807 /* Always zero */ | ||
133 | |||
134 | #if 0 | ||
135 | static char *CUstates[8] = { | ||
136 | "idle", "suspended", "active", 0, 0, 0, 0, 0 | ||
137 | }; | ||
138 | static char *RUstates[16] = { | ||
139 | "idle", "suspended", "no resources", 0, "ready", 0, 0, 0, | ||
140 | 0, 0, "no RBDs", 0, "out of RBDs", 0, 0, 0 | ||
141 | }; | ||
142 | |||
143 | static void | ||
144 | i596_out_status(int status) { | ||
145 | int bad = 0; | ||
146 | char *s; | ||
147 | |||
148 | printk("status %4.4x:", status); | ||
149 | if (status == 0xffff) | ||
150 | printk(" strange..\n"); | ||
151 | else { | ||
152 | if (status & STAT_CX) | ||
153 | printk(" CU done"); | ||
154 | if (status & STAT_CNA) | ||
155 | printk(" CU stopped"); | ||
156 | if (status & STAT_FR) | ||
157 | printk(" got a frame"); | ||
158 | if (status & STAT_RNR) | ||
159 | printk(" RU stopped"); | ||
160 | if (status & STAT_T) | ||
161 | printk(" throttled"); | ||
162 | if (status & STAT_ZERO) | ||
163 | bad = 1; | ||
164 | s = CUstates[(status & STAT_CUS) >> 8]; | ||
165 | if (!s) | ||
166 | bad = 1; | ||
167 | else | ||
168 | printk(" CU(%s)", s); | ||
169 | s = RUstates[(status & STAT_RUS) >> 4]; | ||
170 | if (!s) | ||
171 | bad = 1; | ||
172 | else | ||
173 | printk(" RU(%s)", s); | ||
174 | if (bad) | ||
175 | printk(" bad status"); | ||
176 | printk("\n"); | ||
177 | } | ||
178 | } | ||
179 | #endif | ||
180 | |||
181 | /* Command word bits */ | ||
182 | #define ACK_CX 0x8000 | ||
183 | #define ACK_FR 0x4000 | ||
184 | #define ACK_CNA 0x2000 | ||
185 | #define ACK_RNR 0x1000 | ||
186 | |||
187 | #define CUC_START 0x0100 | ||
188 | #define CUC_RESUME 0x0200 | ||
189 | #define CUC_SUSPEND 0x0300 | ||
190 | #define CUC_ABORT 0x0400 | ||
191 | |||
192 | #define RX_START 0x0010 | ||
193 | #define RX_RESUME 0x0020 | ||
194 | #define RX_SUSPEND 0x0030 | ||
195 | #define RX_ABORT 0x0040 | ||
196 | |||
197 | typedef u32 phys_addr; | ||
198 | |||
199 | static inline phys_addr | ||
200 | va_to_pa(void *x) { | ||
201 | return x ? virt_to_bus(x) : I596_NULL; | ||
202 | } | ||
203 | |||
204 | static inline void * | ||
205 | pa_to_va(phys_addr x) { | ||
206 | return (x == I596_NULL) ? NULL : bus_to_virt(x); | ||
207 | } | ||
208 | |||
209 | /* status bits for cmd */ | ||
210 | #define CMD_STAT_C 0x8000 /* CU command complete */ | ||
211 | #define CMD_STAT_B 0x4000 /* CU command in progress */ | ||
212 | #define CMD_STAT_OK 0x2000 /* CU command completed without errors */ | ||
213 | #define CMD_STAT_A 0x1000 /* CU command abnormally terminated */ | ||
214 | |||
215 | struct i596_cmd { /* 8 bytes */ | ||
216 | unsigned short status; | ||
217 | unsigned short command; | ||
218 | phys_addr pa_next; /* va_to_pa(struct i596_cmd *next) */ | ||
219 | }; | ||
220 | |||
221 | #define EOF 0x8000 | ||
222 | #define SIZE_MASK 0x3fff | ||
223 | |||
224 | struct i596_tbd { | ||
225 | unsigned short size; | ||
226 | unsigned short pad; | ||
227 | phys_addr pa_next; /* va_to_pa(struct i596_tbd *next) */ | ||
228 | phys_addr pa_data; /* va_to_pa(char *data) */ | ||
229 | struct sk_buff *skb; | ||
230 | }; | ||
231 | |||
232 | struct tx_cmd { | ||
233 | struct i596_cmd cmd; | ||
234 | phys_addr pa_tbd; /* va_to_pa(struct i596_tbd *tbd) */ | ||
235 | unsigned short size; | ||
236 | unsigned short pad; | ||
237 | }; | ||
238 | |||
239 | /* status bits for rfd */ | ||
240 | #define RFD_STAT_C 0x8000 /* Frame reception complete */ | ||
241 | #define RFD_STAT_B 0x4000 /* Frame reception in progress */ | ||
242 | #define RFD_STAT_OK 0x2000 /* Frame received without errors */ | ||
243 | #define RFD_STATUS 0x1fff | ||
244 | #define RFD_LENGTH_ERR 0x1000 | ||
245 | #define RFD_CRC_ERR 0x0800 | ||
246 | #define RFD_ALIGN_ERR 0x0400 | ||
247 | #define RFD_NOBUFS_ERR 0x0200 | ||
248 | #define RFD_DMA_ERR 0x0100 /* DMA overrun failure to acquire system bus */ | ||
249 | #define RFD_SHORT_FRAME_ERR 0x0080 | ||
250 | #define RFD_NOEOP_ERR 0x0040 | ||
251 | #define RFD_TRUNC_ERR 0x0020 | ||
252 | #define RFD_MULTICAST 0x0002 /* 0: destination had our address | ||
253 | 1: destination was broadcast/multicast */ | ||
254 | #define RFD_COLLISION 0x0001 | ||
255 | |||
256 | /* receive frame descriptor */ | ||
257 | struct i596_rfd { | ||
258 | unsigned short stat; | ||
259 | unsigned short cmd; | ||
260 | phys_addr pa_next; /* va_to_pa(struct i596_rfd *next) */ | ||
261 | phys_addr pa_rbd; /* va_to_pa(struct i596_rbd *rbd) */ | ||
262 | unsigned short count; | ||
263 | unsigned short size; | ||
264 | char data[1532]; | ||
265 | }; | ||
266 | |||
267 | #define RBD_EL 0x8000 | ||
268 | #define RBD_P 0x4000 | ||
269 | #define RBD_SIZEMASK 0x3fff | ||
270 | #define RBD_EOF 0x8000 | ||
271 | #define RBD_F 0x4000 | ||
272 | |||
273 | /* receive buffer descriptor */ | ||
274 | struct i596_rbd { | ||
275 | unsigned short size; | ||
276 | unsigned short pad; | ||
277 | phys_addr pa_next; /* va_to_pa(struct i596_tbd *next) */ | ||
278 | phys_addr pa_data; /* va_to_pa(char *data) */ | ||
279 | phys_addr pa_prev; /* va_to_pa(struct i596_tbd *prev) */ | ||
280 | |||
281 | /* Driver private part */ | ||
282 | struct sk_buff *skb; | ||
283 | }; | ||
284 | |||
285 | #define RX_RING_SIZE 64 | ||
286 | #define RX_SKBSIZE (ETH_FRAME_LEN+10) | ||
287 | #define RX_RBD_SIZE 32 | ||
288 | |||
289 | /* System Control Block - 40 bytes */ | ||
290 | struct i596_scb { | ||
291 | u16 status; /* 0 */ | ||
292 | u16 command; /* 2 */ | ||
293 | phys_addr pa_cmd; /* 4 - va_to_pa(struct i596_cmd *cmd) */ | ||
294 | phys_addr pa_rfd; /* 8 - va_to_pa(struct i596_rfd *rfd) */ | ||
295 | u32 crc_err; /* 12 */ | ||
296 | u32 align_err; /* 16 */ | ||
297 | u32 resource_err; /* 20 */ | ||
298 | u32 over_err; /* 24 */ | ||
299 | u32 rcvdt_err; /* 28 */ | ||
300 | u32 short_err; /* 32 */ | ||
301 | u16 t_on; /* 36 */ | ||
302 | u16 t_off; /* 38 */ | ||
303 | }; | ||
304 | |||
305 | /* Intermediate System Configuration Pointer - 8 bytes */ | ||
306 | struct i596_iscp { | ||
307 | u32 busy; /* 0 */ | ||
308 | phys_addr pa_scb; /* 4 - va_to_pa(struct i596_scb *scb) */ | ||
309 | }; | ||
310 | |||
311 | /* System Configuration Pointer - 12 bytes */ | ||
312 | struct i596_scp { | ||
313 | u32 sysbus; /* 0 */ | ||
314 | u32 pad; /* 4 */ | ||
315 | phys_addr pa_iscp; /* 8 - va_to_pa(struct i596_iscp *iscp) */ | ||
316 | }; | ||
317 | |||
318 | /* Selftest and dump results - needs 16-byte alignment */ | ||
319 | /* | ||
320 | * The size of the dump area is 304 bytes. When the dump is executed | ||
321 | * by the Port command an extra word will be appended to the dump area. | ||
322 | * The extra word is a copy of the Dump status word (containing the | ||
323 | * C, B, OK bits). [I find 0xa006, with a0 for C+OK and 6 for dump] | ||
324 | */ | ||
325 | struct i596_dump { | ||
326 | u16 dump[153]; /* (304 = 130h) + 2 bytes */ | ||
327 | }; | ||
328 | |||
329 | struct i596_private { /* aligned to a 16-byte boundary */ | ||
330 | struct i596_scp scp; /* 0 - needs 16-byte alignment */ | ||
331 | struct i596_iscp iscp; /* 12 */ | ||
332 | struct i596_scb scb; /* 20 */ | ||
333 | u32 dummy; /* 60 */ | ||
334 | struct i596_dump dump; /* 64 - needs 16-byte alignment */ | ||
335 | |||
336 | struct i596_cmd set_add; | ||
337 | char eth_addr[8]; /* directly follows set_add */ | ||
338 | |||
339 | struct i596_cmd set_conf; | ||
340 | char i596_config[16]; /* directly follows set_conf */ | ||
341 | |||
342 | struct i596_cmd tdr; | ||
343 | unsigned long tdr_stat; /* directly follows tdr */ | ||
344 | |||
345 | int last_restart; | ||
346 | struct i596_rbd *rbd_list; | ||
347 | struct i596_rbd *rbd_tail; | ||
348 | struct i596_rfd *rx_tail; | ||
349 | struct i596_cmd *cmd_tail; | ||
350 | struct i596_cmd *cmd_head; | ||
351 | int cmd_backlog; | ||
352 | unsigned long last_cmd; | ||
353 | spinlock_t cmd_lock; | ||
354 | }; | ||
355 | |||
356 | static char init_setup[14] = { | ||
357 | 0x8E, /* length 14 bytes, prefetch on */ | ||
358 | 0xC8, /* default: fifo to 8, monitor off */ | ||
359 | 0x40, /* default: don't save bad frames (apricot.c had 0x80) */ | ||
360 | 0x2E, /* (default is 0x26) | ||
361 | No source address insertion, 8 byte preamble */ | ||
362 | 0x00, /* default priority and backoff */ | ||
363 | 0x60, /* default interframe spacing */ | ||
364 | 0x00, /* default slot time LSB */ | ||
365 | 0xf2, /* default slot time and nr of retries */ | ||
366 | 0x00, /* default various bits | ||
367 | (0: promiscuous mode, 1: broadcast disable, | ||
368 | 2: encoding mode, 3: transmit on no CRS, | ||
369 | 4: no CRC insertion, 5: CRC type, | ||
370 | 6: bit stuffing, 7: padding) */ | ||
371 | 0x00, /* default carrier sense and collision detect */ | ||
372 | 0x40, /* default minimum frame length */ | ||
373 | 0xff, /* (default is 0xff, and that is what apricot.c has; | ||
374 | elp486.c has 0xfb: Enable crc append in memory.) */ | ||
375 | 0x00, /* default: not full duplex */ | ||
376 | 0x7f /* (default is 0x3f) multi IA */ | ||
377 | }; | ||
378 | |||
379 | static int i596_open(struct net_device *dev); | ||
380 | static netdev_tx_t i596_start_xmit(struct sk_buff *skb, struct net_device *dev); | ||
381 | static irqreturn_t i596_interrupt(int irq, void *dev_id); | ||
382 | static int i596_close(struct net_device *dev); | ||
383 | static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd); | ||
384 | static void print_eth(char *); | ||
385 | static void set_multicast_list(struct net_device *dev); | ||
386 | static void i596_tx_timeout(struct net_device *dev); | ||
387 | |||
388 | static int | ||
389 | i596_timeout(struct net_device *dev, char *msg, int ct) { | ||
390 | struct i596_private *lp; | ||
391 | int boguscnt = ct; | ||
392 | |||
393 | lp = netdev_priv(dev); | ||
394 | while (lp->scb.command) { | ||
395 | if (--boguscnt == 0) { | ||
396 | printk("%s: %s timed out - stat %4.4x, cmd %4.4x\n", | ||
397 | dev->name, msg, | ||
398 | lp->scb.status, lp->scb.command); | ||
399 | return 1; | ||
400 | } | ||
401 | udelay(5); | ||
402 | barrier(); | ||
403 | } | ||
404 | return 0; | ||
405 | } | ||
406 | |||
407 | static inline int | ||
408 | init_rx_bufs(struct net_device *dev, int num) { | ||
409 | struct i596_private *lp; | ||
410 | struct i596_rfd *rfd; | ||
411 | int i; | ||
412 | // struct i596_rbd *rbd; | ||
413 | |||
414 | lp = netdev_priv(dev); | ||
415 | lp->scb.pa_rfd = I596_NULL; | ||
416 | |||
417 | for (i = 0; i < num; i++) { | ||
418 | rfd = kmalloc(sizeof(struct i596_rfd), GFP_KERNEL); | ||
419 | if (rfd == NULL) | ||
420 | break; | ||
421 | |||
422 | rfd->stat = 0; | ||
423 | rfd->pa_rbd = I596_NULL; | ||
424 | rfd->count = 0; | ||
425 | rfd->size = 1532; | ||
426 | if (i == 0) { | ||
427 | rfd->cmd = CMD_EOL; | ||
428 | lp->rx_tail = rfd; | ||
429 | } else { | ||
430 | rfd->cmd = 0; | ||
431 | } | ||
432 | rfd->pa_next = lp->scb.pa_rfd; | ||
433 | lp->scb.pa_rfd = va_to_pa(rfd); | ||
434 | lp->rx_tail->pa_next = lp->scb.pa_rfd; | ||
435 | } | ||
436 | |||
437 | #if 0 | ||
438 | for (i = 0; i<RX_RBD_SIZE; i++) { | ||
439 | rbd = kmalloc(sizeof(struct i596_rbd), GFP_KERNEL); | ||
440 | if (rbd) { | ||
441 | rbd->pad = 0; | ||
442 | rbd->count = 0; | ||
443 | rbd->skb = dev_alloc_skb(RX_SKBSIZE); | ||
444 | if (!rbd->skb) { | ||
445 | printk("dev_alloc_skb failed"); | ||
446 | } | ||
447 | rbd->next = rfd->rbd; | ||
448 | if (i) { | ||
449 | rfd->rbd->prev = rbd; | ||
450 | rbd->size = RX_SKBSIZE; | ||
451 | } else { | ||
452 | rbd->size = (RX_SKBSIZE | RBD_EL); | ||
453 | lp->rbd_tail = rbd; | ||
454 | } | ||
455 | |||
456 | rfd->rbd = rbd; | ||
457 | } | ||
458 | } | ||
459 | lp->rbd_tail->next = rfd->rbd; | ||
460 | #endif | ||
461 | return i; | ||
462 | } | ||
463 | |||
464 | static inline void | ||
465 | remove_rx_bufs(struct net_device *dev) { | ||
466 | struct i596_private *lp; | ||
467 | struct i596_rfd *rfd; | ||
468 | |||
469 | lp = netdev_priv(dev); | ||
470 | lp->rx_tail->pa_next = I596_NULL; | ||
471 | |||
472 | do { | ||
473 | rfd = pa_to_va(lp->scb.pa_rfd); | ||
474 | lp->scb.pa_rfd = rfd->pa_next; | ||
475 | kfree(rfd); | ||
476 | } while (rfd != lp->rx_tail); | ||
477 | |||
478 | lp->rx_tail = NULL; | ||
479 | |||
480 | #if 0 | ||
481 | for (lp->rbd_list) { | ||
482 | } | ||
483 | #endif | ||
484 | } | ||
485 | |||
486 | #define PORT_RESET 0x00 /* reset 82596 */ | ||
487 | #define PORT_SELFTEST 0x01 /* selftest */ | ||
488 | #define PORT_ALTSCP 0x02 /* alternate SCB address */ | ||
489 | #define PORT_DUMP 0x03 /* dump */ | ||
490 | |||
491 | #define IOADDR 0xcb0 /* real constant */ | ||
492 | #define IRQ 10 /* default IRQ - can be changed by ECU */ | ||
493 | |||
494 | /* The 82596 requires two 16-bit write cycles for a port command */ | ||
495 | static inline void | ||
496 | PORT(phys_addr a, unsigned int cmd) { | ||
497 | if (a & 0xf) | ||
498 | printk("lp486e.c: PORT: address not aligned\n"); | ||
499 | outw(((a & 0xffff) | cmd), IOADDR); | ||
500 | outw(((a>>16) & 0xffff), IOADDR+2); | ||
501 | } | ||
502 | |||
503 | static inline void | ||
504 | CA(void) { | ||
505 | outb(0, IOADDR+4); | ||
506 | udelay(8); | ||
507 | } | ||
508 | |||
509 | static inline void | ||
510 | CLEAR_INT(void) { | ||
511 | outb(0, IOADDR+8); | ||
512 | } | ||
513 | |||
514 | #if 0 | ||
515 | /* selftest or dump */ | ||
516 | static void | ||
517 | i596_port_do(struct net_device *dev, int portcmd, char *cmdname) { | ||
518 | struct i596_private *lp = netdev_priv(dev); | ||
519 | u16 *outp; | ||
520 | int i, m; | ||
521 | |||
522 | memset((void *)&(lp->dump), 0, sizeof(struct i596_dump)); | ||
523 | outp = &(lp->dump.dump[0]); | ||
524 | |||
525 | PORT(va_to_pa(outp), portcmd); | ||
526 | mdelay(30); /* random, unmotivated */ | ||
527 | |||
528 | printk("lp486e i82596 %s result:\n", cmdname); | ||
529 | for (m = ARRAY_SIZE(lp->dump.dump); m && lp->dump.dump[m-1] == 0; m--) | ||
530 | ; | ||
531 | for (i = 0; i < m; i++) { | ||
532 | printk(" %04x", lp->dump.dump[i]); | ||
533 | if (i%8 == 7) | ||
534 | printk("\n"); | ||
535 | } | ||
536 | printk("\n"); | ||
537 | } | ||
538 | #endif | ||
539 | |||
540 | static int | ||
541 | i596_scp_setup(struct net_device *dev) { | ||
542 | struct i596_private *lp = netdev_priv(dev); | ||
543 | int boguscnt; | ||
544 | |||
545 | /* Setup SCP, ISCP, SCB */ | ||
546 | /* | ||
547 | * sysbus bits: | ||
548 | * only a single byte is significant - here 0x44 | ||
549 | * 0x80: big endian mode (details depend on stepping) | ||
550 | * 0x40: 1 | ||
551 | * 0x20: interrupt pin is active low | ||
552 | * 0x10: lock function disabled | ||
553 | * 0x08: external triggering of bus throttle timers | ||
554 | * 0x06: 00: 82586 compat mode, 01: segmented mode, 10: linear mode | ||
555 | * 0x01: unused | ||
556 | */ | ||
557 | lp->scp.sysbus = 0x00440000; /* linear mode */ | ||
558 | lp->scp.pad = 0; /* must be zero */ | ||
559 | lp->scp.pa_iscp = va_to_pa(&(lp->iscp)); | ||
560 | |||
561 | /* | ||
562 | * The CPU sets the ISCP to 1 before it gives the first CA() | ||
563 | */ | ||
564 | lp->iscp.busy = 0x0001; | ||
565 | lp->iscp.pa_scb = va_to_pa(&(lp->scb)); | ||
566 | |||
567 | lp->scb.command = 0; | ||
568 | lp->scb.status = 0; | ||
569 | lp->scb.pa_cmd = I596_NULL; | ||
570 | /* lp->scb.pa_rfd has been initialised already */ | ||
571 | |||
572 | lp->last_cmd = jiffies; | ||
573 | lp->cmd_backlog = 0; | ||
574 | lp->cmd_head = NULL; | ||
575 | |||
576 | /* | ||
577 | * Reset the 82596. | ||
578 | * We need to wait 10 systemclock cycles, and | ||
579 | * 5 serial clock cycles. | ||
580 | */ | ||
581 | PORT(0, PORT_RESET); /* address part ignored */ | ||
582 | udelay(100); | ||
583 | |||
584 | /* | ||
585 | * Before the CA signal is asserted, the default SCP address | ||
586 | * (0x00fffff4) can be changed to a 16-byte aligned value | ||
587 | */ | ||
588 | PORT(va_to_pa(&lp->scp), PORT_ALTSCP); /* change the scp address */ | ||
589 | |||
590 | /* | ||
591 | * The initialization procedure begins when a | ||
592 | * Channel Attention signal is asserted after a reset. | ||
593 | */ | ||
594 | |||
595 | CA(); | ||
596 | |||
597 | /* | ||
598 | * The ISCP busy is cleared by the 82596 after the SCB address is read. | ||
599 | */ | ||
600 | boguscnt = 100; | ||
601 | while (lp->iscp.busy) { | ||
602 | if (--boguscnt == 0) { | ||
603 | /* No i82596 present? */ | ||
604 | printk("%s: i82596 initialization timed out\n", | ||
605 | dev->name); | ||
606 | return 1; | ||
607 | } | ||
608 | udelay(5); | ||
609 | barrier(); | ||
610 | } | ||
611 | /* I find here boguscnt==100, so no delay was required. */ | ||
612 | |||
613 | return 0; | ||
614 | } | ||
615 | |||
616 | static int | ||
617 | init_i596(struct net_device *dev) { | ||
618 | struct i596_private *lp; | ||
619 | |||
620 | if (i596_scp_setup(dev)) | ||
621 | return 1; | ||
622 | |||
623 | lp = netdev_priv(dev); | ||
624 | lp->scb.command = 0; | ||
625 | |||
626 | memcpy ((void *)lp->i596_config, init_setup, 14); | ||
627 | lp->set_conf.command = CmdConfigure; | ||
628 | i596_add_cmd(dev, (void *)&lp->set_conf); | ||
629 | |||
630 | memcpy ((void *)lp->eth_addr, dev->dev_addr, 6); | ||
631 | lp->set_add.command = CmdIASetup; | ||
632 | i596_add_cmd(dev, &lp->set_add); | ||
633 | |||
634 | lp->tdr.command = CmdTDR; | ||
635 | i596_add_cmd(dev, &lp->tdr); | ||
636 | |||
637 | if (lp->scb.command && i596_timeout(dev, "i82596 init", 200)) | ||
638 | return 1; | ||
639 | |||
640 | lp->scb.command = RX_START; | ||
641 | CA(); | ||
642 | |||
643 | barrier(); | ||
644 | |||
645 | if (lp->scb.command && i596_timeout(dev, "Receive Unit start", 100)) | ||
646 | return 1; | ||
647 | |||
648 | return 0; | ||
649 | } | ||
650 | |||
651 | /* Receive a single frame */ | ||
652 | static inline int | ||
653 | i596_rx_one(struct net_device *dev, struct i596_private *lp, | ||
654 | struct i596_rfd *rfd, int *frames) { | ||
655 | |||
656 | if (rfd->stat & RFD_STAT_OK) { | ||
657 | /* a good frame */ | ||
658 | int pkt_len = (rfd->count & 0x3fff); | ||
659 | struct sk_buff *skb = netdev_alloc_skb(dev, pkt_len); | ||
660 | |||
661 | (*frames)++; | ||
662 | |||
663 | if (rfd->cmd & CMD_EOL) | ||
664 | printk("Received on EOL\n"); | ||
665 | |||
666 | if (skb == NULL) { | ||
667 | printk ("%s: i596_rx Memory squeeze, " | ||
668 | "dropping packet.\n", dev->name); | ||
669 | dev->stats.rx_dropped++; | ||
670 | return 1; | ||
671 | } | ||
672 | |||
673 | memcpy(skb_put(skb,pkt_len), rfd->data, pkt_len); | ||
674 | |||
675 | skb->protocol = eth_type_trans(skb,dev); | ||
676 | netif_rx(skb); | ||
677 | dev->stats.rx_packets++; | ||
678 | } else { | ||
679 | #if 0 | ||
680 | printk("Frame reception error status %04x\n", | ||
681 | rfd->stat); | ||
682 | #endif | ||
683 | dev->stats.rx_errors++; | ||
684 | if (rfd->stat & RFD_COLLISION) | ||
685 | dev->stats.collisions++; | ||
686 | if (rfd->stat & RFD_SHORT_FRAME_ERR) | ||
687 | dev->stats.rx_length_errors++; | ||
688 | if (rfd->stat & RFD_DMA_ERR) | ||
689 | dev->stats.rx_over_errors++; | ||
690 | if (rfd->stat & RFD_NOBUFS_ERR) | ||
691 | dev->stats.rx_fifo_errors++; | ||
692 | if (rfd->stat & RFD_ALIGN_ERR) | ||
693 | dev->stats.rx_frame_errors++; | ||
694 | if (rfd->stat & RFD_CRC_ERR) | ||
695 | dev->stats.rx_crc_errors++; | ||
696 | if (rfd->stat & RFD_LENGTH_ERR) | ||
697 | dev->stats.rx_length_errors++; | ||
698 | } | ||
699 | rfd->stat = rfd->count = 0; | ||
700 | return 0; | ||
701 | } | ||
702 | |||
703 | static int | ||
704 | i596_rx(struct net_device *dev) { | ||
705 | struct i596_private *lp = netdev_priv(dev); | ||
706 | struct i596_rfd *rfd; | ||
707 | int frames = 0; | ||
708 | |||
709 | while (1) { | ||
710 | rfd = pa_to_va(lp->scb.pa_rfd); | ||
711 | if (!rfd) { | ||
712 | printk(KERN_ERR "i596_rx: NULL rfd?\n"); | ||
713 | return 0; | ||
714 | } | ||
715 | #if 1 | ||
716 | if (rfd->stat && !(rfd->stat & (RFD_STAT_C | RFD_STAT_B))) | ||
717 | printk("SF:%p-%04x\n", rfd, rfd->stat); | ||
718 | #endif | ||
719 | if (!(rfd->stat & RFD_STAT_C)) | ||
720 | break; /* next one not ready */ | ||
721 | if (i596_rx_one(dev, lp, rfd, &frames)) | ||
722 | break; /* out of memory */ | ||
723 | rfd->cmd = CMD_EOL; | ||
724 | lp->rx_tail->cmd = 0; | ||
725 | lp->rx_tail = rfd; | ||
726 | lp->scb.pa_rfd = rfd->pa_next; | ||
727 | barrier(); | ||
728 | } | ||
729 | |||
730 | return frames; | ||
731 | } | ||
732 | |||
733 | static void | ||
734 | i596_cleanup_cmd(struct net_device *dev) { | ||
735 | struct i596_private *lp; | ||
736 | struct i596_cmd *cmd; | ||
737 | |||
738 | lp = netdev_priv(dev); | ||
739 | while (lp->cmd_head) { | ||
740 | cmd = lp->cmd_head; | ||
741 | |||
742 | lp->cmd_head = pa_to_va(lp->cmd_head->pa_next); | ||
743 | lp->cmd_backlog--; | ||
744 | |||
745 | switch ((cmd->command) & 0x7) { | ||
746 | case CmdTx: { | ||
747 | struct tx_cmd *tx_cmd = (struct tx_cmd *) cmd; | ||
748 | struct i596_tbd * tx_cmd_tbd; | ||
749 | tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd); | ||
750 | |||
751 | dev_kfree_skb_any(tx_cmd_tbd->skb); | ||
752 | |||
753 | dev->stats.tx_errors++; | ||
754 | dev->stats.tx_aborted_errors++; | ||
755 | |||
756 | cmd->pa_next = I596_NULL; | ||
757 | kfree((unsigned char *)tx_cmd); | ||
758 | netif_wake_queue(dev); | ||
759 | break; | ||
760 | } | ||
761 | case CmdMulticastList: { | ||
762 | // unsigned short count = *((unsigned short *) (ptr + 1)); | ||
763 | |||
764 | cmd->pa_next = I596_NULL; | ||
765 | kfree((unsigned char *)cmd); | ||
766 | break; | ||
767 | } | ||
768 | default: { | ||
769 | cmd->pa_next = I596_NULL; | ||
770 | break; | ||
771 | } | ||
772 | } | ||
773 | barrier(); | ||
774 | } | ||
775 | |||
776 | if (lp->scb.command && i596_timeout(dev, "i596_cleanup_cmd", 100)) | ||
777 | ; | ||
778 | |||
779 | lp->scb.pa_cmd = va_to_pa(lp->cmd_head); | ||
780 | } | ||
781 | |||
782 | static void i596_reset(struct net_device *dev, struct i596_private *lp, int ioaddr) { | ||
783 | |||
784 | if (lp->scb.command && i596_timeout(dev, "i596_reset", 100)) | ||
785 | ; | ||
786 | |||
787 | netif_stop_queue(dev); | ||
788 | |||
789 | lp->scb.command = CUC_ABORT | RX_ABORT; | ||
790 | CA(); | ||
791 | barrier(); | ||
792 | |||
793 | /* wait for shutdown */ | ||
794 | if (lp->scb.command && i596_timeout(dev, "i596_reset(2)", 400)) | ||
795 | ; | ||
796 | |||
797 | i596_cleanup_cmd(dev); | ||
798 | i596_rx(dev); | ||
799 | |||
800 | netif_start_queue(dev); | ||
801 | /*dev_kfree_skb(skb, FREE_WRITE);*/ | ||
802 | init_i596(dev); | ||
803 | } | ||
804 | |||
805 | static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd) { | ||
806 | struct i596_private *lp = netdev_priv(dev); | ||
807 | int ioaddr = dev->base_addr; | ||
808 | unsigned long flags; | ||
809 | |||
810 | cmd->status = 0; | ||
811 | cmd->command |= (CMD_EOL | CMD_INTR); | ||
812 | cmd->pa_next = I596_NULL; | ||
813 | |||
814 | spin_lock_irqsave(&lp->cmd_lock, flags); | ||
815 | |||
816 | if (lp->cmd_head) { | ||
817 | lp->cmd_tail->pa_next = va_to_pa(cmd); | ||
818 | } else { | ||
819 | lp->cmd_head = cmd; | ||
820 | if (lp->scb.command && i596_timeout(dev, "i596_add_cmd", 100)) | ||
821 | ; | ||
822 | lp->scb.pa_cmd = va_to_pa(cmd); | ||
823 | lp->scb.command = CUC_START; | ||
824 | CA(); | ||
825 | } | ||
826 | lp->cmd_tail = cmd; | ||
827 | lp->cmd_backlog++; | ||
828 | |||
829 | lp->cmd_head = pa_to_va(lp->scb.pa_cmd); | ||
830 | spin_unlock_irqrestore(&lp->cmd_lock, flags); | ||
831 | |||
832 | if (lp->cmd_backlog > 16) { | ||
833 | int tickssofar = jiffies - lp->last_cmd; | ||
834 | if (tickssofar < HZ/4) | ||
835 | return; | ||
836 | |||
837 | printk(KERN_WARNING "%s: command unit timed out, status resetting.\n", dev->name); | ||
838 | i596_reset(dev, lp, ioaddr); | ||
839 | } | ||
840 | } | ||
841 | |||
842 | static int i596_open(struct net_device *dev) | ||
843 | { | ||
844 | int i; | ||
845 | |||
846 | i = request_irq(dev->irq, i596_interrupt, IRQF_SHARED, dev->name, dev); | ||
847 | if (i) { | ||
848 | printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq); | ||
849 | return i; | ||
850 | } | ||
851 | |||
852 | if ((i = init_rx_bufs(dev, RX_RING_SIZE)) < RX_RING_SIZE) | ||
853 | printk(KERN_ERR "%s: only able to allocate %d receive buffers\n", dev->name, i); | ||
854 | |||
855 | if (i < 4) { | ||
856 | free_irq(dev->irq, dev); | ||
857 | return -EAGAIN; | ||
858 | } | ||
859 | netif_start_queue(dev); | ||
860 | init_i596(dev); | ||
861 | return 0; /* Always succeed */ | ||
862 | } | ||
863 | |||
864 | static netdev_tx_t i596_start_xmit (struct sk_buff *skb, struct net_device *dev) { | ||
865 | struct tx_cmd *tx_cmd; | ||
866 | short length; | ||
867 | |||
868 | length = skb->len; | ||
869 | |||
870 | if (length < ETH_ZLEN) { | ||
871 | if (skb_padto(skb, ETH_ZLEN)) | ||
872 | return NETDEV_TX_OK; | ||
873 | length = ETH_ZLEN; | ||
874 | } | ||
875 | |||
876 | tx_cmd = kmalloc((sizeof (struct tx_cmd) + sizeof (struct i596_tbd)), GFP_ATOMIC); | ||
877 | if (tx_cmd == NULL) { | ||
878 | printk(KERN_WARNING "%s: i596_xmit Memory squeeze, dropping packet.\n", dev->name); | ||
879 | dev->stats.tx_dropped++; | ||
880 | dev_kfree_skb (skb); | ||
881 | } else { | ||
882 | struct i596_tbd *tx_cmd_tbd; | ||
883 | tx_cmd_tbd = (struct i596_tbd *) (tx_cmd + 1); | ||
884 | tx_cmd->pa_tbd = va_to_pa (tx_cmd_tbd); | ||
885 | tx_cmd_tbd->pa_next = I596_NULL; | ||
886 | |||
887 | tx_cmd->cmd.command = (CMD_FLEX | CmdTx); | ||
888 | |||
889 | tx_cmd->pad = 0; | ||
890 | tx_cmd->size = 0; | ||
891 | tx_cmd_tbd->pad = 0; | ||
892 | tx_cmd_tbd->size = (EOF | length); | ||
893 | |||
894 | tx_cmd_tbd->pa_data = va_to_pa (skb->data); | ||
895 | tx_cmd_tbd->skb = skb; | ||
896 | |||
897 | if (i596_debug & LOG_SRCDST) | ||
898 | print_eth (skb->data); | ||
899 | |||
900 | i596_add_cmd (dev, (struct i596_cmd *) tx_cmd); | ||
901 | |||
902 | dev->stats.tx_packets++; | ||
903 | } | ||
904 | |||
905 | return NETDEV_TX_OK; | ||
906 | } | ||
907 | |||
908 | static void | ||
909 | i596_tx_timeout (struct net_device *dev) { | ||
910 | struct i596_private *lp = netdev_priv(dev); | ||
911 | int ioaddr = dev->base_addr; | ||
912 | |||
913 | /* Transmitter timeout, serious problems. */ | ||
914 | printk(KERN_WARNING "%s: transmit timed out, status resetting.\n", dev->name); | ||
915 | dev->stats.tx_errors++; | ||
916 | |||
917 | /* Try to restart the adaptor */ | ||
918 | if (lp->last_restart == dev->stats.tx_packets) { | ||
919 | printk ("Resetting board.\n"); | ||
920 | |||
921 | /* Shutdown and restart */ | ||
922 | i596_reset (dev, lp, ioaddr); | ||
923 | } else { | ||
924 | /* Issue a channel attention signal */ | ||
925 | printk ("Kicking board.\n"); | ||
926 | lp->scb.command = (CUC_START | RX_START); | ||
927 | CA(); | ||
928 | lp->last_restart = dev->stats.tx_packets; | ||
929 | } | ||
930 | netif_wake_queue(dev); | ||
931 | } | ||
932 | |||
933 | static void print_eth(char *add) | ||
934 | { | ||
935 | int i; | ||
936 | |||
937 | printk ("Dest "); | ||
938 | for (i = 0; i < 6; i++) | ||
939 | printk(" %2.2X", (unsigned char) add[i]); | ||
940 | printk ("\n"); | ||
941 | |||
942 | printk ("Source"); | ||
943 | for (i = 0; i < 6; i++) | ||
944 | printk(" %2.2X", (unsigned char) add[i+6]); | ||
945 | printk ("\n"); | ||
946 | |||
947 | printk ("type %2.2X%2.2X\n", | ||
948 | (unsigned char) add[12], (unsigned char) add[13]); | ||
949 | } | ||
950 | |||
951 | static const struct net_device_ops i596_netdev_ops = { | ||
952 | .ndo_open = i596_open, | ||
953 | .ndo_stop = i596_close, | ||
954 | .ndo_start_xmit = i596_start_xmit, | ||
955 | .ndo_set_rx_mode = set_multicast_list, | ||
956 | .ndo_tx_timeout = i596_tx_timeout, | ||
957 | .ndo_change_mtu = eth_change_mtu, | ||
958 | .ndo_set_mac_address = eth_mac_addr, | ||
959 | .ndo_validate_addr = eth_validate_addr, | ||
960 | }; | ||
961 | |||
962 | static int __init lp486e_probe(struct net_device *dev) { | ||
963 | struct i596_private *lp; | ||
964 | unsigned char eth_addr[6] = { 0, 0xaa, 0, 0, 0, 0 }; | ||
965 | unsigned char *bios; | ||
966 | int i, j; | ||
967 | int ret = -ENOMEM; | ||
968 | static int probed; | ||
969 | |||
970 | if (probed) | ||
971 | return -ENODEV; | ||
972 | probed++; | ||
973 | |||
974 | if (!request_region(IOADDR, LP486E_TOTAL_SIZE, DRV_NAME)) { | ||
975 | printk(KERN_ERR "lp486e: IO address 0x%x in use\n", IOADDR); | ||
976 | return -EBUSY; | ||
977 | } | ||
978 | |||
979 | lp = netdev_priv(dev); | ||
980 | spin_lock_init(&lp->cmd_lock); | ||
981 | |||
982 | /* | ||
983 | * Do we really have this thing? | ||
984 | */ | ||
985 | if (i596_scp_setup(dev)) { | ||
986 | ret = -ENODEV; | ||
987 | goto err_out_kfree; | ||
988 | } | ||
989 | |||
990 | dev->base_addr = IOADDR; | ||
991 | dev->irq = IRQ; | ||
992 | |||
993 | |||
994 | /* | ||
995 | * How do we find the ethernet address? I don't know. | ||
996 | * One possibility is to look at the EISA configuration area | ||
997 | * [0xe8000-0xe9fff]. This contains the ethernet address | ||
998 | * but not at a fixed address - things depend on setup options. | ||
999 | * | ||
1000 | * If we find no address, or the wrong address, use | ||
1001 | * ifconfig eth0 hw ether a1:a2:a3:a4:a5:a6 | ||
1002 | * with the value found in the BIOS setup. | ||
1003 | */ | ||
1004 | bios = bus_to_virt(0xe8000); | ||
1005 | for (j = 0; j < 0x2000; j++) { | ||
1006 | if (bios[j] == 0 && bios[j+1] == 0xaa && bios[j+2] == 0) { | ||
1007 | printk("%s: maybe address at BIOS 0x%x:", | ||
1008 | dev->name, 0xe8000+j); | ||
1009 | for (i = 0; i < 6; i++) { | ||
1010 | eth_addr[i] = bios[i+j]; | ||
1011 | printk(" %2.2X", eth_addr[i]); | ||
1012 | } | ||
1013 | printk("\n"); | ||
1014 | } | ||
1015 | } | ||
1016 | |||
1017 | printk("%s: lp486e 82596 at %#3lx, IRQ %d,", | ||
1018 | dev->name, dev->base_addr, dev->irq); | ||
1019 | for (i = 0; i < 6; i++) | ||
1020 | printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]); | ||
1021 | printk("\n"); | ||
1022 | |||
1023 | /* The LP486E-specific entries in the device structure. */ | ||
1024 | dev->netdev_ops = &i596_netdev_ops; | ||
1025 | dev->watchdog_timeo = 5*HZ; | ||
1026 | |||
1027 | #if 0 | ||
1028 | /* selftest reports 0x320925ae - don't know what that means */ | ||
1029 | i596_port_do(dev, PORT_SELFTEST, "selftest"); | ||
1030 | i596_port_do(dev, PORT_DUMP, "dump"); | ||
1031 | #endif | ||
1032 | return 0; | ||
1033 | |||
1034 | err_out_kfree: | ||
1035 | release_region(IOADDR, LP486E_TOTAL_SIZE); | ||
1036 | return ret; | ||
1037 | } | ||
1038 | |||
1039 | static inline void | ||
1040 | i596_handle_CU_completion(struct net_device *dev, | ||
1041 | struct i596_private *lp, | ||
1042 | unsigned short status, | ||
1043 | unsigned short *ack_cmdp) { | ||
1044 | struct i596_cmd *cmd; | ||
1045 | int frames_out = 0; | ||
1046 | int commands_done = 0; | ||
1047 | int cmd_val; | ||
1048 | unsigned long flags; | ||
1049 | |||
1050 | spin_lock_irqsave(&lp->cmd_lock, flags); | ||
1051 | cmd = lp->cmd_head; | ||
1052 | |||
1053 | while (lp->cmd_head && (lp->cmd_head->status & CMD_STAT_C)) { | ||
1054 | cmd = lp->cmd_head; | ||
1055 | |||
1056 | lp->cmd_head = pa_to_va(lp->cmd_head->pa_next); | ||
1057 | lp->cmd_backlog--; | ||
1058 | |||
1059 | commands_done++; | ||
1060 | cmd_val = cmd->command & 0x7; | ||
1061 | #if 0 | ||
1062 | printk("finished CU %s command (%d)\n", | ||
1063 | CUcmdnames[cmd_val], cmd_val); | ||
1064 | #endif | ||
1065 | switch (cmd_val) { | ||
1066 | case CmdTx: | ||
1067 | { | ||
1068 | struct tx_cmd *tx_cmd; | ||
1069 | struct i596_tbd *tx_cmd_tbd; | ||
1070 | |||
1071 | tx_cmd = (struct tx_cmd *) cmd; | ||
1072 | tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd); | ||
1073 | |||
1074 | frames_out++; | ||
1075 | if (cmd->status & CMD_STAT_OK) { | ||
1076 | if (i596_debug) | ||
1077 | print_eth(pa_to_va(tx_cmd_tbd->pa_data)); | ||
1078 | } else { | ||
1079 | dev->stats.tx_errors++; | ||
1080 | if (i596_debug) | ||
1081 | printk("transmission failure:%04x\n", | ||
1082 | cmd->status); | ||
1083 | if (cmd->status & 0x0020) | ||
1084 | dev->stats.collisions++; | ||
1085 | if (!(cmd->status & 0x0040)) | ||
1086 | dev->stats.tx_heartbeat_errors++; | ||
1087 | if (cmd->status & 0x0400) | ||
1088 | dev->stats.tx_carrier_errors++; | ||
1089 | if (cmd->status & 0x0800) | ||
1090 | dev->stats.collisions++; | ||
1091 | if (cmd->status & 0x1000) | ||
1092 | dev->stats.tx_aborted_errors++; | ||
1093 | } | ||
1094 | dev_kfree_skb_irq(tx_cmd_tbd->skb); | ||
1095 | |||
1096 | cmd->pa_next = I596_NULL; | ||
1097 | kfree((unsigned char *)tx_cmd); | ||
1098 | netif_wake_queue(dev); | ||
1099 | break; | ||
1100 | } | ||
1101 | |||
1102 | case CmdMulticastList: | ||
1103 | cmd->pa_next = I596_NULL; | ||
1104 | kfree((unsigned char *)cmd); | ||
1105 | break; | ||
1106 | |||
1107 | case CmdTDR: | ||
1108 | { | ||
1109 | unsigned long status = *((unsigned long *) (cmd + 1)); | ||
1110 | if (status & 0x8000) { | ||
1111 | if (i596_debug) | ||
1112 | printk("%s: link ok.\n", dev->name); | ||
1113 | } else { | ||
1114 | if (status & 0x4000) | ||
1115 | printk("%s: Transceiver problem.\n", | ||
1116 | dev->name); | ||
1117 | if (status & 0x2000) | ||
1118 | printk("%s: Termination problem.\n", | ||
1119 | dev->name); | ||
1120 | if (status & 0x1000) | ||
1121 | printk("%s: Short circuit.\n", | ||
1122 | dev->name); | ||
1123 | printk("%s: Time %ld.\n", | ||
1124 | dev->name, status & 0x07ff); | ||
1125 | } | ||
1126 | } | ||
1127 | default: | ||
1128 | cmd->pa_next = I596_NULL; | ||
1129 | lp->last_cmd = jiffies; | ||
1130 | |||
1131 | } | ||
1132 | barrier(); | ||
1133 | } | ||
1134 | |||
1135 | cmd = lp->cmd_head; | ||
1136 | while (cmd && (cmd != lp->cmd_tail)) { | ||
1137 | cmd->command &= 0x1fff; | ||
1138 | cmd = pa_to_va(cmd->pa_next); | ||
1139 | barrier(); | ||
1140 | } | ||
1141 | |||
1142 | if (lp->cmd_head) | ||
1143 | *ack_cmdp |= CUC_START; | ||
1144 | lp->scb.pa_cmd = va_to_pa(lp->cmd_head); | ||
1145 | spin_unlock_irqrestore(&lp->cmd_lock, flags); | ||
1146 | } | ||
1147 | |||
1148 | static irqreturn_t | ||
1149 | i596_interrupt(int irq, void *dev_instance) | ||
1150 | { | ||
1151 | struct net_device *dev = dev_instance; | ||
1152 | struct i596_private *lp = netdev_priv(dev); | ||
1153 | unsigned short status, ack_cmd = 0; | ||
1154 | int frames_in = 0; | ||
1155 | |||
1156 | /* | ||
1157 | * The 82596 examines the command, performs the required action, | ||
1158 | * and then clears the SCB command word. | ||
1159 | */ | ||
1160 | if (lp->scb.command && i596_timeout(dev, "interrupt", 40)) | ||
1161 | ; | ||
1162 | |||
1163 | /* | ||
1164 | * The status word indicates the status of the 82596. | ||
1165 | * It is modified only by the 82596. | ||
1166 | * | ||
1167 | * [So, we must not clear it. I find often status 0xffff, | ||
1168 | * which is not one of the values allowed by the docs.] | ||
1169 | */ | ||
1170 | status = lp->scb.status; | ||
1171 | #if 0 | ||
1172 | if (i596_debug) { | ||
1173 | printk("%s: i596 interrupt, ", dev->name); | ||
1174 | i596_out_status(status); | ||
1175 | } | ||
1176 | #endif | ||
1177 | /* Impossible, but it happens - perhaps when we get | ||
1178 | a receive interrupt but scb.pa_rfd is I596_NULL. */ | ||
1179 | if (status == 0xffff) { | ||
1180 | printk("%s: i596_interrupt: got status 0xffff\n", dev->name); | ||
1181 | goto out; | ||
1182 | } | ||
1183 | |||
1184 | ack_cmd = (status & STAT_ACK); | ||
1185 | |||
1186 | if (status & (STAT_CX | STAT_CNA)) | ||
1187 | i596_handle_CU_completion(dev, lp, status, &ack_cmd); | ||
1188 | |||
1189 | if (status & (STAT_FR | STAT_RNR)) { | ||
1190 | /* Restart the receive unit when it got inactive somehow */ | ||
1191 | if ((status & STAT_RNR) && netif_running(dev)) | ||
1192 | ack_cmd |= RX_START; | ||
1193 | |||
1194 | if (status & STAT_FR) { | ||
1195 | frames_in = i596_rx(dev); | ||
1196 | if (!frames_in) | ||
1197 | printk("receive frame reported, but no frames\n"); | ||
1198 | } | ||
1199 | } | ||
1200 | |||
1201 | /* acknowledge the interrupt */ | ||
1202 | /* | ||
1203 | if ((lp->scb.pa_cmd != I596_NULL) && netif_running(dev)) | ||
1204 | ack_cmd |= CUC_START; | ||
1205 | */ | ||
1206 | |||
1207 | if (lp->scb.command && i596_timeout(dev, "i596 interrupt", 100)) | ||
1208 | ; | ||
1209 | |||
1210 | lp->scb.command = ack_cmd; | ||
1211 | |||
1212 | CLEAR_INT(); | ||
1213 | CA(); | ||
1214 | |||
1215 | out: | ||
1216 | return IRQ_HANDLED; | ||
1217 | } | ||
1218 | |||
1219 | static int i596_close(struct net_device *dev) { | ||
1220 | struct i596_private *lp = netdev_priv(dev); | ||
1221 | |||
1222 | netif_stop_queue(dev); | ||
1223 | |||
1224 | if (i596_debug) | ||
1225 | printk("%s: Shutting down ethercard, status was %4.4x.\n", | ||
1226 | dev->name, lp->scb.status); | ||
1227 | |||
1228 | lp->scb.command = (CUC_ABORT | RX_ABORT); | ||
1229 | CA(); | ||
1230 | |||
1231 | i596_cleanup_cmd(dev); | ||
1232 | |||
1233 | if (lp->scb.command && i596_timeout(dev, "i596_close", 200)) | ||
1234 | ; | ||
1235 | |||
1236 | free_irq(dev->irq, dev); | ||
1237 | remove_rx_bufs(dev); | ||
1238 | |||
1239 | return 0; | ||
1240 | } | ||
1241 | |||
1242 | /* | ||
1243 | * Set or clear the multicast filter for this adaptor. | ||
1244 | */ | ||
1245 | |||
1246 | static void set_multicast_list(struct net_device *dev) { | ||
1247 | struct i596_private *lp = netdev_priv(dev); | ||
1248 | struct i596_cmd *cmd; | ||
1249 | |||
1250 | if (i596_debug > 1) | ||
1251 | printk ("%s: set multicast list %d\n", | ||
1252 | dev->name, netdev_mc_count(dev)); | ||
1253 | |||
1254 | if (!netdev_mc_empty(dev)) { | ||
1255 | struct netdev_hw_addr *ha; | ||
1256 | char *cp; | ||
1257 | cmd = kmalloc(sizeof(struct i596_cmd) + 2 + | ||
1258 | netdev_mc_count(dev) * 6, GFP_ATOMIC); | ||
1259 | if (cmd == NULL) { | ||
1260 | printk (KERN_ERR "%s: set_multicast Memory squeeze.\n", dev->name); | ||
1261 | return; | ||
1262 | } | ||
1263 | cmd->command = CmdMulticastList; | ||
1264 | *((unsigned short *) (cmd + 1)) = netdev_mc_count(dev) * 6; | ||
1265 | cp = ((char *)(cmd + 1))+2; | ||
1266 | netdev_for_each_mc_addr(ha, dev) { | ||
1267 | memcpy(cp, ha->addr, 6); | ||
1268 | cp += 6; | ||
1269 | } | ||
1270 | if (i596_debug & LOG_SRCDST) | ||
1271 | print_eth (((char *)(cmd + 1)) + 2); | ||
1272 | i596_add_cmd(dev, cmd); | ||
1273 | } else { | ||
1274 | if (lp->set_conf.pa_next != I596_NULL) { | ||
1275 | return; | ||
1276 | } | ||
1277 | if (netdev_mc_empty(dev) && | ||
1278 | !(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) { | ||
1279 | lp->i596_config[8] &= ~0x01; | ||
1280 | } else { | ||
1281 | lp->i596_config[8] |= 0x01; | ||
1282 | } | ||
1283 | |||
1284 | i596_add_cmd(dev, &lp->set_conf); | ||
1285 | } | ||
1286 | } | ||
1287 | |||
1288 | MODULE_AUTHOR("Ard van Breemen <ard@cstmel.nl.eu.org>"); | ||
1289 | MODULE_DESCRIPTION("Intel Panther onboard i82596 driver"); | ||
1290 | MODULE_LICENSE("GPL"); | ||
1291 | |||
1292 | static struct net_device *dev_lp486e; | ||
1293 | static int full_duplex; | ||
1294 | static int options; | ||
1295 | static int io = IOADDR; | ||
1296 | static int irq = IRQ; | ||
1297 | |||
1298 | module_param(debug, int, 0); | ||
1299 | //module_param(max_interrupt_work, int, 0); | ||
1300 | //module_param(reverse_probe, int, 0); | ||
1301 | //module_param(rx_copybreak, int, 0); | ||
1302 | module_param(options, int, 0); | ||
1303 | module_param(full_duplex, int, 0); | ||
1304 | |||
1305 | static int __init lp486e_init_module(void) { | ||
1306 | int err; | ||
1307 | struct net_device *dev = alloc_etherdev(sizeof(struct i596_private)); | ||
1308 | if (!dev) | ||
1309 | return -ENOMEM; | ||
1310 | |||
1311 | dev->irq = irq; | ||
1312 | dev->base_addr = io; | ||
1313 | err = lp486e_probe(dev); | ||
1314 | if (err) { | ||
1315 | free_netdev(dev); | ||
1316 | return err; | ||
1317 | } | ||
1318 | err = register_netdev(dev); | ||
1319 | if (err) { | ||
1320 | release_region(dev->base_addr, LP486E_TOTAL_SIZE); | ||
1321 | free_netdev(dev); | ||
1322 | return err; | ||
1323 | } | ||
1324 | dev_lp486e = dev; | ||
1325 | full_duplex = 0; | ||
1326 | options = 0; | ||
1327 | return 0; | ||
1328 | } | ||
1329 | |||
1330 | static void __exit lp486e_cleanup_module(void) { | ||
1331 | unregister_netdev(dev_lp486e); | ||
1332 | release_region(dev_lp486e->base_addr, LP486E_TOTAL_SIZE); | ||
1333 | free_netdev(dev_lp486e); | ||
1334 | } | ||
1335 | |||
1336 | module_init(lp486e_init_module); | ||
1337 | module_exit(lp486e_cleanup_module); | ||