Import of Linux/MIPS 1.3.0

1 files changed, 1120 insertions, 0 deletions

diff --git a/drivers/net/sonic.c b/drivers/net/sonic.c
new file mode 100644
index 000000000..62796c2d0
--- /dev/null
+++ b/drivers/net/sonic.c
@@ -0,0 +1,1120 @@
+/*
+ * sonic.c
+ *
+ * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
+ *
+ * A driver for the onboard Sonic ethernet controller on Mips Jazz
+ * systems (Acer Pica-61, Mips Magnum 4000, Olivetti M700 and
+ * perhaps others, too)
+ *
+ * NOTE: THIS DRIVER IS NOT OPERATIONAL YET! DO NOT TRY TO REALLY USE IT!
+ */
+
+
+static char *version =
+	"sonic.c:v0.01 6/16/95 Andreas Busse (andy@waldorf-gmbh.de)\n";
+
+#include <linux/config.h>
+
+/*
+ * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
+ * National Semiconductors data sheet for the DP83932B Sonic Ethernet
+ * controller, and the files "8390.c" and "skeleton.c" in this directory.
+ */
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/types.h>
+#include <linux/fcntl.h>
+#include <linux/interrupt.h>
+#include <linux/ptrace.h>
+#include <linux/ioport.h>
+#include <linux/in.h>
+#include <linux/malloc.h>
+#include <linux/string.h>
+#include <linux/delay.h>
+#include <asm/system.h>
+#include <asm/bitops.h>
+#include <asm/segment.h>
+#include <asm/io.h>
+#include <asm/dma.h>
+#include <asm/jazz.h>
+#include <asm/jazzdma.h>
+#include <linux/errno.h>
+
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+
+#include "sonic.h"
+
+extern struct device *init_etherdev(struct device *dev, int sizeof_private,
+				    unsigned long *mem_startp);
+
+/* use 0 for production, 1 for verification, >2 for debug */
+#ifndef NET_DEBUG
+#define NET_DEBUG 3
+#endif
+static unsigned int sonic_debug = NET_DEBUG;
+
+/*
+ * set to 1 if you just want to debug the driver without
+ * having a real network connection.
+ */
+#define SONIC_LOOPBACK     0
+#define SONIC_DRIVER_TEST  1
+
+/* Information that need to be kept for each board. */
+struct sonic_local {
+  char *memptr;					        /* ptr to memory used for all buffers */
+  SONIC_CAM_DESCRIPTOR_AREA *cda_vaddr; /* virtual CPU address of CDA */
+  unsigned int cda_laddr;		        /* logical DMA address of CDA */
+  SONIC_TRANSMIT_DESCRIPTOR *tda_vaddr;	/* virtual CPU address of TDA */
+  unsigned int tda_laddr;		        /* logical DMA address of TDA */
+  SONIC_RECEIVE_RESOURCE *rra_vaddr;    /* virtual CPU address of RRA */
+  unsigned int rra_laddr;		        /* logical DMA address of RRA */
+  SONIC_RECEIVE_DESCRIPTOR *rda_vaddr;  /* virtual CPU address of RDA */
+  unsigned int rda_laddr;		        /* logical DMA address of RDA */
+  unsigned int rd_next;                 /* the next RD where we expect data */
+  unsigned char *rba_vaddr; 	        /* virtual CPU address of RBA */
+  unsigned int rba_laddr;		        /* logical DMA address of RBA */
+  unsigned char *pkt_vaddr;		        /* virtual CPU address of tx buffer */
+  unsigned int pkt_laddr;		        /* logical DMA address of tx buffer */
+  struct enet_statistics stats;
+};
+
+/*
+ * We cannot use station (ethernet) address prefixes to detect the
+ * sonic controller since these are board manufacturer depended.
+ * So we check for known Silicon Revision IDs instead. 
+ */
+static unsigned short known_revisions[] =
+{
+  0x04,				/* Mips Magnum 4000 */
+  0xffff			/* end of list */
+};
+
+/* Index to functions, as function prototypes. */
+
+extern int sonic_probe(struct device *dev);
+
+static int sonic_open(struct device *dev);
+static int sonic_send_packet(struct sk_buff *skb, struct device *dev);
+static void sonic_interrupt(int irq, struct pt_regs *regs);
+static void sonic_rx(struct device *dev);
+static int sonic_close(struct device *dev);
+static struct enet_statistics *sonic_get_stats(struct device *dev);
+static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
+static int sonic_init(struct device *dev, int startp);
+static void sonic_init_tda(struct device *dev);
+static void sonic_init_rra(struct device *dev);
+static void sonic_init_rda(struct device *dev);
+static void sonic_init_cam(struct device *dev);
+static void sonic_load_cam(struct device *dev);
+static void sonic_dump_cam(void);
+static void sonic_test(struct device *dev);
+static void hardware_send_packet(struct device *dev, char *buf, int length);
+
+#define tx_done(dev) 1
+
+/*
+ * Probe for a SONIC ethernet controller on a Mips Jazz board.
+ * Either we find the Sonic controller at the usual location,
+ * or we don't deal with a Jazz board (or it's broken...)
+ */
+
+int sonic_probe(struct device *dev)
+{
+	static unsigned version_printed = 0;
+	unsigned int silicon_revision;
+	unsigned int val;
+	struct sonic_local *lp;
+	int i;
+
+	/*
+	 * get the Silicon Revision ID. If this is one of the known
+	 * one assume that we found a SONIC ethernet controller at
+	 * the expected location.
+	 */
+	silicon_revision = sonic_read_register(SONIC_SR);
+	if (sonic_debug > 1)
+		printk("SONIC Silicon Revision = 0x%04x\n",silicon_revision);
+
+	i = 0;
+	while ((known_revisions[i] != 0xffff) &&
+	       (known_revisions[i] != silicon_revision))
+		i++;
+	
+	if (known_revisions[i] == 0xffff) {
+		printk("SONIC ethernet controller not found (0x%4x)\n",
+			silicon_revision);
+		return ENODEV;
+	}
+	
+	/* Allocate a new 'dev' if needed. */
+	if (dev == NULL)
+		dev = init_etherdev(0, sizeof(struct sonic_local), 0);
+
+	if (sonic_debug  &&  version_printed++ == 0)
+		printk(version);
+
+	printk("%s: %s found at 0x%08x, ",
+		dev->name, "SONIC ethernet", SONIC_BASE_ADDR);
+
+	/* Fill in the 'dev' fields. */
+	dev->base_addr = SONIC_BASE_ADDR;
+
+
+	/*
+	 * Put the sonic into software reset, then
+	 * retrieve and print the ethernet address.
+	 */
+
+	sonic_write_register(SONIC_CMD,SONIC_CR_RST);
+	sonic_write_register(SONIC_CEP,0);
+	for (i=0; i<3; i++) {
+		val = sonic_read_register(SONIC_CAP0-i);
+		dev->dev_addr[i*2] = val;
+		dev->dev_addr[i*2+1] = val >> 8;
+	}
+
+	printk("HW Address ");
+	for (i = 0; i < 6; i++) {
+		printk("%2.2x", dev->dev_addr[i]);
+		if (i<5)
+			printk(":");
+	}
+
+	/*
+	 * We don't need to deal with auto-irq stuff since we
+	 * hardwire the sonic interrupt to JAZZ_ETHERNET_IRQ
+	 * (currently 15).
+	 */
+
+	val = request_irq(JAZZ_ETHERNET_IRQ, &sonic_interrupt, 0, "sonic");
+	if (val) {
+	  printk ("\n%s: unable to get IRQ %d (code %d).\n", dev->name,
+			  JAZZ_ETHERNET_IRQ, val);
+	  return EAGAIN;
+	}
+	dev->irq = JAZZ_ETHERNET_IRQ;
+	irq2dev_map[JAZZ_ETHERNET_IRQ] = dev;
+	if (sonic_debug > 1)
+	  printk(" IRQ %d\n", JAZZ_ETHERNET_IRQ);
+
+	/* Initialize the device structure. */
+	
+	if (dev->priv == NULL)
+		dev->priv = kmalloc(sizeof(struct sonic_local), GFP_KERNEL);
+	memset(dev->priv, 0, sizeof(struct sonic_local));
+
+	lp = (struct sonic_local *)dev->priv;
+	dev->open = sonic_open;
+	dev->stop = sonic_close;
+	dev->hard_start_xmit = sonic_send_packet;
+	dev->get_stats	= sonic_get_stats;
+	dev->set_multicast_list = &set_multicast_list;
+
+	/* Fill in the fields of the device structure with ethernet values. */
+
+	ether_setup(dev);
+	return 0;
+}
+
+
+/*
+ * Open/initialize the SONIC controller.
+ *
+ * This routine should set everything up anew at each open, even
+ *  registers that "should" only need to be set once at boot, so that
+ *  there is non-reboot way to recover if something goes wrong.
+ */
+
+static int sonic_open(struct device *dev)
+{
+	struct sonic_local *lp = (struct sonic_local *)dev->priv;
+	struct sk_buff *skb;		/* only for initial checks */
+	int i;
+
+	if (sonic_debug)
+	  printk("sonic_open: initializing sonic driver.\n");
+	
+	/*
+	 * Initialize the SONIC
+	 */
+	sonic_init(dev, 1);
+
+	dev->tbusy = 0;
+	dev->interrupt = 0;
+	dev->start = 1;
+
+	/*
+	 * This will be removed some day...
+	 */
+#if SONIC_DRIVER_TEST
+	sonic_test(dev);			/* go into test mode */
+#endif
+
+	if (sonic_debug)
+	  printk("sonic_open: Initialization done.\n");
+	
+	return 0;
+}
+
+static int sonic_send_packet(struct sk_buff *skb, struct device *dev)
+{
+  /*	struct sonic_local *lp = (struct sonic_local *)dev->priv; */
+
+  if (sonic_debug > 1)
+	printk("sonic_send_packet: skb=%p, dev=%p\n",skb,dev);
+  
+  if (dev->tbusy) {
+	int tickssofar = jiffies - dev->trans_start;
+
+	/* If we get here, some higher level has decided we are broken.
+	   There should really be a "kick me" function call instead. */
+
+	if (sonic_debug)
+	  printk("sonic_send_packet: called with dev->tbusy = 1 !\n");
+	
+	if (tickssofar < 5)
+	  return 1;
+	
+	printk("%s: transmit timed out, %s?\n", dev->name,
+		   tx_done(dev) ? "IRQ conflict" : "network cable problem");
+	
+	/* Try to restart the adaptor. */
+	sonic_init(dev, 1);
+	dev->tbusy=0;
+	dev->trans_start = jiffies;
+  }
+
+  /* If some higher layer thinks we've missed an tx-done interrupt
+	 we are passed NULL. Caution: dev_tint() handles the cli()/sti()
+	 itself. */
+
+  if (skb == NULL) {
+	dev_tint(dev);
+	return 0;
+  }
+
+  /* Block a timer-based transmit from overlapping.  This could better be
+	 done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
+
+  printk("sonic_send_packet: calling set_bit()\n");
+  
+  if (set_bit(0, (void*)&dev->tbusy) != 0)
+	printk("%s: Transmitter access conflict.\n", dev->name);
+  else {
+	short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
+	unsigned char *buf = skb->data;
+
+	if (sonic_debug)
+	  printk("sonic_send_packet: calling hardware_send_packet(%p,%p,%d)\n",
+			 dev,buf,length);
+
+	hardware_send_packet(dev, buf, length);
+	dev->trans_start = jiffies;
+  }
+  dev_kfree_skb (skb, FREE_WRITE);
+
+  /* You might need to clean up and record Tx statistics here. */
+#if 0
+  if (inw(ioaddr) ==			/*RU*/81)
+	lp->stats.tx_aborted_errors++;
+#endif
+	
+  return 0;
+}
+
+/*
+ * The typical workload of the driver:
+ * Handle the network interface interrupts.
+ */
+
+static void
+sonic_interrupt(int irq, struct pt_regs * regs)
+{
+  struct device *dev = (struct device *)(irq2dev_map[irq]);
+  struct sonic_local *lp;
+  int status;
+
+  printk("in sonic_interrupt()\n");
+  
+  if (dev == NULL) {
+	printk ("net_interrupt(): irq %d for unknown device.\n", irq);
+	return;
+  }
+  dev->interrupt = 1;
+  lp = (struct sonic_local *)dev->priv;
+
+  status = sonic_read_register(SONIC_ISR);
+  sonic_write_register(SONIC_ISR,0x7fff); /* clear all bits */
+  
+  if (sonic_debug > 2)
+	printk("sonic_interrupt: ISR=%x\n",status);
+  
+  if (status & SONIC_INT_PKTRX) {
+	sonic_rx(dev);				/* got packet(s) */
+  }
+  if (status & SONIC_INT_TXDN) {
+	lp->stats.tx_packets++;		/* packet transmitted */
+	dev->tbusy = 0;
+	mark_bh(NET_BH);			/* Inform upper layers. */
+  }
+  /*
+   * check error conditions
+   */
+  if (status & SONIC_INT_RFO)
+	lp->stats.rx_fifo_errors++;
+  if (status & (SONIC_INT_RDE | SONIC_INT_RBE | SONIC_INT_RBAE))
+	lp->stats.rx_over_errors++;
+  
+  /*
+   * clear interrupt bits and return
+   */
+  sonic_write_register(SONIC_ISR,status);
+  dev->interrupt = 0;
+  return;
+}
+
+/*
+ * We have a good packet(s), get it/them out of the buffers.
+ */
+
+static void
+sonic_rx(struct device *dev)
+{
+  struct sonic_local *lp;
+  SONIC_RECEIVE_DESCRIPTOR *current;
+  SONIC_RECEIVE_DESCRIPTOR *next;
+  int status;
+
+  lp = (struct sonic_local *)dev->priv;
+  current = lp->rda_vaddr + lp->rd_next;
+  next = lp->rda_vaddr + ((lp->rd_next + 1) & ~(SONIC_MAX_RDS));
+  
+  status = sonic_read_register(SONIC_RCR);
+  if (sonic_debug > 2)
+	printk("sonic_rx: RCR=%x, current=%p, next=%p, rx_status=%x, rx_pktlen=%x, rx_seqno=%x, link=%x, in_use=%x\n",
+		   status,current,next,current->rx_status,current->rx_pktlen,
+		   current->rx_seqno,current->link,current->in_use);
+#if 0  
+  if ((status & SONIC_RCR_PRX) == 0) /* any error ? */
+	{
+	  if (status & SONIC_RCR_FAER) lp->stats.rx_frame_errors++;
+	  if (status & SONIC_RCR_CRCR) lp->stats.rx_crc_errors++;
+	}
+#endif
+  /*
+   * Due to a SONIC bug the packet might still be ok,
+   * so we need to check the rx_status field first.
+   */
+
+  while(current->in_use == 0)
+	{
+	  struct sk_buff *skb;
+	  int pkt_len;
+	  char *pkt_ptr;
+	  int i;
+	  
+	  if ((current->rx_status & SONIC_RCR_PRX) == 0)
+		{
+		  if (status & SONIC_RCR_FAER) lp->stats.rx_frame_errors++;
+		  if (status & SONIC_RCR_CRCR) lp->stats.rx_crc_errors++;
+		}
+	  else
+		{
+		  pkt_len = current->rx_pktlen;
+		  pkt_ptr = (char *)KSEG1ADDR(vdma_log2phys((current->rx_pktptr_h << 16) +
+												current->rx_pktptr_l));
+		  printk("sonic_rx: packet at %p:\n",pkt_ptr);
+		  for (i=0; i<32; i++)
+			printk("%02x ",(unsigned char)pkt_ptr[i]);
+		  printk("\n");
+		  
+		  /* Malloc up new buffer. */
+
+		  printk("sonic_rx: allocating sk_buff...\n");
+		  skb = alloc_skb(pkt_len, GFP_ATOMIC);
+		  if (skb == NULL) {
+			printk("%s: Memory squeeze, dropping packet.\n", dev->name);
+			lp->stats.rx_dropped++;
+			break;
+		  }
+		  skb->len = pkt_len;
+		  skb->dev = dev;
+
+		  /* 'skb->data' points to the start of sk_buff data area. */
+		  
+		  printk("sonic_rx: copying packet from %p to %p\n",pkt_ptr,skb->data);
+		  memcpy(skb->data, (void*)pkt_ptr, pkt_len);
+
+		  printk("sonic_rx: passing packet to upper layer...\n");
+		  netif_rx(skb);			/* pass the packet to upper layers */
+		  lp->stats.rx_packets++;
+		  
+		  /*
+		   * Mark that RD as available again, increment (and possibly
+		   * wrap around) the RD index, and mark the current RD as
+		   * the last in the circular buffer. Also unmark the following RD.
+		   */
+
+		  current->in_use = 1;
+		  current->link |= SONIC_END_OF_LINKS;
+		  next->link &= ~SONIC_END_OF_LINKS;
+		  lp->rd_next = (lp->rd_next + 1) & (SONIC_MAX_RDS-1);
+		}
+	}
+  
+#if 0  
+  do {
+	int status = inw(ioaddr);
+	int pkt_len = inw(ioaddr);
+	  
+	if (pkt_len == 0)			/* Read all the frames? */
+	  break;					/* Done for now */
+
+	if (status & 0x40) {		/* There was an error. */
+	  lp->stats.rx_errors++;
+	  if (status & 0x20) lp->stats.rx_frame_errors++;
+	  if (status & 0x10) lp->stats.rx_over_errors++;
+	  if (status & 0x08) lp->stats.rx_crc_errors++;
+	  if (status & 0x04) lp->stats.rx_fifo_errors++;
+	} else {
+	  /* Malloc up new buffer. */
+	  struct sk_buff *skb;
+
+	  skb = alloc_skb(pkt_len, GFP_ATOMIC);
+	  if (skb == NULL) {
+		printk("%s: Memory squeeze, dropping packet.\n", dev->name);
+		lp->stats.rx_dropped++;
+		break;
+	  }
+	  skb->len = pkt_len;
+	  skb->dev = dev;
+
+	  /* 'skb->data' points to the start of sk_buff data area. */
+	  memcpy(skb->data, (void*)dev->rmem_start,
+			 pkt_len);
+	  /* or */
+	  insw(ioaddr, skb->data, (pkt_len + 1) >> 1);
+
+	  netif_rx(skb);			/* pass the packet to upper layers */
+	  lp->stats.rx_packets++;
+	}
+  } while (--boguscount);
+#endif
+  
+  /* If any worth-while packets have been received, dev_rint()
+	 has done a mark_bh(NET_BH) for us and will work on them
+	 when we get to the bottom-half routine. */
+  return;
+}
+
+
+/*
+ * Close the SONIC device
+ */
+static int
+sonic_close(struct device *dev)
+{
+	struct sonic_local *lp = (struct sonic_local *)dev->priv;
+
+/*	lp->open_time = 0; */
+
+	dev->tbusy = 1;
+	dev->start = 0;
+
+	/* Flush the Tx and disable Rx here. */
+	
+#if 0
+	disable_dma(dev->dma);
+
+	/* If not IRQ or DMA jumpered, free up the line. */
+	
+	outw(0x00, ioaddr+0);		/* Release the physical interrupt line. */
+
+	free_irq(dev->irq);			/* release the IRQ */
+	free_dma(dev->dma);
+	kfree(lp->memptr);			/* free memory */
+	
+	irq2dev_map[dev->irq] = 0;
+#endif
+
+#if 0	
+	/* disable ethernet IRQ on JAZZ boards */
+
+	r4030_write_reg16(JAZZ_IO_IRQ_ENABLE,
+					  r4030_read_reg16(JAZZ_IO_IRQ_ENABLE) &
+					  ~JAZZ_IE_ETHERNET);
+#endif
+	
+	/* Update the statistics here. */
+
+	return 0;
+
+}
+
+/*
+ * Get the current statistics.
+ * This may be called with the device open or closed.
+ */
+
+static struct enet_statistics *
+sonic_get_stats(struct device *dev)
+{
+	struct sonic_local *lp = (struct sonic_local *)dev->priv;
+	short ioaddr = dev->base_addr;
+
+	cli();
+	/* Update the statistics from the device registers. */
+	lp->stats.rx_missed_errors = inw(ioaddr+1);
+	sti();
+
+	return &lp->stats;
+}
+
+/*
+ * Set or clear the multicast filter for this adaptor.
+ * num_addrs == -1	Promiscuous mode, receive all packets
+ * num_addrs == 0	Normal mode, clear multicast list
+ * num_addrs > 0	Multicast mode, receive normal and MC packets, and do
+ *			        best-effort filtering.
+ */
+
+static void
+set_multicast_list(struct device *dev, int num_addrs, void *addrs)
+{
+  unsigned int rcr;
+
+  /* FIXME: don't know how to handle multicast */
+  
+  rcr = sonic_read_register(SONIC_RCR);
+  rcr |= SONIC_RCR_BRD; /* accept broadcast packets */
+  
+  if (sonic_debug > 2)
+	printk("set_multicast_list: RCR=%x\n",rcr);
+  
+  if (num_addrs == -1)
+	rcr |= SONIC_RCR_PRO;
+  else
+	rcr &= ~SONIC_RCR_PRO;
+  
+  if (sonic_debug > 2)
+	printk("set_multicast_list: setting RCR=%x\n",rcr);
+
+  sonic_write_register(SONIC_RCR,rcr);
+}
+
+
+/*
+ * Send a packet
+ */
+static void
+hardware_send_packet(struct device *dev, char *buf, int length)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;
+  unsigned int laddr;
+  volatile SONIC_TRANSMIT_DESCRIPTOR *td = lp->tda_vaddr;
+
+  /*
+   * Map the packet data into the logical DMA address space
+   */
+  vdma_remap(lp->pkt_laddr,PHYSADDR(buf),length);
+  laddr = lp->pkt_laddr + VDMA_OFFSET(buf);
+  
+#if 0
+  if (sonic_debug > 2)
+	printk("hardware_send_packet: buf=%p, laddr=%08x, length=%d\n",buf,laddr,length);
+#endif
+  /*
+   * Setup the transmit descriptor and issue the transmit command.
+   */
+
+  td->tx_status = 0;			/* clear status */
+  td->tx_config = 0;			/* no special configuration */
+  td->tx_pktsize = length;		/* length of packet */
+  td->tx_frag_count = 1;		/* single fragment */
+  td->tx_frag_ptr_l = laddr & 0xffff;
+  td->tx_frag_ptr_h = laddr >> 16;
+  td->tx_frag_size  = length;
+  td->link = (lp->tda_laddr & 0xffff) | SONIC_END_OF_LINKS;
+  
+  /* set the transmit descriptor pointers */
+
+  if (sonic_debug > 3)
+	printk("hardware_send_packet: setting TD pointers: laddr=%08x\n",lp->tda_laddr);
+
+  sonic_write_register(SONIC_UTDA, lp->tda_laddr >> 16);
+  sonic_write_register(SONIC_CTDA, lp->tda_laddr & 0xffff);
+  
+  if (sonic_debug > 3)
+	{
+	  printk("hardware_send_packet: td->tx_status = %x\n",
+			 td->tx_status);
+	  printk("hardware_send_packet: CMD=%x, UTDA=%x, CTDA=%x, TCR=%x, ISR=%x\n",
+			 sonic_read_register(SONIC_CMD),
+			 sonic_read_register(SONIC_UTDA),
+			 sonic_read_register(SONIC_CTDA),
+			 sonic_read_register(SONIC_TCR),
+			 sonic_read_register(SONIC_ISR));
+	  printk("hardware_send_packet: TPS=%x, TFC=%x, TSA0=%x, TSA1=%x, TFS=%x, TTDA=%x\n",
+			 sonic_read_register(SONIC_TPS),
+			 sonic_read_register(SONIC_TFC),
+			 sonic_read_register(SONIC_TSA0),
+			 sonic_read_register(SONIC_TSA1),
+			 sonic_read_register(SONIC_TFS),
+			 sonic_read_register(SONIC_TTDA));
+	}
+  
+  if (sonic_debug > 2)
+	printk("hardware_send_packet: issueing Tx command\n");
+
+  dev->tbusy=1;					/* XXXX needs to be removed later */
+  sonic_write_register(SONIC_CMD,SONIC_CR_TXP);
+
+  udelay(1000);
+
+  if (sonic_debug > 3)
+	{
+	  printk("hardware_send_packet: td->tx_status = %x\n",
+			 td->tx_status);
+	  printk("hardware_send_packet: CMD=%x, UTDA=%x, CTDA=%x, TCR=%x, ISR=%x\n",
+			 sonic_read_register(SONIC_CMD),
+			 sonic_read_register(SONIC_UTDA),
+			 sonic_read_register(SONIC_CTDA),
+			 sonic_read_register(SONIC_TCR),
+			 sonic_read_register(SONIC_ISR));
+	  printk("hardware_send_packet: TPS=%x, TFC=%x, TSA0=%x, TSA1=%x, TFS=%x, TTDA=%x\n",
+			 sonic_read_register(SONIC_TPS),
+			 sonic_read_register(SONIC_TFC),
+			 sonic_read_register(SONIC_TSA0),
+			 sonic_read_register(SONIC_TSA1),
+			 sonic_read_register(SONIC_TFS),
+			 sonic_read_register(SONIC_TTDA));
+	}
+}
+
+/*
+ * Initialize the SONIC ethernet controller.
+ */
+static int
+sonic_init(struct device *dev, int startp)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;
+  unsigned int cda_size,tda_size,rra_size,rda_size,rba_size;
+  unsigned int memneed;
+  char *memptr;
+  unsigned int laddr;
+  unsigned int cmd;
+
+  /*
+   * put the Sonic into software-reset mode and
+   * disable all interrupts
+   */
+  
+  sonic_write_register(SONIC_ISR,0x7fff);
+  sonic_write_register(SONIC_IMR,0);
+  sonic_write_register(SONIC_CMD,SONIC_CR_RST);
+  
+  /*
+   * allocate space for tx/rx control and buffers plus
+   * some pad bytes for alignment. Note that all buffers
+   * must be in the same 64k segment, so we alloc() and
+   * free() memory until we get such a memory block.
+   */
+  if (lp->memptr == NULL) {
+#if 1	
+	cda_size = (sizeof(SONIC_CAM_DESCRIPTOR_AREA) + 15) & ~15;
+	tda_size = (sizeof(SONIC_TRANSMIT_DESCRIPTOR) + 15) & ~15;
+	rra_size = (sizeof(SONIC_RECEIVE_RESOURCE) + 15) & ~15;
+	rda_size = ((sizeof(SONIC_RECEIVE_DESCRIPTOR) * SONIC_MAX_RDS) + 15) & ~15;
+	rba_size = SONIC_RXBUFSIZE;
+#else
+	cda_size = (sizeof(SONIC_CAM_DESCRIPTOR_AREA) + 31) & ~31;
+	tda_size = (sizeof(SONIC_TRANSMIT_DESCRIPTOR) + 31) & ~31;
+	rra_size = (sizeof(SONIC_RECEIVE_RESOURCE) + 31) & ~31;
+	rda_size = ((sizeof(SONIC_RECEIVE_DESCRIPTOR) * SONIC_MAX_RDS) + 31) & ~31;
+	rba_size = SONIC_RXBUFSIZE;
+#endif
+	if (sonic_debug > 2)
+	  printk("cda_size=%x, tda_size=%x, rra_size=%x, rda_size=%x, rba_size=%x\n",
+			 cda_size,tda_size,rra_size,rda_size,rba_size);
+
+	memneed = cda_size+tda_size+rra_size+rda_size+rba_size;
+	lp->memptr = kmalloc(memneed+32,GFP_KERNEL);
+	if (lp->memptr == NULL) {
+	  printk("sonic_open() failed (out of memory).\n");
+	  return -EAGAIN;
+	}
+
+	/*
+	 * If we don't get a memory block in a single 64kbyte area,
+	 * allocate new memory and the free the old block.
+	 */
+	while ((unsigned int)lp->memptr>>16 != ((unsigned int)lp->memptr+memneed+32)>>16) {
+	  memptr = lp->memptr;
+	  lp->memptr = kmalloc(memneed+32,GFP_KERNEL);
+	  kfree(memptr);
+	}
+	
+	/*
+	 * setup the buffer pointers
+	 */
+	lp->cda_vaddr = (SONIC_CAM_DESCRIPTOR_AREA *)((KSEG1ADDR(lp->memptr) + 15) & ~15);
+	lp->tda_vaddr = (SONIC_TRANSMIT_DESCRIPTOR *)(KSEG1ADDR(lp->cda_vaddr) + cda_size);
+	lp->rra_vaddr = (SONIC_RECEIVE_RESOURCE *)(KSEG1ADDR(lp->tda_vaddr) + tda_size);
+	lp->rda_vaddr = (SONIC_RECEIVE_DESCRIPTOR *)(KSEG1ADDR(lp->rra_vaddr) + rra_size);
+	lp->rba_vaddr = (char *)(KSEG1ADDR(lp->rda_vaddr) + rda_size);
+#if 0
+	if (sonic_debug > 2)
+	  printk("cda_v=%p, tda_v=%p, rra_v=%p, rda_v=%p, rba_v=%p\n",
+			 lp->cda_vaddr,lp->tda_vaddr,lp->rra_vaddr,lp->rda_vaddr,lp->rba_vaddr);
+#endif	
+	/*
+	 * allocate DMA pagetables
+	 */
+	laddr = vdma_alloc(PHYSADDR(lp->cda_vaddr),memneed);
+	if (laddr == 0xffffffff) {
+	  printk("sonic_open() failed (out of dma pagetables).\n");
+	  return -EAGAIN;
+	}
+	
+	lp->cda_laddr = laddr;
+	lp->tda_laddr = laddr + cda_size;
+	lp->rra_laddr = laddr + cda_size+tda_size;
+	lp->rda_laddr = laddr + cda_size+tda_size+rra_size;
+	lp->rba_laddr = laddr + cda_size+tda_size+rra_size+rda_size;
+#if 1	
+	if (sonic_debug > 2)
+	  printk("cda_l=%08x,tda_l=%08x,rra_l=%08x,rda_l=%08x,rba_l=%08x\n",
+			 lp->cda_laddr,lp->tda_laddr,lp->rra_laddr,lp->rda_laddr,lp->rba_laddr);
+#endif	
+  }
+
+  /*
+   * clear software reset flag, disable receiver, clear and
+   * enable interrupts, then completely initialize the SONIC
+   */
+  sonic_write_register(SONIC_CMD,0);
+  sonic_write_register(SONIC_CMD,SONIC_CR_RXDIS);
+#if 0  
+  r4030_write_reg16(JAZZ_IO_IRQ_ENABLE,JAZZ_IE_ETHERNET); /*
+					r4030_read_reg16(JAZZ_IO_IRQ_ENABLE) |
+					JAZZ_IE_ETHERNET); */
+#endif
+  if (sonic_debug > 2)
+	printk("sonic_init: initializing descriptors\n");
+
+  sonic_init_rra(dev);			/* initialize the receive resource area */
+  sonic_init_rda(dev);			/* initialize the receive descriptor area */
+  sonic_init_cam(dev);			/* load and init the CAM */
+  sonic_load_cam(dev);
+  sonic_init_tda(dev);			/* initialize the transmit descriptor */
+
+  /*
+   * Now enable the receiver, disable loopback
+   * and enable all interrupts
+   */
+  sonic_write_register(SONIC_CMD,SONIC_CR_RXEN | SONIC_CR_STP);
+#if SONIC_LOOPBACK
+  sonic_write_register(SONIC_RCR,SONIC_RCR_DEFAULT | SONIC_RCR_LB_ENDEC);
+#else
+  sonic_write_register(SONIC_RCR,SONIC_RCR_DEFAULT);
+#endif  
+  sonic_write_register(SONIC_TCR,SONIC_TCR_DEFAULT);
+  sonic_write_register(SONIC_ISR,0x7fff);
+  sonic_write_register(SONIC_IMR,SONIC_IMR_DEFAULT);
+
+  cmd = sonic_read_register(SONIC_CMD);
+  if ((cmd & SONIC_CR_RXEN) == 0 |
+	  (cmd & SONIC_CR_STP) == 0)
+	printk("sonic_init: failed, status=%x\n",cmd);
+
+  if (sonic_debug > 2)
+	printk("sonic_init: new status=%x\n",sonic_read_register(SONIC_CMD));
+
+  return(0);
+}
+
+/*
+ * Initialize the SONIC CAM
+ */
+
+static void
+sonic_init_cam(struct device *dev)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;  
+  SONIC_CAM_DESCRIPTOR_AREA *cam_area = lp->cda_vaddr;
+  int i;
+  
+  cam_area->cam_descriptors[0].cam_entry_pointer = 0;
+  cam_area->cam_descriptors[0].cam_frag2 = dev->dev_addr[1] << 8 | dev->dev_addr[0];
+  cam_area->cam_descriptors[0].cam_frag1 = dev->dev_addr[3] << 8 | dev->dev_addr[2];
+  cam_area->cam_descriptors[0].cam_frag0 = dev->dev_addr[5] << 8 | dev->dev_addr[4];
+
+  /* fill all other CAM ports by some test values */
+  
+  for (i=1; i<CAM_DESCRIPTORS; i++) {
+	cam_area->cam_descriptors[i].cam_entry_pointer = i;
+	cam_area->cam_descriptors[i].cam_frag2 = i*4;
+	cam_area->cam_descriptors[i].cam_frag1 = i*4+1;
+	cam_area->cam_descriptors[i].cam_frag0 = i*4+2;
+  }
+  cam_area->cam_enable = 0x1;		/* use only CAM entry 0 */
+}
+  
+/*
+ * Load the SONIC CAM (Content Adressable Memory)
+ * Actually, this isn't needed as long we're dealing
+ * with the hardware address configured by the BIOS,
+ * but we might want to use multiple hardware addresses.
+ * Later...
+ */
+static void
+sonic_load_cam(struct device *dev)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;
+
+  /*
+   * Clear software reset flag, disable receiver, then load the
+   * CAM with our hardware address(es).
+   * This assumes that the URRA (Upper Receive Resource Area)
+   * pointer has already been set.
+   */
+  sonic_write_register(SONIC_CMD,0);
+  sonic_write_register(SONIC_CMD,SONIC_CR_RXDIS);
+  sonic_write_register(SONIC_CE,(1<<CAM_DESCRIPTORS)-1);
+  sonic_write_register(SONIC_CDP, lp->cda_laddr & 0xffff);
+  sonic_write_register(SONIC_CDC,CAM_DESCRIPTORS);
+#if 0
+  if (sonic_debug > 2) {
+	printk("sonic_loadcam: CMD=%x, CME=%x, CDC=%x, CDP=%x, URRA=%x\n",
+		   sonic_read_register(SONIC_CMD),
+		   sonic_read_register(SONIC_CE),
+		   sonic_read_register(SONIC_CDC),
+		   sonic_read_register(SONIC_CDP),
+		   sonic_read_register(SONIC_URRA));
+	printk("sonic_loadcam: ISR=%x\n",sonic_read_register(SONIC_ISR));
+	printk("sonic_loadcam: issuing LCAM command\n");
+  }
+#endif
+  
+  /*
+   * Now load the CAM
+   */
+  sonic_write_register(SONIC_CMD,SONIC_CR_LCAM);
+  udelay(1000);
+  if ((sonic_read_register(SONIC_ISR) & SONIC_INT_LCD) == 0)
+	printk("sonic_load_cam: LCAM command failed!\n");
+  
+  if (sonic_debug > 2) {
+	printk("sonic_loadcam: CMD=%x, ISR=%x\n",
+		   sonic_read_register(SONIC_CMD),
+		   sonic_read_register(SONIC_ISR));
+	if (sonic_debug > 3)
+	  sonic_dump_cam();
+  }
+}  
+
+/*
+ * initialize the transmit descriptor
+ */
+static void
+sonic_init_tda(struct device *dev)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;
+  SONIC_TRANSMIT_DESCRIPTOR *td = lp->tda_vaddr;
+
+  td->tx_status = 0;
+  td->tx_config = 0;
+  td->tx_pktsize = 0;
+  td->tx_frag_count = 0;
+  td->link = SONIC_END_OF_LINKS;
+
+  sonic_write_register(SONIC_UTDA,lp->tda_laddr >> 16);
+  sonic_write_register(SONIC_CTDA,lp->tda_laddr & 0xffff);
+#if 0  
+  if (sonic_debug > 2)
+	printk("sonic_init_tda: UTDA=%x, CTDA=%x\n",
+		   sonic_read_register(SONIC_UTDA),
+		   sonic_read_register(SONIC_CTDA));
+#endif
+  /*
+   * Allocate two DMA page for mapping transmit data. Two
+   * are needed since the tx data may cross a page boundary.
+   */
+  lp->pkt_vaddr = NULL;			/* no data to send yet */
+  lp->pkt_laddr = vdma_alloc(0,VDMA_PAGESIZE*2);
+
+}
+
+/*
+ * initialize the receive resource area (RRA)
+ */
+static void
+sonic_init_rra(struct device *dev)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;
+  unsigned int rra_start;
+  unsigned int rra_end;
+
+  rra_start = lp->rra_laddr & 0xffff;
+  rra_end   = (rra_start + sizeof(SONIC_RECEIVE_RESOURCE)) & 0xffff;
+  
+  lp->rra_vaddr->rx_bufadr_l = lp->rba_laddr & 0xffff;
+  lp->rra_vaddr->rx_bufadr_h = lp->rba_laddr >> 16;
+  lp->rra_vaddr->rx_bufsize_l = SONIC_RXBUFSIZE & 0xffff;
+  lp->rra_vaddr->rx_bufsize_h = SONIC_RXBUFSIZE >> 16;
+
+  /* initialize all registers */
+  
+  sonic_write_register(SONIC_RSA,rra_start);
+  sonic_write_register(SONIC_REA,rra_end);
+  sonic_write_register(SONIC_RRP,rra_start);
+  sonic_write_register(SONIC_RWP,rra_end);
+  sonic_write_register(SONIC_URRA,lp->rra_laddr >> 16);
+
+  /* load the resource pointers */
+
+  if (sonic_debug > 2)
+	printk("sonic_init_rra: issueing RRRA command\n");
+  
+  sonic_write_register(SONIC_CMD,SONIC_CR_RRRA);
+  udelay(1000);
+  while(sonic_read_register(SONIC_CMD) & SONIC_CR_RRRA) {
+	if (sonic_debug > 2)
+	  printk(".");
+  }
+  if (sonic_debug > 2)
+	printk("sonic_init_rra: status=%x\n",sonic_read_register(SONIC_CMD));
+}
+
+  
+/*
+ * initialize the receive descriptor area (RDA)
+ */
+static void
+sonic_init_rda(struct device *dev)
+{
+  struct sonic_local *lp = (struct sonic_local *)dev->priv;
+  SONIC_RECEIVE_DESCRIPTOR *rd;
+  unsigned int laddr = lp->rda_laddr;
+  int i;
+
+  /*
+   * Initialize the receive descriptors so that they
+   * become a circular linked list, ie. let the last
+   * descriptor point to the first again.
+   */
+  rd = lp->rda_vaddr;
+  for (i=0; i<SONIC_MAX_RDS; i++) {
+	laddr += sizeof(SONIC_RECEIVE_DESCRIPTOR);
+	rd[i].rx_status = 0;
+	rd[i].rx_pktlen = 0;
+	rd[i].rx_pktptr_l = 0;
+	rd[i].rx_pktptr_h = 0;
+	rd[i].rx_seqno = 0;
+	rd[i].link = laddr & 0xffff;
+	rd[i].in_use = 1;			/* not in use */
+  }
+  rd[i-1].link = lp->rda_laddr | SONIC_END_OF_LINKS;
+  lp->rd_next = 0;
+  
+  sonic_write_register(SONIC_URDA,lp->rda_laddr >> 16);
+  sonic_write_register(SONIC_CRDA,lp->rda_laddr & 0xffff);
+
+}
+
+static void sonic_dump_cam()
+{
+  int i,j;
+  int val;
+
+  printk("sonic_dump_cam: CME=%x, CDC=%x, CDP=%x, URRA=%x\n",
+		 sonic_read_register(SONIC_CE),
+		 sonic_read_register(SONIC_CDC),
+		 sonic_read_register(SONIC_CDP),
+		 sonic_read_register(SONIC_URRA));
+  
+  sonic_write_register(SONIC_CMD,SONIC_CR_RST);
+  for (i=0; i<CAM_DESCRIPTORS; i++) {
+	sonic_write_register(SONIC_CEP,i);
+	printk("cam entry %d = ",i);
+	for (j=0; j<3; j++)
+	  printk("%04x ",sonic_read_register(SONIC_CAP0-j));
+	printk("\n");
+  }
+  
+  sonic_write_register(SONIC_CEP,0);
+  for (i=0; i<3; i++) {
+	val = sonic_read_register(SONIC_CAP0-i);
+	printk("%2.2x:%2.2x:",val&0xff,val>>8);
+  }
+  printk("\n");
+  sonic_write_register(SONIC_CMD,0); /* clear reset */
+}
+
+/*
+ * Let the driver check itself. We repeatedly send packets
+ * and expect them to be returned thru the Sonic loopback
+ * mode.
+ */
+#if SONIC_DRIVER_TEST
+static void sonic_test(struct device *dev)
+{
+  struct sk_buff *skb;
+  int i;
+  
+  printk("SONIC TEST MODE STARTED\n");
+
+  /*
+   * switch the sonic to promiscous mode if we don't
+   * use the loopback mode. Otherwise we won't receive
+   * anything except occasional broadcast packets.
+   */
+#if !SONIC_LOOPBACK
+  set_multicast_list(dev,-1,0);
+#endif
+  
+  /*
+   * allocate a single packet buffer and continously
+   * transmit this packet.
+   */
+  skb = (struct sk_buff *)KSEG1ADDR(kmalloc(sizeof(struct sk_buff)+128,GFP_KERNEL));
+  skb->len = 128;
+  for (i=0; i<6; i++) {
+	skb->data[i]   = dev->dev_addr[i]; /* dst address */
+	skb->data[i+6] = dev->dev_addr[i]; /* src address */
+  }
+  skb->data[12] = 0;
+  skb->data[13] = 128;
+  
+  for (i=0; i<32; i++)
+	skb->data[i+14] = i;
+  
+  printk("sonic_test: Sending: skb=%p, data=%p\n",skb,skb->data);
+  
+  while(1) {
+	hardware_send_packet(dev, skb->data, 128);
+	i = 1000;
+	while((dev->tbusy) && (--i))
+	  udelay(2000);
+	if (!i)
+	  printk("sonic_test: TRANSMIT FAILED!\n");
+	skb->data[14]++;
+  }
+}	
+#endif
+
+
+
+/*
+ * Local variables:
+ *  compile-command: "mips-linux-gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O2 -mcpu=r4000 -c sonic.c"
+ *  version-control: t
+ *  kept-new-versions: 5
+ *  tab-width: 4
+ * End:
+ */