Import of Linux/MIPS 2.1.14

1 files changed, 703 insertions, 933 deletions

diff --git a/drivers/net/sonic.c b/drivers/net/sonic.c
index 62796c2d0..75c30ca58 100644
--- a/drivers/net/sonic.c
+++ b/drivers/net/sonic.c
@@ -1,20 +1,20 @@
 /*
  * sonic.c
  *
+ * (C) 1996 by Thomas Bogendoerfer (tsbogend@bigbug.franken.de)
+ * 
+ * This driver is based on work from Andreas Busse, but most of
+ * the code is rewritten.
+ * 
  * (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>
+static const char *version =
+	"sonic.c:v0.10 6.7.96 tsbogend@bigbug.franken.de\n";
 
 /*
  * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
@@ -33,6 +33,8 @@ static char *version =
 #include <linux/malloc.h>
 #include <linux/string.h>
 #include <linux/delay.h>
+#include <asm/cache.h>
+#include <asm/bootinfo.h>
 #include <asm/system.h>
 #include <asm/bitops.h>
 #include <asm/segment.h>
@@ -48,39 +50,52 @@ static char *version =
 
 #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
+#ifdef SONIC_DEBUG
+static unsigned int sonic_debug = SONIC_DEBUG;
+#else 
+static unsigned int sonic_debug = 2;
 #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.
+ * Some tunables for the buffer areas. Power of 2 is required
+ * the current driver uses one receive buffer for each descriptor.
+ */
+#define SONIC_NUM_RRS    16             /* number of receive resources */
+#define SONIC_NUM_RDS    SONIC_NUM_RRS  /* number of receive descriptors */
+#define SONIC_NUM_TDS    16      /* number of transmit descriptors */
+#define SONIC_RBSIZE   1520      /* size of one resource buffer */
+
+#define SONIC_RDS_MASK   (SONIC_NUM_RDS-1)
+#define SONIC_TDS_MASK   (SONIC_NUM_TDS-1)
+
+/*
+ * Base address and interupt of the SONIC controller on JAZZ boards
  */
-#define SONIC_LOOPBACK     0
-#define SONIC_DRIVER_TEST  1
+static struct {
+    unsigned int port;
+    unsigned int irq;
+    } sonic_portlist[] = { {JAZZ_ETHERNET_BASE, JAZZ_ETHERNET_IRQ}, {0, 0}};
+
 
 /* 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;
+    sonic_cda_t   cda;                     /* virtual CPU address of CDA */
+    sonic_td_t    tda[SONIC_NUM_TDS];      /* transmit descriptor area */
+    sonic_rr_t    rra[SONIC_NUM_RRS];      /* receive resource arrea */
+    sonic_rd_t    rda[SONIC_NUM_RDS];      /* receive descriptor area */
+    struct sk_buff* tx_skb[SONIC_NUM_TDS]; /* skbuffs for packets to transmit */
+    unsigned int  tx_laddr[SONIC_NUM_TDS]; /* logical DMA address fro skbuffs */
+    unsigned char *rba;                    /* start of receive buffer areas */    
+    unsigned int  cda_laddr;               /* logical DMA address of CDA */    
+    unsigned int  tda_laddr;               /* logical DMA address of TDA */
+    unsigned int  rra_laddr;               /* logical DMA address of RRA */    
+    unsigned int  rda_laddr;               /* logical DMA address of RDA */
+    unsigned int  rba_laddr;               /* logical DMA address of RBA */
+    unsigned int  cur_tx, cur_rx;          /* current indexes to resource areas */
+    unsigned int  dirty_tx,cur_rra;        /* last unacked transmit packet */
+    char tx_full;
+    struct enet_statistics stats;
 };
 
 /*
@@ -97,131 +112,179 @@ static unsigned short known_revisions[] =
 /* Index to functions, as function prototypes. */
 
 extern int sonic_probe(struct device *dev);
-
+static int sonic_probe1(struct device *dev, unsigned int base_addr, unsigned int irq);
 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_interrupt(int irq, void *dev_id, 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
+static void sonic_multicast_list(struct device *dev);
+static int sonic_init(struct device *dev);
+
 
 /*
  * 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...)
+ * Actually probing is superfluous but we're paranoid.
  */
-
 int sonic_probe(struct device *dev)
 {
-	static unsigned version_printed = 0;
-	unsigned int silicon_revision;
-	unsigned int val;
-	struct sonic_local *lp;
-	int i;
+    unsigned int base_addr = dev ? dev->base_addr : 0;
+    int i;
+
+    /*
+     * Don't probe if we're not running on a Jazz board.
+     */
+    if (mips_machgroup != MACH_GROUP_JAZZ)
+	return -ENODEV;
+    if (base_addr > 0x1ff)	/* Check a single specified location. */
+	return sonic_probe1(dev, base_addr, dev->irq);
+    else if (base_addr != 0)	/* Don't probe at all. */
+	return -ENXIO;
+    
+    for (i = 0; sonic_portlist[i].port; i++) {
+	int base_addr = sonic_portlist[i].port;
+	if (check_region(base_addr, 0x100))
+	    continue;
+	if (sonic_probe1(dev, base_addr, sonic_portlist[i].irq) == 0)
+	    return 0;
+    }
+    return -ENODEV;
+}
 
+static int
+sonic_probe1(struct device *dev, unsigned int base_addr, unsigned int irq)
+{
+    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(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;
+    }
+    
+    request_region(base_addr, 0x100, "SONIC");
+    
+    /* Allocate a new 'dev' if needed. */
+    if (dev == NULL)
+      dev = init_etherdev(0, sizeof(struct sonic_local));
+
+    if (sonic_debug  &&  version_printed++ == 0)
+      printk(version);
+
+    printk("%s: %s found at 0x%08x, ",
+	   dev->name, "SONIC ethernet", base_addr);
+
+    /* Fill in the 'dev' fields. */
+    dev->base_addr = base_addr;
+    dev->irq = irq;
+
+    /*
+     * Put the sonic into software reset, then
+     * retrieve and print the ethernet address.
+     */
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_RST);
+    SONIC_WRITE(SONIC_CEP,0);
+    for (i=0; i<3; i++) {
+	val = SONIC_READ(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(":");
+    }
+    
+    printk(" IRQ %d\n", irq);
+    
+    /* Initialize the device structure. */
+    if (dev->priv == NULL) {
 	/*
-	 * 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.
+	 * the memory be located in the same 64kb segment
 	 */
-	silicon_revision = sonic_read_register(SONIC_SR);
-	if (sonic_debug > 1)
-		printk("SONIC Silicon Revision = 0x%04x\n",silicon_revision);
-
+	lp = NULL;
 	i = 0;
-	while ((known_revisions[i] != 0xffff) &&
-	       (known_revisions[i] != silicon_revision))
-		i++;
+	do {
+	    lp = (struct sonic_local *)kmalloc(sizeof(*lp), GFP_KERNEL);
+	    if ((unsigned long)lp >> 16 != ((unsigned long)lp + sizeof(*lp) ) >> 16) {
+		/* FIXME, free the memory later */
+		kfree (lp);
+		lp = NULL;
+	    }
+	} while (lp == NULL && i++ < 20);
 	
-	if (known_revisions[i] == 0xffff) {
-		printk("SONIC ethernet controller not found (0x%4x)\n",
-			silicon_revision);
-		return ENODEV;
+	if (lp == NULL) {
+	    printk ("%s: couldn't allocate memory for descriptors\n",
+	            dev->name);
+	    return -ENOMEM;
 	}
 	
-	/* 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;
+	memset(lp, 0, sizeof(struct sonic_local));
+	
+	/* get the virtual dma address */
+	lp->cda_laddr = vdma_alloc(PHYSADDR(lp),sizeof(*lp));
+	if (lp->cda_laddr == ~0UL) {
+	    printk ("%s: couldn't get DMA page entry for descriptors\n",
+	            dev->name);
+	    return -ENOMEM;
 	}
 
-	printk("HW Address ");
-	for (i = 0; i < 6; i++) {
-		printk("%2.2x", dev->dev_addr[i]);
-		if (i<5)
-			printk(":");
+	lp->tda_laddr = lp->cda_laddr + sizeof (lp->cda);
+	lp->rra_laddr = lp->tda_laddr + sizeof (lp->tda);
+	lp->rda_laddr = lp->rra_laddr + sizeof (lp->rra);
+	
+	/* allocate receive buffer area */
+	/* FIXME, maybe we should use skbs */
+	if ((lp->rba = (char *)kmalloc(SONIC_NUM_RRS * SONIC_RBSIZE, GFP_KERNEL)) == NULL) {
+	    printk ("%s: couldn't allocate receive buffers\n",dev->name);
+	    return -ENOMEM;
 	}
-
-	/*
-	 * 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;
+	
+	/* get virtual dma address */
+	if ((lp->rba_laddr = vdma_alloc(PHYSADDR(lp->rba),SONIC_NUM_RRS * SONIC_RBSIZE)) == ~0UL) {
+	    printk ("%s: couldn't get DMA page entry for receive buffers\n",dev->name);
+	    return -ENOMEM;
 	}
-	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;
+	/* now convert pointer to KSEG1 pointer */
+	lp->rba = (char *)KSEG1ADDR(lp->rba);
+	cacheflush (lp, sizeof(*lp), CF_DCACHE|CF_ALL);	
+	dev->priv = (struct sonic_local *)KSEG1ADDR(lp);
+    }
+
+    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 = &sonic_multicast_list;
+
+    /* Fill in the fields of the device structure with ethernet values. */
+    ether_setup(dev);
+    return 0;
 }
 
-
 /*
  * Open/initialize the SONIC controller.
  *
@@ -229,890 +292,597 @@ int sonic_probe(struct device *dev)
  *  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");
+    if (sonic_debug > 2)
+      printk("sonic_open: initializing sonic driver.\n");
+    
+    /*
+     * We don't need to deal with auto-irq stuff since we
+     * hardwire the sonic interrupt.
+     */
+/*
+ * XXX Horrible work around:  We install sonic_interrupt as fast interrupt.
+ * This means that during execution of the handler interrupt are disabled
+ * covering another bug otherwise corrupting data.  This doesn't mean
+ * this glue works ok under all situations.
+ */
+//    if (request_irq(dev->irq, &sonic_interrupt, 0, "sonic", dev)) {
+    if (request_irq(dev->irq, &sonic_interrupt, SA_INTERRUPT, "sonic", dev)) {
+	printk ("\n%s: unable to get IRQ %d .\n", dev->name, dev->irq);
+	return EAGAIN;
+    }
+
+    /*
+     * Initialize the SONIC
+     */
+    sonic_init(dev);
+
+    dev->tbusy = 0;
+    dev->interrupt = 0;
+    dev->start = 1;
+
+    if (sonic_debug > 2)
+      printk("sonic_open: Initialization done.\n");
 	
-	/*
-	 * Initialize the SONIC
-	 */
-	sonic_init(dev, 1);
-
-	dev->tbusy = 0;
-	dev->interrupt = 0;
-	dev->start = 1;
+    return 0;
+}
 
-	/*
-	 * 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;
+/*
+ * Close the SONIC device
+ */
+static int
+sonic_close(struct device *dev)
+{
+    unsigned int base_addr = dev->base_addr;
+    
+    if (sonic_debug > 2)
+      printk ("sonic_close\n");
+
+    dev->tbusy = 1;
+    dev->start = 0;
+    
+    /*
+     * stop the SONIC, disable interrupts
+     */
+    SONIC_WRITE(SONIC_ISR,0x7fff);
+    SONIC_WRITE(SONIC_IMR,0);
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_RST);
+
+    free_irq(dev->irq, dev);			/* release the IRQ */
+
+    return 0;
 }
 
+
+/*
+ * transmit packet
+ */
 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) {
+    struct sonic_local *lp = (struct sonic_local *)dev->priv;
+    unsigned int base_addr = dev->base_addr;
+    unsigned int laddr;
+    int entry,length;
+    
+    if (sonic_debug > 2)
+      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)
+	 There should really be a "kick me" function call instead. */
+      
+	if (sonic_debug > 1)
 	  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");
+	printk("%s: transmit timed out.\n", dev->name);
 	
 	/* Try to restart the adaptor. */
-	sonic_init(dev, 1);
+	sonic_init(dev);
 	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) {
+    }
+
+    /*
+     * 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)
+    /* 
+     * Block a timer-based transmit from overlapping.  This could better be
+     * done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
+     */
+    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;
+	return 1;
+    }
+    
+    /*
+     * Map the packet data into the logical DMA address space
+     */
+    if ((laddr = vdma_alloc(PHYSADDR(skb->data),skb->len)) == ~0UL) {
+	printk("%s: no VDMA entry for transmit available.\n",dev->name);
+	dev_kfree_skb(skb,FREE_WRITE);
+	dev->tbusy = 0;
+	return 1;
+    }
+    entry = lp->cur_tx & SONIC_TDS_MASK;    
+    lp->tx_laddr[entry] = laddr;
+    lp->tx_skb[entry] = skb;
+    
+    length = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
+    cacheflush((void *)skb->data, length, CF_DCACHE|CF_ALL);
+    
+    /*
+     * Setup the transmit descriptor and issue the transmit command.
+     */
+    lp->tda[entry].tx_status = 0;		/* clear status */
+    lp->tda[entry].tx_frag_count = 1;		/* single fragment */
+    lp->tda[entry].tx_pktsize = length;		/* length of packet */    
+    lp->tda[entry].tx_frag_ptr_l = laddr & 0xffff;
+    lp->tda[entry].tx_frag_ptr_h = laddr >> 16;
+    lp->tda[entry].tx_frag_size  = length;
+    
+    /* if there are already packets queued, allow sending serveral packets at once */
+    if (lp->dirty_tx != lp->cur_tx)
+	lp->tda[(lp->cur_tx-1) % SONIC_TDS_MASK].link &= ~SONIC_END_OF_LINKS;
+    
+    lp->cur_tx++;
+    
+    if (sonic_debug > 2)
+      printk("sonic_send_packet: issueing Tx command\n");
+
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_TXP);
+
+    dev->trans_start = jiffies;
+
+    if (lp->cur_tx < lp->dirty_tx + SONIC_NUM_TDS)
+      dev->tbusy = 0;
+    else
+      lp->tx_full = 1;
+    
+    return 0;
 }
+
 
 /*
  * The typical workload of the driver:
  * Handle the network interface interrupts.
  */
-
 static void
-sonic_interrupt(int irq, struct pt_regs * regs)
+sonic_interrupt(int irq, void *dev_id, struct pt_regs * regs)
 {
-  struct device *dev = (struct device *)(irq2dev_map[irq]);
-  struct sonic_local *lp;
-  int status;
+    struct device *dev = (struct device *)dev_id;
+    unsigned int base_addr = dev->base_addr;
+    struct sonic_local *lp;
+    int status;
 
-  printk("in sonic_interrupt()\n");
-  
-  if (dev == NULL) {
-	printk ("net_interrupt(): irq %d for unknown device.\n", irq);
+    if (dev == NULL) {
+	printk ("sonic_interrupt: irq %d for unknown device.\n", irq);
 	return;
-  }
-  dev->interrupt = 1;
-  lp = (struct sonic_local *)dev->priv;
+    }
+    dev->interrupt = 1;
+    lp = (struct sonic_local *)dev->priv;
 
-  status = sonic_read_register(SONIC_ISR);
-  sonic_write_register(SONIC_ISR,0x7fff); /* clear all bits */
+    status = SONIC_READ(SONIC_ISR);
+    SONIC_WRITE(SONIC_ISR,0x7fff); /* clear all bits */
   
-  if (sonic_debug > 2)
-	printk("sonic_interrupt: ISR=%x\n",status);
-  
-  if (status & SONIC_INT_PKTRX) {
+    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)
+    }
+    
+    if (status & SONIC_INT_TXDN) {
+	int dirty_tx = lp->dirty_tx;
+	
+	while (dirty_tx < lp->cur_tx) {
+	    int entry = dirty_tx & SONIC_TDS_MASK;
+	    int status = lp->tda[entry].tx_status;
+	    
+	    if (sonic_debug > 3)
+	      printk ("sonic_interrupt: status %d, cur_tx %d, dirty_tx %d\n",
+		      status,lp->cur_tx,lp->dirty_tx);
+	    
+	    if (status == 0)
+	      break;			/* It still hasn't been Txed */
+
+	    /* put back EOL and free descriptor */
+	    lp->tda[entry].link |= SONIC_END_OF_LINKS;
+	    lp->tda[entry].tx_status = 0;
+
+	    if (status & 0x0001)
+	      lp->stats.tx_packets++;
+	    else {
+		lp->stats.tx_errors++;
+		if (status & 0x0642) lp->stats.tx_aborted_errors++;
+		if (status & 0x0180) lp->stats.tx_carrier_errors++;
+		if (status & 0x0020) lp->stats.tx_window_errors++;
+		if (status & 0x0004) lp->stats.tx_fifo_errors++;
+	    }
+
+	    /* We must free the original skb */
+	    if (lp->tx_skb[entry]) {
+		dev_kfree_skb(lp->tx_skb[entry],FREE_WRITE);
+		lp->tx_skb[entry] = 0;
+	    }
+	    /* and the VDMA address */
+	    vdma_free(lp->tx_laddr[entry]);
+	    dirty_tx++;
+	}
+	
+	if (lp->tx_full && dev->tbusy
+	    && dirty_tx + SONIC_NUM_TDS > lp->cur_tx + 2) {
+	    /* The ring is no longer full, clear tbusy. */
+	    lp->tx_full = 0;
+	    dev->tbusy = 0;
+	    mark_bh(NET_BH);
+	}
+	
+	lp->dirty_tx = dirty_tx;
+    }
+    
+    /*
+     * check error conditions
+     */
+    if (status & SONIC_INT_RFO) {
+	printk ("%s: receive fifo underrun\n",dev->name);
 	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;
+    }
+    if (status & SONIC_INT_RDE) {
+	printk ("%s: receive descriptors exhausted\n",dev->name);
+	lp->stats.rx_dropped++;
+    }
+    if (status & SONIC_INT_RBE) {
+	printk ("%s: receive buffer exhausted\n",dev->name);
+	lp->stats.rx_dropped++;	
+    }
+    if (status & SONIC_INT_RBAE) {
+	printk ("%s: receive buffer area exhausted\n",dev->name);
+	lp->stats.rx_dropped++;	
+    }
+
+    /* counter overruns; all counters are 16bit wide */
+    if (status & SONIC_INT_FAE)
+      lp->stats.rx_frame_errors += 65536;
+    if (status & SONIC_INT_CRC)
+      lp->stats.rx_crc_errors += 65536;
+    if (status & SONIC_INT_MP)
+      lp->stats.rx_missed_errors += 65536;
+
+    /* transmit error */
+    if (status & SONIC_INT_TXER)
+      lp->stats.tx_errors++;
+    
+    /*
+     * clear interrupt bits and return
+     */
+    SONIC_WRITE(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) {
+    unsigned int base_addr = dev->base_addr;
+    struct sonic_local *lp = (struct sonic_local *)dev->priv;
+    int entry = lp->cur_rx & SONIC_RDS_MASK;
+    int status;
+
+    while(lp->rda[entry].in_use == 0)
+    {
+	struct sk_buff *skb;
+	int pkt_len;
+	unsigned char *pkt_ptr;
+	
+	status = lp->rda[entry].rx_status;
+	if (sonic_debug > 3)
+	  printk ("status %x, cur_rx %d, cur_rra %d\n",status,lp->cur_rx,lp->cur_rra);
+	if (status & SONIC_RCR_PRX) {	    
+	    pkt_len = lp->rda[entry].rx_pktlen;
+	    pkt_ptr = (char *)KSEG1ADDR(vdma_log2phys((lp->rda[entry].rx_pktptr_h << 16) +
+						      lp->rda[entry].rx_pktptr_l));
+	    
+	    if (sonic_debug > 3)
+	      printk ("pktptr %p (rba %p) h:%x l:%x, rra h:%x l:%x bsize h:%x l:%x\n", pkt_ptr,lp->rba,
+		      lp->rda[entry].rx_pktptr_h,lp->rda[entry].rx_pktptr_l,
+		      lp->rra[lp->cur_rra & 15].rx_bufadr_h,lp->rra[lp->cur_rra & 15].rx_bufadr_l,
+		      SONIC_READ(SONIC_RBWC1),SONIC_READ(SONIC_RBWC0));
+	
+	    /* Malloc up new buffer. */
+	    skb = dev_alloc_skb(pkt_len+2);
+	    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++;
+	    }
+	    skb->dev = dev;
+	    skb_reserve(skb,2);	/* 16 byte align */
+	    skb_put(skb,pkt_len);	/* Make room */
+	    eth_copy_and_sum(skb, pkt_ptr, pkt_len, 0);
+	    skb->protocol=eth_type_trans(skb,dev);
+	    netif_rx(skb);			/* pass the packet to upper layers */
+	    lp->stats.rx_packets++;
+	    
+	} else {
+	    /* This should only happen, if we enable accepting broken packets. */
+	    lp->stats.rx_errors++;
+	    if (status & SONIC_RCR_FAER) lp->stats.rx_frame_errors++;
+	    if (status & SONIC_RCR_CRCR) lp->stats.rx_crc_errors++;
 	}
-  } while (--boguscount);
-#endif
+	
+	lp->rda[entry].in_use = 1;
+	entry = (++lp->cur_rx) & SONIC_RDS_MASK;
+	/* now give back the buffer to the receive buffer area */
+	if (status & SONIC_RCR_LPKT) {
+	    /*
+	     * this was the last packet out of the current receice buffer
+	     * give the buffer back to the SONIC
+	     */
+	    SONIC_WRITE(SONIC_RWP,(lp->rra_laddr + (++lp->cur_rra & 15) * sizeof(sonic_rr_t)) & 0xffff);
+	}
+    }
   
-  /* 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;
+    /* 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;
+    struct sonic_local *lp = (struct sonic_local *)dev->priv;
+    unsigned int base_addr = dev->base_addr;
+
+    /* read the tally counter from the SONIC and reset them */
+    lp->stats.rx_crc_errors += SONIC_READ(SONIC_CRCT);
+    SONIC_WRITE(SONIC_CRCT,0xffff);
+    lp->stats.rx_frame_errors += SONIC_READ(SONIC_FAET);
+    SONIC_WRITE(SONIC_FAET,0xffff);
+    lp->stats.rx_missed_errors += SONIC_READ(SONIC_MPT);
+    SONIC_WRITE(SONIC_MPT,0xffff);
+    
+    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)
+sonic_multicast_list(struct device *dev)
 {
-  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)
+    struct sonic_local *lp = (struct sonic_local *)dev->priv;    
+    unsigned int base_addr = dev->base_addr;    
+    unsigned int rcr;
+    struct dev_mc_list *dmi = dev->mc_list;
+    unsigned char *addr;
+    int i;
+
+    rcr = SONIC_READ(SONIC_RCR) & ~(SONIC_RCR_PRO | SONIC_RCR_AMC);
+    rcr |= SONIC_RCR_BRD; /* accept broadcast packets */
+    
+    if (dev->flags & IFF_PROMISC) {         /* set promiscuous mode */
 	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));
+    } else {
+	if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 15)) {
+	    rcr |= SONIC_RCR_AMC;
+	} else {
+	    if (sonic_debug > 2)
+	      printk ("sonic_multicast_list: mc_count %d\n",dev->mc_count);
+	    lp->cda.cam_enable = 1; /* always enable our own address */
+	    for (i = 1; i <= dev->mc_count; i++) {
+		addr = dmi->dmi_addr;
+		dmi = dmi->next;
+		lp->cda.cam_desc[i].cam_frag2 = addr[1] << 8 | addr[0];
+		lp->cda.cam_desc[i].cam_frag1 = addr[3] << 8 | addr[2];
+		lp->cda.cam_desc[i].cam_frag0 = addr[5] << 8 | addr[4];
+		lp->cda.cam_enable |= (1 << i);
+	    }
+	    /* number of CAM entries to load */
+	    SONIC_WRITE(SONIC_CDC,dev->mc_count+1);
+	    /* issue Load CAM command */
+	    SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);	    
+	    SONIC_WRITE(SONIC_CMD,SONIC_CR_LCAM);	    
 	}
+    }
+    
+    if (sonic_debug > 2)
+      printk("sonic_multicast_list: setting RCR=%x\n",rcr);
+    
+    SONIC_WRITE(SONIC_RCR,rcr);
 }
 
+
 /*
  * Initialize the SONIC ethernet controller.
  */
 static int
-sonic_init(struct device *dev, int startp)
+sonic_init(struct device *dev)
 {
-  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);
+    unsigned int base_addr = dev->base_addr;
+    unsigned int cmd;
+    struct sonic_local *lp = (struct sonic_local *)dev->priv;
+    unsigned int rra_start;
+    unsigned int rra_end;
+    int i;
+    
+    /*
+     * put the Sonic into software-reset mode and
+     * disable all interrupts
+     */
+    SONIC_WRITE(SONIC_ISR,0x7fff);
+    SONIC_WRITE(SONIC_IMR,0);
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_RST);
+  
+    /*
+     * clear software reset flag, disable receiver, clear and
+     * enable interrupts, then completely initialize the SONIC
+     */
+    SONIC_WRITE(SONIC_CMD,0);
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_RXDIS);
+
+
+    /*
+     * initialize the receive resource area
+     */
+    if (sonic_debug > 2)
+      printk ("sonic_init: initialize receive resource area\n");
+    
+    rra_start = lp->rra_laddr & 0xffff;
+    rra_end   = (rra_start + (SONIC_NUM_RRS * sizeof(sonic_rr_t))) & 0xffff;
+  
+    for (i = 0; i < SONIC_NUM_RRS; i++) {
+	lp->rra[i].rx_bufadr_l = (lp->rba_laddr + i * SONIC_RBSIZE) & 0xffff;
+	lp->rra[i].rx_bufadr_h = (lp->rba_laddr + i * SONIC_RBSIZE) >> 16;
+	lp->rra[i].rx_bufsize_l = SONIC_RBSIZE >> 1;
+	lp->rra[i].rx_bufsize_h = 0;
+    }
+
+    /* initialize all RRA registers */
+    SONIC_WRITE(SONIC_RSA,rra_start);
+    SONIC_WRITE(SONIC_REA,rra_end);
+    SONIC_WRITE(SONIC_RRP,rra_start);
+    SONIC_WRITE(SONIC_RWP,rra_end);
+    SONIC_WRITE(SONIC_URRA,lp->rra_laddr >> 16);
+    SONIC_WRITE(SONIC_EOBC,(SONIC_RBSIZE-2) >> 1);
+    
+    lp->cur_rra = SONIC_NUM_RRS - 2;
+
+    /* load the resource pointers */
+    if (sonic_debug > 3)
+      printk("sonic_init: issueing RRRA command\n");
+  
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_RRRA);
+    i = 0;
+    while (i++ < 100) {
+	if (SONIC_READ(SONIC_CMD) & SONIC_CR_RRRA)
+	  break;
+    }
+    
+    if (sonic_debug > 2)
+      printk("sonic_init: status=%x\n",SONIC_READ(SONIC_CMD));
+    
+    /*
+     * Initialize the receive descriptors so that they
+     * become a circular linked list, ie. let the last
+     * descriptor point to the first again.
+     */
+    if (sonic_debug > 2)
+      printk ("sonic_init: initialize receive descriptors\n");      
+    for (i=0; i<SONIC_NUM_RDS; i++) {
+	lp->rda[i].rx_status = 0;
+	lp->rda[i].rx_pktlen = 0;
+	lp->rda[i].rx_pktptr_l = 0;
+	lp->rda[i].rx_pktptr_h = 0;
+	lp->rda[i].rx_seqno = 0;
+	lp->rda[i].in_use = 1;		       	
+	lp->rda[i].link = lp->rda_laddr + (i+1) * sizeof (sonic_rd_t);
+    }
+    /* fix last descriptor */
+    lp->rda[SONIC_NUM_RDS-1].link = lp->rda_laddr;
+    lp->cur_rx = 0;
+    
+    SONIC_WRITE(SONIC_URDA,lp->rda_laddr >> 16);
+    SONIC_WRITE(SONIC_CRDA,lp->rda_laddr & 0xffff);
+    
+    /* 
+     * initialize transmit descriptors
+     */
+    if (sonic_debug > 2)
+      printk ("sonic_init: initialize transmit descriptors\n");
+    for (i = 0; i < SONIC_NUM_TDS; i++) {
+	lp->tda[i].tx_status = 0;
+	lp->tda[i].tx_config = 0;
+	lp->tda[i].tx_pktsize = 0;
+	lp->tda[i].tx_frag_count = 0;
+	lp->tda[i].link = (lp->tda_laddr + (i+1) * sizeof (sonic_td_t)) | SONIC_END_OF_LINKS;
+    }
+    lp->tda[SONIC_NUM_TDS-1].link = (lp->tda_laddr & 0xffff) | SONIC_END_OF_LINKS;    
+
+    SONIC_WRITE(SONIC_UTDA,lp->tda_laddr >> 16);
+    SONIC_WRITE(SONIC_CTDA,lp->tda_laddr & 0xffff);
+    
+    /*
+     * put our own address to CAM desc[0]
+     */
+    lp->cda.cam_desc[0].cam_frag2 = dev->dev_addr[1] << 8 | dev->dev_addr[0];
+    lp->cda.cam_desc[0].cam_frag1 = dev->dev_addr[3] << 8 | dev->dev_addr[2];
+    lp->cda.cam_desc[0].cam_frag0 = dev->dev_addr[5] << 8 | dev->dev_addr[4];
+    lp->cda.cam_enable = 1;
+    
+    for (i=0; i < 16; i++)
+      lp->cda.cam_desc[i].cam_entry_pointer = i;
+
+    /*
+     * initialize CAM registers
+     */
+    SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
+    SONIC_WRITE(SONIC_CDC,1);
+    
+    /*
+     * load the CAM
+     */
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_LCAM);
+    
+    i = 0;
+    while (i++ < 100) {
+	if (SONIC_READ(SONIC_ISR) & SONIC_INT_LCD)
+	  break;
+    }
+    if (sonic_debug > 2) {
+	printk("sonic_init: CMD=%x, ISR=%x\n",
+	       SONIC_READ(SONIC_CMD),
+	       SONIC_READ(SONIC_ISR));
+    }
+
+    /*
+     * enable receiver, disable loopback
+     * and enable all interrupts
+     */
+    SONIC_WRITE(SONIC_CMD,SONIC_CR_RXEN | SONIC_CR_STP);
+    SONIC_WRITE(SONIC_RCR,SONIC_RCR_DEFAULT);
+    SONIC_WRITE(SONIC_TCR,SONIC_TCR_DEFAULT);
+    SONIC_WRITE(SONIC_ISR,0x7fff);
+    SONIC_WRITE(SONIC_IMR,SONIC_IMR_DEFAULT);
+
+    cmd = SONIC_READ(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(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"
+ *  compile-command: "mipsel-linux-gcc -D__KERNEL__ -D__mips64 -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