?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / net / lp486e.c
blobc87d90a837fb2eefc9072ff826d167171b8a4d38
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 payed 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 #define SLOW_DOWN_IO udelay(5)
60
61 #include <linux/module.h>
62 #include <linux/init.h>
63 #include <linux/delay.h>
64 #include <linux/kernel.h>
65 #include <linux/string.h>
66 #include <linux/errno.h>
67 #include <linux/ioport.h>
68 #include <linux/slab.h>
69 #include <linux/interrupt.h>
70 #include <linux/netdevice.h>
71 #include <linux/etherdevice.h>
72 #include <linux/skbuff.h>
73
74 #include <asm/bitops.h>
75 #include <asm/io.h>
76 #include <asm/dma.h>
77
78 #define DRV_NAME "lp486e"
79
80 /* debug print flags */
81 #define LOG_SRCDST 0x80000000
82 #define LOG_STATINT 0x40000000
83 #define LOG_STARTINT 0x20000000
84
85 #define i596_debug debug
86
87 static int i596_debug = 0;
88
89 static const char * const medianame[] = {
90 "10baseT", "AUI",
91 "10baseT-FD", "AUI-FD",
92 };
93
94 #define LP486E_TOTAL_SIZE 16
95
96 #define I596_NULL (0xffffffff)
97
98 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
99 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
100 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
101
102 #define CMD_FLEX 0x0008 /* Enable flexible memory model */
103
104 enum commands {
105 CmdNOP = 0,
106 CmdIASetup = 1,
107 CmdConfigure = 2,
108 CmdMulticastList = 3,
109 CmdTx = 4,
110 CmdTDR = 5,
111 CmdDump = 6,
112 CmdDiagnose = 7
113 };
114
115 char *CUcmdnames[8] = { "NOP", "IASetup", "Configure", "MulticastList",
116 "Tx", "TDR", "Dump", "Diagnose" };
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 struct net_device_stats stats;
354 spinlock_t cmd_lock;
355 };
356
357 static char init_setup[14] = {
358 0x8E, /* length 14 bytes, prefetch on */
359 0xC8, /* default: fifo to 8, monitor off */
360 0x40, /* default: don't save bad frames (apricot.c had 0x80) */
361 0x2E, /* (default is 0x26)
362 No source address insertion, 8 byte preamble */
363 0x00, /* default priority and backoff */
364 0x60, /* default interframe spacing */
365 0x00, /* default slot time LSB */
366 0xf2, /* default slot time and nr of retries */
367 0x00, /* default various bits
368 (0: promiscuous mode, 1: broadcast disable,
369 2: encoding mode, 3: transmit on no CRS,
370 4: no CRC insertion, 5: CRC type,
371 6: bit stuffing, 7: padding) */
372 0x00, /* default carrier sense and collision detect */
373 0x40, /* default minimum frame length */
374 0xff, /* (default is 0xff, and that is what apricot.c has;
375 elp486.c has 0xfb: Enable crc append in memory.) */
376 0x00, /* default: not full duplex */
377 0x7f /* (default is 0x3f) multi IA */
378 };
379
380 static int i596_open(struct net_device *dev);
381 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
382 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs);
383 static int i596_close(struct net_device *dev);
384 static struct net_device_stats *i596_get_stats(struct net_device *dev);
385 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
386 static void print_eth(char *);
387 static void set_multicast_list(struct net_device *dev);
388 static void i596_tx_timeout(struct net_device *dev);
389
390 static int
391 i596_timeout(struct net_device *dev, char *msg, int ct) {
392 struct i596_private *lp;
393 int boguscnt = ct;
394
395 lp = (struct i596_private *) dev->priv;
396 while (lp->scb.command) {
397 if (--boguscnt == 0) {
398 printk("%s: %s timed out - stat %4.4x, cmd %4.4x\n",
399 dev->name, msg,
400 lp->scb.status, lp->scb.command);
401 return 1;
402 }
403 udelay(5);
404 barrier();
405 }
406 return 0;
407 }
408
409 static inline int
410 init_rx_bufs(struct net_device *dev, int num) {
411 struct i596_private *lp;
412 struct i596_rfd *rfd;
413 int i;
414 // struct i596_rbd *rbd;
415
416 lp = (struct i596_private *) dev->priv;
417 lp->scb.pa_rfd = I596_NULL;
418
419 for (i = 0; i < num; i++) {
420 rfd = kmalloc(sizeof(struct i596_rfd), GFP_KERNEL);
421 if (rfd == NULL)
422 break;
423
424 rfd->stat = 0;
425 rfd->pa_rbd = I596_NULL;
426 rfd->count = 0;
427 rfd->size = 1532;
428 if (i == 0) {
429 rfd->cmd = CMD_EOL;
430 lp->rx_tail = rfd;
431 } else {
432 rfd->cmd = 0;
433 }
434 rfd->pa_next = lp->scb.pa_rfd;
435 lp->scb.pa_rfd = va_to_pa(rfd);
436 lp->rx_tail->pa_next = lp->scb.pa_rfd;
437 }
438
439 #if 0
440 for (i = 0; i<RX_RBD_SIZE; i++) {
441 rbd = kmalloc(sizeof(struct i596_rbd), GFP_KERNEL);
442 if (rbd) {
443 rbd->pad = 0;
444 rbd->count = 0;
445 rbd->skb = dev_alloc_skb(RX_SKB_SIZE);
446 if (!rbd->skb) {
447 printk("dev_alloc_skb failed");
448 }
449 rbd->next = rfd->rbd;
450 if (i) {
451 rfd->rbd->prev = rbd;
452 rbd->size = RX_SKB_SIZE;
453 } else {
454 rbd->size = (RX_SKB_SIZE | RBD_EL);
455 lp->rbd_tail = rbd;
456 }
457
458 rfd->rbd = rbd;
459 } else {
460 printk("Could not kmalloc rbd\n");
461 }
462 }
463 lp->rbd_tail->next = rfd->rbd;
464 #endif
465 return (i);
466 }
467
468 static inline void
469 remove_rx_bufs(struct net_device *dev) {
470 struct i596_private *lp;
471 struct i596_rfd *rfd;
472
473 lp = (struct i596_private *) dev->priv;
474 lp->rx_tail->pa_next = I596_NULL;
475
476 do {
477 rfd = pa_to_va(lp->scb.pa_rfd);
478 lp->scb.pa_rfd = rfd->pa_next;
479 kfree(rfd);
480 } while (rfd != lp->rx_tail);
481
482 lp->rx_tail = NULL;
483
484 #if 0
485 for (lp->rbd_list) {
486 }
487 #endif
488 }
489
490 #define PORT_RESET 0x00 /* reset 82596 */
491 #define PORT_SELFTEST 0x01 /* selftest */
492 #define PORT_ALTSCP 0x02 /* alternate SCB address */
493 #define PORT_DUMP 0x03 /* dump */
494
495 #define IOADDR 0xcb0 /* real constant */
496 #define IRQ 10 /* default IRQ - can be changed by ECU */
497
498 /* The 82596 requires two 16-bit write cycles for a port command */
499 static inline void
500 PORT(phys_addr a, unsigned int cmd) {
501 if (a & 0xf)
502 printk("lp486e.c: PORT: address not aligned\n");
503 outw(((a & 0xffff) | cmd), IOADDR);
504 outw(((a>>16) & 0xffff), IOADDR+2);
505 }
506
507 static inline void
508 CA(void) {
509 outb(0, IOADDR+4);
510 udelay(8);
511 }
512
513 static inline void
514 CLEAR_INT(void) {
515 outb(0, IOADDR+8);
516 }
517
518 #define SIZE(x) (sizeof(x)/sizeof((x)[0]))
519
520 #if 0
521 /* selftest or dump */
522 static void
523 i596_port_do(struct net_device *dev, int portcmd, char *cmdname) {
524 struct i596_private *lp = dev->priv;
525 u16 *outp;
526 int i, m;
527
528 memset((void *)&(lp->dump), 0, sizeof(struct i596_dump));
529 outp = &(lp->dump.dump[0]);
530
531 PORT(va_to_pa(outp), portcmd);
532 mdelay(30); /* random, unmotivated */
533
534 printk("lp486e i82596 %s result:\n", cmdname);
535 for (m = SIZE(lp->dump.dump); m && lp->dump.dump[m-1] == 0; m--)
536 ;
537 for (i = 0; i < m; i++) {
538 printk(" %04x", lp->dump.dump[i]);
539 if (i%8 == 7)
540 printk("\n");
541 }
542 printk("\n");
543 }
544 #endif
545
546 static int
547 i596_scp_setup(struct net_device *dev) {
548 struct i596_private *lp = dev->priv;
549 int boguscnt;
550
551 /* Setup SCP, ISCP, SCB */
552 /*
553 * sysbus bits:
554 * only a single byte is significant - here 0x44
555 * 0x80: big endian mode (details depend on stepping)
556 * 0x40: 1
557 * 0x20: interrupt pin is active low
558 * 0x10: lock function disabled
559 * 0x08: external triggering of bus throttle timers
560 * 0x06: 00: 82586 compat mode, 01: segmented mode, 10: linear mode
561 * 0x01: unused
562 */
563 lp->scp.sysbus = 0x00440000; /* linear mode */
564 lp->scp.pad = 0; /* must be zero */
565 lp->scp.pa_iscp = va_to_pa(&(lp->iscp));
566
567 /*
568 * The CPU sets the ISCP to 1 before it gives the first CA()
569 */
570 lp->iscp.busy = 0x0001;
571 lp->iscp.pa_scb = va_to_pa(&(lp->scb));
572
573 lp->scb.command = 0;
574 lp->scb.status = 0;
575 lp->scb.pa_cmd = I596_NULL;
576 /* lp->scb.pa_rfd has been initialised already */
577
578 lp->last_cmd = jiffies;
579 lp->cmd_backlog = 0;
580 lp->cmd_head = NULL;
581
582 /*
583 * Reset the 82596.
584 * We need to wait 10 systemclock cycles, and
585 * 5 serial clock cycles.
586 */
587 PORT(0, PORT_RESET); /* address part ignored */
588 udelay(100);
589
590 /*
591 * Before the CA signal is asserted, the default SCP address
592 * (0x00fffff4) can be changed to a 16-byte aligned value
593 */
594 PORT(va_to_pa(&lp->scp), PORT_ALTSCP); /* change the scp address */
595
596 /*
597 * The initialization procedure begins when a
598 * Channel Attention signal is asserted after a reset.
599 */
600
601 CA();
602
603 /*
604 * The ISCP busy is cleared by the 82596 after the SCB address is read.
605 */
606 boguscnt = 100;
607 while (lp->iscp.busy) {
608 if (--boguscnt == 0) {
609 /* No i82596 present? */
610 printk("%s: i82596 initialization timed out\n",
611 dev->name);
612 return 1;
613 }
614 udelay(5);
615 barrier();
616 }
617 /* I find here boguscnt==100, so no delay was required. */
618
619 return 0;
620 }
621
622 static int
623 init_i596(struct net_device *dev) {
624 struct i596_private *lp;
625
626 if (i596_scp_setup(dev))
627 return 1;
628
629 lp = (struct i596_private *) dev->priv;
630 lp->scb.command = 0;
631
632 memcpy ((void *)lp->i596_config, init_setup, 14);
633 lp->set_conf.command = CmdConfigure;
634 i596_add_cmd(dev, (void *)&lp->set_conf);
635
636 memcpy ((void *)lp->eth_addr, dev->dev_addr, 6);
637 lp->set_add.command = CmdIASetup;
638 i596_add_cmd(dev, (struct i596_cmd *)&lp->set_add);
639
640 lp->tdr.command = CmdTDR;
641 i596_add_cmd(dev, (struct i596_cmd *)&lp->tdr);
642
643 if (lp->scb.command && i596_timeout(dev, "i82596 init", 200))
644 return 1;
645
646 lp->scb.command = RX_START;
647 CA();
648
649 barrier();
650
651 if (lp->scb.command && i596_timeout(dev, "Receive Unit start", 100))
652 return 1;
653
654 return 0;
655 }
656
657 /* Receive a single frame */
658 static inline int
659 i596_rx_one(struct net_device *dev, struct i596_private *lp,
660 struct i596_rfd *rfd, int *frames) {
661
662 if (rfd->stat & RFD_STAT_OK) {
663 /* a good frame */
664 int pkt_len = (rfd->count & 0x3fff);
665 struct sk_buff *skb = dev_alloc_skb(pkt_len);
666
667 (*frames)++;
668
669 if (rfd->cmd & CMD_EOL)
670 printk("Received on EOL\n");
671
672 if (skb == NULL) {
673 printk ("%s: i596_rx Memory squeeze, "
674 "dropping packet.\n", dev->name);
675 lp->stats.rx_dropped++;
676 return 1;
677 }
678
679 skb->dev = dev;
680 memcpy(skb_put(skb,pkt_len), rfd->data, pkt_len);
681
682 skb->protocol = eth_type_trans(skb,dev);
683 netif_rx(skb);
684 dev->last_rx = jiffies;
685 lp->stats.rx_packets++;
686 } else {
687 #if 0
688 printk("Frame reception error status %04x\n",
689 rfd->stat);
690 #endif
691 lp->stats.rx_errors++;
692 if (rfd->stat & RFD_COLLISION)
693 lp->stats.collisions++;
694 if (rfd->stat & RFD_SHORT_FRAME_ERR)
695 lp->stats.rx_length_errors++;
696 if (rfd->stat & RFD_DMA_ERR)
697 lp->stats.rx_over_errors++;
698 if (rfd->stat & RFD_NOBUFS_ERR)
699 lp->stats.rx_fifo_errors++;
700 if (rfd->stat & RFD_ALIGN_ERR)
701 lp->stats.rx_frame_errors++;
702 if (rfd->stat & RFD_CRC_ERR)
703 lp->stats.rx_crc_errors++;
704 if (rfd->stat & RFD_LENGTH_ERR)
705 lp->stats.rx_length_errors++;
706 }
707 rfd->stat = rfd->count = 0;
708 return 0;
709 }
710
711 static int
712 i596_rx(struct net_device *dev) {
713 struct i596_private *lp = (struct i596_private *) dev->priv;
714 struct i596_rfd *rfd;
715 int frames = 0;
716
717 while (1) {
718 rfd = pa_to_va(lp->scb.pa_rfd);
719 if (!rfd) {
720 printk(KERN_ERR "i596_rx: NULL rfd?\n");
721 return 0;
722 }
723 #if 1
724 if (rfd->stat && !(rfd->stat & (RFD_STAT_C | RFD_STAT_B)))
725 printk("SF:%p-%04x\n", rfd, rfd->stat);
726 #endif
727 if (!(rfd->stat & RFD_STAT_C))
728 break; /* next one not ready */
729 if (i596_rx_one(dev, lp, rfd, &frames))
730 break; /* out of memory */
731 rfd->cmd = CMD_EOL;
732 lp->rx_tail->cmd = 0;
733 lp->rx_tail = rfd;
734 lp->scb.pa_rfd = rfd->pa_next;
735 barrier();
736 }
737
738 return frames;
739 }
740
741 static void
742 i596_cleanup_cmd(struct net_device *dev) {
743 struct i596_private *lp;
744 struct i596_cmd *cmd;
745
746 lp = (struct i596_private *) dev->priv;
747 while (lp->cmd_head) {
748 cmd = (struct i596_cmd *)lp->cmd_head;
749
750 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
751 lp->cmd_backlog--;
752
753 switch ((cmd->command) & 0x7) {
754 case CmdTx: {
755 struct tx_cmd *tx_cmd = (struct tx_cmd *) cmd;
756 struct i596_tbd * tx_cmd_tbd;
757 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
758
759 dev_kfree_skb_any(tx_cmd_tbd->skb);
760
761 lp->stats.tx_errors++;
762 lp->stats.tx_aborted_errors++;
763
764 cmd->pa_next = I596_NULL;
765 kfree((unsigned char *)tx_cmd);
766 netif_wake_queue(dev);
767 break;
768 }
769 case CmdMulticastList: {
770 // unsigned short count = *((unsigned short *) (ptr + 1));
771
772 cmd->pa_next = I596_NULL;
773 kfree((unsigned char *)cmd);
774 break;
775 }
776 default: {
777 cmd->pa_next = I596_NULL;
778 break;
779 }
780 }
781 barrier();
782 }
783
784 if (lp->scb.command && i596_timeout(dev, "i596_cleanup_cmd", 100))
785 ;
786
787 lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
788 }
789
790 static void i596_reset(struct net_device *dev, struct i596_private *lp, int ioaddr) {
791
792 if (lp->scb.command && i596_timeout(dev, "i596_reset", 100))
793 ;
794
795 netif_stop_queue(dev);
796
797 lp->scb.command = CUC_ABORT | RX_ABORT;
798 CA();
799 barrier();
800
801 /* wait for shutdown */
802 if (lp->scb.command && i596_timeout(dev, "i596_reset(2)", 400))
803 ;
804
805 i596_cleanup_cmd(dev);
806 i596_rx(dev);
807
808 netif_start_queue(dev);
809 /*dev_kfree_skb(skb, FREE_WRITE);*/
810 init_i596(dev);
811 }
812
813 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd) {
814 struct i596_private *lp = dev->priv;
815 int ioaddr = dev->base_addr;
816 unsigned long flags;
817
818 cmd->status = 0;
819 cmd->command |= (CMD_EOL | CMD_INTR);
820 cmd->pa_next = I596_NULL;
821
822 spin_lock_irqsave(&lp->cmd_lock, flags);
823
824 if (lp->cmd_head) {
825 lp->cmd_tail->pa_next = va_to_pa(cmd);
826 } else {
827 lp->cmd_head = cmd;
828 if (lp->scb.command && i596_timeout(dev, "i596_add_cmd", 100))
829 ;
830 lp->scb.pa_cmd = va_to_pa(cmd);
831 lp->scb.command = CUC_START;
832 CA();
833 }
834 lp->cmd_tail = cmd;
835 lp->cmd_backlog++;
836
837 lp->cmd_head = pa_to_va(lp->scb.pa_cmd);
838 spin_unlock_irqrestore(&lp->cmd_lock, flags);
839
840 if (lp->cmd_backlog > 16) {
841 int tickssofar = jiffies - lp->last_cmd;
842 if (tickssofar < HZ/4)
843 return;
844
845 printk(KERN_WARNING "%s: command unit timed out, status resetting.\n", dev->name);
846 i596_reset(dev, lp, ioaddr);
847 }
848 }
849
850 static int i596_open(struct net_device *dev)
851 {
852 int i;
853
854 i = request_irq(dev->irq, &i596_interrupt, SA_SHIRQ, dev->name, dev);
855 if (i) {
856 printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
857 return i;
858 }
859
860 if ((i = init_rx_bufs(dev, RX_RING_SIZE)) < RX_RING_SIZE)
861 printk(KERN_ERR "%s: only able to allocate %d receive buffers\n", dev->name, i);
862
863 if (i < 4) {
864 free_irq(dev->irq, dev);
865 return -EAGAIN;
866 }
867 netif_start_queue(dev);
868 init_i596(dev);
869 return 0; /* Always succeed */
870 }
871
872 static int i596_start_xmit (struct sk_buff *skb, struct net_device *dev) {
873 struct i596_private *lp = dev->priv;
874 struct tx_cmd *tx_cmd;
875 short length;
876
877 length = skb->len;
878
879 if (length < ETH_ZLEN) {
880 skb = skb_padto(skb, ETH_ZLEN);
881 if (skb == NULL)
882 return 0;
883 length = ETH_ZLEN;
884 }
885
886 dev->trans_start = jiffies;
887
888 tx_cmd = (struct tx_cmd *) kmalloc ((sizeof (struct tx_cmd) + sizeof (struct i596_tbd)), GFP_ATOMIC);
889 if (tx_cmd == NULL) {
890 printk(KERN_WARNING "%s: i596_xmit Memory squeeze, dropping packet.\n", dev->name);
891 lp->stats.tx_dropped++;
892 dev_kfree_skb (skb);
893 } else {
894 struct i596_tbd *tx_cmd_tbd;
895 tx_cmd_tbd = (struct i596_tbd *) (tx_cmd + 1);
896 tx_cmd->pa_tbd = va_to_pa (tx_cmd_tbd);
897 tx_cmd_tbd->pa_next = I596_NULL;
898
899 tx_cmd->cmd.command = (CMD_FLEX | CmdTx);
900
901 tx_cmd->pad = 0;
902 tx_cmd->size = 0;
903 tx_cmd_tbd->pad = 0;
904 tx_cmd_tbd->size = (EOF | length);
905
906 tx_cmd_tbd->pa_data = va_to_pa (skb->data);
907 tx_cmd_tbd->skb = skb;
908
909 if (i596_debug & LOG_SRCDST)
910 print_eth (skb->data);
911
912 i596_add_cmd (dev, (struct i596_cmd *) tx_cmd);
913
914 lp->stats.tx_packets++;
915 }
916
917 return 0;
918 }
919
920 static void
921 i596_tx_timeout (struct net_device *dev) {
922 struct i596_private *lp = dev->priv;
923 int ioaddr = dev->base_addr;
924
925 /* Transmitter timeout, serious problems. */
926 printk(KERN_WARNING "%s: transmit timed out, status resetting.\n", dev->name);
927 lp->stats.tx_errors++;
928
929 /* Try to restart the adaptor */
930 if (lp->last_restart == lp->stats.tx_packets) {
931 printk ("Resetting board.\n");
932
933 /* Shutdown and restart */
934 i596_reset (dev, lp, ioaddr);
935 } else {
936 /* Issue a channel attention signal */
937 printk ("Kicking board.\n");
938 lp->scb.command = (CUC_START | RX_START);
939 CA();
940 lp->last_restart = lp->stats.tx_packets;
941 }
942 netif_wake_queue(dev);
943 }
944
945 static void print_eth(char *add)
946 {
947 int i;
948
949 printk ("Dest ");
950 for (i = 0; i < 6; i++)
951 printk(" %2.2X", (unsigned char) add[i]);
952 printk ("\n");
953
954 printk ("Source");
955 for (i = 0; i < 6; i++)
956 printk(" %2.2X", (unsigned char) add[i+6]);
957 printk ("\n");
958
959 printk ("type %2.2X%2.2X\n",
960 (unsigned char) add[12], (unsigned char) add[13]);
961 }
962
963 int __init lp486e_probe(struct net_device *dev) {
964 struct i596_private *lp;
965 unsigned char eth_addr[6] = { 0, 0xaa, 0, 0, 0, 0 };
966 unsigned char *bios;
967 int i, j;
968 int ret = -ENOMEM;
969 static int probed;
970
971 if (probed)
972 return -ENODEV;
973 probed++;
974
975 if (!request_region(IOADDR, LP486E_TOTAL_SIZE, DRV_NAME)) {
976 printk(KERN_ERR "lp486e: IO address 0x%x in use\n", IOADDR);
977 return -EBUSY;
978 }
979
980 lp = (struct i596_private *) dev->priv;
981 spin_lock_init(&lp->cmd_lock);
982
983 /*
984 * Do we really have this thing?
985 */
986 if (i596_scp_setup(dev)) {
987 ret = -ENODEV;
988 goto err_out_kfree;
989 }
990
991 dev->base_addr = IOADDR;
992 dev->irq = IRQ;
993
994
995 /*
996 * How do we find the ethernet address? I don't know.
997 * One possibility is to look at the EISA configuration area
998 * [0xe8000-0xe9fff]. This contains the ethernet address
999 * but not at a fixed address - things depend on setup options.
1000 *
1001 * If we find no address, or the wrong address, use
1002 * ifconfig eth0 hw ether a1:a2:a3:a4:a5:a6
1003 * with the value found in the BIOS setup.
1004 */
1005 bios = bus_to_virt(0xe8000);
1006 for (j = 0; j < 0x2000; j++) {
1007 if (bios[j] == 0 && bios[j+1] == 0xaa && bios[j+2] == 0) {
1008 printk("%s: maybe address at BIOS 0x%x:",
1009 dev->name, 0xe8000+j);
1010 for (i = 0; i < 6; i++) {
1011 eth_addr[i] = bios[i+j];
1012 printk(" %2.2X", eth_addr[i]);
1013 }
1014 printk("\n");
1015 }
1016 }
1017
1018 printk("%s: lp486e 82596 at %#3lx, IRQ %d,",
1019 dev->name, dev->base_addr, dev->irq);
1020 for (i = 0; i < 6; i++)
1021 printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]);
1022 printk("\n");
1023
1024 /* The LP486E-specific entries in the device structure. */
1025 dev->open = &i596_open;
1026 dev->stop = &i596_close;
1027 dev->hard_start_xmit = &i596_start_xmit;
1028 dev->get_stats = &i596_get_stats;
1029 dev->set_multicast_list = &set_multicast_list;
1030 dev->watchdog_timeo = 5*HZ;
1031 dev->tx_timeout = i596_tx_timeout;
1032
1033 #if 0
1034 /* selftest reports 0x320925ae - don't know what that means */
1035 i596_port_do(dev, PORT_SELFTEST, "selftest");
1036 i596_port_do(dev, PORT_DUMP, "dump");
1037 #endif
1038 return 0;
1039
1040 err_out_kfree:
1041 release_region(IOADDR, LP486E_TOTAL_SIZE);
1042 return ret;
1043 }
1044
1045 static inline void
1046 i596_handle_CU_completion(struct net_device *dev,
1047 struct i596_private *lp,
1048 unsigned short status,
1049 unsigned short *ack_cmdp) {
1050 struct i596_cmd *cmd;
1051 int frames_out = 0;
1052 int commands_done = 0;
1053 int cmd_val;
1054 unsigned long flags;
1055
1056 spin_lock_irqsave(&lp->cmd_lock, flags);
1057 cmd = lp->cmd_head;
1058
1059 while (lp->cmd_head && (lp->cmd_head->status & CMD_STAT_C)) {
1060 cmd = lp->cmd_head;
1061
1062 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
1063 lp->cmd_backlog--;
1064
1065 commands_done++;
1066 cmd_val = cmd->command & 0x7;
1067 #if 0
1068 printk("finished CU %s command (%d)\n",
1069 CUcmdnames[cmd_val], cmd_val);
1070 #endif
1071 switch (cmd_val) {
1072 case CmdTx:
1073 {
1074 struct tx_cmd *tx_cmd;
1075 struct i596_tbd *tx_cmd_tbd;
1076
1077 tx_cmd = (struct tx_cmd *) cmd;
1078 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
1079
1080 frames_out++;
1081 if (cmd->status & CMD_STAT_OK) {
1082 if (i596_debug)
1083 print_eth(pa_to_va(tx_cmd_tbd->pa_data));
1084 } else {
1085 lp->stats.tx_errors++;
1086 if (i596_debug)
1087 printk("transmission failure:%04x\n",
1088 cmd->status);
1089 if (cmd->status & 0x0020)
1090 lp->stats.collisions++;
1091 if (!(cmd->status & 0x0040))
1092 lp->stats.tx_heartbeat_errors++;
1093 if (cmd->status & 0x0400)
1094 lp->stats.tx_carrier_errors++;
1095 if (cmd->status & 0x0800)
1096 lp->stats.collisions++;
1097 if (cmd->status & 0x1000)
1098 lp->stats.tx_aborted_errors++;
1099 }
1100 dev_kfree_skb_irq(tx_cmd_tbd->skb);
1101
1102 cmd->pa_next = I596_NULL;
1103 kfree((unsigned char *)tx_cmd);
1104 netif_wake_queue(dev);
1105 break;
1106 }
1107
1108 case CmdMulticastList:
1109 cmd->pa_next = I596_NULL;
1110 kfree((unsigned char *)cmd);
1111 break;
1112
1113 case CmdTDR:
1114 {
1115 unsigned long status = *((unsigned long *) (cmd + 1));
1116 if (status & 0x8000) {
1117 if (i596_debug)
1118 printk("%s: link ok.\n", dev->name);
1119 } else {
1120 if (status & 0x4000)
1121 printk("%s: Transceiver problem.\n",
1122 dev->name);
1123 if (status & 0x2000)
1124 printk("%s: Termination problem.\n",
1125 dev->name);
1126 if (status & 0x1000)
1127 printk("%s: Short circuit.\n",
1128 dev->name);
1129 printk("%s: Time %ld.\n",
1130 dev->name, status & 0x07ff);
1131 }
1132 }
1133 default:
1134 cmd->pa_next = I596_NULL;
1135 lp->last_cmd = jiffies;
1136
1137 }
1138 barrier();
1139 }
1140
1141 cmd = lp->cmd_head;
1142 while (cmd && (cmd != lp->cmd_tail)) {
1143 cmd->command &= 0x1fff;
1144 cmd = pa_to_va(cmd->pa_next);
1145 barrier();
1146 }
1147
1148 if (lp->cmd_head)
1149 *ack_cmdp |= CUC_START;
1150 lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
1151 spin_unlock_irqrestore(&lp->cmd_lock, flags);
1152 }
1153
1154 static irqreturn_t
1155 i596_interrupt (int irq, void *dev_instance, struct pt_regs *regs) {
1156 struct net_device *dev = (struct net_device *) dev_instance;
1157 struct i596_private *lp;
1158 unsigned short status, ack_cmd = 0;
1159 int frames_in = 0;
1160
1161 lp = (struct i596_private *) dev->priv;
1162
1163 /*
1164 * The 82596 examines the command, performs the required action,
1165 * and then clears the SCB command word.
1166 */
1167 if (lp->scb.command && i596_timeout(dev, "interrupt", 40))
1168 ;
1169
1170 /*
1171 * The status word indicates the status of the 82596.
1172 * It is modified only by the 82596.
1173 *
1174 * [So, we must not clear it. I find often status 0xffff,
1175 * which is not one of the values allowed by the docs.]
1176 */
1177 status = lp->scb.status;
1178 #if 0
1179 if (i596_debug) {
1180 printk("%s: i596 interrupt, ", dev->name);
1181 i596_out_status(status);
1182 }
1183 #endif
1184 /* Impossible, but it happens - perhaps when we get
1185 a receive interrupt but scb.pa_rfd is I596_NULL. */
1186 if (status == 0xffff) {
1187 printk("%s: i596_interrupt: got status 0xffff\n", dev->name);
1188 goto out;
1189 }
1190
1191 ack_cmd = (status & STAT_ACK);
1192
1193 if (status & (STAT_CX | STAT_CNA))
1194 i596_handle_CU_completion(dev, lp, status, &ack_cmd);
1195
1196 if (status & (STAT_FR | STAT_RNR)) {
1197 /* Restart the receive unit when it got inactive somehow */
1198 if ((status & STAT_RNR) && netif_running(dev))
1199 ack_cmd |= RX_START;
1200
1201 if (status & STAT_FR) {
1202 frames_in = i596_rx(dev);
1203 if (!frames_in)
1204 printk("receive frame reported, but no frames\n");
1205 }
1206 }
1207
1208 /* acknowledge the interrupt */
1209 /*
1210 if ((lp->scb.pa_cmd != I596_NULL) && netif_running(dev))
1211 ack_cmd |= CUC_START;
1212 */
1213
1214 if (lp->scb.command && i596_timeout(dev, "i596 interrupt", 100))
1215 ;
1216
1217 lp->scb.command = ack_cmd;
1218
1219 CLEAR_INT();
1220 CA();
1221
1222 out:
1223 return IRQ_HANDLED;
1224 }
1225
1226 static int i596_close(struct net_device *dev) {
1227 struct i596_private *lp = dev->priv;
1228
1229 netif_stop_queue(dev);
1230
1231 if (i596_debug)
1232 printk("%s: Shutting down ethercard, status was %4.4x.\n",
1233 dev->name, lp->scb.status);
1234
1235 lp->scb.command = (CUC_ABORT | RX_ABORT);
1236 CA();
1237
1238 i596_cleanup_cmd(dev);
1239
1240 if (lp->scb.command && i596_timeout(dev, "i596_close", 200))
1241 ;
1242
1243 free_irq(dev->irq, dev);
1244 remove_rx_bufs(dev);
1245
1246 return 0;
1247 }
1248
1249 static struct net_device_stats * i596_get_stats(struct net_device *dev) {
1250 struct i596_private *lp = dev->priv;
1251
1252 return &lp->stats;
1253 }
1254
1255 /*
1256 * Set or clear the multicast filter for this adaptor.
1257 */
1258
1259 static void set_multicast_list(struct net_device *dev) {
1260 struct i596_private *lp = dev->priv;
1261 struct i596_cmd *cmd;
1262
1263 if (i596_debug > 1)
1264 printk ("%s: set multicast list %d\n",
1265 dev->name, dev->mc_count);
1266
1267 if (dev->mc_count > 0) {
1268 struct dev_mc_list *dmi;
1269 char *cp;
1270 cmd = (struct i596_cmd *)kmalloc(sizeof(struct i596_cmd)+2+dev->mc_count*6, GFP_ATOMIC);
1271 if (cmd == NULL) {
1272 printk (KERN_ERR "%s: set_multicast Memory squeeze.\n", dev->name);
1273 return;
1274 }
1275 cmd->command = CmdMulticastList;
1276 *((unsigned short *) (cmd + 1)) = dev->mc_count * 6;
1277 cp = ((char *)(cmd + 1))+2;
1278 for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) {
1279 memcpy(cp, dmi,6);
1280 cp += 6;
1281 }
1282 if (i596_debug & LOG_SRCDST)
1283 print_eth (((char *)(cmd + 1)) + 2);
1284 i596_add_cmd(dev, cmd);
1285 } else {
1286 if (lp->set_conf.pa_next != I596_NULL) {
1287 return;
1288 }
1289 if (dev->mc_count == 0 && !(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1290 if (dev->flags & IFF_ALLMULTI)
1291 dev->flags |= IFF_PROMISC;
1292 lp->i596_config[8] &= ~0x01;
1293 } else {
1294 lp->i596_config[8] |= 0x01;
1295 }
1296
1297 i596_add_cmd(dev, (struct i596_cmd *) &lp->set_conf);
1298 }
1299 }
1300
1301 MODULE_AUTHOR("Ard van Breemen <ard@cstmel.nl.eu.org>");
1302 MODULE_DESCRIPTION("Intel Panther onboard i82596 driver");
1303 MODULE_LICENSE("GPL");
1304
1305 MODULE_PARM(debug, "i");
1306 //MODULE_PARM(max_interrupt_work, "i");
1307 //MODULE_PARM(reverse_probe, "i");
1308 //MODULE_PARM(rx_copybreak, "i");
1309 MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
1310 MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
1311
1312 static struct net_device *dev_lp486e;
1313 static int full_duplex;
1314 static int options;
1315 static int io = IOADDR;
1316 static int irq = IRQ;
1317
1318 static int __init lp486e_init_module(void) {
1319 int err;
1320 struct net_device *dev = alloc_etherdev(sizeof(struct i596_private));
1321 if (!dev)
1322 return -ENOMEM;
1323
1324 dev->irq = irq;
1325 dev->base_addr = io;
1326 err = lp486e_probe(dev);
1327 if (err) {
1328 free_netdev(dev);
1329 return err;
1330 }
1331 err = register_netdev(dev);
1332 if (err) {
1333 release_region(dev->base_addr, LP486E_TOTAL_SIZE);
1334 free_netdev(dev);
1335 return err;
1336 }
1337 dev_lp486e = dev;
1338 full_duplex = 0;
1339 options = 0;
1340 return 0;
1341 }
1342
1343 static void __exit lp486e_cleanup_module(void) {
1344 unregister_netdev(dev_lp486e);
1345 release_region(dev_lp486e->base_addr, LP486E_TOTAL_SIZE);
1346 free_netdev(dev_lp486e);
1347 }
1348
1349 module_init(lp486e_init_module);
1350 module_exit(lp486e_cleanup_module);
MOXA 2.6.9 from sdlinux-moxaart.tgz