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