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