drivers/net/: all drivers/net/ cleanup with ARRAY_SIZE
[linux-2.6.git] / 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 #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         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);
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_SKBSIZE);
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_SKBSIZE;
453                         } else {
454                                 rbd->size = (RX_SKBSIZE | 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 #if 0
519 /* selftest or dump */
520 static void
521 i596_port_do(struct net_device *dev, int portcmd, char *cmdname) {
522         struct i596_private *lp = dev->priv;
523         u16 *outp;
524         int i, m;
525
526         memset((void *)&(lp->dump), 0, sizeof(struct i596_dump));
527         outp = &(lp->dump.dump[0]);
528
529         PORT(va_to_pa(outp), portcmd);
530         mdelay(30);             /* random, unmotivated */
531
532         printk("lp486e i82596 %s result:\n", cmdname);
533         for (m = ARRAY_SIZE(lp->dump.dump); m && lp->dump.dump[m-1] == 0; m--)
534                 ;
535         for (i = 0; i < m; i++) {
536                 printk(" %04x", lp->dump.dump[i]);
537                 if (i%8 == 7)
538                         printk("\n");
539         }
540         printk("\n");
541 }
542 #endif
543
544 static int
545 i596_scp_setup(struct net_device *dev) {
546         struct i596_private *lp = dev->priv;
547         int boguscnt;
548
549         /* Setup SCP, ISCP, SCB */
550         /*
551          * sysbus bits:
552          *  only a single byte is significant - here 0x44
553          *  0x80: big endian mode (details depend on stepping)
554          *  0x40: 1
555          *  0x20: interrupt pin is active low
556          *  0x10: lock function disabled
557          *  0x08: external triggering of bus throttle timers
558          *  0x06: 00: 82586 compat mode, 01: segmented mode, 10: linear mode
559          *  0x01: unused
560          */
561         lp->scp.sysbus = 0x00440000;            /* linear mode */
562         lp->scp.pad = 0;                        /* must be zero */
563         lp->scp.pa_iscp = va_to_pa(&(lp->iscp));
564
565         /*
566          * The CPU sets the ISCP to 1 before it gives the first CA()
567          */
568         lp->iscp.busy = 0x0001;
569         lp->iscp.pa_scb = va_to_pa(&(lp->scb));
570
571         lp->scb.command = 0;
572         lp->scb.status = 0;
573         lp->scb.pa_cmd = I596_NULL;
574         /* lp->scb.pa_rfd has been initialised already */
575
576         lp->last_cmd = jiffies;
577         lp->cmd_backlog = 0;
578         lp->cmd_head = NULL;
579
580         /*
581          * Reset the 82596.
582          * We need to wait 10 systemclock cycles, and
583          * 5 serial clock cycles.
584          */
585         PORT(0, PORT_RESET);    /* address part ignored */
586         udelay(100);
587
588         /*
589          * Before the CA signal is asserted, the default SCP address
590          * (0x00fffff4) can be changed to a 16-byte aligned value
591          */
592         PORT(va_to_pa(&lp->scp), PORT_ALTSCP);  /* change the scp address */
593
594         /*
595          * The initialization procedure begins when a
596          * Channel Attention signal is asserted after a reset.
597          */
598
599         CA();
600
601         /*
602          * The ISCP busy is cleared by the 82596 after the SCB address is read.
603          */
604         boguscnt = 100;
605         while (lp->iscp.busy) {
606                 if (--boguscnt == 0) {
607                         /* No i82596 present? */
608                         printk("%s: i82596 initialization timed out\n",
609                                dev->name);
610                         return 1;
611                 }
612                 udelay(5);
613                 barrier();
614         }
615         /* I find here boguscnt==100, so no delay was required. */
616
617         return 0;
618 }
619
620 static int
621 init_i596(struct net_device *dev) {
622         struct i596_private *lp;
623
624         if (i596_scp_setup(dev))
625                 return 1;
626
627         lp = (struct i596_private *) dev->priv;
628         lp->scb.command = 0;
629
630         memcpy ((void *)lp->i596_config, init_setup, 14);
631         lp->set_conf.command = CmdConfigure;
632         i596_add_cmd(dev, (void *)&lp->set_conf);
633
634         memcpy ((void *)lp->eth_addr, dev->dev_addr, 6);
635         lp->set_add.command = CmdIASetup;
636         i596_add_cmd(dev, (struct i596_cmd *)&lp->set_add);
637
638         lp->tdr.command = CmdTDR;
639         i596_add_cmd(dev, (struct i596_cmd *)&lp->tdr);
640
641         if (lp->scb.command && i596_timeout(dev, "i82596 init", 200))
642                 return 1;
643
644         lp->scb.command = RX_START;
645         CA();
646
647         barrier();
648
649         if (lp->scb.command && i596_timeout(dev, "Receive Unit start", 100))
650                 return 1;
651
652         return 0;
653 }
654
655 /* Receive a single frame */
656 static inline int
657 i596_rx_one(struct net_device *dev, struct i596_private *lp,
658             struct i596_rfd *rfd, int *frames) {
659
660         if (rfd->stat & RFD_STAT_OK) {
661                 /* a good frame */
662                 int pkt_len = (rfd->count & 0x3fff);
663                 struct sk_buff *skb = dev_alloc_skb(pkt_len);
664
665                 (*frames)++;
666
667                 if (rfd->cmd & CMD_EOL)
668                         printk("Received on EOL\n");
669
670                 if (skb == NULL) {
671                         printk ("%s: i596_rx Memory squeeze, "
672                                 "dropping packet.\n", dev->name);
673                         lp->stats.rx_dropped++;
674                         return 1;
675                 }
676
677                 memcpy(skb_put(skb,pkt_len), rfd->data, pkt_len);
678
679                 skb->protocol = eth_type_trans(skb,dev);
680                 netif_rx(skb);
681                 dev->last_rx = jiffies;
682                 lp->stats.rx_packets++;
683         } else {
684 #if 0
685                 printk("Frame reception error status %04x\n",
686                        rfd->stat);
687 #endif
688                 lp->stats.rx_errors++;
689                 if (rfd->stat & RFD_COLLISION)
690                         lp->stats.collisions++;
691                 if (rfd->stat & RFD_SHORT_FRAME_ERR)
692                         lp->stats.rx_length_errors++;
693                 if (rfd->stat & RFD_DMA_ERR)
694                         lp->stats.rx_over_errors++;
695                 if (rfd->stat & RFD_NOBUFS_ERR)
696                         lp->stats.rx_fifo_errors++;
697                 if (rfd->stat & RFD_ALIGN_ERR)
698                         lp->stats.rx_frame_errors++;
699                 if (rfd->stat & RFD_CRC_ERR)
700                         lp->stats.rx_crc_errors++;
701                 if (rfd->stat & RFD_LENGTH_ERR)
702                         lp->stats.rx_length_errors++;
703         }
704         rfd->stat = rfd->count = 0;
705         return 0;
706 }
707
708 static int
709 i596_rx(struct net_device *dev) {
710         struct i596_private *lp = (struct i596_private *) dev->priv;
711         struct i596_rfd *rfd;
712         int frames = 0;
713
714         while (1) {
715                 rfd = pa_to_va(lp->scb.pa_rfd);
716                 if (!rfd) {
717                         printk(KERN_ERR "i596_rx: NULL rfd?\n");
718                         return 0;
719                 }
720 #if 1
721                 if (rfd->stat && !(rfd->stat & (RFD_STAT_C | RFD_STAT_B)))
722                         printk("SF:%p-%04x\n", rfd, rfd->stat);
723 #endif
724                 if (!(rfd->stat & RFD_STAT_C))
725                         break;          /* next one not ready */
726                 if (i596_rx_one(dev, lp, rfd, &frames))
727                         break;          /* out of memory */
728                 rfd->cmd = CMD_EOL;
729                 lp->rx_tail->cmd = 0;
730                 lp->rx_tail = rfd;
731                 lp->scb.pa_rfd = rfd->pa_next;
732                 barrier();
733         }
734
735         return frames;
736 }
737
738 static void
739 i596_cleanup_cmd(struct net_device *dev) {
740         struct i596_private *lp;
741         struct i596_cmd *cmd;
742
743         lp = (struct i596_private *) dev->priv;
744         while (lp->cmd_head) {
745                 cmd = (struct i596_cmd *)lp->cmd_head;
746
747                 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
748                 lp->cmd_backlog--;
749
750                 switch ((cmd->command) & 0x7) {
751                         case CmdTx: {
752                                 struct tx_cmd *tx_cmd = (struct tx_cmd *) cmd;
753                                 struct i596_tbd * tx_cmd_tbd;
754                                 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
755
756                                 dev_kfree_skb_any(tx_cmd_tbd->skb);
757
758                                 lp->stats.tx_errors++;
759                                 lp->stats.tx_aborted_errors++;
760
761                                 cmd->pa_next = I596_NULL;
762                                 kfree((unsigned char *)tx_cmd);
763                                 netif_wake_queue(dev);
764                                 break;
765                         }
766                         case CmdMulticastList: {
767                                 // unsigned short count = *((unsigned short *) (ptr + 1));
768
769                                 cmd->pa_next = I596_NULL;
770                                 kfree((unsigned char *)cmd);
771                                 break;
772                         }
773                         default: {
774                                 cmd->pa_next = I596_NULL;
775                                 break;
776                         }
777                 }
778                 barrier();
779         }
780
781         if (lp->scb.command && i596_timeout(dev, "i596_cleanup_cmd", 100))
782                 ;
783
784         lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
785 }
786
787 static void i596_reset(struct net_device *dev, struct i596_private *lp, int ioaddr) {
788
789         if (lp->scb.command && i596_timeout(dev, "i596_reset", 100))
790                 ;
791
792         netif_stop_queue(dev);
793
794         lp->scb.command = CUC_ABORT | RX_ABORT;
795         CA();
796         barrier();
797
798         /* wait for shutdown */
799         if (lp->scb.command && i596_timeout(dev, "i596_reset(2)", 400))
800                 ;
801
802         i596_cleanup_cmd(dev);
803         i596_rx(dev);
804
805         netif_start_queue(dev);
806         /*dev_kfree_skb(skb, FREE_WRITE);*/
807         init_i596(dev);
808 }
809
810 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd) {
811         struct i596_private *lp = dev->priv;
812         int ioaddr = dev->base_addr;
813         unsigned long flags;
814
815         cmd->status = 0;
816         cmd->command |= (CMD_EOL | CMD_INTR);
817         cmd->pa_next = I596_NULL;
818
819         spin_lock_irqsave(&lp->cmd_lock, flags);
820
821         if (lp->cmd_head) {
822                 lp->cmd_tail->pa_next = va_to_pa(cmd);
823         } else {
824                 lp->cmd_head = cmd;
825                 if (lp->scb.command && i596_timeout(dev, "i596_add_cmd", 100))
826                         ;
827                 lp->scb.pa_cmd = va_to_pa(cmd);
828                 lp->scb.command = CUC_START;
829                 CA();
830         }
831         lp->cmd_tail = cmd;
832         lp->cmd_backlog++;
833
834         lp->cmd_head = pa_to_va(lp->scb.pa_cmd);
835         spin_unlock_irqrestore(&lp->cmd_lock, flags);
836
837         if (lp->cmd_backlog > 16) {
838                 int tickssofar = jiffies - lp->last_cmd;
839                 if (tickssofar < HZ/4)
840                         return;
841
842                 printk(KERN_WARNING "%s: command unit timed out, status resetting.\n", dev->name);
843                 i596_reset(dev, lp, ioaddr);
844         }
845 }
846
847 static int i596_open(struct net_device *dev)
848 {
849         int i;
850
851         i = request_irq(dev->irq, &i596_interrupt, IRQF_SHARED, dev->name, dev);
852         if (i) {
853                 printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
854                 return i;
855         }
856
857         if ((i = init_rx_bufs(dev, RX_RING_SIZE)) < RX_RING_SIZE)
858                 printk(KERN_ERR "%s: only able to allocate %d receive buffers\n", dev->name, i);
859
860         if (i < 4) {
861                 free_irq(dev->irq, dev);
862                 return -EAGAIN;
863         }
864         netif_start_queue(dev);
865         init_i596(dev);
866         return 0;                       /* Always succeed */
867 }
868
869 static int i596_start_xmit (struct sk_buff *skb, struct net_device *dev) {
870         struct i596_private *lp = dev->priv;
871         struct tx_cmd *tx_cmd;
872         short length;
873
874         length = skb->len;
875
876         if (length < ETH_ZLEN) {
877                 if (skb_padto(skb, ETH_ZLEN))
878                         return 0;
879                 length = ETH_ZLEN;
880         }
881
882         dev->trans_start = jiffies;
883
884         tx_cmd = kmalloc((sizeof (struct tx_cmd) + sizeof (struct i596_tbd)), GFP_ATOMIC);
885         if (tx_cmd == NULL) {
886                 printk(KERN_WARNING "%s: i596_xmit Memory squeeze, dropping packet.\n", dev->name);
887                 lp->stats.tx_dropped++;
888                 dev_kfree_skb (skb);
889         } else {
890                 struct i596_tbd *tx_cmd_tbd;
891                 tx_cmd_tbd = (struct i596_tbd *) (tx_cmd + 1);
892                 tx_cmd->pa_tbd = va_to_pa (tx_cmd_tbd);
893                 tx_cmd_tbd->pa_next = I596_NULL;
894
895                 tx_cmd->cmd.command = (CMD_FLEX | CmdTx);
896
897                 tx_cmd->pad = 0;
898                 tx_cmd->size = 0;
899                 tx_cmd_tbd->pad = 0;
900                 tx_cmd_tbd->size = (EOF | length);
901
902                 tx_cmd_tbd->pa_data = va_to_pa (skb->data);
903                 tx_cmd_tbd->skb = skb;
904
905                 if (i596_debug & LOG_SRCDST)
906                         print_eth (skb->data);
907
908                 i596_add_cmd (dev, (struct i596_cmd *) tx_cmd);
909
910                 lp->stats.tx_packets++;
911         }
912
913         return 0;
914 }
915
916 static void
917 i596_tx_timeout (struct net_device *dev) {
918         struct i596_private *lp = dev->priv;
919         int ioaddr = dev->base_addr;
920
921         /* Transmitter timeout, serious problems. */
922         printk(KERN_WARNING "%s: transmit timed out, status resetting.\n", dev->name);
923         lp->stats.tx_errors++;
924
925         /* Try to restart the adaptor */
926         if (lp->last_restart == lp->stats.tx_packets) {
927                 printk ("Resetting board.\n");
928
929                 /* Shutdown and restart */
930                 i596_reset (dev, lp, ioaddr);
931         } else {
932                 /* Issue a channel attention signal */
933                 printk ("Kicking board.\n");
934                 lp->scb.command = (CUC_START | RX_START);
935                 CA();
936                 lp->last_restart = lp->stats.tx_packets;
937         }
938         netif_wake_queue(dev);
939 }
940
941 static void print_eth(char *add)
942 {
943         int i;
944
945         printk ("Dest  ");
946         for (i = 0; i < 6; i++)
947                 printk(" %2.2X", (unsigned char) add[i]);
948         printk ("\n");
949
950         printk ("Source");
951         for (i = 0; i < 6; i++)
952                 printk(" %2.2X", (unsigned char) add[i+6]);
953         printk ("\n");
954
955         printk ("type %2.2X%2.2X\n",
956                 (unsigned char) add[12], (unsigned char) add[13]);
957 }
958
959 static int __init lp486e_probe(struct net_device *dev) {
960         struct i596_private *lp;
961         unsigned char eth_addr[6] = { 0, 0xaa, 0, 0, 0, 0 };
962         unsigned char *bios;
963         int i, j;
964         int ret = -ENOMEM;
965         static int probed;
966
967         if (probed)
968                 return -ENODEV;
969         probed++;
970
971         if (!request_region(IOADDR, LP486E_TOTAL_SIZE, DRV_NAME)) {
972                 printk(KERN_ERR "lp486e: IO address 0x%x in use\n", IOADDR);
973                 return -EBUSY;
974         }
975
976         lp = (struct i596_private *) dev->priv;
977         spin_lock_init(&lp->cmd_lock);
978
979         /*
980          * Do we really have this thing?
981          */
982         if (i596_scp_setup(dev)) {
983                 ret = -ENODEV;
984                 goto err_out_kfree;
985         }
986
987         dev->base_addr = IOADDR;
988         dev->irq = IRQ;
989
990
991         /*
992          * How do we find the ethernet address? I don't know.
993          * One possibility is to look at the EISA configuration area
994          * [0xe8000-0xe9fff]. This contains the ethernet address
995          * but not at a fixed address - things depend on setup options.
996          *
997          * If we find no address, or the wrong address, use
998          *   ifconfig eth0 hw ether a1:a2:a3:a4:a5:a6
999          * with the value found in the BIOS setup.
1000          */
1001         bios = bus_to_virt(0xe8000);
1002         for (j = 0; j < 0x2000; j++) {
1003                 if (bios[j] == 0 && bios[j+1] == 0xaa && bios[j+2] == 0) {
1004                         printk("%s: maybe address at BIOS 0x%x:",
1005                                dev->name, 0xe8000+j);
1006                         for (i = 0; i < 6; i++) {
1007                                 eth_addr[i] = bios[i+j];
1008                                 printk(" %2.2X", eth_addr[i]);
1009                         }
1010                         printk("\n");
1011                 }
1012         }
1013
1014         printk("%s: lp486e 82596 at %#3lx, IRQ %d,",
1015                dev->name, dev->base_addr, dev->irq);
1016         for (i = 0; i < 6; i++)
1017                 printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]);
1018         printk("\n");
1019
1020         /* The LP486E-specific entries in the device structure. */
1021         dev->open = &i596_open;
1022         dev->stop = &i596_close;
1023         dev->hard_start_xmit = &i596_start_xmit;
1024         dev->get_stats = &i596_get_stats;
1025         dev->set_multicast_list = &set_multicast_list;
1026         dev->watchdog_timeo = 5*HZ;
1027         dev->tx_timeout = i596_tx_timeout;
1028
1029 #if 0
1030         /* selftest reports 0x320925ae - don't know what that means */
1031         i596_port_do(dev, PORT_SELFTEST, "selftest");
1032         i596_port_do(dev, PORT_DUMP, "dump");
1033 #endif
1034         return 0;
1035
1036 err_out_kfree:
1037         release_region(IOADDR, LP486E_TOTAL_SIZE);
1038         return ret;
1039 }
1040
1041 static inline void
1042 i596_handle_CU_completion(struct net_device *dev,
1043                           struct i596_private *lp,
1044                           unsigned short status,
1045                           unsigned short *ack_cmdp) {
1046         struct i596_cmd *cmd;
1047         int frames_out = 0;
1048         int commands_done = 0;
1049         int cmd_val;
1050         unsigned long flags;
1051
1052         spin_lock_irqsave(&lp->cmd_lock, flags);
1053         cmd = lp->cmd_head;
1054
1055         while (lp->cmd_head && (lp->cmd_head->status & CMD_STAT_C)) {
1056                 cmd = lp->cmd_head;
1057
1058                 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
1059                 lp->cmd_backlog--;
1060
1061                 commands_done++;
1062                 cmd_val = cmd->command & 0x7;
1063 #if 0
1064                 printk("finished CU %s command (%d)\n",
1065                        CUcmdnames[cmd_val], cmd_val);
1066 #endif
1067                 switch (cmd_val) {
1068                 case CmdTx:
1069                 {
1070                         struct tx_cmd *tx_cmd;
1071                         struct i596_tbd *tx_cmd_tbd;
1072
1073                         tx_cmd = (struct tx_cmd *) cmd;
1074                         tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
1075
1076                         frames_out++;
1077                         if (cmd->status & CMD_STAT_OK) {
1078                                 if (i596_debug)
1079                                         print_eth(pa_to_va(tx_cmd_tbd->pa_data));
1080                         } else {
1081                                 lp->stats.tx_errors++;
1082                                 if (i596_debug)
1083                                         printk("transmission failure:%04x\n",
1084                                                cmd->status);
1085                                 if (cmd->status & 0x0020)
1086                                         lp->stats.collisions++;
1087                                 if (!(cmd->status & 0x0040))
1088                                         lp->stats.tx_heartbeat_errors++;
1089                                 if (cmd->status & 0x0400)
1090                                         lp->stats.tx_carrier_errors++;
1091                                 if (cmd->status & 0x0800)
1092                                         lp->stats.collisions++;
1093                                 if (cmd->status & 0x1000)
1094                                         lp->stats.tx_aborted_errors++;
1095                         }
1096                         dev_kfree_skb_irq(tx_cmd_tbd->skb);
1097
1098                         cmd->pa_next = I596_NULL;
1099                         kfree((unsigned char *)tx_cmd);
1100                         netif_wake_queue(dev);
1101                         break;
1102                 }
1103
1104                 case CmdMulticastList:
1105                         cmd->pa_next = I596_NULL;
1106                         kfree((unsigned char *)cmd);
1107                         break;
1108
1109                 case CmdTDR:
1110                 {
1111                         unsigned long status = *((unsigned long *) (cmd + 1));
1112                         if (status & 0x8000) {
1113                                 if (i596_debug)
1114                                         printk("%s: link ok.\n", dev->name);
1115                         } else {
1116                                 if (status & 0x4000)
1117                                         printk("%s: Transceiver problem.\n",
1118                                                dev->name);
1119                                 if (status & 0x2000)
1120                                         printk("%s: Termination problem.\n",
1121                                                dev->name);
1122                                 if (status & 0x1000)
1123                                         printk("%s: Short circuit.\n",
1124                                                dev->name);
1125                                 printk("%s: Time %ld.\n",
1126                                        dev->name, status & 0x07ff);
1127                         }
1128                 }
1129                 default:
1130                         cmd->pa_next = I596_NULL;
1131                         lp->last_cmd = jiffies;
1132
1133                 }
1134                 barrier();
1135         }
1136
1137         cmd = lp->cmd_head;
1138         while (cmd && (cmd != lp->cmd_tail)) {
1139                 cmd->command &= 0x1fff;
1140                 cmd = pa_to_va(cmd->pa_next);
1141                 barrier();
1142         }
1143
1144         if (lp->cmd_head)
1145                 *ack_cmdp |= CUC_START;
1146         lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
1147         spin_unlock_irqrestore(&lp->cmd_lock, flags);
1148 }
1149
1150 static irqreturn_t
1151 i596_interrupt (int irq, void *dev_instance) {
1152         struct net_device *dev = (struct net_device *) dev_instance;
1153         struct i596_private *lp;
1154         unsigned short status, ack_cmd = 0;
1155         int frames_in = 0;
1156
1157         lp = (struct i596_private *) dev->priv;
1158
1159         /*
1160          * The 82596 examines the command, performs the required action,
1161          * and then clears the SCB command word.
1162          */
1163         if (lp->scb.command && i596_timeout(dev, "interrupt", 40))
1164                 ;
1165
1166         /*
1167          * The status word indicates the status of the 82596.
1168          * It is modified only by the 82596.
1169          *
1170          * [So, we must not clear it. I find often status 0xffff,
1171          *  which is not one of the values allowed by the docs.]
1172          */
1173         status = lp->scb.status;
1174 #if 0
1175         if (i596_debug) {
1176                 printk("%s: i596 interrupt, ", dev->name);
1177                 i596_out_status(status);
1178         }
1179 #endif
1180         /* Impossible, but it happens - perhaps when we get
1181            a receive interrupt but scb.pa_rfd is I596_NULL. */
1182         if (status == 0xffff) {
1183                 printk("%s: i596_interrupt: got status 0xffff\n", dev->name);
1184                 goto out;
1185         }
1186
1187         ack_cmd = (status & STAT_ACK);
1188
1189         if (status & (STAT_CX | STAT_CNA))
1190                 i596_handle_CU_completion(dev, lp, status, &ack_cmd);
1191
1192         if (status & (STAT_FR | STAT_RNR)) {
1193                 /* Restart the receive unit when it got inactive somehow */
1194                 if ((status & STAT_RNR) && netif_running(dev))
1195                         ack_cmd |= RX_START;
1196
1197                 if (status & STAT_FR) {
1198                         frames_in = i596_rx(dev);
1199                         if (!frames_in)
1200                                 printk("receive frame reported, but no frames\n");
1201                 }
1202         }
1203
1204         /* acknowledge the interrupt */
1205         /*
1206         if ((lp->scb.pa_cmd != I596_NULL) && netif_running(dev))
1207                 ack_cmd |= CUC_START;
1208         */
1209
1210         if (lp->scb.command && i596_timeout(dev, "i596 interrupt", 100))
1211                 ;
1212
1213         lp->scb.command = ack_cmd;
1214
1215         CLEAR_INT();
1216         CA();
1217
1218  out:
1219         return IRQ_HANDLED;
1220 }
1221
1222 static int i596_close(struct net_device *dev) {
1223         struct i596_private *lp = dev->priv;
1224
1225         netif_stop_queue(dev);
1226
1227         if (i596_debug)
1228                 printk("%s: Shutting down ethercard, status was %4.4x.\n",
1229                        dev->name, lp->scb.status);
1230
1231         lp->scb.command = (CUC_ABORT | RX_ABORT);
1232         CA();
1233
1234         i596_cleanup_cmd(dev);
1235
1236         if (lp->scb.command && i596_timeout(dev, "i596_close", 200))
1237                 ;
1238
1239         free_irq(dev->irq, dev);
1240         remove_rx_bufs(dev);
1241
1242         return 0;
1243 }
1244
1245 static struct net_device_stats * i596_get_stats(struct net_device *dev) {
1246         struct i596_private *lp = dev->priv;
1247
1248         return &lp->stats;
1249 }
1250
1251 /*
1252 *       Set or clear the multicast filter for this adaptor.
1253 */
1254
1255 static void set_multicast_list(struct net_device *dev) {
1256         struct i596_private *lp = dev->priv;
1257         struct i596_cmd *cmd;
1258
1259         if (i596_debug > 1)
1260                 printk ("%s: set multicast list %d\n",
1261                         dev->name, dev->mc_count);
1262
1263         if (dev->mc_count > 0) {
1264                 struct dev_mc_list *dmi;
1265                 char *cp;
1266                 cmd = kmalloc(sizeof(struct i596_cmd)+2+dev->mc_count*6, GFP_ATOMIC);
1267                 if (cmd == NULL) {
1268                         printk (KERN_ERR "%s: set_multicast Memory squeeze.\n", dev->name);
1269                         return;
1270                 }
1271                 cmd->command = CmdMulticastList;
1272                 *((unsigned short *) (cmd + 1)) = dev->mc_count * 6;
1273                 cp = ((char *)(cmd + 1))+2;
1274                 for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) {
1275                         memcpy(cp, dmi,6);
1276                         cp += 6;
1277                 }
1278                 if (i596_debug & LOG_SRCDST)
1279                         print_eth (((char *)(cmd + 1)) + 2);
1280                 i596_add_cmd(dev, cmd);
1281         } else {
1282                 if (lp->set_conf.pa_next != I596_NULL) {
1283                         return;
1284                 }
1285                 if (dev->mc_count == 0 && !(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1286                         if (dev->flags & IFF_ALLMULTI)
1287                                 dev->flags |= IFF_PROMISC;
1288                         lp->i596_config[8] &= ~0x01;
1289                 } else {
1290                         lp->i596_config[8] |= 0x01;
1291                 }
1292
1293                 i596_add_cmd(dev, (struct i596_cmd *) &lp->set_conf);
1294         }
1295 }
1296
1297 MODULE_AUTHOR("Ard van Breemen <ard@cstmel.nl.eu.org>");
1298 MODULE_DESCRIPTION("Intel Panther onboard i82596 driver");
1299 MODULE_LICENSE("GPL");
1300
1301 static struct net_device *dev_lp486e;
1302 static int full_duplex;
1303 static int options;
1304 static int io = IOADDR;
1305 static int irq = IRQ;
1306
1307 module_param(debug, int, 0);
1308 //module_param(max_interrupt_work, int, 0);
1309 //module_param(reverse_probe, int, 0);
1310 //module_param(rx_copybreak, int, 0);
1311 module_param(options, int, 0);
1312 module_param(full_duplex, int, 0);
1313
1314 static int __init lp486e_init_module(void) {
1315         int err;
1316         struct net_device *dev = alloc_etherdev(sizeof(struct i596_private));
1317         if (!dev)
1318                 return -ENOMEM;
1319
1320         dev->irq = irq;
1321         dev->base_addr = io;
1322         err = lp486e_probe(dev);
1323         if (err) {
1324                 free_netdev(dev);
1325                 return err;
1326         }
1327         err = register_netdev(dev);
1328         if (err) {
1329                 release_region(dev->base_addr, LP486E_TOTAL_SIZE);
1330                 free_netdev(dev);
1331                 return err;
1332         }
1333         dev_lp486e = dev;
1334         full_duplex = 0;
1335         options = 0;
1336         return 0;
1337 }
1338
1339 static void __exit lp486e_cleanup_module(void) {
1340         unregister_netdev(dev_lp486e);
1341         release_region(dev_lp486e->base_addr, LP486E_TOTAL_SIZE);
1342         free_netdev(dev_lp486e);
1343 }
1344
1345 module_init(lp486e_init_module);
1346 module_exit(lp486e_cleanup_module);