1 /* lasi_82596.c -- driver for the intel 82596 ethernet controller, as
2    munged into HPPA boxen .
3 
4    This driver is based upon 82596.c, original credits are below...
5    but there were too many hoops which HP wants jumped through to
6    keep this code in there in a sane manner.
7 
8    3 primary sources of the mess --
9    1) hppa needs *lots* of cacheline flushing to keep this kind of
10    MMIO running.
11 
12    2) The 82596 needs to see all of its pointers as their physical
13    address.  Thus virt_to_bus/bus_to_virt are *everywhere*.
14 
15    3) The implementation HP is using seems to be significantly pickier
16    about when and how the command and RX units are started.  some
17    command ordering was changed.
18 
19    Examination of the mach driver leads one to believe that there
20    might be a saner way to pull this off...  anyone who feels like a
21    full rewrite can be my guest.
22 
23    Split 02/13/2000 Sam Creasey (sammy@oh.verio.com)
24 
25    02/01/2000  Initial modifications for parisc by Helge Deller (deller@gmx.de)
26    03/02/2000  changes for better/correct(?) cache-flushing (deller)
27 */
28 
29 /* 82596.c: A generic 82596 ethernet driver for linux. */
30 /*
31    Based on Apricot.c
32    Written 1994 by Mark Evans.
33    This driver is for the Apricot 82596 bus-master interface
34 
35    Modularised 12/94 Mark Evans
36 
37 
38    Modified to support the 82596 ethernet chips on 680x0 VME boards.
39    by Richard Hirst <richard@sleepie.demon.co.uk>
40    Renamed to be 82596.c
41 
42    980825:  Changed to receive directly in to sk_buffs which are
43    allocated at open() time.  Eliminates copy on incoming frames
44    (small ones are still copied).  Shared data now held in a
45    non-cached page, so we can run on 68060 in copyback mode.
46 
47    TBD:
48    * look at deferring rx frames rather than discarding (as per tulip)
49    * handle tx ring full as per tulip
50    * performance test to tune rx_copybreak
51 
52    Most of my modifications relate to the braindead big-endian
53    implementation by Intel.  When the i596 is operating in
54    'big-endian' mode, it thinks a 32 bit value of 0x12345678
55    should be stored as 0x56781234.  This is a real pain, when
56    you have linked lists which are shared by the 680x0 and the
57    i596.
58 
59    Driver skeleton
60    Written 1993 by Donald Becker.
61    Copyright 1993 United States Government as represented by the Director,
62    National Security Agency. This software may only be used and distributed
63    according to the terms of the GNU General Public License as modified by SRC,
64    incorporated herein by reference.
65 
66    The author may be reached as becker@scyld.com, or C/O
67    Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
68 
69  */
70 
71 #include <linux/module.h>
72 #include <linux/kernel.h>
73 #include <linux/string.h>
74 #include <linux/errno.h>
75 #include <linux/ioport.h>
76 #include <linux/interrupt.h>
77 #include <linux/delay.h>
78 #include <linux/netdevice.h>
79 #include <linux/etherdevice.h>
80 #include <linux/skbuff.h>
81 #include <linux/types.h>
82 #include <linux/bitops.h>
83 #include <linux/dma-mapping.h>
84 #include <linux/io.h>
85 #include <linux/irq.h>
86 #include <linux/gfp.h>
87 
88 /* DEBUG flags
89  */
90 
91 #define DEB_INIT	0x0001
92 #define DEB_PROBE	0x0002
93 #define DEB_SERIOUS	0x0004
94 #define DEB_ERRORS	0x0008
95 #define DEB_MULTI	0x0010
96 #define DEB_TDR		0x0020
97 #define DEB_OPEN	0x0040
98 #define DEB_RESET	0x0080
99 #define DEB_ADDCMD	0x0100
100 #define DEB_STATUS	0x0200
101 #define DEB_STARTTX	0x0400
102 #define DEB_RXADDR	0x0800
103 #define DEB_TXADDR	0x1000
104 #define DEB_RXFRAME	0x2000
105 #define DEB_INTS	0x4000
106 #define DEB_STRUCT	0x8000
107 #define DEB_ANY		0xffff
108 
109 
110 #define DEB(x, y)	if (i596_debug & (x)) { y; }
111 
112 
113 /*
114  * The MPU_PORT command allows direct access to the 82596. With PORT access
115  * the following commands are available (p5-18). The 32-bit port command
116  * must be word-swapped with the most significant word written first.
117  * This only applies to VME boards.
118  */
119 #define PORT_RESET		0x00	/* reset 82596 */
120 #define PORT_SELFTEST		0x01	/* selftest */
121 #define PORT_ALTSCP		0x02	/* alternate SCB address */
122 #define PORT_ALTDUMP		0x03	/* Alternate DUMP address */
123 
124 static int i596_debug = (DEB_SERIOUS|DEB_PROBE);
125 
126 /* Copy frames shorter than rx_copybreak, otherwise pass on up in
127  * a full sized sk_buff.  Value of 100 stolen from tulip.c (!alpha).
128  */
129 static int rx_copybreak = 100;
130 
131 #define PKT_BUF_SZ	1536
132 #define MAX_MC_CNT	64
133 
134 #define ISCP_BUSY	0x0001
135 
136 #define I596_NULL ((u32)0xffffffff)
137 
138 #define CMD_EOL		0x8000	/* The last command of the list, stop. */
139 #define CMD_SUSP	0x4000	/* Suspend after doing cmd. */
140 #define CMD_INTR	0x2000	/* Interrupt after doing cmd. */
141 
142 #define CMD_FLEX	0x0008	/* Enable flexible memory model */
143 
144 enum commands {
145 	CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
146 	CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7
147 };
148 
149 #define STAT_C		0x8000	/* Set to 0 after execution */
150 #define STAT_B		0x4000	/* Command being executed */
151 #define STAT_OK		0x2000	/* Command executed ok */
152 #define STAT_A		0x1000	/* Command aborted */
153 
154 #define	 CUC_START	0x0100
155 #define	 CUC_RESUME	0x0200
156 #define	 CUC_SUSPEND    0x0300
157 #define	 CUC_ABORT	0x0400
158 #define	 RX_START	0x0010
159 #define	 RX_RESUME	0x0020
160 #define	 RX_SUSPEND	0x0030
161 #define	 RX_ABORT	0x0040
162 
163 #define TX_TIMEOUT	(HZ/20)
164 
165 
166 struct i596_reg {
167 	unsigned short porthi;
168 	unsigned short portlo;
169 	u32            ca;
170 };
171 
172 #define EOF		0x8000
173 #define SIZE_MASK	0x3fff
174 
175 struct i596_tbd {
176 	unsigned short size;
177 	unsigned short pad;
178 	u32            next;
179 	u32            data;
180 	u32 cache_pad[5];		/* Total 32 bytes... */
181 };
182 
183 /* The command structure has two 'next' pointers; v_next is the address of
184  * the next command as seen by the CPU, b_next is the address of the next
185  * command as seen by the 82596.  The b_next pointer, as used by the 82596
186  * always references the status field of the next command, rather than the
187  * v_next field, because the 82596 is unaware of v_next.  It may seem more
188  * logical to put v_next at the end of the structure, but we cannot do that
189  * because the 82596 expects other fields to be there, depending on command
190  * type.
191  */
192 
193 struct i596_cmd {
194 	struct i596_cmd *v_next;	/* Address from CPUs viewpoint */
195 	unsigned short status;
196 	unsigned short command;
197 	u32            b_next;	/* Address from i596 viewpoint */
198 };
199 
200 struct tx_cmd {
201 	struct i596_cmd cmd;
202 	u32            tbd;
203 	unsigned short size;
204 	unsigned short pad;
205 	struct sk_buff *skb;		/* So we can free it after tx */
206 	dma_addr_t dma_addr;
207 #ifdef __LP64__
208 	u32 cache_pad[6];		/* Total 64 bytes... */
209 #else
210 	u32 cache_pad[1];		/* Total 32 bytes... */
211 #endif
212 };
213 
214 struct tdr_cmd {
215 	struct i596_cmd cmd;
216 	unsigned short status;
217 	unsigned short pad;
218 };
219 
220 struct mc_cmd {
221 	struct i596_cmd cmd;
222 	short mc_cnt;
223 	char mc_addrs[MAX_MC_CNT*6];
224 };
225 
226 struct sa_cmd {
227 	struct i596_cmd cmd;
228 	char eth_addr[8];
229 };
230 
231 struct cf_cmd {
232 	struct i596_cmd cmd;
233 	char i596_config[16];
234 };
235 
236 struct i596_rfd {
237 	unsigned short stat;
238 	unsigned short cmd;
239 	u32            b_next;	/* Address from i596 viewpoint */
240 	u32            rbd;
241 	unsigned short count;
242 	unsigned short size;
243 	struct i596_rfd *v_next;	/* Address from CPUs viewpoint */
244 	struct i596_rfd *v_prev;
245 #ifndef __LP64__
246 	u32 cache_pad[2];		/* Total 32 bytes... */
247 #endif
248 };
249 
250 struct i596_rbd {
251 	/* hardware data */
252 	unsigned short count;
253 	unsigned short zero1;
254 	u32            b_next;
255 	u32            b_data;		/* Address from i596 viewpoint */
256 	unsigned short size;
257 	unsigned short zero2;
258 	/* driver data */
259 	struct sk_buff *skb;
260 	struct i596_rbd *v_next;
261 	u32            b_addr;		/* This rbd addr from i596 view */
262 	unsigned char *v_data;		/* Address from CPUs viewpoint */
263 					/* Total 32 bytes... */
264 #ifdef __LP64__
265     u32 cache_pad[4];
266 #endif
267 };
268 
269 /* These values as chosen so struct i596_dma fits in one page... */
270 
271 #define TX_RING_SIZE 32
272 #define RX_RING_SIZE 16
273 
274 struct i596_scb {
275 	unsigned short status;
276 	unsigned short command;
277 	u32           cmd;
278 	u32           rfd;
279 	u32           crc_err;
280 	u32           align_err;
281 	u32           resource_err;
282 	u32           over_err;
283 	u32           rcvdt_err;
284 	u32           short_err;
285 	unsigned short t_on;
286 	unsigned short t_off;
287 };
288 
289 struct i596_iscp {
290 	u32 stat;
291 	u32 scb;
292 };
293 
294 struct i596_scp {
295 	u32 sysbus;
296 	u32 pad;
297 	u32 iscp;
298 };
299 
300 struct i596_dma {
301 	struct i596_scp scp		        __attribute__((aligned(32)));
302 	volatile struct i596_iscp iscp		__attribute__((aligned(32)));
303 	volatile struct i596_scb scb		__attribute__((aligned(32)));
304 	struct sa_cmd sa_cmd			__attribute__((aligned(32)));
305 	struct cf_cmd cf_cmd			__attribute__((aligned(32)));
306 	struct tdr_cmd tdr_cmd			__attribute__((aligned(32)));
307 	struct mc_cmd mc_cmd			__attribute__((aligned(32)));
308 	struct i596_rfd rfds[RX_RING_SIZE]	__attribute__((aligned(32)));
309 	struct i596_rbd rbds[RX_RING_SIZE]	__attribute__((aligned(32)));
310 	struct tx_cmd tx_cmds[TX_RING_SIZE]	__attribute__((aligned(32)));
311 	struct i596_tbd tbds[TX_RING_SIZE]	__attribute__((aligned(32)));
312 };
313 
314 struct i596_private {
315 	struct i596_dma *dma;
316 	u32    stat;
317 	int last_restart;
318 	struct i596_rfd *rfd_head;
319 	struct i596_rbd *rbd_head;
320 	struct i596_cmd *cmd_tail;
321 	struct i596_cmd *cmd_head;
322 	int cmd_backlog;
323 	u32    last_cmd;
324 	int next_tx_cmd;
325 	int options;
326 	spinlock_t lock;       /* serialize access to chip */
327 	dma_addr_t dma_addr;
328 	void __iomem *mpu_port;
329 	void __iomem *ca;
330 };
331 
332 static const char init_setup[] =
333 {
334 	0x8E,		/* length, prefetch on */
335 	0xC8,		/* fifo to 8, monitor off */
336 	0x80,		/* don't save bad frames */
337 	0x2E,		/* No source address insertion, 8 byte preamble */
338 	0x00,		/* priority and backoff defaults */
339 	0x60,		/* interframe spacing */
340 	0x00,		/* slot time LSB */
341 	0xf2,		/* slot time and retries */
342 	0x00,		/* promiscuous mode */
343 	0x00,		/* collision detect */
344 	0x40,		/* minimum frame length */
345 	0xff,
346 	0x00,
347 	0x7f /*  *multi IA */ };
348 
349 static int i596_open(struct net_device *dev);
350 static netdev_tx_t i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
351 static irqreturn_t i596_interrupt(int irq, void *dev_id);
352 static int i596_close(struct net_device *dev);
353 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
354 static void i596_tx_timeout (struct net_device *dev, unsigned int txqueue);
355 static void print_eth(unsigned char *buf, char *str);
356 static void set_multicast_list(struct net_device *dev);
357 static inline void ca(struct net_device *dev);
358 static void mpu_port(struct net_device *dev, int c, dma_addr_t x);
359 
360 static int rx_ring_size = RX_RING_SIZE;
361 static int ticks_limit = 100;
362 static int max_cmd_backlog = TX_RING_SIZE-1;
363 
364 #ifdef CONFIG_NET_POLL_CONTROLLER
365 static void i596_poll_controller(struct net_device *dev);
366 #endif
367 
virt_to_dma(struct i596_private * lp,volatile void * v)368 static inline dma_addr_t virt_to_dma(struct i596_private *lp, volatile void *v)
369 {
370 	return lp->dma_addr + ((unsigned long)v - (unsigned long)lp->dma);
371 }
372 
373 #ifdef NONCOHERENT_DMA
dma_sync_dev(struct net_device * ndev,volatile void * addr,size_t len)374 static inline void dma_sync_dev(struct net_device *ndev, volatile void *addr,
375 		size_t len)
376 {
377 	dma_sync_single_for_device(ndev->dev.parent,
378 			virt_to_dma(netdev_priv(ndev), addr), len,
379 			DMA_BIDIRECTIONAL);
380 }
381 
dma_sync_cpu(struct net_device * ndev,volatile void * addr,size_t len)382 static inline void dma_sync_cpu(struct net_device *ndev, volatile void *addr,
383 		size_t len)
384 {
385 	dma_sync_single_for_cpu(ndev->dev.parent,
386 			virt_to_dma(netdev_priv(ndev), addr), len,
387 			DMA_BIDIRECTIONAL);
388 }
389 #else
dma_sync_dev(struct net_device * ndev,volatile void * addr,size_t len)390 static inline void dma_sync_dev(struct net_device *ndev, volatile void *addr,
391 		size_t len)
392 {
393 }
dma_sync_cpu(struct net_device * ndev,volatile void * addr,size_t len)394 static inline void dma_sync_cpu(struct net_device *ndev, volatile void *addr,
395 		size_t len)
396 {
397 }
398 #endif /* NONCOHERENT_DMA */
399 
wait_istat(struct net_device * dev,struct i596_dma * dma,int delcnt,char * str)400 static inline int wait_istat(struct net_device *dev, struct i596_dma *dma, int delcnt, char *str)
401 {
402 	dma_sync_cpu(dev, &(dma->iscp), sizeof(struct i596_iscp));
403 	while (--delcnt && dma->iscp.stat) {
404 		udelay(10);
405 		dma_sync_cpu(dev, &(dma->iscp), sizeof(struct i596_iscp));
406 	}
407 	if (!delcnt) {
408 		printk(KERN_ERR "%s: %s, iscp.stat %04x, didn't clear\n",
409 		     dev->name, str, SWAP16(dma->iscp.stat));
410 		return -1;
411 	} else
412 		return 0;
413 }
414 
415 
wait_cmd(struct net_device * dev,struct i596_dma * dma,int delcnt,char * str)416 static inline int wait_cmd(struct net_device *dev, struct i596_dma *dma, int delcnt, char *str)
417 {
418 	dma_sync_cpu(dev, &(dma->scb), sizeof(struct i596_scb));
419 	while (--delcnt && dma->scb.command) {
420 		udelay(10);
421 		dma_sync_cpu(dev, &(dma->scb), sizeof(struct i596_scb));
422 	}
423 	if (!delcnt) {
424 		printk(KERN_ERR "%s: %s, status %4.4x, cmd %4.4x.\n",
425 		       dev->name, str,
426 		       SWAP16(dma->scb.status),
427 		       SWAP16(dma->scb.command));
428 		return -1;
429 	} else
430 		return 0;
431 }
432 
433 
i596_display_data(struct net_device * dev)434 static void i596_display_data(struct net_device *dev)
435 {
436 	struct i596_private *lp = netdev_priv(dev);
437 	struct i596_dma *dma = lp->dma;
438 	struct i596_cmd *cmd;
439 	struct i596_rfd *rfd;
440 	struct i596_rbd *rbd;
441 
442 	printk(KERN_DEBUG "lp and scp at %p, .sysbus = %08x, .iscp = %08x\n",
443 	       &dma->scp, dma->scp.sysbus, SWAP32(dma->scp.iscp));
444 	printk(KERN_DEBUG "iscp at %p, iscp.stat = %08x, .scb = %08x\n",
445 	       &dma->iscp, SWAP32(dma->iscp.stat), SWAP32(dma->iscp.scb));
446 	printk(KERN_DEBUG "scb at %p, scb.status = %04x, .command = %04x,"
447 		" .cmd = %08x, .rfd = %08x\n",
448 	       &dma->scb, SWAP16(dma->scb.status), SWAP16(dma->scb.command),
449 		SWAP16(dma->scb.cmd), SWAP32(dma->scb.rfd));
450 	printk(KERN_DEBUG "   errors: crc %x, align %x, resource %x,"
451 	       " over %x, rcvdt %x, short %x\n",
452 	       SWAP32(dma->scb.crc_err), SWAP32(dma->scb.align_err),
453 	       SWAP32(dma->scb.resource_err), SWAP32(dma->scb.over_err),
454 	       SWAP32(dma->scb.rcvdt_err), SWAP32(dma->scb.short_err));
455 	cmd = lp->cmd_head;
456 	while (cmd != NULL) {
457 		printk(KERN_DEBUG
458 		       "cmd at %p, .status = %04x, .command = %04x,"
459 		       " .b_next = %08x\n",
460 		       cmd, SWAP16(cmd->status), SWAP16(cmd->command),
461 		       SWAP32(cmd->b_next));
462 		cmd = cmd->v_next;
463 	}
464 	rfd = lp->rfd_head;
465 	printk(KERN_DEBUG "rfd_head = %p\n", rfd);
466 	do {
467 		printk(KERN_DEBUG
468 		       "   %p .stat %04x, .cmd %04x, b_next %08x, rbd %08x,"
469 		       " count %04x\n",
470 		       rfd, SWAP16(rfd->stat), SWAP16(rfd->cmd),
471 		       SWAP32(rfd->b_next), SWAP32(rfd->rbd),
472 		       SWAP16(rfd->count));
473 		rfd = rfd->v_next;
474 	} while (rfd != lp->rfd_head);
475 	rbd = lp->rbd_head;
476 	printk(KERN_DEBUG "rbd_head = %p\n", rbd);
477 	do {
478 		printk(KERN_DEBUG
479 		       "   %p .count %04x, b_next %08x, b_data %08x,"
480 		       " size %04x\n",
481 			rbd, SWAP16(rbd->count), SWAP32(rbd->b_next),
482 		       SWAP32(rbd->b_data), SWAP16(rbd->size));
483 		rbd = rbd->v_next;
484 	} while (rbd != lp->rbd_head);
485 	dma_sync_cpu(dev, dma, sizeof(struct i596_dma));
486 }
487 
init_rx_bufs(struct net_device * dev)488 static inline int init_rx_bufs(struct net_device *dev)
489 {
490 	struct i596_private *lp = netdev_priv(dev);
491 	struct i596_dma *dma = lp->dma;
492 	int i;
493 	struct i596_rfd *rfd;
494 	struct i596_rbd *rbd;
495 
496 	/* First build the Receive Buffer Descriptor List */
497 
498 	for (i = 0, rbd = dma->rbds; i < rx_ring_size; i++, rbd++) {
499 		dma_addr_t dma_addr;
500 		struct sk_buff *skb;
501 
502 		skb = netdev_alloc_skb_ip_align(dev, PKT_BUF_SZ);
503 		if (skb == NULL)
504 			return -1;
505 		dma_addr = dma_map_single(dev->dev.parent, skb->data,
506 					  PKT_BUF_SZ, DMA_FROM_DEVICE);
507 		rbd->v_next = rbd+1;
508 		rbd->b_next = SWAP32(virt_to_dma(lp, rbd+1));
509 		rbd->b_addr = SWAP32(virt_to_dma(lp, rbd));
510 		rbd->skb = skb;
511 		rbd->v_data = skb->data;
512 		rbd->b_data = SWAP32(dma_addr);
513 		rbd->size = SWAP16(PKT_BUF_SZ);
514 	}
515 	lp->rbd_head = dma->rbds;
516 	rbd = dma->rbds + rx_ring_size - 1;
517 	rbd->v_next = dma->rbds;
518 	rbd->b_next = SWAP32(virt_to_dma(lp, dma->rbds));
519 
520 	/* Now build the Receive Frame Descriptor List */
521 
522 	for (i = 0, rfd = dma->rfds; i < rx_ring_size; i++, rfd++) {
523 		rfd->rbd = I596_NULL;
524 		rfd->v_next = rfd+1;
525 		rfd->v_prev = rfd-1;
526 		rfd->b_next = SWAP32(virt_to_dma(lp, rfd+1));
527 		rfd->cmd = SWAP16(CMD_FLEX);
528 	}
529 	lp->rfd_head = dma->rfds;
530 	dma->scb.rfd = SWAP32(virt_to_dma(lp, dma->rfds));
531 	rfd = dma->rfds;
532 	rfd->rbd = SWAP32(virt_to_dma(lp, lp->rbd_head));
533 	rfd->v_prev = dma->rfds + rx_ring_size - 1;
534 	rfd = dma->rfds + rx_ring_size - 1;
535 	rfd->v_next = dma->rfds;
536 	rfd->b_next = SWAP32(virt_to_dma(lp, dma->rfds));
537 	rfd->cmd = SWAP16(CMD_EOL|CMD_FLEX);
538 
539 	dma_sync_dev(dev, dma, sizeof(struct i596_dma));
540 	return 0;
541 }
542 
remove_rx_bufs(struct net_device * dev)543 static inline void remove_rx_bufs(struct net_device *dev)
544 {
545 	struct i596_private *lp = netdev_priv(dev);
546 	struct i596_rbd *rbd;
547 	int i;
548 
549 	for (i = 0, rbd = lp->dma->rbds; i < rx_ring_size; i++, rbd++) {
550 		if (rbd->skb == NULL)
551 			break;
552 		dma_unmap_single(dev->dev.parent,
553 				 (dma_addr_t)SWAP32(rbd->b_data),
554 				 PKT_BUF_SZ, DMA_FROM_DEVICE);
555 		dev_kfree_skb(rbd->skb);
556 	}
557 }
558 
559 
rebuild_rx_bufs(struct net_device * dev)560 static void rebuild_rx_bufs(struct net_device *dev)
561 {
562 	struct i596_private *lp = netdev_priv(dev);
563 	struct i596_dma *dma = lp->dma;
564 	int i;
565 
566 	/* Ensure rx frame/buffer descriptors are tidy */
567 
568 	for (i = 0; i < rx_ring_size; i++) {
569 		dma->rfds[i].rbd = I596_NULL;
570 		dma->rfds[i].cmd = SWAP16(CMD_FLEX);
571 	}
572 	dma->rfds[rx_ring_size-1].cmd = SWAP16(CMD_EOL|CMD_FLEX);
573 	lp->rfd_head = dma->rfds;
574 	dma->scb.rfd = SWAP32(virt_to_dma(lp, dma->rfds));
575 	lp->rbd_head = dma->rbds;
576 	dma->rfds[0].rbd = SWAP32(virt_to_dma(lp, dma->rbds));
577 
578 	dma_sync_dev(dev, dma, sizeof(struct i596_dma));
579 }
580 
581 
init_i596_mem(struct net_device * dev)582 static int init_i596_mem(struct net_device *dev)
583 {
584 	struct i596_private *lp = netdev_priv(dev);
585 	struct i596_dma *dma = lp->dma;
586 	unsigned long flags;
587 
588 	mpu_port(dev, PORT_RESET, 0);
589 	udelay(100);			/* Wait 100us - seems to help */
590 
591 	/* change the scp address */
592 
593 	lp->last_cmd = jiffies;
594 
595 	dma->scp.sysbus = SYSBUS;
596 	dma->scp.iscp = SWAP32(virt_to_dma(lp, &(dma->iscp)));
597 	dma->iscp.scb = SWAP32(virt_to_dma(lp, &(dma->scb)));
598 	dma->iscp.stat = SWAP32(ISCP_BUSY);
599 	lp->cmd_backlog = 0;
600 
601 	lp->cmd_head = NULL;
602 	dma->scb.cmd = I596_NULL;
603 
604 	DEB(DEB_INIT, printk(KERN_DEBUG "%s: starting i82596.\n", dev->name));
605 
606 	dma_sync_dev(dev, &(dma->scp), sizeof(struct i596_scp));
607 	dma_sync_dev(dev, &(dma->iscp), sizeof(struct i596_iscp));
608 	dma_sync_dev(dev, &(dma->scb), sizeof(struct i596_scb));
609 
610 	mpu_port(dev, PORT_ALTSCP, virt_to_dma(lp, &dma->scp));
611 	ca(dev);
612 	if (wait_istat(dev, dma, 1000, "initialization timed out"))
613 		goto failed;
614 	DEB(DEB_INIT, printk(KERN_DEBUG
615 			     "%s: i82596 initialization successful\n",
616 			     dev->name));
617 
618 	if (request_irq(dev->irq, i596_interrupt, 0, "i82596", dev)) {
619 		printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
620 		goto failed;
621 	}
622 
623 	/* Ensure rx frame/buffer descriptors are tidy */
624 	rebuild_rx_bufs(dev);
625 
626 	dma->scb.command = 0;
627 	dma_sync_dev(dev, &(dma->scb), sizeof(struct i596_scb));
628 
629 	DEB(DEB_INIT, printk(KERN_DEBUG
630 			     "%s: queuing CmdConfigure\n", dev->name));
631 	memcpy(dma->cf_cmd.i596_config, init_setup, 14);
632 	dma->cf_cmd.cmd.command = SWAP16(CmdConfigure);
633 	dma_sync_dev(dev, &(dma->cf_cmd), sizeof(struct cf_cmd));
634 	i596_add_cmd(dev, &dma->cf_cmd.cmd);
635 
636 	DEB(DEB_INIT, printk(KERN_DEBUG "%s: queuing CmdSASetup\n", dev->name));
637 	memcpy(dma->sa_cmd.eth_addr, dev->dev_addr, ETH_ALEN);
638 	dma->sa_cmd.cmd.command = SWAP16(CmdSASetup);
639 	dma_sync_dev(dev, &(dma->sa_cmd), sizeof(struct sa_cmd));
640 	i596_add_cmd(dev, &dma->sa_cmd.cmd);
641 
642 	DEB(DEB_INIT, printk(KERN_DEBUG "%s: queuing CmdTDR\n", dev->name));
643 	dma->tdr_cmd.cmd.command = SWAP16(CmdTDR);
644 	dma_sync_dev(dev, &(dma->tdr_cmd), sizeof(struct tdr_cmd));
645 	i596_add_cmd(dev, &dma->tdr_cmd.cmd);
646 
647 	spin_lock_irqsave (&lp->lock, flags);
648 
649 	if (wait_cmd(dev, dma, 1000, "timed out waiting to issue RX_START")) {
650 		spin_unlock_irqrestore (&lp->lock, flags);
651 		goto failed_free_irq;
652 	}
653 	DEB(DEB_INIT, printk(KERN_DEBUG "%s: Issuing RX_START\n", dev->name));
654 	dma->scb.command = SWAP16(RX_START);
655 	dma->scb.rfd = SWAP32(virt_to_dma(lp, dma->rfds));
656 	dma_sync_dev(dev, &(dma->scb), sizeof(struct i596_scb));
657 
658 	ca(dev);
659 
660 	spin_unlock_irqrestore (&lp->lock, flags);
661 	if (wait_cmd(dev, dma, 1000, "RX_START not processed"))
662 		goto failed_free_irq;
663 	DEB(DEB_INIT, printk(KERN_DEBUG
664 			     "%s: Receive unit started OK\n", dev->name));
665 	return 0;
666 
667 failed_free_irq:
668 	free_irq(dev->irq, dev);
669 failed:
670 	printk(KERN_ERR "%s: Failed to initialise 82596\n", dev->name);
671 	mpu_port(dev, PORT_RESET, 0);
672 	return -1;
673 }
674 
675 
i596_rx(struct net_device * dev)676 static inline int i596_rx(struct net_device *dev)
677 {
678 	struct i596_private *lp = netdev_priv(dev);
679 	struct i596_rfd *rfd;
680 	struct i596_rbd *rbd;
681 	int frames = 0;
682 
683 	DEB(DEB_RXFRAME, printk(KERN_DEBUG
684 				"i596_rx(), rfd_head %p, rbd_head %p\n",
685 				lp->rfd_head, lp->rbd_head));
686 
687 
688 	rfd = lp->rfd_head;		/* Ref next frame to check */
689 
690 	dma_sync_cpu(dev, rfd, sizeof(struct i596_rfd));
691 	while (rfd->stat & SWAP16(STAT_C)) {	/* Loop while complete frames */
692 		if (rfd->rbd == I596_NULL)
693 			rbd = NULL;
694 		else if (rfd->rbd == lp->rbd_head->b_addr) {
695 			rbd = lp->rbd_head;
696 			dma_sync_cpu(dev, rbd, sizeof(struct i596_rbd));
697 		} else {
698 			printk(KERN_ERR "%s: rbd chain broken!\n", dev->name);
699 			/* XXX Now what? */
700 			rbd = NULL;
701 		}
702 		DEB(DEB_RXFRAME, printk(KERN_DEBUG
703 				      "  rfd %p, rfd.rbd %08x, rfd.stat %04x\n",
704 				      rfd, rfd->rbd, rfd->stat));
705 
706 		if (rbd != NULL && (rfd->stat & SWAP16(STAT_OK))) {
707 			/* a good frame */
708 			int pkt_len = SWAP16(rbd->count) & 0x3fff;
709 			struct sk_buff *skb = rbd->skb;
710 			int rx_in_place = 0;
711 
712 			DEB(DEB_RXADDR, print_eth(rbd->v_data, "received"));
713 			frames++;
714 
715 			/* Check if the packet is long enough to just accept
716 			 * without copying to a properly sized skbuff.
717 			 */
718 
719 			if (pkt_len > rx_copybreak) {
720 				struct sk_buff *newskb;
721 				dma_addr_t dma_addr;
722 
723 				dma_unmap_single(dev->dev.parent,
724 						 (dma_addr_t)SWAP32(rbd->b_data),
725 						 PKT_BUF_SZ, DMA_FROM_DEVICE);
726 				/* Get fresh skbuff to replace filled one. */
727 				newskb = netdev_alloc_skb_ip_align(dev,
728 								   PKT_BUF_SZ);
729 				if (newskb == NULL) {
730 					skb = NULL;	/* drop pkt */
731 					goto memory_squeeze;
732 				}
733 
734 				/* Pass up the skb already on the Rx ring. */
735 				skb_put(skb, pkt_len);
736 				rx_in_place = 1;
737 				rbd->skb = newskb;
738 				dma_addr = dma_map_single(dev->dev.parent,
739 							  newskb->data,
740 							  PKT_BUF_SZ,
741 							  DMA_FROM_DEVICE);
742 				rbd->v_data = newskb->data;
743 				rbd->b_data = SWAP32(dma_addr);
744 				dma_sync_dev(dev, rbd, sizeof(struct i596_rbd));
745 			} else {
746 				skb = netdev_alloc_skb_ip_align(dev, pkt_len);
747 			}
748 memory_squeeze:
749 			if (skb == NULL) {
750 				/* XXX tulip.c can defer packets here!! */
751 				dev->stats.rx_dropped++;
752 			} else {
753 				if (!rx_in_place) {
754 					/* 16 byte align the data fields */
755 					dma_sync_single_for_cpu(dev->dev.parent,
756 								(dma_addr_t)SWAP32(rbd->b_data),
757 								PKT_BUF_SZ, DMA_FROM_DEVICE);
758 					skb_put_data(skb, rbd->v_data,
759 						     pkt_len);
760 					dma_sync_single_for_device(dev->dev.parent,
761 								   (dma_addr_t)SWAP32(rbd->b_data),
762 								   PKT_BUF_SZ, DMA_FROM_DEVICE);
763 				}
764 				skb->len = pkt_len;
765 				skb->protocol = eth_type_trans(skb, dev);
766 				netif_rx(skb);
767 				dev->stats.rx_packets++;
768 				dev->stats.rx_bytes += pkt_len;
769 			}
770 		} else {
771 			DEB(DEB_ERRORS, printk(KERN_DEBUG
772 					       "%s: Error, rfd.stat = 0x%04x\n",
773 					       dev->name, rfd->stat));
774 			dev->stats.rx_errors++;
775 			if (rfd->stat & SWAP16(0x0100))
776 				dev->stats.collisions++;
777 			if (rfd->stat & SWAP16(0x8000))
778 				dev->stats.rx_length_errors++;
779 			if (rfd->stat & SWAP16(0x0001))
780 				dev->stats.rx_over_errors++;
781 			if (rfd->stat & SWAP16(0x0002))
782 				dev->stats.rx_fifo_errors++;
783 			if (rfd->stat & SWAP16(0x0004))
784 				dev->stats.rx_frame_errors++;
785 			if (rfd->stat & SWAP16(0x0008))
786 				dev->stats.rx_crc_errors++;
787 			if (rfd->stat & SWAP16(0x0010))
788 				dev->stats.rx_length_errors++;
789 		}
790 
791 		/* Clear the buffer descriptor count and EOF + F flags */
792 
793 		if (rbd != NULL && (rbd->count & SWAP16(0x4000))) {
794 			rbd->count = 0;
795 			lp->rbd_head = rbd->v_next;
796 			dma_sync_dev(dev, rbd, sizeof(struct i596_rbd));
797 		}
798 
799 		/* Tidy the frame descriptor, marking it as end of list */
800 
801 		rfd->rbd = I596_NULL;
802 		rfd->stat = 0;
803 		rfd->cmd = SWAP16(CMD_EOL|CMD_FLEX);
804 		rfd->count = 0;
805 
806 		/* Update record of next frame descriptor to process */
807 
808 		lp->dma->scb.rfd = rfd->b_next;
809 		lp->rfd_head = rfd->v_next;
810 		dma_sync_dev(dev, rfd, sizeof(struct i596_rfd));
811 
812 		/* Remove end-of-list from old end descriptor */
813 
814 		rfd->v_prev->cmd = SWAP16(CMD_FLEX);
815 		dma_sync_dev(dev, rfd->v_prev, sizeof(struct i596_rfd));
816 		rfd = lp->rfd_head;
817 		dma_sync_cpu(dev, rfd, sizeof(struct i596_rfd));
818 	}
819 
820 	DEB(DEB_RXFRAME, printk(KERN_DEBUG "frames %d\n", frames));
821 
822 	return 0;
823 }
824 
825 
i596_cleanup_cmd(struct net_device * dev,struct i596_private * lp)826 static inline void i596_cleanup_cmd(struct net_device *dev, struct i596_private *lp)
827 {
828 	struct i596_cmd *ptr;
829 
830 	while (lp->cmd_head != NULL) {
831 		ptr = lp->cmd_head;
832 		lp->cmd_head = ptr->v_next;
833 		lp->cmd_backlog--;
834 
835 		switch (SWAP16(ptr->command) & 0x7) {
836 		case CmdTx:
837 			{
838 				struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
839 				struct sk_buff *skb = tx_cmd->skb;
840 				dma_unmap_single(dev->dev.parent,
841 						 tx_cmd->dma_addr,
842 						 skb->len, DMA_TO_DEVICE);
843 
844 				dev_kfree_skb(skb);
845 
846 				dev->stats.tx_errors++;
847 				dev->stats.tx_aborted_errors++;
848 
849 				ptr->v_next = NULL;
850 				ptr->b_next = I596_NULL;
851 				tx_cmd->cmd.command = 0;  /* Mark as free */
852 				break;
853 			}
854 		default:
855 			ptr->v_next = NULL;
856 			ptr->b_next = I596_NULL;
857 		}
858 		dma_sync_dev(dev, ptr, sizeof(struct i596_cmd));
859 	}
860 
861 	wait_cmd(dev, lp->dma, 100, "i596_cleanup_cmd timed out");
862 	lp->dma->scb.cmd = I596_NULL;
863 	dma_sync_dev(dev, &(lp->dma->scb), sizeof(struct i596_scb));
864 }
865 
866 
i596_reset(struct net_device * dev,struct i596_private * lp)867 static inline void i596_reset(struct net_device *dev, struct i596_private *lp)
868 {
869 	unsigned long flags;
870 
871 	DEB(DEB_RESET, printk(KERN_DEBUG "i596_reset\n"));
872 
873 	spin_lock_irqsave (&lp->lock, flags);
874 
875 	wait_cmd(dev, lp->dma, 100, "i596_reset timed out");
876 
877 	netif_stop_queue(dev);
878 
879 	/* FIXME: this command might cause an lpmc */
880 	lp->dma->scb.command = SWAP16(CUC_ABORT | RX_ABORT);
881 	dma_sync_dev(dev, &(lp->dma->scb), sizeof(struct i596_scb));
882 	ca(dev);
883 
884 	/* wait for shutdown */
885 	wait_cmd(dev, lp->dma, 1000, "i596_reset 2 timed out");
886 	spin_unlock_irqrestore (&lp->lock, flags);
887 
888 	i596_cleanup_cmd(dev, lp);
889 	i596_rx(dev);
890 
891 	netif_start_queue(dev);
892 	init_i596_mem(dev);
893 }
894 
895 
i596_add_cmd(struct net_device * dev,struct i596_cmd * cmd)896 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd)
897 {
898 	struct i596_private *lp = netdev_priv(dev);
899 	struct i596_dma *dma = lp->dma;
900 	unsigned long flags;
901 
902 	DEB(DEB_ADDCMD, printk(KERN_DEBUG "i596_add_cmd cmd_head %p\n",
903 			       lp->cmd_head));
904 
905 	cmd->status = 0;
906 	cmd->command |= SWAP16(CMD_EOL | CMD_INTR);
907 	cmd->v_next = NULL;
908 	cmd->b_next = I596_NULL;
909 	dma_sync_dev(dev, cmd, sizeof(struct i596_cmd));
910 
911 	spin_lock_irqsave (&lp->lock, flags);
912 
913 	if (lp->cmd_head != NULL) {
914 		lp->cmd_tail->v_next = cmd;
915 		lp->cmd_tail->b_next = SWAP32(virt_to_dma(lp, &cmd->status));
916 		dma_sync_dev(dev, lp->cmd_tail, sizeof(struct i596_cmd));
917 	} else {
918 		lp->cmd_head = cmd;
919 		wait_cmd(dev, dma, 100, "i596_add_cmd timed out");
920 		dma->scb.cmd = SWAP32(virt_to_dma(lp, &cmd->status));
921 		dma->scb.command = SWAP16(CUC_START);
922 		dma_sync_dev(dev, &(dma->scb), sizeof(struct i596_scb));
923 		ca(dev);
924 	}
925 	lp->cmd_tail = cmd;
926 	lp->cmd_backlog++;
927 
928 	spin_unlock_irqrestore (&lp->lock, flags);
929 
930 	if (lp->cmd_backlog > max_cmd_backlog) {
931 		unsigned long tickssofar = jiffies - lp->last_cmd;
932 
933 		if (tickssofar < ticks_limit)
934 			return;
935 
936 		printk(KERN_ERR
937 		       "%s: command unit timed out, status resetting.\n",
938 		       dev->name);
939 #if 1
940 		i596_reset(dev, lp);
941 #endif
942 	}
943 }
944 
i596_open(struct net_device * dev)945 static int i596_open(struct net_device *dev)
946 {
947 	DEB(DEB_OPEN, printk(KERN_DEBUG
948 			     "%s: i596_open() irq %d.\n", dev->name, dev->irq));
949 
950 	if (init_rx_bufs(dev)) {
951 		printk(KERN_ERR "%s: Failed to init rx bufs\n", dev->name);
952 		return -EAGAIN;
953 	}
954 	if (init_i596_mem(dev)) {
955 		printk(KERN_ERR "%s: Failed to init memory\n", dev->name);
956 		goto out_remove_rx_bufs;
957 	}
958 	netif_start_queue(dev);
959 
960 	return 0;
961 
962 out_remove_rx_bufs:
963 	remove_rx_bufs(dev);
964 	return -EAGAIN;
965 }
966 
i596_tx_timeout(struct net_device * dev,unsigned int txqueue)967 static void i596_tx_timeout (struct net_device *dev, unsigned int txqueue)
968 {
969 	struct i596_private *lp = netdev_priv(dev);
970 
971 	/* Transmitter timeout, serious problems. */
972 	DEB(DEB_ERRORS, printk(KERN_DEBUG
973 			       "%s: transmit timed out, status resetting.\n",
974 			       dev->name));
975 
976 	dev->stats.tx_errors++;
977 
978 	/* Try to restart the adaptor */
979 	if (lp->last_restart == dev->stats.tx_packets) {
980 		DEB(DEB_ERRORS, printk(KERN_DEBUG "Resetting board.\n"));
981 		/* Shutdown and restart */
982 		i596_reset (dev, lp);
983 	} else {
984 		/* Issue a channel attention signal */
985 		DEB(DEB_ERRORS, printk(KERN_DEBUG "Kicking board.\n"));
986 		lp->dma->scb.command = SWAP16(CUC_START | RX_START);
987 		dma_sync_dev(dev, &(lp->dma->scb), sizeof(struct i596_scb));
988 		ca (dev);
989 		lp->last_restart = dev->stats.tx_packets;
990 	}
991 
992 	netif_trans_update(dev); /* prevent tx timeout */
993 	netif_wake_queue (dev);
994 }
995 
996 
i596_start_xmit(struct sk_buff * skb,struct net_device * dev)997 static netdev_tx_t i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
998 {
999 	struct i596_private *lp = netdev_priv(dev);
1000 	struct tx_cmd *tx_cmd;
1001 	struct i596_tbd *tbd;
1002 	short length = skb->len;
1003 
1004 	DEB(DEB_STARTTX, printk(KERN_DEBUG
1005 				"%s: i596_start_xmit(%x,%p) called\n",
1006 				dev->name, skb->len, skb->data));
1007 
1008 	if (length < ETH_ZLEN) {
1009 		if (skb_padto(skb, ETH_ZLEN))
1010 			return NETDEV_TX_OK;
1011 		length = ETH_ZLEN;
1012 	}
1013 
1014 	netif_stop_queue(dev);
1015 
1016 	tx_cmd = lp->dma->tx_cmds + lp->next_tx_cmd;
1017 	tbd = lp->dma->tbds + lp->next_tx_cmd;
1018 
1019 	if (tx_cmd->cmd.command) {
1020 		DEB(DEB_ERRORS, printk(KERN_DEBUG
1021 				       "%s: xmit ring full, dropping packet.\n",
1022 				       dev->name));
1023 		dev->stats.tx_dropped++;
1024 
1025 		dev_kfree_skb_any(skb);
1026 	} else {
1027 		if (++lp->next_tx_cmd == TX_RING_SIZE)
1028 			lp->next_tx_cmd = 0;
1029 		tx_cmd->tbd = SWAP32(virt_to_dma(lp, tbd));
1030 		tbd->next = I596_NULL;
1031 
1032 		tx_cmd->cmd.command = SWAP16(CMD_FLEX | CmdTx);
1033 		tx_cmd->skb = skb;
1034 
1035 		tx_cmd->pad = 0;
1036 		tx_cmd->size = 0;
1037 		tbd->pad = 0;
1038 		tbd->size = SWAP16(EOF | length);
1039 
1040 		tx_cmd->dma_addr = dma_map_single(dev->dev.parent, skb->data,
1041 						  skb->len, DMA_TO_DEVICE);
1042 		tbd->data = SWAP32(tx_cmd->dma_addr);
1043 
1044 		DEB(DEB_TXADDR, print_eth(skb->data, "tx-queued"));
1045 		dma_sync_dev(dev, tx_cmd, sizeof(struct tx_cmd));
1046 		dma_sync_dev(dev, tbd, sizeof(struct i596_tbd));
1047 		i596_add_cmd(dev, &tx_cmd->cmd);
1048 
1049 		dev->stats.tx_packets++;
1050 		dev->stats.tx_bytes += length;
1051 	}
1052 
1053 	netif_start_queue(dev);
1054 
1055 	return NETDEV_TX_OK;
1056 }
1057 
print_eth(unsigned char * add,char * str)1058 static void print_eth(unsigned char *add, char *str)
1059 {
1060 	printk(KERN_DEBUG "i596 0x%p, %pM --> %pM %02X%02X, %s\n",
1061 	       add, add + 6, add, add[12], add[13], str);
1062 }
1063 static const struct net_device_ops i596_netdev_ops = {
1064 	.ndo_open		= i596_open,
1065 	.ndo_stop		= i596_close,
1066 	.ndo_start_xmit		= i596_start_xmit,
1067 	.ndo_set_rx_mode	= set_multicast_list,
1068 	.ndo_tx_timeout		= i596_tx_timeout,
1069 	.ndo_validate_addr	= eth_validate_addr,
1070 	.ndo_set_mac_address	= eth_mac_addr,
1071 #ifdef CONFIG_NET_POLL_CONTROLLER
1072 	.ndo_poll_controller	= i596_poll_controller,
1073 #endif
1074 };
1075 
i82596_probe(struct net_device * dev)1076 static int i82596_probe(struct net_device *dev)
1077 {
1078 	struct i596_private *lp = netdev_priv(dev);
1079 	int ret;
1080 
1081 	/* This lot is ensure things have been cache line aligned. */
1082 	BUILD_BUG_ON(sizeof(struct i596_rfd) != 32);
1083 	BUILD_BUG_ON(sizeof(struct i596_rbd) &  31);
1084 	BUILD_BUG_ON(sizeof(struct tx_cmd)   &  31);
1085 	BUILD_BUG_ON(sizeof(struct i596_tbd) != 32);
1086 #ifndef __LP64__
1087 	BUILD_BUG_ON(sizeof(struct i596_dma) > 4096);
1088 #endif
1089 
1090 	if (!dev->base_addr || !dev->irq)
1091 		return -ENODEV;
1092 
1093 	dev->netdev_ops = &i596_netdev_ops;
1094 	dev->watchdog_timeo = TX_TIMEOUT;
1095 
1096 	memset(lp->dma, 0, sizeof(struct i596_dma));
1097 	lp->dma->scb.command = 0;
1098 	lp->dma->scb.cmd = I596_NULL;
1099 	lp->dma->scb.rfd = I596_NULL;
1100 	spin_lock_init(&lp->lock);
1101 
1102 	dma_sync_dev(dev, lp->dma, sizeof(struct i596_dma));
1103 
1104 	ret = register_netdev(dev);
1105 	if (ret)
1106 		return ret;
1107 
1108 	DEB(DEB_PROBE, printk(KERN_INFO "%s: 82596 at %#3lx, %pM IRQ %d.\n",
1109 			      dev->name, dev->base_addr, dev->dev_addr,
1110 			      dev->irq));
1111 	DEB(DEB_INIT, printk(KERN_INFO
1112 			     "%s: dma at 0x%p (%d bytes), lp->scb at 0x%p\n",
1113 			     dev->name, lp->dma, (int)sizeof(struct i596_dma),
1114 			     &lp->dma->scb));
1115 
1116 	return 0;
1117 }
1118 
1119 #ifdef CONFIG_NET_POLL_CONTROLLER
i596_poll_controller(struct net_device * dev)1120 static void i596_poll_controller(struct net_device *dev)
1121 {
1122 	disable_irq(dev->irq);
1123 	i596_interrupt(dev->irq, dev);
1124 	enable_irq(dev->irq);
1125 }
1126 #endif
1127 
i596_interrupt(int irq,void * dev_id)1128 static irqreturn_t i596_interrupt(int irq, void *dev_id)
1129 {
1130 	struct net_device *dev = dev_id;
1131 	struct i596_private *lp;
1132 	struct i596_dma *dma;
1133 	unsigned short status, ack_cmd = 0;
1134 
1135 	lp = netdev_priv(dev);
1136 	dma = lp->dma;
1137 
1138 	spin_lock (&lp->lock);
1139 
1140 	wait_cmd(dev, dma, 100, "i596 interrupt, timeout");
1141 	status = SWAP16(dma->scb.status);
1142 
1143 	DEB(DEB_INTS, printk(KERN_DEBUG
1144 			     "%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1145 			dev->name, dev->irq, status));
1146 
1147 	ack_cmd = status & 0xf000;
1148 
1149 	if (!ack_cmd) {
1150 		DEB(DEB_ERRORS, printk(KERN_DEBUG
1151 				       "%s: interrupt with no events\n",
1152 				       dev->name));
1153 		spin_unlock (&lp->lock);
1154 		return IRQ_NONE;
1155 	}
1156 
1157 	if ((status & 0x8000) || (status & 0x2000)) {
1158 		struct i596_cmd *ptr;
1159 
1160 		if ((status & 0x8000))
1161 			DEB(DEB_INTS,
1162 			    printk(KERN_DEBUG
1163 				   "%s: i596 interrupt completed command.\n",
1164 				   dev->name));
1165 		if ((status & 0x2000))
1166 			DEB(DEB_INTS,
1167 			    printk(KERN_DEBUG
1168 				   "%s: i596 interrupt command unit inactive %x.\n",
1169 				   dev->name, status & 0x0700));
1170 
1171 		while (lp->cmd_head != NULL) {
1172 			dma_sync_cpu(dev, lp->cmd_head, sizeof(struct i596_cmd));
1173 			if (!(lp->cmd_head->status & SWAP16(STAT_C)))
1174 				break;
1175 
1176 			ptr = lp->cmd_head;
1177 
1178 			DEB(DEB_STATUS,
1179 			    printk(KERN_DEBUG
1180 				   "cmd_head->status = %04x, ->command = %04x\n",
1181 				   SWAP16(lp->cmd_head->status),
1182 				   SWAP16(lp->cmd_head->command)));
1183 			lp->cmd_head = ptr->v_next;
1184 			lp->cmd_backlog--;
1185 
1186 			switch (SWAP16(ptr->command) & 0x7) {
1187 			case CmdTx:
1188 			    {
1189 				struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
1190 				struct sk_buff *skb = tx_cmd->skb;
1191 
1192 				if (ptr->status & SWAP16(STAT_OK)) {
1193 					DEB(DEB_TXADDR,
1194 					    print_eth(skb->data, "tx-done"));
1195 				} else {
1196 					dev->stats.tx_errors++;
1197 					if (ptr->status & SWAP16(0x0020))
1198 						dev->stats.collisions++;
1199 					if (!(ptr->status & SWAP16(0x0040)))
1200 						dev->stats.tx_heartbeat_errors++;
1201 					if (ptr->status & SWAP16(0x0400))
1202 						dev->stats.tx_carrier_errors++;
1203 					if (ptr->status & SWAP16(0x0800))
1204 						dev->stats.collisions++;
1205 					if (ptr->status & SWAP16(0x1000))
1206 						dev->stats.tx_aborted_errors++;
1207 				}
1208 				dma_unmap_single(dev->dev.parent,
1209 						 tx_cmd->dma_addr,
1210 						 skb->len, DMA_TO_DEVICE);
1211 				dev_consume_skb_irq(skb);
1212 
1213 				tx_cmd->cmd.command = 0; /* Mark free */
1214 				break;
1215 			    }
1216 			case CmdTDR:
1217 			    {
1218 				unsigned short status = SWAP16(((struct tdr_cmd *)ptr)->status);
1219 
1220 				if (status & 0x8000) {
1221 					DEB(DEB_ANY,
1222 					    printk(KERN_DEBUG "%s: link ok.\n",
1223 						   dev->name));
1224 				} else {
1225 					if (status & 0x4000)
1226 						printk(KERN_ERR
1227 						       "%s: Transceiver problem.\n",
1228 						       dev->name);
1229 					if (status & 0x2000)
1230 						printk(KERN_ERR
1231 						       "%s: Termination problem.\n",
1232 						       dev->name);
1233 					if (status & 0x1000)
1234 						printk(KERN_ERR
1235 						       "%s: Short circuit.\n",
1236 						       dev->name);
1237 
1238 					DEB(DEB_TDR,
1239 					    printk(KERN_DEBUG "%s: Time %d.\n",
1240 						   dev->name, status & 0x07ff));
1241 				}
1242 				break;
1243 			    }
1244 			case CmdConfigure:
1245 				/*
1246 				 * Zap command so set_multicast_list() know
1247 				 * it is free
1248 				 */
1249 				ptr->command = 0;
1250 				break;
1251 			}
1252 			ptr->v_next = NULL;
1253 			ptr->b_next = I596_NULL;
1254 			dma_sync_dev(dev, ptr, sizeof(struct i596_cmd));
1255 			lp->last_cmd = jiffies;
1256 		}
1257 
1258 		/* This mess is arranging that only the last of any outstanding
1259 		 * commands has the interrupt bit set.  Should probably really
1260 		 * only add to the cmd queue when the CU is stopped.
1261 		 */
1262 		ptr = lp->cmd_head;
1263 		while ((ptr != NULL) && (ptr != lp->cmd_tail)) {
1264 			struct i596_cmd *prev = ptr;
1265 
1266 			ptr->command &= SWAP16(0x1fff);
1267 			ptr = ptr->v_next;
1268 			dma_sync_dev(dev, prev, sizeof(struct i596_cmd));
1269 		}
1270 
1271 		if (lp->cmd_head != NULL)
1272 			ack_cmd |= CUC_START;
1273 		dma->scb.cmd = SWAP32(virt_to_dma(lp, &lp->cmd_head->status));
1274 		dma_sync_dev(dev, &dma->scb, sizeof(struct i596_scb));
1275 	}
1276 	if ((status & 0x1000) || (status & 0x4000)) {
1277 		if ((status & 0x4000))
1278 			DEB(DEB_INTS,
1279 			    printk(KERN_DEBUG
1280 				   "%s: i596 interrupt received a frame.\n",
1281 				   dev->name));
1282 		i596_rx(dev);
1283 		/* Only RX_START if stopped - RGH 07-07-96 */
1284 		if (status & 0x1000) {
1285 			if (netif_running(dev)) {
1286 				DEB(DEB_ERRORS,
1287 				    printk(KERN_DEBUG
1288 					   "%s: i596 interrupt receive unit inactive, status 0x%x\n",
1289 					   dev->name, status));
1290 				ack_cmd |= RX_START;
1291 				dev->stats.rx_errors++;
1292 				dev->stats.rx_fifo_errors++;
1293 				rebuild_rx_bufs(dev);
1294 			}
1295 		}
1296 	}
1297 	wait_cmd(dev, dma, 100, "i596 interrupt, timeout");
1298 	dma->scb.command = SWAP16(ack_cmd);
1299 	dma_sync_dev(dev, &dma->scb, sizeof(struct i596_scb));
1300 
1301 	/* DANGER: I suspect that some kind of interrupt
1302 	 acknowledgement aside from acking the 82596 might be needed
1303 	 here...  but it's running acceptably without */
1304 
1305 	ca(dev);
1306 
1307 	wait_cmd(dev, dma, 100, "i596 interrupt, exit timeout");
1308 	DEB(DEB_INTS, printk(KERN_DEBUG "%s: exiting interrupt.\n", dev->name));
1309 
1310 	spin_unlock (&lp->lock);
1311 	return IRQ_HANDLED;
1312 }
1313 
i596_close(struct net_device * dev)1314 static int i596_close(struct net_device *dev)
1315 {
1316 	struct i596_private *lp = netdev_priv(dev);
1317 	unsigned long flags;
1318 
1319 	netif_stop_queue(dev);
1320 
1321 	DEB(DEB_INIT,
1322 	    printk(KERN_DEBUG
1323 		   "%s: Shutting down ethercard, status was %4.4x.\n",
1324 		   dev->name, SWAP16(lp->dma->scb.status)));
1325 
1326 	spin_lock_irqsave(&lp->lock, flags);
1327 
1328 	wait_cmd(dev, lp->dma, 100, "close1 timed out");
1329 	lp->dma->scb.command = SWAP16(CUC_ABORT | RX_ABORT);
1330 	dma_sync_dev(dev, &lp->dma->scb, sizeof(struct i596_scb));
1331 
1332 	ca(dev);
1333 
1334 	wait_cmd(dev, lp->dma, 100, "close2 timed out");
1335 	spin_unlock_irqrestore(&lp->lock, flags);
1336 	DEB(DEB_STRUCT, i596_display_data(dev));
1337 	i596_cleanup_cmd(dev, lp);
1338 
1339 	free_irq(dev->irq, dev);
1340 	remove_rx_bufs(dev);
1341 
1342 	return 0;
1343 }
1344 
1345 /*
1346  *    Set or clear the multicast filter for this adaptor.
1347  */
1348 
set_multicast_list(struct net_device * dev)1349 static void set_multicast_list(struct net_device *dev)
1350 {
1351 	struct i596_private *lp = netdev_priv(dev);
1352 	struct i596_dma *dma = lp->dma;
1353 	int config = 0, cnt;
1354 
1355 	DEB(DEB_MULTI,
1356 	    printk(KERN_DEBUG
1357 		   "%s: set multicast list, %d entries, promisc %s, allmulti %s\n",
1358 		   dev->name, netdev_mc_count(dev),
1359 		   dev->flags & IFF_PROMISC ? "ON" : "OFF",
1360 		   dev->flags & IFF_ALLMULTI ? "ON" : "OFF"));
1361 
1362 	if ((dev->flags & IFF_PROMISC) &&
1363 	    !(dma->cf_cmd.i596_config[8] & 0x01)) {
1364 		dma->cf_cmd.i596_config[8] |= 0x01;
1365 		config = 1;
1366 	}
1367 	if (!(dev->flags & IFF_PROMISC) &&
1368 	    (dma->cf_cmd.i596_config[8] & 0x01)) {
1369 		dma->cf_cmd.i596_config[8] &= ~0x01;
1370 		config = 1;
1371 	}
1372 	if ((dev->flags & IFF_ALLMULTI) &&
1373 	    (dma->cf_cmd.i596_config[11] & 0x20)) {
1374 		dma->cf_cmd.i596_config[11] &= ~0x20;
1375 		config = 1;
1376 	}
1377 	if (!(dev->flags & IFF_ALLMULTI) &&
1378 	    !(dma->cf_cmd.i596_config[11] & 0x20)) {
1379 		dma->cf_cmd.i596_config[11] |= 0x20;
1380 		config = 1;
1381 	}
1382 	if (config) {
1383 		if (dma->cf_cmd.cmd.command)
1384 			printk(KERN_INFO
1385 			       "%s: config change request already queued\n",
1386 			       dev->name);
1387 		else {
1388 			dma->cf_cmd.cmd.command = SWAP16(CmdConfigure);
1389 			dma_sync_dev(dev, &dma->cf_cmd, sizeof(struct cf_cmd));
1390 			i596_add_cmd(dev, &dma->cf_cmd.cmd);
1391 		}
1392 	}
1393 
1394 	cnt = netdev_mc_count(dev);
1395 	if (cnt > MAX_MC_CNT) {
1396 		cnt = MAX_MC_CNT;
1397 		printk(KERN_NOTICE "%s: Only %d multicast addresses supported",
1398 			dev->name, cnt);
1399 	}
1400 
1401 	if (!netdev_mc_empty(dev)) {
1402 		struct netdev_hw_addr *ha;
1403 		unsigned char *cp;
1404 		struct mc_cmd *cmd;
1405 
1406 		cmd = &dma->mc_cmd;
1407 		cmd->cmd.command = SWAP16(CmdMulticastList);
1408 		cmd->mc_cnt = SWAP16(netdev_mc_count(dev) * 6);
1409 		cp = cmd->mc_addrs;
1410 		netdev_for_each_mc_addr(ha, dev) {
1411 			if (!cnt--)
1412 				break;
1413 			memcpy(cp, ha->addr, ETH_ALEN);
1414 			if (i596_debug > 1)
1415 				DEB(DEB_MULTI,
1416 				    printk(KERN_DEBUG
1417 					   "%s: Adding address %pM\n",
1418 					   dev->name, cp));
1419 			cp += ETH_ALEN;
1420 		}
1421 		dma_sync_dev(dev, &dma->mc_cmd, sizeof(struct mc_cmd));
1422 		i596_add_cmd(dev, &cmd->cmd);
1423 	}
1424 }
1425