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