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