?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] powerpc: get rid of per_cpu EEH counters
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / 82596.c
blob13b745b39667710b33308b4c8f4d770758fec599
1 /* 82596.c: A generic 82596 ethernet driver for linux. */
2 /*
3 Based on Apricot.c
4 Written 1994 by Mark Evans.
5 This driver is for the Apricot 82596 bus-master interface
6
7 Modularised 12/94 Mark Evans
8
9
10 Modified to support the 82596 ethernet chips on 680x0 VME boards.
11 by Richard Hirst <richard@sleepie.demon.co.uk>
12 Renamed to be 82596.c
13
14 980825: Changed to receive directly in to sk_buffs which are
15 allocated at open() time. Eliminates copy on incoming frames
16 (small ones are still copied). Shared data now held in a
17 non-cached page, so we can run on 68060 in copyback mode.
18
19 TBD:
20 * look at deferring rx frames rather than discarding (as per tulip)
21 * handle tx ring full as per tulip
22 * performace test to tune rx_copybreak
23
24 Most of my modifications relate to the braindead big-endian
25 implementation by Intel. When the i596 is operating in
26 'big-endian' mode, it thinks a 32 bit value of 0x12345678
27 should be stored as 0x56781234. This is a real pain, when
28 you have linked lists which are shared by the 680x0 and the
29 i596.
30
31 Driver skeleton
32 Written 1993 by Donald Becker.
33 Copyright 1993 United States Government as represented by the Director,
34 National Security Agency. This software may only be used and distributed
35 according to the terms of the GNU General Public License as modified by SRC,
36 incorporated herein by reference.
37
38 The author may be reached as becker@scyld.com, or C/O
39 Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
40
41 */
42
43 #include <linux/config.h>
44 #include <linux/module.h>
45 #include <linux/kernel.h>
46 #include <linux/string.h>
47 #include <linux/errno.h>
48 #include <linux/ioport.h>
49 #include <linux/slab.h>
50 #include <linux/interrupt.h>
51 #include <linux/delay.h>
52 #include <linux/netdevice.h>
53 #include <linux/etherdevice.h>
54 #include <linux/skbuff.h>
55 #include <linux/init.h>
56 #include <linux/bitops.h>
57
58 #include <asm/io.h>
59 #include <asm/dma.h>
60 #include <asm/pgtable.h>
61
62 static char version[] __initdata =
63 "82596.c $Revision: 1.5 $\n";
64
65 #define DRV_NAME "82596"
66
67 /* DEBUG flags
68 */
69
70 #define DEB_INIT 0x0001
71 #define DEB_PROBE 0x0002
72 #define DEB_SERIOUS 0x0004
73 #define DEB_ERRORS 0x0008
74 #define DEB_MULTI 0x0010
75 #define DEB_TDR 0x0020
76 #define DEB_OPEN 0x0040
77 #define DEB_RESET 0x0080
78 #define DEB_ADDCMD 0x0100
79 #define DEB_STATUS 0x0200
80 #define DEB_STARTTX 0x0400
81 #define DEB_RXADDR 0x0800
82 #define DEB_TXADDR 0x1000
83 #define DEB_RXFRAME 0x2000
84 #define DEB_INTS 0x4000
85 #define DEB_STRUCT 0x8000
86 #define DEB_ANY 0xffff
87
88
89 #define DEB(x,y) if (i596_debug & (x)) y
90
91
92 #if defined(CONFIG_MVME16x_NET) || defined(CONFIG_MVME16x_NET_MODULE)
93 #define ENABLE_MVME16x_NET
94 #endif
95 #if defined(CONFIG_BVME6000_NET) || defined(CONFIG_BVME6000_NET_MODULE)
96 #define ENABLE_BVME6000_NET
97 #endif
98 #if defined(CONFIG_APRICOT) || defined(CONFIG_APRICOT_MODULE)
99 #define ENABLE_APRICOT
100 #endif
101
102 #ifdef ENABLE_MVME16x_NET
103 #include <asm/mvme16xhw.h>
104 #endif
105 #ifdef ENABLE_BVME6000_NET
106 #include <asm/bvme6000hw.h>
107 #endif
108
109 /*
110 * Define various macros for Channel Attention, word swapping etc., dependent
111 * on architecture. MVME and BVME are 680x0 based, otherwise it is Intel.
112 */
113
114 #ifdef __mc68000__
115 #define WSWAPrfd(x) ((struct i596_rfd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
116 #define WSWAPrbd(x) ((struct i596_rbd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
117 #define WSWAPiscp(x) ((struct i596_iscp *)(((u32)(x)<<16) | ((((u32)(x)))>>16)))
118 #define WSWAPscb(x) ((struct i596_scb *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
119 #define WSWAPcmd(x) ((struct i596_cmd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
120 #define WSWAPtbd(x) ((struct i596_tbd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
121 #define WSWAPchar(x) ((char *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
122 #define ISCP_BUSY 0x00010000
123 #define MACH_IS_APRICOT 0
124 #else
125 #define WSWAPrfd(x) ((struct i596_rfd *)(x))
126 #define WSWAPrbd(x) ((struct i596_rbd *)(x))
127 #define WSWAPiscp(x) ((struct i596_iscp *)(x))
128 #define WSWAPscb(x) ((struct i596_scb *)(x))
129 #define WSWAPcmd(x) ((struct i596_cmd *)(x))
130 #define WSWAPtbd(x) ((struct i596_tbd *)(x))
131 #define WSWAPchar(x) ((char *)(x))
132 #define ISCP_BUSY 0x0001
133 #define MACH_IS_APRICOT 1
134 #endif
135
136 /*
137 * The MPU_PORT command allows direct access to the 82596. With PORT access
138 * the following commands are available (p5-18). The 32-bit port command
139 * must be word-swapped with the most significant word written first.
140 * This only applies to VME boards.
141 */
142 #define PORT_RESET 0x00 /* reset 82596 */
143 #define PORT_SELFTEST 0x01 /* selftest */
144 #define PORT_ALTSCP 0x02 /* alternate SCB address */
145 #define PORT_ALTDUMP 0x03 /* Alternate DUMP address */
146
147 static int i596_debug = (DEB_SERIOUS|DEB_PROBE);
148
149 MODULE_AUTHOR("Richard Hirst");
150 MODULE_DESCRIPTION("i82596 driver");
151 MODULE_LICENSE("GPL");
152
153 module_param(i596_debug, int, 0);
154 MODULE_PARM_DESC(i596_debug, "i82596 debug mask");
155
156
157 /* Copy frames shorter than rx_copybreak, otherwise pass on up in
158 * a full sized sk_buff. Value of 100 stolen from tulip.c (!alpha).
159 */
160 static int rx_copybreak = 100;
161
162 #define PKT_BUF_SZ 1536
163 #define MAX_MC_CNT 64
164
165 #define I596_TOTAL_SIZE 17
166
167 #define I596_NULL ((void *)0xffffffff)
168
169 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
170 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
171 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
172
173 #define CMD_FLEX 0x0008 /* Enable flexible memory model */
174
175 enum commands {
176 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
177 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7
178 };
179
180 #define STAT_C 0x8000 /* Set to 0 after execution */
181 #define STAT_B 0x4000 /* Command being executed */
182 #define STAT_OK 0x2000 /* Command executed ok */
183 #define STAT_A 0x1000 /* Command aborted */
184
185 #define CUC_START 0x0100
186 #define CUC_RESUME 0x0200
187 #define CUC_SUSPEND 0x0300
188 #define CUC_ABORT 0x0400
189 #define RX_START 0x0010
190 #define RX_RESUME 0x0020
191 #define RX_SUSPEND 0x0030
192 #define RX_ABORT 0x0040
193
194 #define TX_TIMEOUT 5
195
196
197 struct i596_reg {
198 unsigned short porthi;
199 unsigned short portlo;
200 unsigned long ca;
201 };
202
203 #define EOF 0x8000
204 #define SIZE_MASK 0x3fff
205
206 struct i596_tbd {
207 unsigned short size;
208 unsigned short pad;
209 struct i596_tbd *next;
210 char *data;
211 };
212
213 /* The command structure has two 'next' pointers; v_next is the address of
214 * the next command as seen by the CPU, b_next is the address of the next
215 * command as seen by the 82596. The b_next pointer, as used by the 82596
216 * always references the status field of the next command, rather than the
217 * v_next field, because the 82596 is unaware of v_next. It may seem more
218 * logical to put v_next at the end of the structure, but we cannot do that
219 * because the 82596 expects other fields to be there, depending on command
220 * type.
221 */
222
223 struct i596_cmd {
224 struct i596_cmd *v_next; /* Address from CPUs viewpoint */
225 unsigned short status;
226 unsigned short command;
227 struct i596_cmd *b_next; /* Address from i596 viewpoint */
228 };
229
230 struct tx_cmd {
231 struct i596_cmd cmd;
232 struct i596_tbd *tbd;
233 unsigned short size;
234 unsigned short pad;
235 struct sk_buff *skb; /* So we can free it after tx */
236 };
237
238 struct tdr_cmd {
239 struct i596_cmd cmd;
240 unsigned short status;
241 unsigned short pad;
242 };
243
244 struct mc_cmd {
245 struct i596_cmd cmd;
246 short mc_cnt;
247 char mc_addrs[MAX_MC_CNT*6];
248 };
249
250 struct sa_cmd {
251 struct i596_cmd cmd;
252 char eth_addr[8];
253 };
254
255 struct cf_cmd {
256 struct i596_cmd cmd;
257 char i596_config[16];
258 };
259
260 struct i596_rfd {
261 unsigned short stat;
262 unsigned short cmd;
263 struct i596_rfd *b_next; /* Address from i596 viewpoint */
264 struct i596_rbd *rbd;
265 unsigned short count;
266 unsigned short size;
267 struct i596_rfd *v_next; /* Address from CPUs viewpoint */
268 struct i596_rfd *v_prev;
269 };
270
271 struct i596_rbd {
272 unsigned short count;
273 unsigned short zero1;
274 struct i596_rbd *b_next;
275 unsigned char *b_data; /* Address from i596 viewpoint */
276 unsigned short size;
277 unsigned short zero2;
278 struct sk_buff *skb;
279 struct i596_rbd *v_next;
280 struct i596_rbd *b_addr; /* This rbd addr from i596 view */
281 unsigned char *v_data; /* Address from CPUs viewpoint */
282 };
283
284 #define TX_RING_SIZE 64
285 #define RX_RING_SIZE 16
286
287 struct i596_scb {
288 unsigned short status;
289 unsigned short command;
290 struct i596_cmd *cmd;
291 struct i596_rfd *rfd;
292 unsigned long crc_err;
293 unsigned long align_err;
294 unsigned long resource_err;
295 unsigned long over_err;
296 unsigned long rcvdt_err;
297 unsigned long short_err;
298 unsigned short t_on;
299 unsigned short t_off;
300 };
301
302 struct i596_iscp {
303 unsigned long stat;
304 struct i596_scb *scb;
305 };
306
307 struct i596_scp {
308 unsigned long sysbus;
309 unsigned long pad;
310 struct i596_iscp *iscp;
311 };
312
313 struct i596_private {
314 volatile struct i596_scp scp;
315 volatile struct i596_iscp iscp;
316 volatile struct i596_scb scb;
317 struct sa_cmd sa_cmd;
318 struct cf_cmd cf_cmd;
319 struct tdr_cmd tdr_cmd;
320 struct mc_cmd mc_cmd;
321 unsigned long stat;
322 int last_restart __attribute__((aligned(4)));
323 struct i596_rfd *rfd_head;
324 struct i596_rbd *rbd_head;
325 struct i596_cmd *cmd_tail;
326 struct i596_cmd *cmd_head;
327 int cmd_backlog;
328 unsigned long last_cmd;
329 struct net_device_stats stats;
330 struct i596_rfd rfds[RX_RING_SIZE];
331 struct i596_rbd rbds[RX_RING_SIZE];
332 struct tx_cmd tx_cmds[TX_RING_SIZE];
333 struct i596_tbd tbds[TX_RING_SIZE];
334 int next_tx_cmd;
335 spinlock_t lock;
336 };
337
338 static char init_setup[] =
339 {
340 0x8E, /* length, prefetch on */
341 0xC8, /* fifo to 8, monitor off */
342 #ifdef CONFIG_VME
343 0xc0, /* don't save bad frames */
344 #else
345 0x80, /* don't save bad frames */
346 #endif
347 0x2E, /* No source address insertion, 8 byte preamble */
348 0x00, /* priority and backoff defaults */
349 0x60, /* interframe spacing */
350 0x00, /* slot time LSB */
351 0xf2, /* slot time and retries */
352 0x00, /* promiscuous mode */
353 0x00, /* collision detect */
354 0x40, /* minimum frame length */
355 0xff,
356 0x00,
357 0x7f /* *multi IA */ };
358
359 static int i596_open(struct net_device *dev);
360 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
361 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs);
362 static int i596_close(struct net_device *dev);
363 static struct net_device_stats *i596_get_stats(struct net_device *dev);
364 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
365 static void i596_tx_timeout (struct net_device *dev);
366 static void print_eth(unsigned char *buf, char *str);
367 static void set_multicast_list(struct net_device *dev);
368
369 static int rx_ring_size = RX_RING_SIZE;
370 static int ticks_limit = 25;
371 static int max_cmd_backlog = TX_RING_SIZE-1;
372
373
374 static inline void CA(struct net_device *dev)
375 {
376 #ifdef ENABLE_MVME16x_NET
377 if (MACH_IS_MVME16x) {
378 ((struct i596_reg *) dev->base_addr)->ca = 1;
379 }
380 #endif
381 #ifdef ENABLE_BVME6000_NET
382 if (MACH_IS_BVME6000) {
383 volatile u32 i;
384
385 i = *(volatile u32 *) (dev->base_addr);
386 }
387 #endif
388 #ifdef ENABLE_APRICOT
389 if (MACH_IS_APRICOT) {
390 outw(0, (short) (dev->base_addr) + 4);
391 }
392 #endif
393 }
394
395
396 static inline void MPU_PORT(struct net_device *dev, int c, volatile void *x)
397 {
398 #ifdef ENABLE_MVME16x_NET
399 if (MACH_IS_MVME16x) {
400 struct i596_reg *p = (struct i596_reg *) (dev->base_addr);
401 p->porthi = ((c) | (u32) (x)) & 0xffff;
402 p->portlo = ((c) | (u32) (x)) >> 16;
403 }
404 #endif
405 #ifdef ENABLE_BVME6000_NET
406 if (MACH_IS_BVME6000) {
407 u32 v = (u32) (c) | (u32) (x);
408 v = ((u32) (v) << 16) | ((u32) (v) >> 16);
409 *(volatile u32 *) dev->base_addr = v;
410 udelay(1);
411 *(volatile u32 *) dev->base_addr = v;
412 }
413 #endif
414 }
415
416
417 static inline int wait_istat(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
418 {
419 while (--delcnt && lp->iscp.stat)
420 udelay(10);
421 if (!delcnt) {
422 printk(KERN_ERR "%s: %s, status %4.4x, cmd %4.4x.\n",
423 dev->name, str, lp->scb.status, lp->scb.command);
424 return -1;
425 }
426 else
427 return 0;
428 }
429
430
431 static inline int wait_cmd(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
432 {
433 while (--delcnt && lp->scb.command)
434 udelay(10);
435 if (!delcnt) {
436 printk(KERN_ERR "%s: %s, status %4.4x, cmd %4.4x.\n",
437 dev->name, str, lp->scb.status, lp->scb.command);
438 return -1;
439 }
440 else
441 return 0;
442 }
443
444
445 static inline int wait_cfg(struct net_device *dev, struct i596_cmd *cmd, int delcnt, char *str)
446 {
447 volatile struct i596_cmd *c = cmd;
448
449 while (--delcnt && c->command)
450 udelay(10);
451 if (!delcnt) {
452 printk(KERN_ERR "%s: %s.\n", dev->name, str);
453 return -1;
454 }
455 else
456 return 0;
457 }
458
459
460 static void i596_display_data(struct net_device *dev)
461 {
462 struct i596_private *lp = dev->priv;
463 struct i596_cmd *cmd;
464 struct i596_rfd *rfd;
465 struct i596_rbd *rbd;
466
467 printk(KERN_ERR "lp and scp at %p, .sysbus = %08lx, .iscp = %p\n",
468 &lp->scp, lp->scp.sysbus, lp->scp.iscp);
469 printk(KERN_ERR "iscp at %p, iscp.stat = %08lx, .scb = %p\n",
470 &lp->iscp, lp->iscp.stat, lp->iscp.scb);
471 printk(KERN_ERR "scb at %p, scb.status = %04x, .command = %04x,"
472 " .cmd = %p, .rfd = %p\n",
473 &lp->scb, lp->scb.status, lp->scb.command,
474 lp->scb.cmd, lp->scb.rfd);
475 printk(KERN_ERR " errors: crc %lx, align %lx, resource %lx,"
476 " over %lx, rcvdt %lx, short %lx\n",
477 lp->scb.crc_err, lp->scb.align_err, lp->scb.resource_err,
478 lp->scb.over_err, lp->scb.rcvdt_err, lp->scb.short_err);
479 cmd = lp->cmd_head;
480 while (cmd != I596_NULL) {
481 printk(KERN_ERR "cmd at %p, .status = %04x, .command = %04x, .b_next = %p\n",
482 cmd, cmd->status, cmd->command, cmd->b_next);
483 cmd = cmd->v_next;
484 }
485 rfd = lp->rfd_head;
486 printk(KERN_ERR "rfd_head = %p\n", rfd);
487 do {
488 printk(KERN_ERR " %p .stat %04x, .cmd %04x, b_next %p, rbd %p,"
489 " count %04x\n",
490 rfd, rfd->stat, rfd->cmd, rfd->b_next, rfd->rbd,
491 rfd->count);
492 rfd = rfd->v_next;
493 } while (rfd != lp->rfd_head);
494 rbd = lp->rbd_head;
495 printk(KERN_ERR "rbd_head = %p\n", rbd);
496 do {
497 printk(KERN_ERR " %p .count %04x, b_next %p, b_data %p, size %04x\n",
498 rbd, rbd->count, rbd->b_next, rbd->b_data, rbd->size);
499 rbd = rbd->v_next;
500 } while (rbd != lp->rbd_head);
501 }
502
503
504 #if defined(ENABLE_MVME16x_NET) || defined(ENABLE_BVME6000_NET)
505 static irqreturn_t i596_error(int irq, void *dev_id, struct pt_regs *regs)
506 {
507 struct net_device *dev = dev_id;
508 #ifdef ENABLE_MVME16x_NET
509 if (MACH_IS_MVME16x) {
510 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
511
512 pcc2[0x28] = 1;
513 pcc2[0x2b] = 0x1d;
514 }
515 #endif
516 #ifdef ENABLE_BVME6000_NET
517 if (MACH_IS_BVME6000) {
518 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
519
520 *ethirq = 1;
521 *ethirq = 3;
522 }
523 #endif
524 printk(KERN_ERR "%s: Error interrupt\n", dev->name);
525 i596_display_data(dev);
526 return IRQ_HANDLED;
527 }
528 #endif
529
530 static inline void init_rx_bufs(struct net_device *dev)
531 {
532 struct i596_private *lp = dev->priv;
533 int i;
534 struct i596_rfd *rfd;
535 struct i596_rbd *rbd;
536
537 /* First build the Receive Buffer Descriptor List */
538
539 for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
540 struct sk_buff *skb = dev_alloc_skb(PKT_BUF_SZ);
541
542 if (skb == NULL)
543 panic("82596: alloc_skb() failed");
544 skb->dev = dev;
545 rbd->v_next = rbd+1;
546 rbd->b_next = WSWAPrbd(virt_to_bus(rbd+1));
547 rbd->b_addr = WSWAPrbd(virt_to_bus(rbd));
548 rbd->skb = skb;
549 rbd->v_data = skb->data;
550 rbd->b_data = WSWAPchar(virt_to_bus(skb->data));
551 rbd->size = PKT_BUF_SZ;
552 #ifdef __mc68000__
553 cache_clear(virt_to_phys(skb->data), PKT_BUF_SZ);
554 #endif
555 }
556 lp->rbd_head = lp->rbds;
557 rbd = lp->rbds + rx_ring_size - 1;
558 rbd->v_next = lp->rbds;
559 rbd->b_next = WSWAPrbd(virt_to_bus(lp->rbds));
560
561 /* Now build the Receive Frame Descriptor List */
562
563 for (i = 0, rfd = lp->rfds; i < rx_ring_size; i++, rfd++) {
564 rfd->rbd = I596_NULL;
565 rfd->v_next = rfd+1;
566 rfd->v_prev = rfd-1;
567 rfd->b_next = WSWAPrfd(virt_to_bus(rfd+1));
568 rfd->cmd = CMD_FLEX;
569 }
570 lp->rfd_head = lp->rfds;
571 lp->scb.rfd = WSWAPrfd(virt_to_bus(lp->rfds));
572 rfd = lp->rfds;
573 rfd->rbd = lp->rbd_head;
574 rfd->v_prev = lp->rfds + rx_ring_size - 1;
575 rfd = lp->rfds + rx_ring_size - 1;
576 rfd->v_next = lp->rfds;
577 rfd->b_next = WSWAPrfd(virt_to_bus(lp->rfds));
578 rfd->cmd = CMD_EOL|CMD_FLEX;
579 }
580
581 static inline void remove_rx_bufs(struct net_device *dev)
582 {
583 struct i596_private *lp = dev->priv;
584 struct i596_rbd *rbd;
585 int i;
586
587 for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
588 if (rbd->skb == NULL)
589 break;
590 dev_kfree_skb(rbd->skb);
591 }
592 }
593
594
595 static void rebuild_rx_bufs(struct net_device *dev)
596 {
597 struct i596_private *lp = dev->priv;
598 int i;
599
600 /* Ensure rx frame/buffer descriptors are tidy */
601
602 for (i = 0; i < rx_ring_size; i++) {
603 lp->rfds[i].rbd = I596_NULL;
604 lp->rfds[i].cmd = CMD_FLEX;
605 }
606 lp->rfds[rx_ring_size-1].cmd = CMD_EOL|CMD_FLEX;
607 lp->rfd_head = lp->rfds;
608 lp->scb.rfd = WSWAPrfd(virt_to_bus(lp->rfds));
609 lp->rbd_head = lp->rbds;
610 lp->rfds[0].rbd = WSWAPrbd(virt_to_bus(lp->rbds));
611 }
612
613
614 static int init_i596_mem(struct net_device *dev)
615 {
616 struct i596_private *lp = dev->priv;
617 #if !defined(ENABLE_MVME16x_NET) && !defined(ENABLE_BVME6000_NET)
618 short ioaddr = dev->base_addr;
619 #endif
620 unsigned long flags;
621
622 MPU_PORT(dev, PORT_RESET, NULL);
623
624 udelay(100); /* Wait 100us - seems to help */
625
626 #if defined(ENABLE_MVME16x_NET) || defined(ENABLE_BVME6000_NET)
627 #ifdef ENABLE_MVME16x_NET
628 if (MACH_IS_MVME16x) {
629 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
630
631 /* Disable all ints for now */
632 pcc2[0x28] = 1;
633 pcc2[0x2a] = 0x48;
634 /* Following disables snooping. Snooping is not required
635 * as we make appropriate use of non-cached pages for
636 * shared data, and cache_push/cache_clear.
637 */
638 pcc2[0x2b] = 0x08;
639 }
640 #endif
641 #ifdef ENABLE_BVME6000_NET
642 if (MACH_IS_BVME6000) {
643 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
644
645 *ethirq = 1;
646 }
647 #endif
648
649 /* change the scp address */
650
651 MPU_PORT(dev, PORT_ALTSCP, (void *)virt_to_bus((void *)&lp->scp));
652
653 #elif defined(ENABLE_APRICOT)
654
655 {
656 u32 scp = virt_to_bus(&lp->scp);
657
658 /* change the scp address */
659 outw(0, ioaddr);
660 outw(0, ioaddr);
661 outb(4, ioaddr + 0xf);
662 outw(scp | 2, ioaddr);
663 outw(scp >> 16, ioaddr);
664 }
665 #endif
666
667 lp->last_cmd = jiffies;
668
669 #ifdef ENABLE_MVME16x_NET
670 if (MACH_IS_MVME16x)
671 lp->scp.sysbus = 0x00000054;
672 #endif
673 #ifdef ENABLE_BVME6000_NET
674 if (MACH_IS_BVME6000)
675 lp->scp.sysbus = 0x0000004c;
676 #endif
677 #ifdef ENABLE_APRICOT
678 if (MACH_IS_APRICOT)
679 lp->scp.sysbus = 0x00440000;
680 #endif
681
682 lp->scp.iscp = WSWAPiscp(virt_to_bus((void *)&lp->iscp));
683 lp->iscp.scb = WSWAPscb(virt_to_bus((void *)&lp->scb));
684 lp->iscp.stat = ISCP_BUSY;
685 lp->cmd_backlog = 0;
686
687 lp->cmd_head = lp->scb.cmd = I596_NULL;
688
689 #ifdef ENABLE_BVME6000_NET
690 if (MACH_IS_BVME6000) {
691 lp->scb.t_on = 7 * 25;
692 lp->scb.t_off = 1 * 25;
693 }
694 #endif
695
696 DEB(DEB_INIT,printk(KERN_DEBUG "%s: starting i82596.\n", dev->name));
697
698 #if defined(ENABLE_APRICOT)
699 (void) inb(ioaddr + 0x10);
700 outb(4, ioaddr + 0xf);
701 #endif
702 CA(dev);
703
704 if (wait_istat(dev,lp,1000,"initialization timed out"))
705 goto failed;
706 DEB(DEB_INIT,printk(KERN_DEBUG "%s: i82596 initialization successful\n", dev->name));
707
708 /* Ensure rx frame/buffer descriptors are tidy */
709 rebuild_rx_bufs(dev);
710 lp->scb.command = 0;
711
712 #ifdef ENABLE_MVME16x_NET
713 if (MACH_IS_MVME16x) {
714 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
715
716 /* Enable ints, etc. now */
717 pcc2[0x2a] = 0x55; /* Edge sensitive */
718 pcc2[0x2b] = 0x15;
719 }
720 #endif
721 #ifdef ENABLE_BVME6000_NET
722 if (MACH_IS_BVME6000) {
723 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
724
725 *ethirq = 3;
726 }
727 #endif
728
729
730 DEB(DEB_INIT,printk(KERN_DEBUG "%s: queuing CmdConfigure\n", dev->name));
731 memcpy(lp->cf_cmd.i596_config, init_setup, 14);
732 lp->cf_cmd.cmd.command = CmdConfigure;
733 i596_add_cmd(dev, &lp->cf_cmd.cmd);
734
735 DEB(DEB_INIT,printk(KERN_DEBUG "%s: queuing CmdSASetup\n", dev->name));
736 memcpy(lp->sa_cmd.eth_addr, dev->dev_addr, 6);
737 lp->sa_cmd.cmd.command = CmdSASetup;
738 i596_add_cmd(dev, &lp->sa_cmd.cmd);
739
740 DEB(DEB_INIT,printk(KERN_DEBUG "%s: queuing CmdTDR\n", dev->name));
741 lp->tdr_cmd.cmd.command = CmdTDR;
742 i596_add_cmd(dev, &lp->tdr_cmd.cmd);
743
744 spin_lock_irqsave (&lp->lock, flags);
745
746 if (wait_cmd(dev,lp,1000,"timed out waiting to issue RX_START")) {
747 spin_unlock_irqrestore (&lp->lock, flags);
748 goto failed;
749 }
750 DEB(DEB_INIT,printk(KERN_DEBUG "%s: Issuing RX_START\n", dev->name));
751 lp->scb.command = RX_START;
752 CA(dev);
753
754 spin_unlock_irqrestore (&lp->lock, flags);
755
756 if (wait_cmd(dev,lp,1000,"RX_START not processed"))
757 goto failed;
758 DEB(DEB_INIT,printk(KERN_DEBUG "%s: Receive unit started OK\n", dev->name));
759 return 0;
760
761 failed:
762 printk(KERN_CRIT "%s: Failed to initialise 82596\n", dev->name);
763 MPU_PORT(dev, PORT_RESET, NULL);
764 return -1;
765 }
766
767 static inline int i596_rx(struct net_device *dev)
768 {
769 struct i596_private *lp = dev->priv;
770 struct i596_rfd *rfd;
771 struct i596_rbd *rbd;
772 int frames = 0;
773
774 DEB(DEB_RXFRAME,printk(KERN_DEBUG "i596_rx(), rfd_head %p, rbd_head %p\n",
775 lp->rfd_head, lp->rbd_head));
776
777 rfd = lp->rfd_head; /* Ref next frame to check */
778
779 while ((rfd->stat) & STAT_C) { /* Loop while complete frames */
780 if (rfd->rbd == I596_NULL)
781 rbd = I596_NULL;
782 else if (rfd->rbd == lp->rbd_head->b_addr)
783 rbd = lp->rbd_head;
784 else {
785 printk(KERN_CRIT "%s: rbd chain broken!\n", dev->name);
786 /* XXX Now what? */
787 rbd = I596_NULL;
788 }
789 DEB(DEB_RXFRAME, printk(KERN_DEBUG " rfd %p, rfd.rbd %p, rfd.stat %04x\n",
790 rfd, rfd->rbd, rfd->stat));
791
792 if (rbd != I596_NULL && ((rfd->stat) & STAT_OK)) {
793 /* a good frame */
794 int pkt_len = rbd->count & 0x3fff;
795 struct sk_buff *skb = rbd->skb;
796 int rx_in_place = 0;
797
798 DEB(DEB_RXADDR,print_eth(rbd->v_data, "received"));
799 frames++;
800
801 /* Check if the packet is long enough to just accept
802 * without copying to a properly sized skbuff.
803 */
804
805 if (pkt_len > rx_copybreak) {
806 struct sk_buff *newskb;
807
808 /* Get fresh skbuff to replace filled one. */
809 newskb = dev_alloc_skb(PKT_BUF_SZ);
810 if (newskb == NULL) {
811 skb = NULL; /* drop pkt */
812 goto memory_squeeze;
813 }
814 /* Pass up the skb already on the Rx ring. */
815 skb_put(skb, pkt_len);
816 rx_in_place = 1;
817 rbd->skb = newskb;
818 newskb->dev = dev;
819 rbd->v_data = newskb->data;
820 rbd->b_data = WSWAPchar(virt_to_bus(newskb->data));
821 #ifdef __mc68000__
822 cache_clear(virt_to_phys(newskb->data), PKT_BUF_SZ);
823 #endif
824 }
825 else
826 skb = dev_alloc_skb(pkt_len + 2);
827 memory_squeeze:
828 if (skb == NULL) {
829 /* XXX tulip.c can defer packets here!! */
830 printk(KERN_WARNING "%s: i596_rx Memory squeeze, dropping packet.\n", dev->name);
831 lp->stats.rx_dropped++;
832 }
833 else {
834 skb->dev = dev;
835 if (!rx_in_place) {
836 /* 16 byte align the data fields */
837 skb_reserve(skb, 2);
838 memcpy(skb_put(skb,pkt_len), rbd->v_data, pkt_len);
839 }
840 skb->protocol=eth_type_trans(skb,dev);
841 skb->len = pkt_len;
842 #ifdef __mc68000__
843 cache_clear(virt_to_phys(rbd->skb->data),
844 pkt_len);
845 #endif
846 netif_rx(skb);
847 dev->last_rx = jiffies;
848 lp->stats.rx_packets++;
849 lp->stats.rx_bytes+=pkt_len;
850 }
851 }
852 else {
853 DEB(DEB_ERRORS, printk(KERN_DEBUG "%s: Error, rfd.stat = 0x%04x\n",
854 dev->name, rfd->stat));
855 lp->stats.rx_errors++;
856 if ((rfd->stat) & 0x0001)
857 lp->stats.collisions++;
858 if ((rfd->stat) & 0x0080)
859 lp->stats.rx_length_errors++;
860 if ((rfd->stat) & 0x0100)
861 lp->stats.rx_over_errors++;
862 if ((rfd->stat) & 0x0200)
863 lp->stats.rx_fifo_errors++;
864 if ((rfd->stat) & 0x0400)
865 lp->stats.rx_frame_errors++;
866 if ((rfd->stat) & 0x0800)
867 lp->stats.rx_crc_errors++;
868 if ((rfd->stat) & 0x1000)
869 lp->stats.rx_length_errors++;
870 }
871
872 /* Clear the buffer descriptor count and EOF + F flags */
873
874 if (rbd != I596_NULL && (rbd->count & 0x4000)) {
875 rbd->count = 0;
876 lp->rbd_head = rbd->v_next;
877 }
878
879 /* Tidy the frame descriptor, marking it as end of list */
880
881 rfd->rbd = I596_NULL;
882 rfd->stat = 0;
883 rfd->cmd = CMD_EOL|CMD_FLEX;
884 rfd->count = 0;
885
886 /* Remove end-of-list from old end descriptor */
887
888 rfd->v_prev->cmd = CMD_FLEX;
889
890 /* Update record of next frame descriptor to process */
891
892 lp->scb.rfd = rfd->b_next;
893 lp->rfd_head = rfd->v_next;
894 rfd = lp->rfd_head;
895 }
896
897 DEB(DEB_RXFRAME,printk(KERN_DEBUG "frames %d\n", frames));
898
899 return 0;
900 }
901
902
903 static inline void i596_cleanup_cmd(struct net_device *dev, struct i596_private *lp)
904 {
905 struct i596_cmd *ptr;
906
907 while (lp->cmd_head != I596_NULL) {
908 ptr = lp->cmd_head;
909 lp->cmd_head = ptr->v_next;
910 lp->cmd_backlog--;
911
912 switch ((ptr->command) & 0x7) {
913 case CmdTx:
914 {
915 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
916 struct sk_buff *skb = tx_cmd->skb;
917
918 dev_kfree_skb(skb);
919
920 lp->stats.tx_errors++;
921 lp->stats.tx_aborted_errors++;
922
923 ptr->v_next = ptr->b_next = I596_NULL;
924 tx_cmd->cmd.command = 0; /* Mark as free */
925 break;
926 }
927 default:
928 ptr->v_next = ptr->b_next = I596_NULL;
929 }
930 }
931
932 wait_cmd(dev,lp,100,"i596_cleanup_cmd timed out");
933 lp->scb.cmd = I596_NULL;
934 }
935
936 static inline void i596_reset(struct net_device *dev, struct i596_private *lp, int ioaddr)
937 {
938 unsigned long flags;
939
940 DEB(DEB_RESET,printk(KERN_DEBUG "i596_reset\n"));
941
942 spin_lock_irqsave (&lp->lock, flags);
943
944 wait_cmd(dev,lp,100,"i596_reset timed out");
945
946 netif_stop_queue(dev);
947
948 lp->scb.command = CUC_ABORT | RX_ABORT;
949 CA(dev);
950
951 /* wait for shutdown */
952 wait_cmd(dev,lp,1000,"i596_reset 2 timed out");
953 spin_unlock_irqrestore (&lp->lock, flags);
954
955 i596_cleanup_cmd(dev,lp);
956 i596_rx(dev);
957
958 netif_start_queue(dev);
959 init_i596_mem(dev);
960 }
961
962 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd)
963 {
964 struct i596_private *lp = dev->priv;
965 int ioaddr = dev->base_addr;
966 unsigned long flags;
967
968 DEB(DEB_ADDCMD,printk(KERN_DEBUG "i596_add_cmd\n"));
969
970 cmd->status = 0;
971 cmd->command |= (CMD_EOL | CMD_INTR);
972 cmd->v_next = cmd->b_next = I596_NULL;
973
974 spin_lock_irqsave (&lp->lock, flags);
975
976 if (lp->cmd_head != I596_NULL) {
977 lp->cmd_tail->v_next = cmd;
978 lp->cmd_tail->b_next = WSWAPcmd(virt_to_bus(&cmd->status));
979 } else {
980 lp->cmd_head = cmd;
981 wait_cmd(dev,lp,100,"i596_add_cmd timed out");
982 lp->scb.cmd = WSWAPcmd(virt_to_bus(&cmd->status));
983 lp->scb.command = CUC_START;
984 CA(dev);
985 }
986 lp->cmd_tail = cmd;
987 lp->cmd_backlog++;
988
989 spin_unlock_irqrestore (&lp->lock, flags);
990
991 if (lp->cmd_backlog > max_cmd_backlog) {
992 unsigned long tickssofar = jiffies - lp->last_cmd;
993
994 if (tickssofar < ticks_limit)
995 return;
996
997 printk(KERN_NOTICE "%s: command unit timed out, status resetting.\n", dev->name);
998
999 i596_reset(dev, lp, ioaddr);
1000 }
1001 }
1002
1003 static int i596_open(struct net_device *dev)
1004 {
1005 int res = 0;
1006
1007 DEB(DEB_OPEN,printk(KERN_DEBUG "%s: i596_open() irq %d.\n", dev->name, dev->irq));
1008
1009 if (request_irq(dev->irq, i596_interrupt, 0, "i82596", dev)) {
1010 printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
1011 return -EAGAIN;
1012 }
1013 #ifdef ENABLE_MVME16x_NET
1014 if (MACH_IS_MVME16x) {
1015 if (request_irq(0x56, i596_error, 0, "i82596_error", dev))
1016 return -EAGAIN;
1017 }
1018 #endif
1019 init_rx_bufs(dev);
1020
1021 netif_start_queue(dev);
1022
1023 /* Initialize the 82596 memory */
1024 if (init_i596_mem(dev)) {
1025 res = -EAGAIN;
1026 free_irq(dev->irq, dev);
1027 }
1028
1029 return res;
1030 }
1031
1032 static void i596_tx_timeout (struct net_device *dev)
1033 {
1034 struct i596_private *lp = dev->priv;
1035 int ioaddr = dev->base_addr;
1036
1037 /* Transmitter timeout, serious problems. */
1038 DEB(DEB_ERRORS,printk(KERN_ERR "%s: transmit timed out, status resetting.\n",
1039 dev->name));
1040
1041 lp->stats.tx_errors++;
1042
1043 /* Try to restart the adaptor */
1044 if (lp->last_restart == lp->stats.tx_packets) {
1045 DEB(DEB_ERRORS,printk(KERN_ERR "Resetting board.\n"));
1046 /* Shutdown and restart */
1047 i596_reset (dev, lp, ioaddr);
1048 } else {
1049 /* Issue a channel attention signal */
1050 DEB(DEB_ERRORS,printk(KERN_ERR "Kicking board.\n"));
1051 lp->scb.command = CUC_START | RX_START;
1052 CA (dev);
1053 lp->last_restart = lp->stats.tx_packets;
1054 }
1055
1056 dev->trans_start = jiffies;
1057 netif_wake_queue (dev);
1058 }
1059
1060
1061 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
1062 {
1063 struct i596_private *lp = dev->priv;
1064 struct tx_cmd *tx_cmd;
1065 struct i596_tbd *tbd;
1066 short length = skb->len;
1067 dev->trans_start = jiffies;
1068
1069 DEB(DEB_STARTTX,printk(KERN_DEBUG "%s: i596_start_xmit(%x,%x) called\n", dev->name,
1070 skb->len, (unsigned int)skb->data));
1071
1072 if (skb->len < ETH_ZLEN) {
1073 skb = skb_padto(skb, ETH_ZLEN);
1074 if (skb == NULL)
1075 return 0;
1076 length = ETH_ZLEN;
1077 }
1078 netif_stop_queue(dev);
1079
1080 tx_cmd = lp->tx_cmds + lp->next_tx_cmd;
1081 tbd = lp->tbds + lp->next_tx_cmd;
1082
1083 if (tx_cmd->cmd.command) {
1084 printk(KERN_NOTICE "%s: xmit ring full, dropping packet.\n",
1085 dev->name);
1086 lp->stats.tx_dropped++;
1087
1088 dev_kfree_skb(skb);
1089 } else {
1090 if (++lp->next_tx_cmd == TX_RING_SIZE)
1091 lp->next_tx_cmd = 0;
1092 tx_cmd->tbd = WSWAPtbd(virt_to_bus(tbd));
1093 tbd->next = I596_NULL;
1094
1095 tx_cmd->cmd.command = CMD_FLEX | CmdTx;
1096 tx_cmd->skb = skb;
1097
1098 tx_cmd->pad = 0;
1099 tx_cmd->size = 0;
1100 tbd->pad = 0;
1101 tbd->size = EOF | length;
1102
1103 tbd->data = WSWAPchar(virt_to_bus(skb->data));
1104
1105 #ifdef __mc68000__
1106 cache_push(virt_to_phys(skb->data), length);
1107 #endif
1108 DEB(DEB_TXADDR,print_eth(skb->data, "tx-queued"));
1109 i596_add_cmd(dev, &tx_cmd->cmd);
1110
1111 lp->stats.tx_packets++;
1112 lp->stats.tx_bytes += length;
1113 }
1114
1115 netif_start_queue(dev);
1116
1117 return 0;
1118 }
1119
1120 static void print_eth(unsigned char *add, char *str)
1121 {
1122 int i;
1123
1124 printk(KERN_DEBUG "i596 0x%p, ", add);
1125 for (i = 0; i < 6; i++)
1126 printk(" %02X", add[i + 6]);
1127 printk(" -->");
1128 for (i = 0; i < 6; i++)
1129 printk(" %02X", add[i]);
1130 printk(" %02X%02X, %s\n", add[12], add[13], str);
1131 }
1132
1133 static int io = 0x300;
1134 static int irq = 10;
1135
1136 struct net_device * __init i82596_probe(int unit)
1137 {
1138 struct net_device *dev;
1139 int i;
1140 struct i596_private *lp;
1141 char eth_addr[8];
1142 static int probed;
1143 int err;
1144
1145 if (probed)
1146 return ERR_PTR(-ENODEV);
1147 probed++;
1148
1149 dev = alloc_etherdev(0);
1150 if (!dev)
1151 return ERR_PTR(-ENOMEM);
1152
1153 if (unit >= 0) {
1154 sprintf(dev->name, "eth%d", unit);
1155 netdev_boot_setup_check(dev);
1156 } else {
1157 dev->base_addr = io;
1158 dev->irq = irq;
1159 }
1160
1161 #ifdef ENABLE_MVME16x_NET
1162 if (MACH_IS_MVME16x) {
1163 if (mvme16x_config & MVME16x_CONFIG_NO_ETHERNET) {
1164 printk(KERN_NOTICE "Ethernet probe disabled - chip not present\n");
1165 err = -ENODEV;
1166 goto out;
1167 }
1168 memcpy(eth_addr, (void *) 0xfffc1f2c, 6); /* YUCK! Get addr from NOVRAM */
1169 dev->base_addr = MVME_I596_BASE;
1170 dev->irq = (unsigned) MVME16x_IRQ_I596;
1171 }
1172 #endif
1173 #ifdef ENABLE_BVME6000_NET
1174 if (MACH_IS_BVME6000) {
1175 volatile unsigned char *rtc = (unsigned char *) BVME_RTC_BASE;
1176 unsigned char msr = rtc[3];
1177 int i;
1178
1179 rtc[3] |= 0x80;
1180 for (i = 0; i < 6; i++)
1181 eth_addr[i] = rtc[i * 4 + 7]; /* Stored in RTC RAM at offset 1 */
1182 rtc[3] = msr;
1183 dev->base_addr = BVME_I596_BASE;
1184 dev->irq = (unsigned) BVME_IRQ_I596;
1185 }
1186 #endif
1187 #ifdef ENABLE_APRICOT
1188 {
1189 int checksum = 0;
1190 int ioaddr = 0x300;
1191
1192 /* this is easy the ethernet interface can only be at 0x300 */
1193 /* first check nothing is already registered here */
1194
1195 if (!request_region(ioaddr, I596_TOTAL_SIZE, DRV_NAME)) {
1196 printk(KERN_ERR "82596: IO address 0x%04x in use\n", ioaddr);
1197 err = -EBUSY;
1198 goto out;
1199 }
1200
1201 for (i = 0; i < 8; i++) {
1202 eth_addr[i] = inb(ioaddr + 8 + i);
1203 checksum += eth_addr[i];
1204 }
1205
1206 /* checksum is a multiple of 0x100, got this wrong first time
1207 some machines have 0x100, some 0x200. The DOS driver doesn't
1208 even bother with the checksum.
1209 Some other boards trip the checksum.. but then appear as
1210 ether address 0. Trap these - AC */
1211
1212 if ((checksum % 0x100) ||
1213 (memcmp(eth_addr, "\x00\x00\x49", 3) != 0)) {
1214 err = -ENODEV;
1215 goto out1;
1216 }
1217
1218 dev->base_addr = ioaddr;
1219 dev->irq = 10;
1220 }
1221 #endif
1222 dev->mem_start = (int)__get_free_pages(GFP_ATOMIC, 0);
1223 if (!dev->mem_start) {
1224 err = -ENOMEM;
1225 goto out1;
1226 }
1227
1228 DEB(DEB_PROBE,printk(KERN_INFO "%s: 82596 at %#3lx,", dev->name, dev->base_addr));
1229
1230 for (i = 0; i < 6; i++)
1231 DEB(DEB_PROBE,printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]));
1232
1233 DEB(DEB_PROBE,printk(" IRQ %d.\n", dev->irq));
1234
1235 DEB(DEB_PROBE,printk(KERN_INFO "%s", version));
1236
1237 /* The 82596-specific entries in the device structure. */
1238 SET_MODULE_OWNER(dev);
1239 dev->open = i596_open;
1240 dev->stop = i596_close;
1241 dev->hard_start_xmit = i596_start_xmit;
1242 dev->get_stats = i596_get_stats;
1243 dev->set_multicast_list = set_multicast_list;
1244 dev->tx_timeout = i596_tx_timeout;
1245 dev->watchdog_timeo = TX_TIMEOUT;
1246
1247 dev->priv = (void *)(dev->mem_start);
1248
1249 lp = dev->priv;
1250 DEB(DEB_INIT,printk(KERN_DEBUG "%s: lp at 0x%08lx (%d bytes), lp->scb at 0x%08lx\n",
1251 dev->name, (unsigned long)lp,
1252 sizeof(struct i596_private), (unsigned long)&lp->scb));
1253 memset((void *) lp, 0, sizeof(struct i596_private));
1254
1255 #ifdef __mc68000__
1256 cache_push(virt_to_phys((void *)(dev->mem_start)), 4096);
1257 cache_clear(virt_to_phys((void *)(dev->mem_start)), 4096);
1258 kernel_set_cachemode((void *)(dev->mem_start), 4096, IOMAP_NOCACHE_SER);
1259 #endif
1260 lp->scb.command = 0;
1261 lp->scb.cmd = I596_NULL;
1262 lp->scb.rfd = I596_NULL;
1263 spin_lock_init(&lp->lock);
1264
1265 err = register_netdev(dev);
1266 if (err)
1267 goto out2;
1268 return dev;
1269 out2:
1270 #ifdef __mc68000__
1271 /* XXX This assumes default cache mode to be IOMAP_FULL_CACHING,
1272 * XXX which may be invalid (CONFIG_060_WRITETHROUGH)
1273 */
1274 kernel_set_cachemode((void *)(dev->mem_start), 4096,
1275 IOMAP_FULL_CACHING);
1276 #endif
1277 free_page ((u32)(dev->mem_start));
1278 out1:
1279 #ifdef ENABLE_APRICOT
1280 release_region(dev->base_addr, I596_TOTAL_SIZE);
1281 #endif
1282 out:
1283 free_netdev(dev);
1284 return ERR_PTR(err);
1285 }
1286
1287 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1288 {
1289 struct net_device *dev = dev_id;
1290 struct i596_private *lp;
1291 short ioaddr;
1292 unsigned short status, ack_cmd = 0;
1293 int handled = 0;
1294
1295 #ifdef ENABLE_BVME6000_NET
1296 if (MACH_IS_BVME6000) {
1297 if (*(char *) BVME_LOCAL_IRQ_STAT & BVME_ETHERR) {
1298 i596_error(irq, dev_id, regs);
1299 return IRQ_HANDLED;
1300 }
1301 }
1302 #endif
1303 if (dev == NULL) {
1304 printk(KERN_ERR "i596_interrupt(): irq %d for unknown device.\n", irq);
1305 return IRQ_NONE;
1306 }
1307
1308 ioaddr = dev->base_addr;
1309 lp = dev->priv;
1310
1311 spin_lock (&lp->lock);
1312
1313 wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1314 status = lp->scb.status;
1315
1316 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1317 dev->name, irq, status));
1318
1319 ack_cmd = status & 0xf000;
1320
1321 if ((status & 0x8000) || (status & 0x2000)) {
1322 struct i596_cmd *ptr;
1323
1324 handled = 1;
1325 if ((status & 0x8000))
1326 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt completed command.\n", dev->name));
1327 if ((status & 0x2000))
1328 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt command unit inactive %x.\n", dev->name, status & 0x0700));
1329
1330 while ((lp->cmd_head != I596_NULL) && (lp->cmd_head->status & STAT_C)) {
1331 ptr = lp->cmd_head;
1332
1333 DEB(DEB_STATUS,printk(KERN_DEBUG "cmd_head->status = %04x, ->command = %04x\n",
1334 lp->cmd_head->status, lp->cmd_head->command));
1335 lp->cmd_head = ptr->v_next;
1336 lp->cmd_backlog--;
1337
1338 switch ((ptr->command) & 0x7) {
1339 case CmdTx:
1340 {
1341 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
1342 struct sk_buff *skb = tx_cmd->skb;
1343
1344 if ((ptr->status) & STAT_OK) {
1345 DEB(DEB_TXADDR,print_eth(skb->data, "tx-done"));
1346 } else {
1347 lp->stats.tx_errors++;
1348 if ((ptr->status) & 0x0020)
1349 lp->stats.collisions++;
1350 if (!((ptr->status) & 0x0040))
1351 lp->stats.tx_heartbeat_errors++;
1352 if ((ptr->status) & 0x0400)
1353 lp->stats.tx_carrier_errors++;
1354 if ((ptr->status) & 0x0800)
1355 lp->stats.collisions++;
1356 if ((ptr->status) & 0x1000)
1357 lp->stats.tx_aborted_errors++;
1358 }
1359
1360 dev_kfree_skb_irq(skb);
1361
1362 tx_cmd->cmd.command = 0; /* Mark free */
1363 break;
1364 }
1365 case CmdTDR:
1366 {
1367 unsigned short status = ((struct tdr_cmd *)ptr)->status;
1368
1369 if (status & 0x8000) {
1370 DEB(DEB_TDR,printk(KERN_INFO "%s: link ok.\n", dev->name));
1371 } else {
1372 if (status & 0x4000)
1373 printk(KERN_ERR "%s: Transceiver problem.\n", dev->name);
1374 if (status & 0x2000)
1375 printk(KERN_ERR "%s: Termination problem.\n", dev->name);
1376 if (status & 0x1000)
1377 printk(KERN_ERR "%s: Short circuit.\n", dev->name);
1378
1379 DEB(DEB_TDR,printk(KERN_INFO "%s: Time %d.\n", dev->name, status & 0x07ff));
1380 }
1381 break;
1382 }
1383 case CmdConfigure:
1384 case CmdMulticastList:
1385 /* Zap command so set_multicast_list() knows it is free */
1386 ptr->command = 0;
1387 break;
1388 }
1389 ptr->v_next = ptr->b_next = I596_NULL;
1390 lp->last_cmd = jiffies;
1391 }
1392
1393 ptr = lp->cmd_head;
1394 while ((ptr != I596_NULL) && (ptr != lp->cmd_tail)) {
1395 ptr->command &= 0x1fff;
1396 ptr = ptr->v_next;
1397 }
1398
1399 if ((lp->cmd_head != I596_NULL))
1400 ack_cmd |= CUC_START;
1401 lp->scb.cmd = WSWAPcmd(virt_to_bus(&lp->cmd_head->status));
1402 }
1403 if ((status & 0x1000) || (status & 0x4000)) {
1404 if ((status & 0x4000))
1405 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt received a frame.\n", dev->name));
1406 i596_rx(dev);
1407 /* Only RX_START if stopped - RGH 07-07-96 */
1408 if (status & 0x1000) {
1409 if (netif_running(dev)) {
1410 DEB(DEB_ERRORS,printk(KERN_ERR "%s: i596 interrupt receive unit inactive, status 0x%x\n", dev->name, status));
1411 ack_cmd |= RX_START;
1412 lp->stats.rx_errors++;
1413 lp->stats.rx_fifo_errors++;
1414 rebuild_rx_bufs(dev);
1415 }
1416 }
1417 }
1418 wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1419 lp->scb.command = ack_cmd;
1420
1421 #ifdef ENABLE_MVME16x_NET
1422 if (MACH_IS_MVME16x) {
1423 /* Ack the interrupt */
1424
1425 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
1426
1427 pcc2[0x2a] |= 0x08;
1428 }
1429 #endif
1430 #ifdef ENABLE_BVME6000_NET
1431 if (MACH_IS_BVME6000) {
1432 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
1433
1434 *ethirq = 1;
1435 *ethirq = 3;
1436 }
1437 #endif
1438 #ifdef ENABLE_APRICOT
1439 (void) inb(ioaddr + 0x10);
1440 outb(4, ioaddr + 0xf);
1441 #endif
1442 CA(dev);
1443
1444 DEB(DEB_INTS,printk(KERN_DEBUG "%s: exiting interrupt.\n", dev->name));
1445
1446 spin_unlock (&lp->lock);
1447 return IRQ_RETVAL(handled);
1448 }
1449
1450 static int i596_close(struct net_device *dev)
1451 {
1452 struct i596_private *lp = dev->priv;
1453 unsigned long flags;
1454
1455 netif_stop_queue(dev);
1456
1457 DEB(DEB_INIT,printk(KERN_DEBUG "%s: Shutting down ethercard, status was %4.4x.\n",
1458 dev->name, lp->scb.status));
1459
1460 spin_lock_irqsave(&lp->lock, flags);
1461
1462 wait_cmd(dev,lp,100,"close1 timed out");
1463 lp->scb.command = CUC_ABORT | RX_ABORT;
1464 CA(dev);
1465
1466 wait_cmd(dev,lp,100,"close2 timed out");
1467
1468 spin_unlock_irqrestore(&lp->lock, flags);
1469 DEB(DEB_STRUCT,i596_display_data(dev));
1470 i596_cleanup_cmd(dev,lp);
1471
1472 #ifdef ENABLE_MVME16x_NET
1473 if (MACH_IS_MVME16x) {
1474 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
1475
1476 /* Disable all ints */
1477 pcc2[0x28] = 1;
1478 pcc2[0x2a] = 0x40;
1479 pcc2[0x2b] = 0x40; /* Set snooping bits now! */
1480 }
1481 #endif
1482 #ifdef ENABLE_BVME6000_NET
1483 if (MACH_IS_BVME6000) {
1484 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
1485
1486 *ethirq = 1;
1487 }
1488 #endif
1489
1490 free_irq(dev->irq, dev);
1491 remove_rx_bufs(dev);
1492
1493 return 0;
1494 }
1495
1496 static struct net_device_stats *
1497 i596_get_stats(struct net_device *dev)
1498 {
1499 struct i596_private *lp = dev->priv;
1500
1501 return &lp->stats;
1502 }
1503
1504 /*
1505 * Set or clear the multicast filter for this adaptor.
1506 */
1507
1508 static void set_multicast_list(struct net_device *dev)
1509 {
1510 struct i596_private *lp = dev->priv;
1511 int config = 0, cnt;
1512
1513 DEB(DEB_MULTI,printk(KERN_DEBUG "%s: set multicast list, %d entries, promisc %s, allmulti %s\n",
1514 dev->name, dev->mc_count,
1515 dev->flags & IFF_PROMISC ? "ON" : "OFF",
1516 dev->flags & IFF_ALLMULTI ? "ON" : "OFF"));
1517
1518 if (wait_cfg(dev, &lp->cf_cmd.cmd, 1000, "config change request timed out"))
1519 return;
1520
1521 if ((dev->flags & IFF_PROMISC) && !(lp->cf_cmd.i596_config[8] & 0x01)) {
1522 lp->cf_cmd.i596_config[8] |= 0x01;
1523 config = 1;
1524 }
1525 if (!(dev->flags & IFF_PROMISC) && (lp->cf_cmd.i596_config[8] & 0x01)) {
1526 lp->cf_cmd.i596_config[8] &= ~0x01;
1527 config = 1;
1528 }
1529 if ((dev->flags & IFF_ALLMULTI) && (lp->cf_cmd.i596_config[11] & 0x20)) {
1530 lp->cf_cmd.i596_config[11] &= ~0x20;
1531 config = 1;
1532 }
1533 if (!(dev->flags & IFF_ALLMULTI) && !(lp->cf_cmd.i596_config[11] & 0x20)) {
1534 lp->cf_cmd.i596_config[11] |= 0x20;
1535 config = 1;
1536 }
1537 if (config) {
1538 lp->cf_cmd.cmd.command = CmdConfigure;
1539 i596_add_cmd(dev, &lp->cf_cmd.cmd);
1540 }
1541
1542 cnt = dev->mc_count;
1543 if (cnt > MAX_MC_CNT)
1544 {
1545 cnt = MAX_MC_CNT;
1546 printk(KERN_ERR "%s: Only %d multicast addresses supported",
1547 dev->name, cnt);
1548 }
1549
1550 if (dev->mc_count > 0) {
1551 struct dev_mc_list *dmi;
1552 unsigned char *cp;
1553 struct mc_cmd *cmd;
1554
1555 if (wait_cfg(dev, &lp->mc_cmd.cmd, 1000, "multicast list change request timed out"))
1556 return;
1557 cmd = &lp->mc_cmd;
1558 cmd->cmd.command = CmdMulticastList;
1559 cmd->mc_cnt = dev->mc_count * 6;
1560 cp = cmd->mc_addrs;
1561 for (dmi = dev->mc_list; cnt && dmi != NULL; dmi = dmi->next, cnt--, cp += 6) {
1562 memcpy(cp, dmi->dmi_addr, 6);
1563 if (i596_debug > 1)
1564 DEB(DEB_MULTI,printk(KERN_INFO "%s: Adding address %02x:%02x:%02x:%02x:%02x:%02x\n",
1565 dev->name, cp[0],cp[1],cp[2],cp[3],cp[4],cp[5]));
1566 }
1567 i596_add_cmd(dev, &cmd->cmd);
1568 }
1569 }
1570
1571 #ifdef MODULE
1572 static struct net_device *dev_82596;
1573
1574 #ifdef ENABLE_APRICOT
1575 module_param(irq, int, 0);
1576 MODULE_PARM_DESC(irq, "Apricot IRQ number");
1577 #endif
1578
1579 static int debug = -1;
1580 module_param(debug, int, 0);
1581 MODULE_PARM_DESC(debug, "i82596 debug mask");
1582
1583 int init_module(void)
1584 {
1585 if (debug >= 0)
1586 i596_debug = debug;
1587 dev_82596 = i82596_probe(-1);
1588 if (IS_ERR(dev_82596))
1589 return PTR_ERR(dev_82596);
1590 return 0;
1591 }
1592
1593 void cleanup_module(void)
1594 {
1595 unregister_netdev(dev_82596);
1596 #ifdef __mc68000__
1597 /* XXX This assumes default cache mode to be IOMAP_FULL_CACHING,
1598 * XXX which may be invalid (CONFIG_060_WRITETHROUGH)
1599 */
1600
1601 kernel_set_cachemode((void *)(dev_82596->mem_start), 4096,
1602 IOMAP_FULL_CACHING);
1603 #endif
1604 free_page ((u32)(dev_82596->mem_start));
1605 #ifdef ENABLE_APRICOT
1606 /* If we don't do this, we can't re-insmod it later. */
1607 release_region(dev_82596->base_addr, I596_TOTAL_SIZE);
1608 #endif
1609 free_netdev(dev_82596);
1610 }
1611
1612 #endif /* MODULE */
1613 \f
1614 /*
1615 * Local variables:
1616 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 82596.c"
1617 * End:
1618 */
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree