PageRenderTime 118ms CodeModel.GetById 22ms app.highlight 84ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/net/ethernet/i825xx/lib82596.c

http://github.com/mirrors/linux
C | 1410 lines | 1064 code | 214 blank | 132 comment | 122 complexity | d70466553007b8506058a635303a34ab MD5 | raw file
   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
 124static 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 */
 129static 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
 144enum 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
 166struct 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
 175struct 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
 193struct 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
 200struct 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
 214struct tdr_cmd {
 215	struct i596_cmd cmd;
 216	unsigned short status;
 217	unsigned short pad;
 218};
 219
 220struct mc_cmd {
 221	struct i596_cmd cmd;
 222	short mc_cnt;
 223	char mc_addrs[MAX_MC_CNT*6];
 224};
 225
 226struct sa_cmd {
 227	struct i596_cmd cmd;
 228	char eth_addr[8];
 229};
 230
 231struct cf_cmd {
 232	struct i596_cmd cmd;
 233	char i596_config[16];
 234};
 235
 236struct 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
 250struct 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
 274struct 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
 289struct i596_iscp {
 290	u32 stat;
 291	u32 scb;
 292};
 293
 294struct i596_scp {
 295	u32 sysbus;
 296	u32 pad;
 297	u32 iscp;
 298};
 299
 300struct 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
 314struct 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
 332static 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
 349static int i596_open(struct net_device *dev);
 350static netdev_tx_t i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
 351static irqreturn_t i596_interrupt(int irq, void *dev_id);
 352static int i596_close(struct net_device *dev);
 353static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
 354static void i596_tx_timeout (struct net_device *dev, unsigned int txqueue);
 355static void print_eth(unsigned char *buf, char *str);
 356static void set_multicast_list(struct net_device *dev);
 357static inline void ca(struct net_device *dev);
 358static void mpu_port(struct net_device *dev, int c, dma_addr_t x);
 359
 360static int rx_ring_size = RX_RING_SIZE;
 361static int ticks_limit = 100;
 362static int max_cmd_backlog = TX_RING_SIZE-1;
 363
 364#ifdef CONFIG_NET_POLL_CONTROLLER
 365static void i596_poll_controller(struct net_device *dev);
 366#endif
 367
 368
 369static inline int wait_istat(struct net_device *dev, struct i596_dma *dma, int delcnt, char *str)
 370{
 371	DMA_INV(dev, &(dma->iscp), sizeof(struct i596_iscp));
 372	while (--delcnt && dma->iscp.stat) {
 373		udelay(10);
 374		DMA_INV(dev, &(dma->iscp), sizeof(struct i596_iscp));
 375	}
 376	if (!delcnt) {
 377		printk(KERN_ERR "%s: %s, iscp.stat %04x, didn't clear\n",
 378		     dev->name, str, SWAP16(dma->iscp.stat));
 379		return -1;
 380	} else
 381		return 0;
 382}
 383
 384
 385static inline int wait_cmd(struct net_device *dev, struct i596_dma *dma, int delcnt, char *str)
 386{
 387	DMA_INV(dev, &(dma->scb), sizeof(struct i596_scb));
 388	while (--delcnt && dma->scb.command) {
 389		udelay(10);
 390		DMA_INV(dev, &(dma->scb), sizeof(struct i596_scb));
 391	}
 392	if (!delcnt) {
 393		printk(KERN_ERR "%s: %s, status %4.4x, cmd %4.4x.\n",
 394		       dev->name, str,
 395		       SWAP16(dma->scb.status),
 396		       SWAP16(dma->scb.command));
 397		return -1;
 398	} else
 399		return 0;
 400}
 401
 402
 403static void i596_display_data(struct net_device *dev)
 404{
 405	struct i596_private *lp = netdev_priv(dev);
 406	struct i596_dma *dma = lp->dma;
 407	struct i596_cmd *cmd;
 408	struct i596_rfd *rfd;
 409	struct i596_rbd *rbd;
 410
 411	printk(KERN_DEBUG "lp and scp at %p, .sysbus = %08x, .iscp = %08x\n",
 412	       &dma->scp, dma->scp.sysbus, SWAP32(dma->scp.iscp));
 413	printk(KERN_DEBUG "iscp at %p, iscp.stat = %08x, .scb = %08x\n",
 414	       &dma->iscp, SWAP32(dma->iscp.stat), SWAP32(dma->iscp.scb));
 415	printk(KERN_DEBUG "scb at %p, scb.status = %04x, .command = %04x,"
 416		" .cmd = %08x, .rfd = %08x\n",
 417	       &dma->scb, SWAP16(dma->scb.status), SWAP16(dma->scb.command),
 418		SWAP16(dma->scb.cmd), SWAP32(dma->scb.rfd));
 419	printk(KERN_DEBUG "   errors: crc %x, align %x, resource %x,"
 420	       " over %x, rcvdt %x, short %x\n",
 421	       SWAP32(dma->scb.crc_err), SWAP32(dma->scb.align_err),
 422	       SWAP32(dma->scb.resource_err), SWAP32(dma->scb.over_err),
 423	       SWAP32(dma->scb.rcvdt_err), SWAP32(dma->scb.short_err));
 424	cmd = lp->cmd_head;
 425	while (cmd != NULL) {
 426		printk(KERN_DEBUG
 427		       "cmd at %p, .status = %04x, .command = %04x,"
 428		       " .b_next = %08x\n",
 429		       cmd, SWAP16(cmd->status), SWAP16(cmd->command),
 430		       SWAP32(cmd->b_next));
 431		cmd = cmd->v_next;
 432	}
 433	rfd = lp->rfd_head;
 434	printk(KERN_DEBUG "rfd_head = %p\n", rfd);
 435	do {
 436		printk(KERN_DEBUG
 437		       "   %p .stat %04x, .cmd %04x, b_next %08x, rbd %08x,"
 438		       " count %04x\n",
 439		       rfd, SWAP16(rfd->stat), SWAP16(rfd->cmd),
 440		       SWAP32(rfd->b_next), SWAP32(rfd->rbd),
 441		       SWAP16(rfd->count));
 442		rfd = rfd->v_next;
 443	} while (rfd != lp->rfd_head);
 444	rbd = lp->rbd_head;
 445	printk(KERN_DEBUG "rbd_head = %p\n", rbd);
 446	do {
 447		printk(KERN_DEBUG
 448		       "   %p .count %04x, b_next %08x, b_data %08x,"
 449		       " size %04x\n",
 450			rbd, SWAP16(rbd->count), SWAP32(rbd->b_next),
 451		       SWAP32(rbd->b_data), SWAP16(rbd->size));
 452		rbd = rbd->v_next;
 453	} while (rbd != lp->rbd_head);
 454	DMA_INV(dev, dma, sizeof(struct i596_dma));
 455}
 456
 457
 458#define virt_to_dma(lp, v) ((lp)->dma_addr + (dma_addr_t)((unsigned long)(v)-(unsigned long)((lp)->dma)))
 459
 460static inline int init_rx_bufs(struct net_device *dev)
 461{
 462	struct i596_private *lp = netdev_priv(dev);
 463	struct i596_dma *dma = lp->dma;
 464	int i;
 465	struct i596_rfd *rfd;
 466	struct i596_rbd *rbd;
 467
 468	/* First build the Receive Buffer Descriptor List */
 469
 470	for (i = 0, rbd = dma->rbds; i < rx_ring_size; i++, rbd++) {
 471		dma_addr_t dma_addr;
 472		struct sk_buff *skb;
 473
 474		skb = netdev_alloc_skb_ip_align(dev, PKT_BUF_SZ);
 475		if (skb == NULL)
 476			return -1;
 477		dma_addr = dma_map_single(dev->dev.parent, skb->data,
 478					  PKT_BUF_SZ, DMA_FROM_DEVICE);
 479		rbd->v_next = rbd+1;
 480		rbd->b_next = SWAP32(virt_to_dma(lp, rbd+1));
 481		rbd->b_addr = SWAP32(virt_to_dma(lp, rbd));
 482		rbd->skb = skb;
 483		rbd->v_data = skb->data;
 484		rbd->b_data = SWAP32(dma_addr);
 485		rbd->size = SWAP16(PKT_BUF_SZ);
 486	}
 487	lp->rbd_head = dma->rbds;
 488	rbd = dma->rbds + rx_ring_size - 1;
 489	rbd->v_next = dma->rbds;
 490	rbd->b_next = SWAP32(virt_to_dma(lp, dma->rbds));
 491
 492	/* Now build the Receive Frame Descriptor List */
 493
 494	for (i = 0, rfd = dma->rfds; i < rx_ring_size; i++, rfd++) {
 495		rfd->rbd = I596_NULL;
 496		rfd->v_next = rfd+1;
 497		rfd->v_prev = rfd-1;
 498		rfd->b_next = SWAP32(virt_to_dma(lp, rfd+1));
 499		rfd->cmd = SWAP16(CMD_FLEX);
 500	}
 501	lp->rfd_head = dma->rfds;
 502	dma->scb.rfd = SWAP32(virt_to_dma(lp, dma->rfds));
 503	rfd = dma->rfds;
 504	rfd->rbd = SWAP32(virt_to_dma(lp, lp->rbd_head));
 505	rfd->v_prev = dma->rfds + rx_ring_size - 1;
 506	rfd = dma->rfds + rx_ring_size - 1;
 507	rfd->v_next = dma->rfds;
 508	rfd->b_next = SWAP32(virt_to_dma(lp, dma->rfds));
 509	rfd->cmd = SWAP16(CMD_EOL|CMD_FLEX);
 510
 511	DMA_WBACK_INV(dev, dma, sizeof(struct i596_dma));
 512	return 0;
 513}
 514
 515static inline void remove_rx_bufs(struct net_device *dev)
 516{
 517	struct i596_private *lp = netdev_priv(dev);
 518	struct i596_rbd *rbd;
 519	int i;
 520
 521	for (i = 0, rbd = lp->dma->rbds; i < rx_ring_size; i++, rbd++) {
 522		if (rbd->skb == NULL)
 523			break;
 524		dma_unmap_single(dev->dev.parent,
 525				 (dma_addr_t)SWAP32(rbd->b_data),
 526				 PKT_BUF_SZ, DMA_FROM_DEVICE);
 527		dev_kfree_skb(rbd->skb);
 528	}
 529}
 530
 531
 532static void rebuild_rx_bufs(struct net_device *dev)
 533{
 534	struct i596_private *lp = netdev_priv(dev);
 535	struct i596_dma *dma = lp->dma;
 536	int i;
 537
 538	/* Ensure rx frame/buffer descriptors are tidy */
 539
 540	for (i = 0; i < rx_ring_size; i++) {
 541		dma->rfds[i].rbd = I596_NULL;
 542		dma->rfds[i].cmd = SWAP16(CMD_FLEX);
 543	}
 544	dma->rfds[rx_ring_size-1].cmd = SWAP16(CMD_EOL|CMD_FLEX);
 545	lp->rfd_head = dma->rfds;
 546	dma->scb.rfd = SWAP32(virt_to_dma(lp, dma->rfds));
 547	lp->rbd_head = dma->rbds;
 548	dma->rfds[0].rbd = SWAP32(virt_to_dma(lp, dma->rbds));
 549
 550	DMA_WBACK_INV(dev, dma, sizeof(struct i596_dma));
 551}
 552
 553
 554static int init_i596_mem(struct net_device *dev)
 555{
 556	struct i596_private *lp = netdev_priv(dev);
 557	struct i596_dma *dma = lp->dma;
 558	unsigned long flags;
 559
 560	mpu_port(dev, PORT_RESET, 0);
 561	udelay(100);			/* Wait 100us - seems to help */
 562
 563	/* change the scp address */
 564
 565	lp->last_cmd = jiffies;
 566
 567	dma->scp.sysbus = SYSBUS;
 568	dma->scp.iscp = SWAP32(virt_to_dma(lp, &(dma->iscp)));
 569	dma->iscp.scb = SWAP32(virt_to_dma(lp, &(dma->scb)));
 570	dma->iscp.stat = SWAP32(ISCP_BUSY);
 571	lp->cmd_backlog = 0;
 572
 573	lp->cmd_head = NULL;
 574	dma->scb.cmd = I596_NULL;
 575
 576	DEB(DEB_INIT, printk(KERN_DEBUG "%s: starting i82596.\n", dev->name));
 577
 578	DMA_WBACK(dev, &(dma->scp), sizeof(struct i596_scp));
 579	DMA_WBACK(dev, &(dma->iscp), sizeof(struct i596_iscp));
 580	DMA_WBACK(dev, &(dma->scb), sizeof(struct i596_scb));
 581
 582	mpu_port(dev, PORT_ALTSCP, virt_to_dma(lp, &dma->scp));
 583	ca(dev);
 584	if (wait_istat(dev, dma, 1000, "initialization timed out"))
 585		goto failed;
 586	DEB(DEB_INIT, printk(KERN_DEBUG
 587			     "%s: i82596 initialization successful\n",
 588			     dev->name));
 589
 590	if (request_irq(dev->irq, i596_interrupt, 0, "i82596", dev)) {
 591		printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
 592		goto failed;
 593	}
 594
 595	/* Ensure rx frame/buffer descriptors are tidy */
 596	rebuild_rx_bufs(dev);
 597
 598	dma->scb.command = 0;
 599	DMA_WBACK(dev, &(dma->scb), sizeof(struct i596_scb));
 600
 601	DEB(DEB_INIT, printk(KERN_DEBUG
 602			     "%s: queuing CmdConfigure\n", dev->name));
 603	memcpy(dma->cf_cmd.i596_config, init_setup, 14);
 604	dma->cf_cmd.cmd.command = SWAP16(CmdConfigure);
 605	DMA_WBACK(dev, &(dma->cf_cmd), sizeof(struct cf_cmd));
 606	i596_add_cmd(dev, &dma->cf_cmd.cmd);
 607
 608	DEB(DEB_INIT, printk(KERN_DEBUG "%s: queuing CmdSASetup\n", dev->name));
 609	memcpy(dma->sa_cmd.eth_addr, dev->dev_addr, ETH_ALEN);
 610	dma->sa_cmd.cmd.command = SWAP16(CmdSASetup);
 611	DMA_WBACK(dev, &(dma->sa_cmd), sizeof(struct sa_cmd));
 612	i596_add_cmd(dev, &dma->sa_cmd.cmd);
 613
 614	DEB(DEB_INIT, printk(KERN_DEBUG "%s: queuing CmdTDR\n", dev->name));
 615	dma->tdr_cmd.cmd.command = SWAP16(CmdTDR);
 616	DMA_WBACK(dev, &(dma->tdr_cmd), sizeof(struct tdr_cmd));
 617	i596_add_cmd(dev, &dma->tdr_cmd.cmd);
 618
 619	spin_lock_irqsave (&lp->lock, flags);
 620
 621	if (wait_cmd(dev, dma, 1000, "timed out waiting to issue RX_START")) {
 622		spin_unlock_irqrestore (&lp->lock, flags);
 623		goto failed_free_irq;
 624	}
 625	DEB(DEB_INIT, printk(KERN_DEBUG "%s: Issuing RX_START\n", dev->name));
 626	dma->scb.command = SWAP16(RX_START);
 627	dma->scb.rfd = SWAP32(virt_to_dma(lp, dma->rfds));
 628	DMA_WBACK(dev, &(dma->scb), sizeof(struct i596_scb));
 629
 630	ca(dev);
 631
 632	spin_unlock_irqrestore (&lp->lock, flags);
 633	if (wait_cmd(dev, dma, 1000, "RX_START not processed"))
 634		goto failed_free_irq;
 635	DEB(DEB_INIT, printk(KERN_DEBUG
 636			     "%s: Receive unit started OK\n", dev->name));
 637	return 0;
 638
 639failed_free_irq:
 640	free_irq(dev->irq, dev);
 641failed:
 642	printk(KERN_ERR "%s: Failed to initialise 82596\n", dev->name);
 643	mpu_port(dev, PORT_RESET, 0);
 644	return -1;
 645}
 646
 647
 648static inline int i596_rx(struct net_device *dev)
 649{
 650	struct i596_private *lp = netdev_priv(dev);
 651	struct i596_rfd *rfd;
 652	struct i596_rbd *rbd;
 653	int frames = 0;
 654
 655	DEB(DEB_RXFRAME, printk(KERN_DEBUG
 656				"i596_rx(), rfd_head %p, rbd_head %p\n",
 657				lp->rfd_head, lp->rbd_head));
 658
 659
 660	rfd = lp->rfd_head;		/* Ref next frame to check */
 661
 662	DMA_INV(dev, rfd, sizeof(struct i596_rfd));
 663	while (rfd->stat & SWAP16(STAT_C)) {	/* Loop while complete frames */
 664		if (rfd->rbd == I596_NULL)
 665			rbd = NULL;
 666		else if (rfd->rbd == lp->rbd_head->b_addr) {
 667			rbd = lp->rbd_head;
 668			DMA_INV(dev, rbd, sizeof(struct i596_rbd));
 669		} else {
 670			printk(KERN_ERR "%s: rbd chain broken!\n", dev->name);
 671			/* XXX Now what? */
 672			rbd = NULL;
 673		}
 674		DEB(DEB_RXFRAME, printk(KERN_DEBUG
 675				      "  rfd %p, rfd.rbd %08x, rfd.stat %04x\n",
 676				      rfd, rfd->rbd, rfd->stat));
 677
 678		if (rbd != NULL && (rfd->stat & SWAP16(STAT_OK))) {
 679			/* a good frame */
 680			int pkt_len = SWAP16(rbd->count) & 0x3fff;
 681			struct sk_buff *skb = rbd->skb;
 682			int rx_in_place = 0;
 683
 684			DEB(DEB_RXADDR, print_eth(rbd->v_data, "received"));
 685			frames++;
 686
 687			/* Check if the packet is long enough to just accept
 688			 * without copying to a properly sized skbuff.
 689			 */
 690
 691			if (pkt_len > rx_copybreak) {
 692				struct sk_buff *newskb;
 693				dma_addr_t dma_addr;
 694
 695				dma_unmap_single(dev->dev.parent,
 696						 (dma_addr_t)SWAP32(rbd->b_data),
 697						 PKT_BUF_SZ, DMA_FROM_DEVICE);
 698				/* Get fresh skbuff to replace filled one. */
 699				newskb = netdev_alloc_skb_ip_align(dev,
 700								   PKT_BUF_SZ);
 701				if (newskb == NULL) {
 702					skb = NULL;	/* drop pkt */
 703					goto memory_squeeze;
 704				}
 705
 706				/* Pass up the skb already on the Rx ring. */
 707				skb_put(skb, pkt_len);
 708				rx_in_place = 1;
 709				rbd->skb = newskb;
 710				dma_addr = dma_map_single(dev->dev.parent,
 711							  newskb->data,
 712							  PKT_BUF_SZ,
 713							  DMA_FROM_DEVICE);
 714				rbd->v_data = newskb->data;
 715				rbd->b_data = SWAP32(dma_addr);
 716				DMA_WBACK_INV(dev, rbd, sizeof(struct i596_rbd));
 717			} else {
 718				skb = netdev_alloc_skb_ip_align(dev, pkt_len);
 719			}
 720memory_squeeze:
 721			if (skb == NULL) {
 722				/* XXX tulip.c can defer packets here!! */
 723				dev->stats.rx_dropped++;
 724			} else {
 725				if (!rx_in_place) {
 726					/* 16 byte align the data fields */
 727					dma_sync_single_for_cpu(dev->dev.parent,
 728								(dma_addr_t)SWAP32(rbd->b_data),
 729								PKT_BUF_SZ, DMA_FROM_DEVICE);
 730					skb_put_data(skb, rbd->v_data,
 731						     pkt_len);
 732					dma_sync_single_for_device(dev->dev.parent,
 733								   (dma_addr_t)SWAP32(rbd->b_data),
 734								   PKT_BUF_SZ, DMA_FROM_DEVICE);
 735				}
 736				skb->len = pkt_len;
 737				skb->protocol = eth_type_trans(skb, dev);
 738				netif_rx(skb);
 739				dev->stats.rx_packets++;
 740				dev->stats.rx_bytes += pkt_len;
 741			}
 742		} else {
 743			DEB(DEB_ERRORS, printk(KERN_DEBUG
 744					       "%s: Error, rfd.stat = 0x%04x\n",
 745					       dev->name, rfd->stat));
 746			dev->stats.rx_errors++;
 747			if (rfd->stat & SWAP16(0x0100))
 748				dev->stats.collisions++;
 749			if (rfd->stat & SWAP16(0x8000))
 750				dev->stats.rx_length_errors++;
 751			if (rfd->stat & SWAP16(0x0001))
 752				dev->stats.rx_over_errors++;
 753			if (rfd->stat & SWAP16(0x0002))
 754				dev->stats.rx_fifo_errors++;
 755			if (rfd->stat & SWAP16(0x0004))
 756				dev->stats.rx_frame_errors++;
 757			if (rfd->stat & SWAP16(0x0008))
 758				dev->stats.rx_crc_errors++;
 759			if (rfd->stat & SWAP16(0x0010))
 760				dev->stats.rx_length_errors++;
 761		}
 762
 763		/* Clear the buffer descriptor count and EOF + F flags */
 764
 765		if (rbd != NULL && (rbd->count & SWAP16(0x4000))) {
 766			rbd->count = 0;
 767			lp->rbd_head = rbd->v_next;
 768			DMA_WBACK_INV(dev, rbd, sizeof(struct i596_rbd));
 769		}
 770
 771		/* Tidy the frame descriptor, marking it as end of list */
 772
 773		rfd->rbd = I596_NULL;
 774		rfd->stat = 0;
 775		rfd->cmd = SWAP16(CMD_EOL|CMD_FLEX);
 776		rfd->count = 0;
 777
 778		/* Update record of next frame descriptor to process */
 779
 780		lp->dma->scb.rfd = rfd->b_next;
 781		lp->rfd_head = rfd->v_next;
 782		DMA_WBACK_INV(dev, rfd, sizeof(struct i596_rfd));
 783
 784		/* Remove end-of-list from old end descriptor */
 785
 786		rfd->v_prev->cmd = SWAP16(CMD_FLEX);
 787		DMA_WBACK_INV(dev, rfd->v_prev, sizeof(struct i596_rfd));
 788		rfd = lp->rfd_head;
 789		DMA_INV(dev, rfd, sizeof(struct i596_rfd));
 790	}
 791
 792	DEB(DEB_RXFRAME, printk(KERN_DEBUG "frames %d\n", frames));
 793
 794	return 0;
 795}
 796
 797
 798static inline void i596_cleanup_cmd(struct net_device *dev, struct i596_private *lp)
 799{
 800	struct i596_cmd *ptr;
 801
 802	while (lp->cmd_head != NULL) {
 803		ptr = lp->cmd_head;
 804		lp->cmd_head = ptr->v_next;
 805		lp->cmd_backlog--;
 806
 807		switch (SWAP16(ptr->command) & 0x7) {
 808		case CmdTx:
 809			{
 810				struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
 811				struct sk_buff *skb = tx_cmd->skb;
 812				dma_unmap_single(dev->dev.parent,
 813						 tx_cmd->dma_addr,
 814						 skb->len, DMA_TO_DEVICE);
 815
 816				dev_kfree_skb(skb);
 817
 818				dev->stats.tx_errors++;
 819				dev->stats.tx_aborted_errors++;
 820
 821				ptr->v_next = NULL;
 822				ptr->b_next = I596_NULL;
 823				tx_cmd->cmd.command = 0;  /* Mark as free */
 824				break;
 825			}
 826		default:
 827			ptr->v_next = NULL;
 828			ptr->b_next = I596_NULL;
 829		}
 830		DMA_WBACK_INV(dev, ptr, sizeof(struct i596_cmd));
 831	}
 832
 833	wait_cmd(dev, lp->dma, 100, "i596_cleanup_cmd timed out");
 834	lp->dma->scb.cmd = I596_NULL;
 835	DMA_WBACK(dev, &(lp->dma->scb), sizeof(struct i596_scb));
 836}
 837
 838
 839static inline void i596_reset(struct net_device *dev, struct i596_private *lp)
 840{
 841	unsigned long flags;
 842
 843	DEB(DEB_RESET, printk(KERN_DEBUG "i596_reset\n"));
 844
 845	spin_lock_irqsave (&lp->lock, flags);
 846
 847	wait_cmd(dev, lp->dma, 100, "i596_reset timed out");
 848
 849	netif_stop_queue(dev);
 850
 851	/* FIXME: this command might cause an lpmc */
 852	lp->dma->scb.command = SWAP16(CUC_ABORT | RX_ABORT);
 853	DMA_WBACK(dev, &(lp->dma->scb), sizeof(struct i596_scb));
 854	ca(dev);
 855
 856	/* wait for shutdown */
 857	wait_cmd(dev, lp->dma, 1000, "i596_reset 2 timed out");
 858	spin_unlock_irqrestore (&lp->lock, flags);
 859
 860	i596_cleanup_cmd(dev, lp);
 861	i596_rx(dev);
 862
 863	netif_start_queue(dev);
 864	init_i596_mem(dev);
 865}
 866
 867
 868static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd)
 869{
 870	struct i596_private *lp = netdev_priv(dev);
 871	struct i596_dma *dma = lp->dma;
 872	unsigned long flags;
 873
 874	DEB(DEB_ADDCMD, printk(KERN_DEBUG "i596_add_cmd cmd_head %p\n",
 875			       lp->cmd_head));
 876
 877	cmd->status = 0;
 878	cmd->command |= SWAP16(CMD_EOL | CMD_INTR);
 879	cmd->v_next = NULL;
 880	cmd->b_next = I596_NULL;
 881	DMA_WBACK(dev, cmd, sizeof(struct i596_cmd));
 882
 883	spin_lock_irqsave (&lp->lock, flags);
 884
 885	if (lp->cmd_head != NULL) {
 886		lp->cmd_tail->v_next = cmd;
 887		lp->cmd_tail->b_next = SWAP32(virt_to_dma(lp, &cmd->status));
 888		DMA_WBACK(dev, lp->cmd_tail, sizeof(struct i596_cmd));
 889	} else {
 890		lp->cmd_head = cmd;
 891		wait_cmd(dev, dma, 100, "i596_add_cmd timed out");
 892		dma->scb.cmd = SWAP32(virt_to_dma(lp, &cmd->status));
 893		dma->scb.command = SWAP16(CUC_START);
 894		DMA_WBACK(dev, &(dma->scb), sizeof(struct i596_scb));
 895		ca(dev);
 896	}
 897	lp->cmd_tail = cmd;
 898	lp->cmd_backlog++;
 899
 900	spin_unlock_irqrestore (&lp->lock, flags);
 901
 902	if (lp->cmd_backlog > max_cmd_backlog) {
 903		unsigned long tickssofar = jiffies - lp->last_cmd;
 904
 905		if (tickssofar < ticks_limit)
 906			return;
 907
 908		printk(KERN_ERR
 909		       "%s: command unit timed out, status resetting.\n",
 910		       dev->name);
 911#if 1
 912		i596_reset(dev, lp);
 913#endif
 914	}
 915}
 916
 917static int i596_open(struct net_device *dev)
 918{
 919	DEB(DEB_OPEN, printk(KERN_DEBUG
 920			     "%s: i596_open() irq %d.\n", dev->name, dev->irq));
 921
 922	if (init_rx_bufs(dev)) {
 923		printk(KERN_ERR "%s: Failed to init rx bufs\n", dev->name);
 924		return -EAGAIN;
 925	}
 926	if (init_i596_mem(dev)) {
 927		printk(KERN_ERR "%s: Failed to init memory\n", dev->name);
 928		goto out_remove_rx_bufs;
 929	}
 930	netif_start_queue(dev);
 931
 932	return 0;
 933
 934out_remove_rx_bufs:
 935	remove_rx_bufs(dev);
 936	return -EAGAIN;
 937}
 938
 939static void i596_tx_timeout (struct net_device *dev, unsigned int txqueue)
 940{
 941	struct i596_private *lp = netdev_priv(dev);
 942
 943	/* Transmitter timeout, serious problems. */
 944	DEB(DEB_ERRORS, printk(KERN_DEBUG
 945			       "%s: transmit timed out, status resetting.\n",
 946			       dev->name));
 947
 948	dev->stats.tx_errors++;
 949
 950	/* Try to restart the adaptor */
 951	if (lp->last_restart == dev->stats.tx_packets) {
 952		DEB(DEB_ERRORS, printk(KERN_DEBUG "Resetting board.\n"));
 953		/* Shutdown and restart */
 954		i596_reset (dev, lp);
 955	} else {
 956		/* Issue a channel attention signal */
 957		DEB(DEB_ERRORS, printk(KERN_DEBUG "Kicking board.\n"));
 958		lp->dma->scb.command = SWAP16(CUC_START | RX_START);
 959		DMA_WBACK_INV(dev, &(lp->dma->scb), sizeof(struct i596_scb));
 960		ca (dev);
 961		lp->last_restart = dev->stats.tx_packets;
 962	}
 963
 964	netif_trans_update(dev); /* prevent tx timeout */
 965	netif_wake_queue (dev);
 966}
 967
 968
 969static netdev_tx_t i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
 970{
 971	struct i596_private *lp = netdev_priv(dev);
 972	struct tx_cmd *tx_cmd;
 973	struct i596_tbd *tbd;
 974	short length = skb->len;
 975
 976	DEB(DEB_STARTTX, printk(KERN_DEBUG
 977				"%s: i596_start_xmit(%x,%p) called\n",
 978				dev->name, skb->len, skb->data));
 979
 980	if (length < ETH_ZLEN) {
 981		if (skb_padto(skb, ETH_ZLEN))
 982			return NETDEV_TX_OK;
 983		length = ETH_ZLEN;
 984	}
 985
 986	netif_stop_queue(dev);
 987
 988	tx_cmd = lp->dma->tx_cmds + lp->next_tx_cmd;
 989	tbd = lp->dma->tbds + lp->next_tx_cmd;
 990
 991	if (tx_cmd->cmd.command) {
 992		DEB(DEB_ERRORS, printk(KERN_DEBUG
 993				       "%s: xmit ring full, dropping packet.\n",
 994				       dev->name));
 995		dev->stats.tx_dropped++;
 996
 997		dev_kfree_skb_any(skb);
 998	} else {
 999		if (++lp->next_tx_cmd == TX_RING_SIZE)
1000			lp->next_tx_cmd = 0;
1001		tx_cmd->tbd = SWAP32(virt_to_dma(lp, tbd));
1002		tbd->next = I596_NULL;
1003
1004		tx_cmd->cmd.command = SWAP16(CMD_FLEX | CmdTx);
1005		tx_cmd->skb = skb;
1006
1007		tx_cmd->pad = 0;
1008		tx_cmd->size = 0;
1009		tbd->pad = 0;
1010		tbd->size = SWAP16(EOF | length);
1011
1012		tx_cmd->dma_addr = dma_map_single(dev->dev.parent, skb->data,
1013						  skb->len, DMA_TO_DEVICE);
1014		tbd->data = SWAP32(tx_cmd->dma_addr);
1015
1016		DEB(DEB_TXADDR, print_eth(skb->data, "tx-queued"));
1017		DMA_WBACK_INV(dev, tx_cmd, sizeof(struct tx_cmd));
1018		DMA_WBACK_INV(dev, tbd, sizeof(struct i596_tbd));
1019		i596_add_cmd(dev, &tx_cmd->cmd);
1020
1021		dev->stats.tx_packets++;
1022		dev->stats.tx_bytes += length;
1023	}
1024
1025	netif_start_queue(dev);
1026
1027	return NETDEV_TX_OK;
1028}
1029
1030static void print_eth(unsigned char *add, char *str)
1031{
1032	printk(KERN_DEBUG "i596 0x%p, %pM --> %pM %02X%02X, %s\n",
1033	       add, add + 6, add, add[12], add[13], str);
1034}
1035static const struct net_device_ops i596_netdev_ops = {
1036	.ndo_open		= i596_open,
1037	.ndo_stop		= i596_close,
1038	.ndo_start_xmit		= i596_start_xmit,
1039	.ndo_set_rx_mode	= set_multicast_list,
1040	.ndo_tx_timeout		= i596_tx_timeout,
1041	.ndo_validate_addr	= eth_validate_addr,
1042	.ndo_set_mac_address	= eth_mac_addr,
1043#ifdef CONFIG_NET_POLL_CONTROLLER
1044	.ndo_poll_controller	= i596_poll_controller,
1045#endif
1046};
1047
1048static int i82596_probe(struct net_device *dev)
1049{
1050	int i;
1051	struct i596_private *lp = netdev_priv(dev);
1052	struct i596_dma *dma;
1053
1054	/* This lot is ensure things have been cache line aligned. */
1055	BUILD_BUG_ON(sizeof(struct i596_rfd) != 32);
1056	BUILD_BUG_ON(sizeof(struct i596_rbd) &  31);
1057	BUILD_BUG_ON(sizeof(struct tx_cmd)   &  31);
1058	BUILD_BUG_ON(sizeof(struct i596_tbd) != 32);
1059#ifndef __LP64__
1060	BUILD_BUG_ON(sizeof(struct i596_dma) > 4096);
1061#endif
1062
1063	if (!dev->base_addr || !dev->irq)
1064		return -ENODEV;
1065
1066	dma = dma_alloc_attrs(dev->dev.parent, sizeof(struct i596_dma),
1067			      &lp->dma_addr, GFP_KERNEL,
1068			      LIB82596_DMA_ATTR);
1069	if (!dma) {
1070		printk(KERN_ERR "%s: Couldn't get shared memory\n", __FILE__);
1071		return -ENOMEM;
1072	}
1073
1074	dev->netdev_ops = &i596_netdev_ops;
1075	dev->watchdog_timeo = TX_TIMEOUT;
1076
1077	memset(dma, 0, sizeof(struct i596_dma));
1078	lp->dma = dma;
1079
1080	dma->scb.command = 0;
1081	dma->scb.cmd = I596_NULL;
1082	dma->scb.rfd = I596_NULL;
1083	spin_lock_init(&lp->lock);
1084
1085	DMA_WBACK_INV(dev, dma, sizeof(struct i596_dma));
1086
1087	i = register_netdev(dev);
1088	if (i) {
1089		dma_free_attrs(dev->dev.parent, sizeof(struct i596_dma),
1090			       dma, lp->dma_addr, LIB82596_DMA_ATTR);
1091		return i;
1092	}
1093
1094	DEB(DEB_PROBE, printk(KERN_INFO "%s: 82596 at %#3lx, %pM IRQ %d.\n",
1095			      dev->name, dev->base_addr, dev->dev_addr,
1096			      dev->irq));
1097	DEB(DEB_INIT, printk(KERN_INFO
1098			     "%s: dma at 0x%p (%d bytes), lp->scb at 0x%p\n",
1099			     dev->name, dma, (int)sizeof(struct i596_dma),
1100			     &dma->scb));
1101
1102	return 0;
1103}
1104
1105#ifdef CONFIG_NET_POLL_CONTROLLER
1106static void i596_poll_controller(struct net_device *dev)
1107{
1108	disable_irq(dev->irq);
1109	i596_interrupt(dev->irq, dev);
1110	enable_irq(dev->irq);
1111}
1112#endif
1113
1114static irqreturn_t i596_interrupt(int irq, void *dev_id)
1115{
1116	struct net_device *dev = dev_id;
1117	struct i596_private *lp;
1118	struct i596_dma *dma;
1119	unsigned short status, ack_cmd = 0;
1120
1121	lp = netdev_priv(dev);
1122	dma = lp->dma;
1123
1124	spin_lock (&lp->lock);
1125
1126	wait_cmd(dev, dma, 100, "i596 interrupt, timeout");
1127	status = SWAP16(dma->scb.status);
1128
1129	DEB(DEB_INTS, printk(KERN_DEBUG
1130			     "%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1131			dev->name, dev->irq, status));
1132
1133	ack_cmd = status & 0xf000;
1134
1135	if (!ack_cmd) {
1136		DEB(DEB_ERRORS, printk(KERN_DEBUG
1137				       "%s: interrupt with no events\n",
1138				       dev->name));
1139		spin_unlock (&lp->lock);
1140		return IRQ_NONE;
1141	}
1142
1143	if ((status & 0x8000) || (status & 0x2000)) {
1144		struct i596_cmd *ptr;
1145
1146		if ((status & 0x8000))
1147			DEB(DEB_INTS,
1148			    printk(KERN_DEBUG
1149				   "%s: i596 interrupt completed command.\n",
1150				   dev->name));
1151		if ((status & 0x2000))
1152			DEB(DEB_INTS,
1153			    printk(KERN_DEBUG
1154				   "%s: i596 interrupt command unit inactive %x.\n",
1155				   dev->name, status & 0x0700));
1156
1157		while (lp->cmd_head != NULL) {
1158			DMA_INV(dev, lp->cmd_head, sizeof(struct i596_cmd));
1159			if (!(lp->cmd_head->status & SWAP16(STAT_C)))
1160				break;
1161
1162			ptr = lp->cmd_head;
1163
1164			DEB(DEB_STATUS,
1165			    printk(KERN_DEBUG
1166				   "cmd_head->status = %04x, ->command = %04x\n",
1167				   SWAP16(lp->cmd_head->status),
1168				   SWAP16(lp->cmd_head->command)));
1169			lp->cmd_head = ptr->v_next;
1170			lp->cmd_backlog--;
1171
1172			switch (SWAP16(ptr->command) & 0x7) {
1173			case CmdTx:
1174			    {
1175				struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
1176				struct sk_buff *skb = tx_cmd->skb;
1177
1178				if (ptr->status & SWAP16(STAT_OK)) {
1179					DEB(DEB_TXADDR,
1180					    print_eth(skb->data, "tx-done"));
1181				} else {
1182					dev->stats.tx_errors++;
1183					if (ptr->status & SWAP16(0x0020))
1184						dev->stats.collisions++;
1185					if (!(ptr->status & SWAP16(0x0040)))
1186						dev->stats.tx_heartbeat_errors++;
1187					if (ptr->status & SWAP16(0x0400))
1188						dev->stats.tx_carrier_errors++;
1189					if (ptr->status & SWAP16(0x0800))
1190						dev->stats.collisions++;
1191					if (ptr->status & SWAP16(0x1000))
1192						dev->stats.tx_aborted_errors++;
1193				}
1194				dma_unmap_single(dev->dev.parent,
1195						 tx_cmd->dma_addr,
1196						 skb->len, DMA_TO_DEVICE);
1197				dev_consume_skb_irq(skb);
1198
1199				tx_cmd->cmd.command = 0; /* Mark free */
1200				break;
1201			    }
1202			case CmdTDR:
1203			    {
1204				unsigned short status = SWAP16(((struct tdr_cmd *)ptr)->status);
1205
1206				if (status & 0x8000) {
1207					DEB(DEB_ANY,
1208					    printk(KERN_DEBUG "%s: link ok.\n",
1209						   dev->name));
1210				} else {
1211					if (status & 0x4000)
1212						printk(KERN_ERR
1213						       "%s: Transceiver problem.\n",
1214						       dev->name);
1215					if (status & 0x2000)
1216						printk(KERN_ERR
1217						       "%s: Termination problem.\n",
1218						       dev->name);
1219					if (status & 0x1000)
1220						printk(KERN_ERR
1221						       "%s: Short circuit.\n",
1222						       dev->name);
1223
1224					DEB(DEB_TDR,
1225					    printk(KERN_DEBUG "%s: Time %d.\n",
1226						   dev->name, status & 0x07ff));
1227				}
1228				break;
1229			    }
1230			case CmdConfigure:
1231				/*
1232				 * Zap command so set_multicast_list() know
1233				 * it is free
1234				 */
1235				ptr->command = 0;
1236				break;
1237			}
1238			ptr->v_next = NULL;
1239			ptr->b_next = I596_NULL;
1240			DMA_WBACK(dev, ptr, sizeof(struct i596_cmd));
1241			lp->last_cmd = jiffies;
1242		}
1243
1244		/* This mess is arranging that only the last of any outstanding
1245		 * commands has the interrupt bit set.  Should probably really
1246		 * only add to the cmd queue when the CU is stopped.
1247		 */
1248		ptr = lp->cmd_head;
1249		while ((ptr != NULL) && (ptr != lp->cmd_tail)) {
1250			struct i596_cmd *prev = ptr;
1251
1252			ptr->command &= SWAP16(0x1fff);
1253			ptr = ptr->v_next;
1254			DMA_WBACK_INV(dev, prev, sizeof(struct i596_cmd));
1255		}
1256
1257		if (lp->cmd_head != NULL)
1258			ack_cmd |= CUC_START;
1259		dma->scb.cmd = SWAP32(virt_to_dma(lp, &lp->cmd_head->status));
1260		DMA_WBACK_INV(dev, &dma->scb, sizeof(struct i596_scb));
1261	}
1262	if ((status & 0x1000) || (status & 0x4000)) {
1263		if ((status & 0x4000))
1264			DEB(DEB_INTS,
1265			    printk(KERN_DEBUG
1266				   "%s: i596 interrupt received a frame.\n",
1267				   dev->name));
1268		i596_rx(dev);
1269		/* Only RX_START if stopped - RGH 07-07-96 */
1270		if (status & 0x1000) {
1271			if (netif_running(dev)) {
1272				DEB(DEB_ERRORS,
1273				    printk(KERN_DEBUG
1274					   "%s: i596 interrupt receive unit inactive, status 0x%x\n",
1275					   dev->name, status));
1276				ack_cmd |= RX_START;
1277				dev->stats.rx_errors++;
1278				dev->stats.rx_fifo_errors++;
1279				rebuild_rx_bufs(dev);
1280			}
1281		}
1282	}
1283	wait_cmd(dev, dma, 100, "i596 interrupt, timeout");
1284	dma->scb.command = SWAP16(ack_cmd);
1285	DMA_WBACK(dev, &dma->scb, sizeof(struct i596_scb));
1286
1287	/* DANGER: I suspect that some kind of interrupt
1288	 acknowledgement aside from acking the 82596 might be needed
1289	 here...  but it's running acceptably without */
1290
1291	ca(dev);
1292
1293	wait_cmd(dev, dma, 100, "i596 interrupt, exit timeout");
1294	DEB(DEB_INTS, printk(KERN_DEBUG "%s: exiting interrupt.\n", dev->name));
1295
1296	spin_unlock (&lp->lock);
1297	return IRQ_HANDLED;
1298}
1299
1300static int i596_close(struct net_device *dev)
1301{
1302	struct i596_private *lp = netdev_priv(dev);
1303	unsigned long flags;
1304
1305	netif_stop_queue(dev);
1306
1307	DEB(DEB_INIT,
1308	    printk(KERN_DEBUG
1309		   "%s: Shutting down ethercard, status was %4.4x.\n",
1310		   dev->name, SWAP16(lp->dma->scb.status)));
1311
1312	spin_lock_irqsave(&lp->lock, flags);
1313
1314	wait_cmd(dev, lp->dma, 100, "close1 timed out");
1315	lp->dma->scb.command = SWAP16(CUC_ABORT | RX_ABORT);
1316	DMA_WBACK(dev, &lp->dma->scb, sizeof(struct i596_scb));
1317
1318	ca(dev);
1319
1320	wait_cmd(dev, lp->dma, 100, "close2 timed out");
1321	spin_unlock_irqrestore(&lp->lock, flags);
1322	DEB(DEB_STRUCT, i596_display_data(dev));
1323	i596_cleanup_cmd(dev, lp);
1324
1325	free_irq(dev->irq, dev);
1326	remove_rx_bufs(dev);
1327
1328	return 0;
1329}
1330
1331/*
1332 *    Set or clear the multicast filter for this adaptor.
1333 */
1334
1335static void set_multicast_list(struct net_device *dev)
1336{
1337	struct i596_private *lp = netdev_priv(dev);
1338	struct i596_dma *dma = lp->dma;
1339	int config = 0, cnt;
1340
1341	DEB(DEB_MULTI,
1342	    printk(KERN_DEBUG
1343		   "%s: set multicast list, %d entries, promisc %s, allmulti %s\n",
1344		   dev->name, netdev_mc_count(dev),
1345		   dev->flags & IFF_PROMISC ? "ON" : "OFF",
1346		   dev->flags & IFF_ALLMULTI ? "ON" : "OFF"));
1347
1348	if ((dev->flags & IFF_PROMISC) &&
1349	    !(dma->cf_cmd.i596_config[8] & 0x01)) {
1350		dma->cf_cmd.i596_config[8] |= 0x01;
1351		config = 1;
1352	}
1353	if (!(dev->flags & IFF_PROMISC) &&
1354	    (dma->cf_cmd.i596_config[8] & 0x01)) {
1355		dma->cf_cmd.i596_config[8] &= ~0x01;
1356		config = 1;
1357	}
1358	if ((dev->flags & IFF_ALLMULTI) &&
1359	    (dma->cf_cmd.i596_config[11] & 0x20)) {
1360		dma->cf_cmd.i596_config[11] &= ~0x20;
1361		config = 1;
1362	}
1363	if (!(dev->flags & IFF_ALLMULTI) &&
1364	    !(dma->cf_cmd.i596_config[11] & 0x20)) {
1365		dma->cf_cmd.i596_config[11] |= 0x20;
1366		config = 1;
1367	}
1368	if (config) {
1369		if (dma->cf_cmd.cmd.command)
1370			printk(KERN_INFO
1371			       "%s: config change request already queued\n",
1372			       dev->name);
1373		else {
1374			dma->cf_cmd.cmd.command = SWAP16(CmdConfigure);
1375			DMA_WBACK_INV(dev, &dma->cf_cmd, sizeof(struct cf_cmd));
1376			i596_add_cmd(dev, &dma->cf_cmd.cmd);
1377		}
1378	}
1379
1380	cnt = netdev_mc_count(dev);
1381	if (cnt > MAX_MC_CNT) {
1382		cnt = MAX_MC_CNT;
1383		printk(KERN_NOTICE "%s: Only %d multicast addresses supported",
1384			dev->name, cnt);
1385	}
1386
1387	if (!netdev_mc_empty(dev)) {
1388		struct netdev_hw_addr *ha;
1389		unsigned char *cp;
1390		struct mc_cmd *cmd;
1391
1392		cmd = &dma->mc_cmd;
1393		cmd->cmd.command = SWAP16(CmdMulticastList);
1394		cmd->mc_cnt = SWAP16(netdev_mc_count(dev) * 6);
1395		cp = cmd->mc_addrs;
1396		netdev_for_each_mc_addr(ha, dev) {
1397			if (!cnt--)
1398				break;
1399			memcpy(cp, ha->addr, ETH_ALEN);
1400			if (i596_debug > 1)
1401				DEB(DEB_MULTI,
1402				    printk(KERN_DEBUG
1403					   "%s: Adding address %pM\n",
1404					   dev->name, cp));
1405			cp += ETH_ALEN;
1406		}
1407		DMA_WBACK_INV(dev, &dma->mc_cmd, sizeof(struct mc_cmd));
1408		i596_add_cmd(dev, &cmd->cmd);
1409	}
1410}