?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: thinkpad-acpi: bump up version to 0.16
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / lp486e.c
blob5fc18da1873dcb279edfc8e27d2358cce87be44d
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 memcpy(skb_put(skb,pkt_len), rfd->data, pkt_len);
680
681 skb->protocol = eth_type_trans(skb,dev);
682 netif_rx(skb);
683 dev->last_rx = jiffies;
684 lp->stats.rx_packets++;
685 } else {
686 #if 0
687 printk("Frame reception error status %04x\n",
688 rfd->stat);
689 #endif
690 lp->stats.rx_errors++;
691 if (rfd->stat & RFD_COLLISION)
692 lp->stats.collisions++;
693 if (rfd->stat & RFD_SHORT_FRAME_ERR)
694 lp->stats.rx_length_errors++;
695 if (rfd->stat & RFD_DMA_ERR)
696 lp->stats.rx_over_errors++;
697 if (rfd->stat & RFD_NOBUFS_ERR)
698 lp->stats.rx_fifo_errors++;
699 if (rfd->stat & RFD_ALIGN_ERR)
700 lp->stats.rx_frame_errors++;
701 if (rfd->stat & RFD_CRC_ERR)
702 lp->stats.rx_crc_errors++;
703 if (rfd->stat & RFD_LENGTH_ERR)
704 lp->stats.rx_length_errors++;
705 }
706 rfd->stat = rfd->count = 0;
707 return 0;
708 }
709
710 static int
711 i596_rx(struct net_device *dev) {
712 struct i596_private *lp = (struct i596_private *) dev->priv;
713 struct i596_rfd *rfd;
714 int frames = 0;
715
716 while (1) {
717 rfd = pa_to_va(lp->scb.pa_rfd);
718 if (!rfd) {
719 printk(KERN_ERR "i596_rx: NULL rfd?\n");
720 return 0;
721 }
722 #if 1
723 if (rfd->stat && !(rfd->stat & (RFD_STAT_C | RFD_STAT_B)))
724 printk("SF:%p-%04x\n", rfd, rfd->stat);
725 #endif
726 if (!(rfd->stat & RFD_STAT_C))
727 break; /* next one not ready */
728 if (i596_rx_one(dev, lp, rfd, &frames))
729 break; /* out of memory */
730 rfd->cmd = CMD_EOL;
731 lp->rx_tail->cmd = 0;
732 lp->rx_tail = rfd;
733 lp->scb.pa_rfd = rfd->pa_next;
734 barrier();
735 }
736
737 return frames;
738 }
739
740 static void
741 i596_cleanup_cmd(struct net_device *dev) {
742 struct i596_private *lp;
743 struct i596_cmd *cmd;
744
745 lp = (struct i596_private *) dev->priv;
746 while (lp->cmd_head) {
747 cmd = (struct i596_cmd *)lp->cmd_head;
748
749 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
750 lp->cmd_backlog--;
751
752 switch ((cmd->command) & 0x7) {
753 case CmdTx: {
754 struct tx_cmd *tx_cmd = (struct tx_cmd *) cmd;
755 struct i596_tbd * tx_cmd_tbd;
756 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
757
758 dev_kfree_skb_any(tx_cmd_tbd->skb);
759
760 lp->stats.tx_errors++;
761 lp->stats.tx_aborted_errors++;
762
763 cmd->pa_next = I596_NULL;
764 kfree((unsigned char *)tx_cmd);
765 netif_wake_queue(dev);
766 break;
767 }
768 case CmdMulticastList: {
769 // unsigned short count = *((unsigned short *) (ptr + 1));
770
771 cmd->pa_next = I596_NULL;
772 kfree((unsigned char *)cmd);
773 break;
774 }
775 default: {
776 cmd->pa_next = I596_NULL;
777 break;
778 }
779 }
780 barrier();
781 }
782
783 if (lp->scb.command && i596_timeout(dev, "i596_cleanup_cmd", 100))
784 ;
785
786 lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
787 }
788
789 static void i596_reset(struct net_device *dev, struct i596_private *lp, int ioaddr) {
790
791 if (lp->scb.command && i596_timeout(dev, "i596_reset", 100))
792 ;
793
794 netif_stop_queue(dev);
795
796 lp->scb.command = CUC_ABORT | RX_ABORT;
797 CA();
798 barrier();
799
800 /* wait for shutdown */
801 if (lp->scb.command && i596_timeout(dev, "i596_reset(2)", 400))
802 ;
803
804 i596_cleanup_cmd(dev);
805 i596_rx(dev);
806
807 netif_start_queue(dev);
808 /*dev_kfree_skb(skb, FREE_WRITE);*/
809 init_i596(dev);
810 }
811
812 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd) {
813 struct i596_private *lp = dev->priv;
814 int ioaddr = dev->base_addr;
815 unsigned long flags;
816
817 cmd->status = 0;
818 cmd->command |= (CMD_EOL | CMD_INTR);
819 cmd->pa_next = I596_NULL;
820
821 spin_lock_irqsave(&lp->cmd_lock, flags);
822
823 if (lp->cmd_head) {
824 lp->cmd_tail->pa_next = va_to_pa(cmd);
825 } else {
826 lp->cmd_head = cmd;
827 if (lp->scb.command && i596_timeout(dev, "i596_add_cmd", 100))
828 ;
829 lp->scb.pa_cmd = va_to_pa(cmd);
830 lp->scb.command = CUC_START;
831 CA();
832 }
833 lp->cmd_tail = cmd;
834 lp->cmd_backlog++;
835
836 lp->cmd_head = pa_to_va(lp->scb.pa_cmd);
837 spin_unlock_irqrestore(&lp->cmd_lock, flags);
838
839 if (lp->cmd_backlog > 16) {
840 int tickssofar = jiffies - lp->last_cmd;
841 if (tickssofar < HZ/4)
842 return;
843
844 printk(KERN_WARNING "%s: command unit timed out, status resetting.\n", dev->name);
845 i596_reset(dev, lp, ioaddr);
846 }
847 }
848
849 static int i596_open(struct net_device *dev)
850 {
851 int i;
852
853 i = request_irq(dev->irq, &i596_interrupt, IRQF_SHARED, dev->name, dev);
854 if (i) {
855 printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
856 return i;
857 }
858
859 if ((i = init_rx_bufs(dev, RX_RING_SIZE)) < RX_RING_SIZE)
860 printk(KERN_ERR "%s: only able to allocate %d receive buffers\n", dev->name, i);
861
862 if (i < 4) {
863 free_irq(dev->irq, dev);
864 return -EAGAIN;
865 }
866 netif_start_queue(dev);
867 init_i596(dev);
868 return 0; /* Always succeed */
869 }
870
871 static int i596_start_xmit (struct sk_buff *skb, struct net_device *dev) {
872 struct i596_private *lp = dev->priv;
873 struct tx_cmd *tx_cmd;
874 short length;
875
876 length = skb->len;
877
878 if (length < ETH_ZLEN) {
879 if (skb_padto(skb, ETH_ZLEN))
880 return 0;
881 length = ETH_ZLEN;
882 }
883
884 dev->trans_start = jiffies;
885
886 tx_cmd = kmalloc((sizeof (struct tx_cmd) + sizeof (struct i596_tbd)), GFP_ATOMIC);
887 if (tx_cmd == NULL) {
888 printk(KERN_WARNING "%s: i596_xmit Memory squeeze, dropping packet.\n", dev->name);
889 lp->stats.tx_dropped++;
890 dev_kfree_skb (skb);
891 } else {
892 struct i596_tbd *tx_cmd_tbd;
893 tx_cmd_tbd = (struct i596_tbd *) (tx_cmd + 1);
894 tx_cmd->pa_tbd = va_to_pa (tx_cmd_tbd);
895 tx_cmd_tbd->pa_next = I596_NULL;
896
897 tx_cmd->cmd.command = (CMD_FLEX | CmdTx);
898
899 tx_cmd->pad = 0;
900 tx_cmd->size = 0;
901 tx_cmd_tbd->pad = 0;
902 tx_cmd_tbd->size = (EOF | length);
903
904 tx_cmd_tbd->pa_data = va_to_pa (skb->data);
905 tx_cmd_tbd->skb = skb;
906
907 if (i596_debug & LOG_SRCDST)
908 print_eth (skb->data);
909
910 i596_add_cmd (dev, (struct i596_cmd *) tx_cmd);
911
912 lp->stats.tx_packets++;
913 }
914
915 return 0;
916 }
917
918 static void
919 i596_tx_timeout (struct net_device *dev) {
920 struct i596_private *lp = dev->priv;
921 int ioaddr = dev->base_addr;
922
923 /* Transmitter timeout, serious problems. */
924 printk(KERN_WARNING "%s: transmit timed out, status resetting.\n", dev->name);
925 lp->stats.tx_errors++;
926
927 /* Try to restart the adaptor */
928 if (lp->last_restart == lp->stats.tx_packets) {
929 printk ("Resetting board.\n");
930
931 /* Shutdown and restart */
932 i596_reset (dev, lp, ioaddr);
933 } else {
934 /* Issue a channel attention signal */
935 printk ("Kicking board.\n");
936 lp->scb.command = (CUC_START | RX_START);
937 CA();
938 lp->last_restart = lp->stats.tx_packets;
939 }
940 netif_wake_queue(dev);
941 }
942
943 static void print_eth(char *add)
944 {
945 int i;
946
947 printk ("Dest ");
948 for (i = 0; i < 6; i++)
949 printk(" %2.2X", (unsigned char) add[i]);
950 printk ("\n");
951
952 printk ("Source");
953 for (i = 0; i < 6; i++)
954 printk(" %2.2X", (unsigned char) add[i+6]);
955 printk ("\n");
956
957 printk ("type %2.2X%2.2X\n",
958 (unsigned char) add[12], (unsigned char) add[13]);
959 }
960
961 static int __init lp486e_probe(struct net_device *dev) {
962 struct i596_private *lp;
963 unsigned char eth_addr[6] = { 0, 0xaa, 0, 0, 0, 0 };
964 unsigned char *bios;
965 int i, j;
966 int ret = -ENOMEM;
967 static int probed;
968
969 if (probed)
970 return -ENODEV;
971 probed++;
972
973 if (!request_region(IOADDR, LP486E_TOTAL_SIZE, DRV_NAME)) {
974 printk(KERN_ERR "lp486e: IO address 0x%x in use\n", IOADDR);
975 return -EBUSY;
976 }
977
978 lp = (struct i596_private *) dev->priv;
979 spin_lock_init(&lp->cmd_lock);
980
981 /*
982 * Do we really have this thing?
983 */
984 if (i596_scp_setup(dev)) {
985 ret = -ENODEV;
986 goto err_out_kfree;
987 }
988
989 dev->base_addr = IOADDR;
990 dev->irq = IRQ;
991
992
993 /*
994 * How do we find the ethernet address? I don't know.
995 * One possibility is to look at the EISA configuration area
996 * [0xe8000-0xe9fff]. This contains the ethernet address
997 * but not at a fixed address - things depend on setup options.
998 *
999 * If we find no address, or the wrong address, use
1000 * ifconfig eth0 hw ether a1:a2:a3:a4:a5:a6
1001 * with the value found in the BIOS setup.
1002 */
1003 bios = bus_to_virt(0xe8000);
1004 for (j = 0; j < 0x2000; j++) {
1005 if (bios[j] == 0 && bios[j+1] == 0xaa && bios[j+2] == 0) {
1006 printk("%s: maybe address at BIOS 0x%x:",
1007 dev->name, 0xe8000+j);
1008 for (i = 0; i < 6; i++) {
1009 eth_addr[i] = bios[i+j];
1010 printk(" %2.2X", eth_addr[i]);
1011 }
1012 printk("\n");
1013 }
1014 }
1015
1016 printk("%s: lp486e 82596 at %#3lx, IRQ %d,",
1017 dev->name, dev->base_addr, dev->irq);
1018 for (i = 0; i < 6; i++)
1019 printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]);
1020 printk("\n");
1021
1022 /* The LP486E-specific entries in the device structure. */
1023 dev->open = &i596_open;
1024 dev->stop = &i596_close;
1025 dev->hard_start_xmit = &i596_start_xmit;
1026 dev->get_stats = &i596_get_stats;
1027 dev->set_multicast_list = &set_multicast_list;
1028 dev->watchdog_timeo = 5*HZ;
1029 dev->tx_timeout = i596_tx_timeout;
1030
1031 #if 0
1032 /* selftest reports 0x320925ae - don't know what that means */
1033 i596_port_do(dev, PORT_SELFTEST, "selftest");
1034 i596_port_do(dev, PORT_DUMP, "dump");
1035 #endif
1036 return 0;
1037
1038 err_out_kfree:
1039 release_region(IOADDR, LP486E_TOTAL_SIZE);
1040 return ret;
1041 }
1042
1043 static inline void
1044 i596_handle_CU_completion(struct net_device *dev,
1045 struct i596_private *lp,
1046 unsigned short status,
1047 unsigned short *ack_cmdp) {
1048 struct i596_cmd *cmd;
1049 int frames_out = 0;
1050 int commands_done = 0;
1051 int cmd_val;
1052 unsigned long flags;
1053
1054 spin_lock_irqsave(&lp->cmd_lock, flags);
1055 cmd = lp->cmd_head;
1056
1057 while (lp->cmd_head && (lp->cmd_head->status & CMD_STAT_C)) {
1058 cmd = lp->cmd_head;
1059
1060 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
1061 lp->cmd_backlog--;
1062
1063 commands_done++;
1064 cmd_val = cmd->command & 0x7;
1065 #if 0
1066 printk("finished CU %s command (%d)\n",
1067 CUcmdnames[cmd_val], cmd_val);
1068 #endif
1069 switch (cmd_val) {
1070 case CmdTx:
1071 {
1072 struct tx_cmd *tx_cmd;
1073 struct i596_tbd *tx_cmd_tbd;
1074
1075 tx_cmd = (struct tx_cmd *) cmd;
1076 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
1077
1078 frames_out++;
1079 if (cmd->status & CMD_STAT_OK) {
1080 if (i596_debug)
1081 print_eth(pa_to_va(tx_cmd_tbd->pa_data));
1082 } else {
1083 lp->stats.tx_errors++;
1084 if (i596_debug)
1085 printk("transmission failure:%04x\n",
1086 cmd->status);
1087 if (cmd->status & 0x0020)
1088 lp->stats.collisions++;
1089 if (!(cmd->status & 0x0040))
1090 lp->stats.tx_heartbeat_errors++;
1091 if (cmd->status & 0x0400)
1092 lp->stats.tx_carrier_errors++;
1093 if (cmd->status & 0x0800)
1094 lp->stats.collisions++;
1095 if (cmd->status & 0x1000)
1096 lp->stats.tx_aborted_errors++;
1097 }
1098 dev_kfree_skb_irq(tx_cmd_tbd->skb);
1099
1100 cmd->pa_next = I596_NULL;
1101 kfree((unsigned char *)tx_cmd);
1102 netif_wake_queue(dev);
1103 break;
1104 }
1105
1106 case CmdMulticastList:
1107 cmd->pa_next = I596_NULL;
1108 kfree((unsigned char *)cmd);
1109 break;
1110
1111 case CmdTDR:
1112 {
1113 unsigned long status = *((unsigned long *) (cmd + 1));
1114 if (status & 0x8000) {
1115 if (i596_debug)
1116 printk("%s: link ok.\n", dev->name);
1117 } else {
1118 if (status & 0x4000)
1119 printk("%s: Transceiver problem.\n",
1120 dev->name);
1121 if (status & 0x2000)
1122 printk("%s: Termination problem.\n",
1123 dev->name);
1124 if (status & 0x1000)
1125 printk("%s: Short circuit.\n",
1126 dev->name);
1127 printk("%s: Time %ld.\n",
1128 dev->name, status & 0x07ff);
1129 }
1130 }
1131 default:
1132 cmd->pa_next = I596_NULL;
1133 lp->last_cmd = jiffies;
1134
1135 }
1136 barrier();
1137 }
1138
1139 cmd = lp->cmd_head;
1140 while (cmd && (cmd != lp->cmd_tail)) {
1141 cmd->command &= 0x1fff;
1142 cmd = pa_to_va(cmd->pa_next);
1143 barrier();
1144 }
1145
1146 if (lp->cmd_head)
1147 *ack_cmdp |= CUC_START;
1148 lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
1149 spin_unlock_irqrestore(&lp->cmd_lock, flags);
1150 }
1151
1152 static irqreturn_t
1153 i596_interrupt (int irq, void *dev_instance) {
1154 struct net_device *dev = (struct net_device *) dev_instance;
1155 struct i596_private *lp;
1156 unsigned short status, ack_cmd = 0;
1157 int frames_in = 0;
1158
1159 lp = (struct i596_private *) dev->priv;
1160
1161 /*
1162 * The 82596 examines the command, performs the required action,
1163 * and then clears the SCB command word.
1164 */
1165 if (lp->scb.command && i596_timeout(dev, "interrupt", 40))
1166 ;
1167
1168 /*
1169 * The status word indicates the status of the 82596.
1170 * It is modified only by the 82596.
1171 *
1172 * [So, we must not clear it. I find often status 0xffff,
1173 * which is not one of the values allowed by the docs.]
1174 */
1175 status = lp->scb.status;
1176 #if 0
1177 if (i596_debug) {
1178 printk("%s: i596 interrupt, ", dev->name);
1179 i596_out_status(status);
1180 }
1181 #endif
1182 /* Impossible, but it happens - perhaps when we get
1183 a receive interrupt but scb.pa_rfd is I596_NULL. */
1184 if (status == 0xffff) {
1185 printk("%s: i596_interrupt: got status 0xffff\n", dev->name);
1186 goto out;
1187 }
1188
1189 ack_cmd = (status & STAT_ACK);
1190
1191 if (status & (STAT_CX | STAT_CNA))
1192 i596_handle_CU_completion(dev, lp, status, &ack_cmd);
1193
1194 if (status & (STAT_FR | STAT_RNR)) {
1195 /* Restart the receive unit when it got inactive somehow */
1196 if ((status & STAT_RNR) && netif_running(dev))
1197 ack_cmd |= RX_START;
1198
1199 if (status & STAT_FR) {
1200 frames_in = i596_rx(dev);
1201 if (!frames_in)
1202 printk("receive frame reported, but no frames\n");
1203 }
1204 }
1205
1206 /* acknowledge the interrupt */
1207 /*
1208 if ((lp->scb.pa_cmd != I596_NULL) && netif_running(dev))
1209 ack_cmd |= CUC_START;
1210 */
1211
1212 if (lp->scb.command && i596_timeout(dev, "i596 interrupt", 100))
1213 ;
1214
1215 lp->scb.command = ack_cmd;
1216
1217 CLEAR_INT();
1218 CA();
1219
1220 out:
1221 return IRQ_HANDLED;
1222 }
1223
1224 static int i596_close(struct net_device *dev) {
1225 struct i596_private *lp = dev->priv;
1226
1227 netif_stop_queue(dev);
1228
1229 if (i596_debug)
1230 printk("%s: Shutting down ethercard, status was %4.4x.\n",
1231 dev->name, lp->scb.status);
1232
1233 lp->scb.command = (CUC_ABORT | RX_ABORT);
1234 CA();
1235
1236 i596_cleanup_cmd(dev);
1237
1238 if (lp->scb.command && i596_timeout(dev, "i596_close", 200))
1239 ;
1240
1241 free_irq(dev->irq, dev);
1242 remove_rx_bufs(dev);
1243
1244 return 0;
1245 }
1246
1247 static struct net_device_stats * i596_get_stats(struct net_device *dev) {
1248 struct i596_private *lp = dev->priv;
1249
1250 return &lp->stats;
1251 }
1252
1253 /*
1254 * Set or clear the multicast filter for this adaptor.
1255 */
1256
1257 static void set_multicast_list(struct net_device *dev) {
1258 struct i596_private *lp = dev->priv;
1259 struct i596_cmd *cmd;
1260
1261 if (i596_debug > 1)
1262 printk ("%s: set multicast list %d\n",
1263 dev->name, dev->mc_count);
1264
1265 if (dev->mc_count > 0) {
1266 struct dev_mc_list *dmi;
1267 char *cp;
1268 cmd = kmalloc(sizeof(struct i596_cmd)+2+dev->mc_count*6, GFP_ATOMIC);
1269 if (cmd == NULL) {
1270 printk (KERN_ERR "%s: set_multicast Memory squeeze.\n", dev->name);
1271 return;
1272 }
1273 cmd->command = CmdMulticastList;
1274 *((unsigned short *) (cmd + 1)) = dev->mc_count * 6;
1275 cp = ((char *)(cmd + 1))+2;
1276 for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) {
1277 memcpy(cp, dmi,6);
1278 cp += 6;
1279 }
1280 if (i596_debug & LOG_SRCDST)
1281 print_eth (((char *)(cmd + 1)) + 2);
1282 i596_add_cmd(dev, cmd);
1283 } else {
1284 if (lp->set_conf.pa_next != I596_NULL) {
1285 return;
1286 }
1287 if (dev->mc_count == 0 && !(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1288 if (dev->flags & IFF_ALLMULTI)
1289 dev->flags |= IFF_PROMISC;
1290 lp->i596_config[8] &= ~0x01;
1291 } else {
1292 lp->i596_config[8] |= 0x01;
1293 }
1294
1295 i596_add_cmd(dev, (struct i596_cmd *) &lp->set_conf);
1296 }
1297 }
1298
1299 MODULE_AUTHOR("Ard van Breemen <ard@cstmel.nl.eu.org>");
1300 MODULE_DESCRIPTION("Intel Panther onboard i82596 driver");
1301 MODULE_LICENSE("GPL");
1302
1303 static struct net_device *dev_lp486e;
1304 static int full_duplex;
1305 static int options;
1306 static int io = IOADDR;
1307 static int irq = IRQ;
1308
1309 module_param(debug, int, 0);
1310 //module_param(max_interrupt_work, int, 0);
1311 //module_param(reverse_probe, int, 0);
1312 //module_param(rx_copybreak, int, 0);
1313 module_param(options, int, 0);
1314 module_param(full_duplex, int, 0);
1315
1316 static int __init lp486e_init_module(void) {
1317 int err;
1318 struct net_device *dev = alloc_etherdev(sizeof(struct i596_private));
1319 if (!dev)
1320 return -ENOMEM;
1321
1322 dev->irq = irq;
1323 dev->base_addr = io;
1324 err = lp486e_probe(dev);
1325 if (err) {
1326 free_netdev(dev);
1327 return err;
1328 }
1329 err = register_netdev(dev);
1330 if (err) {
1331 release_region(dev->base_addr, LP486E_TOTAL_SIZE);
1332 free_netdev(dev);
1333 return err;
1334 }
1335 dev_lp486e = dev;
1336 full_duplex = 0;
1337 options = 0;
1338 return 0;
1339 }
1340
1341 static void __exit lp486e_cleanup_module(void) {
1342 unregister_netdev(dev_lp486e);
1343 release_region(dev_lp486e->base_addr, LP486E_TOTAL_SIZE);
1344 free_netdev(dev_lp486e);
1345 }
1346
1347 module_init(lp486e_init_module);
1348 module_exit(lp486e_cleanup_module);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree