patch-2.1.17 linux/drivers/net/a2065.c

• Lines: 1387
• Date: Fri Dec 20 11:20:00 1996
• Orig file: v2.1.16/linux/drivers/net/a2065.c
• Orig date: Mon May 20 07:54:28 1996

diff -u --recursive --new-file v2.1.16/linux/drivers/net/a2065.c linux/drivers/net/a2065.c
@@ -41,33 +41,27 @@
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/string.h>
+#include <linux/interrupt.h>
 #include <linux/ptrace.h>
-#include <linux/errno.h>
 #include <linux/ioport.h>
 #include <linux/malloc.h>
-#include <linux/interrupt.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
+#include <linux/string.h>
+#include <linux/config.h>
 
 #include <asm/bitops.h>
 #include <asm/io.h>
 #include <asm/irq.h>
+#include <linux/errno.h>
 
-#include <asm/bootinfo.h>
 #include <asm/amigaints.h>
 #include <asm/amigahw.h>
 #include <asm/zorro.h>
 
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
 #include "a2065.h"
 
-#ifdef A2065_DEBUG
-int a2065_debug = A2065_DEBUG;
-#else
-int a2065_debug = 1;
-#endif
-
 
 	/*
 	 *		Transmit/Receive Ring Definitions
@@ -82,722 +76,736 @@
 #define TX_RING_MOD_MASK	(TX_RING_SIZE-1)
 #define RX_RING_MOD_MASK	(RX_RING_SIZE-1)
 
-#define PKT_BUF_SIZE		(1520)
+#define PKT_BUF_SIZE		(1544)
+#define RX_BUFF_SIZE            PKT_BUF_SIZE
+#define TX_BUFF_SIZE            PKT_BUF_SIZE
 
 
 	/*
-	 *		Private Device Data
+	 *		Layout of the Lance's RAM Buffer
 	 */
 
-struct a2065_private {
-	struct A2065Board *board;
-	struct TDRE *tx_ring[TX_RING_SIZE];
-	struct RDRE *rx_ring[RX_RING_SIZE];
-	u_char *tx_buff[TX_RING_SIZE];
-	u_char *rx_buff[RX_RING_SIZE];
-	int cur_tx, cur_rx;		/* The next free ring entry */
-	int dirty_tx;			/* The ring entries to be free()ed. */
-	struct enet_statistics stats;
-	char tx_full;
-	unsigned long lock;
-	int key;
+
+struct lance_init_block {
+	unsigned short mode;		/* Pre-set mode (reg. 15) */
+	unsigned char phys_addr[6];     /* Physical ethernet address */
+	unsigned filter[2];		/* Multicast filter. */
+
+	/* Receive and transmit ring base, along with extra bits. */
+	unsigned short rx_ptr;		/* receive descriptor addr */
+	unsigned short rx_len;		/* receive len and high addr */
+	unsigned short tx_ptr;		/* transmit descriptor addr */
+	unsigned short tx_len;		/* transmit len and high addr */
+    
+	/* The Tx and Rx ring entries must aligned on 8-byte boundaries. */
+	struct lance_rx_desc brx_ring[RX_RING_SIZE];
+	struct lance_tx_desc btx_ring[TX_RING_SIZE];
+
+	char   rx_buf [RX_RING_SIZE][RX_BUFF_SIZE];
+	char   tx_buf [TX_RING_SIZE][TX_BUFF_SIZE];
 };
 
 
 	/*
-	 *		Structure Created in the A2065's RAM Buffer
+	 *		Private Device Data
 	 */
 
-struct lancedata {
-	struct InitBlock init;
-	struct TDRE tx_ring[TX_RING_SIZE];
-	struct RDRE rx_ring[RX_RING_SIZE];
-	u_char tx_buff[TX_RING_SIZE][PKT_BUF_SIZE];
-	u_char rx_buff[RX_RING_SIZE][PKT_BUF_SIZE];
+struct lance_private {
+	char *name;
+	volatile struct lance_regs *ll;
+	volatile struct lance_init_block *init_block;	    /* Hosts view */
+	volatile struct lance_init_block *lance_init_block; /* Lance view */
+
+	int rx_new, tx_new;
+	int rx_old, tx_old;
+    
+	int lance_log_rx_bufs, lance_log_tx_bufs;
+	int rx_ring_mod_mask, tx_ring_mod_mask;
+
+	struct enet_statistics stats;
+	int tpe;		      /* cable-selection is TPE */
+	int auto_select;	      /* cable-selection by carrier */
+	unsigned short busmaster_regval;
+
+#ifdef CONFIG_AMIGA
+	int key;
+#endif
+#ifdef CONFIG_SUNLANCE
+	struct Linux_SBus_DMA *ledma; /* if set this points to ledma and arch=4m */
+	int burst_sizes;	      /* ledma SBus burst sizes */
+#endif
 };
 
+#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
+			lp->tx_old+lp->tx_ring_mod_mask-lp->tx_new:\
+			lp->tx_old - lp->tx_new-1)
 
-static int a2065_open(struct device *dev);
-static void a2065_init_ring(struct device *dev);
-static int a2065_start_xmit(struct sk_buff *skb, struct device *dev);
-static int a2065_rx(struct device *dev);
-static void a2065_interrupt(int irq, struct pt_regs *fp, void *data);
-static int a2065_close(struct device *dev);
-static struct enet_statistics *a2065_get_stats(struct device *dev);
-static void set_multicast_list(struct device *dev);
 
+#define LANCE_ADDR(x) ((int)(x) & ~0xff000000)
 
-int a2065_probe(struct device *dev)
+/* Load the CSR registers */
+static void load_csrs (struct lance_private *lp)
 {
-	int key1, key2;
-	struct ConfigDev *cd;
-	u_long board;
-	u_long sn;
-	struct a2065_private *priv;
+	volatile struct lance_regs *ll = lp->ll;
+	volatile struct lance_init_block *aib = lp->lance_init_block;
+	int leptr;
 
-	if ((key1 = zorro_find(MANUF_COMMODORE, PROD_A2065, 0, 0)) ||
-	    (key2 = zorro_find(MANUF_AMERISTAR, PROD_AMERISTAR2065, 0, 0))) {
-		cd = zorro_get_board(key1 ? key1 : key2);
-		if ((board = (u_long)cd->cd_BoardAddr)) {
-			sn = cd->cd_Rom.er_SerialNumber;
-			if (key1) {			/* Commodore */
-				dev->dev_addr[0] = 0x00;
-				dev->dev_addr[1] = 0x80;
-				dev->dev_addr[2] = 0x10;
-			} else {			/* Ameristar */
-				dev->dev_addr[0] = 0x00;
-				dev->dev_addr[1] = 0x00;
-				dev->dev_addr[2] = 0x9f;
-			}
-			dev->dev_addr[3] = (sn>>16) & 0xff;
-			dev->dev_addr[4] = (sn>>8) & 0xff;
-			dev->dev_addr[5] = sn & 0xff;
-			printk("%s: A2065 at 0x%08lx, Ethernet Address %02x:%02x:%02x:%02x:%02x:%02x\n",
-			       dev->name, board, dev->dev_addr[0],
-			       dev->dev_addr[1], dev->dev_addr[2],
-			       dev->dev_addr[3], dev->dev_addr[4],
-			       dev->dev_addr[5]);
+	leptr = LANCE_ADDR (aib);
 
-			init_etherdev(dev, 0);
+	ll->rap = LE_CSR1;
+	ll->rdp = (leptr & 0xFFFF);
+	ll->rap = LE_CSR2;
+	ll->rdp = leptr >> 16;
+	ll->rap = LE_CSR3;
+	ll->rdp = lp->busmaster_regval;
 
-			dev->priv = kmalloc(sizeof(struct
-						   a2065_private),
-					    GFP_KERNEL);
-			priv = (struct a2065_private *)dev->priv;
-			memset(priv, 0, sizeof(struct a2065_private));
+	/* Point back to csr0 */
+	ll->rap = LE_CSR0;
+}
 
-			priv->board = (struct A2065Board *)ZTWO_VADDR(board);
-			priv->key = key1 ? key1 : key2;
+#define ZERO 0
 
-			dev->open = &a2065_open;
-			dev->stop = &a2065_close;
-			dev->hard_start_xmit = &a2065_start_xmit;
-			dev->get_stats = &a2065_get_stats;
-			dev->set_multicast_list = &set_multicast_list;
+/* Setup the Lance Rx and Tx rings */
+/* Sets dev->tbusy */
+static void lance_init_ring (struct device *dev)
+{
+	struct lance_private *lp = (struct lance_private *) dev->priv;
+	volatile struct lance_init_block *ib = lp->init_block;
+	volatile struct lance_init_block *aib; /* for LANCE_ADDR computations */
+	int leptr;
+	int i;
 
-			zorro_config_board(key1 ? key1 : key2, 0);
-			return(0);
-		}
-	}
-	return(ENODEV);
-}
+	aib = lp->lance_init_block;
 
+	/* Lock out other processes while setting up hardware */
+	dev->tbusy = 1;
+	lp->rx_new = lp->tx_new = 0;
+	lp->rx_old = lp->tx_old = 0;
+
+	ib->mode = 0;
+
+	/* Copy the ethernet address to the lance init block
+	 * Note that on the sparc you need to swap the ethernet address.
+	 */
+	ib->phys_addr [0] = dev->dev_addr [1];
+	ib->phys_addr [1] = dev->dev_addr [0];
+	ib->phys_addr [2] = dev->dev_addr [3];
+	ib->phys_addr [3] = dev->dev_addr [2];
+	ib->phys_addr [4] = dev->dev_addr [5];
+	ib->phys_addr [5] = dev->dev_addr [4];
+
+	if (ZERO)
+		printk ("TX rings:\n");
+    
+	/* Setup the Tx ring entries */
+	for (i = 0; i <= (1<<lp->lance_log_tx_bufs); i++) {
+		leptr = LANCE_ADDR(&aib->tx_buf[i][0]);
+		ib->btx_ring [i].tmd0      = leptr;
+		ib->btx_ring [i].tmd1_hadr = leptr >> 16;
+		ib->btx_ring [i].tmd1_bits = 0;
+		ib->btx_ring [i].length    = 0xf000; /* The ones required by tmd2 */
+		ib->btx_ring [i].misc      = 0;
+		if (i < 3)
+			if (ZERO) printk ("%d: 0x%8.8x\n", i, leptr);
+	}
+
+	/* Setup the Rx ring entries */
+	if (ZERO)
+		printk ("RX rings:\n");
+	for (i = 0; i < (1<<lp->lance_log_rx_bufs); i++) {
+		leptr = LANCE_ADDR(&aib->rx_buf[i][0]);
+
+		ib->brx_ring [i].rmd0      = leptr;
+		ib->brx_ring [i].rmd1_hadr = leptr >> 16;
+		ib->brx_ring [i].rmd1_bits = LE_R1_OWN;
+		ib->brx_ring [i].length    = -RX_BUFF_SIZE | 0xf000;
+		ib->brx_ring [i].mblength  = 0;
+		if (i < 3 && ZERO)
+			printk ("%d: 0x%8.8x\n", i, leptr);
+	}
+
+	/* Setup the initialization block */
+    
+	/* Setup rx descriptor pointer */
+	leptr = LANCE_ADDR(&aib->brx_ring);
+	ib->rx_len = (lp->lance_log_rx_bufs << 13) | (leptr >> 16);
+	ib->rx_ptr = leptr;
+	if (ZERO)
+		printk ("RX ptr: %8.8x\n", leptr);
+    
+	/* Setup tx descriptor pointer */
+	leptr = LANCE_ADDR(&aib->btx_ring);
+	ib->tx_len = (lp->lance_log_tx_bufs << 13) | (leptr >> 16);
+	ib->tx_ptr = leptr;
+	if (ZERO)
+		printk ("TX ptr: %8.8x\n", leptr);
+
+	/* Clear the multicast filter */
+	ib->filter [0] = 0;
+	ib->filter [1] = 0;
+}
 
-static int a2065_open(struct device *dev)
+static int init_restart_lance (struct lance_private *lp)
 {
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
-	struct A2065Board *board = priv->board;
-	struct lancedata *lancedata;		/* LANCE point of view */
-	struct lancedata *alancedata;		/* Amiga point of view */
-
-	lancedata = (struct lancedata *)offsetof(struct A2065Board, RAM);
-	alancedata = (struct lancedata *)board->RAM;
-
-	/* Stop the LANCE */
-	board->Lance.RAP = CSR0;		/* LANCE Controller Status */
-	board->Lance.RDP = STOP;
-
-	/* Enable big endian byte ordering */
-	board->Lance.RAP = CSR3;		/* CSR3 */
-	board->Lance.RDP = BSWP;
-
-	/* Set the Init Block Pointer */
-	board->Lance.RAP = CSR1;		/* IADR[15:0] */
-	board->Lance.RDP = (u_long)&lancedata->init;
-	board->Lance.RAP = CSR2;		/* IADR[23:16] */
-	board->Lance.RDP = 0x0000;
-
-	/* Set the Mode */
-	alancedata->init.Mode = 0;
-
-	/* Set the Ethernet Hardware Address */
-	                    /* Physical Address Register */
-	alancedata->init.PADR[0] = dev->dev_addr[1];
-	alancedata->init.PADR[1] = dev->dev_addr[0];
-	alancedata->init.PADR[2] = dev->dev_addr[3];
-	alancedata->init.PADR[3] = dev->dev_addr[2];
-	alancedata->init.PADR[4] = dev->dev_addr[5];
-	alancedata->init.PADR[5] = dev->dev_addr[4];
-
-	/* Set the Multicast Table */
-	                    /* Logical Address Filter, LADRF[31:0] */
-	alancedata->init.LADRF[0] = 0x00000000;
-	                    /* Logical Address Filter, LADRF[63:32] */	
-	alancedata->init.LADRF[1] = 0x00000000;
-
-	/* Set the Receive and Transmit Descriptor Ring Pointers */
-	alancedata->init.RDRA = (u_long)&lancedata->rx_ring;
-	alancedata->init.RLEN = LANCE_LOG_RX_BUFFERS << 13;
-	alancedata->init.TDRA = (u_long)&lancedata->tx_ring;
-	alancedata->init.TLEN = LANCE_LOG_TX_BUFFERS << 13;
+	volatile struct lance_regs *ll = lp->ll;
+	int i;
 
-	/* Initialise the Rings */
-	a2065_init_ring(dev);
+	ll->rap = LE_CSR0;
+	ll->rdp = LE_C0_INIT;
 
+	/* Wait for the lance to complete initialization */
+	for (i = 0; (i < 100) && !(ll->rdp & (LE_C0_ERR | LE_C0_IDON)); i++)
+		barrier();
+	if ((i == 100) || (ll->rdp & LE_C0_ERR)) {
+		printk ("LANCE unopened after %d ticks, csr0=%4.4x.\n", i, ll->rdp);
+		return -1;
+	}
+
+	/* Clear IDON by writing a "1", enable interrupts and start lance */
+	ll->rdp = LE_C0_IDON;
+	ll->rdp = LE_C0_INEA | LE_C0_STRT;
 
-	/* Install the Interrupt handler */
-	if (!add_isr(IRQ_AMIGA_PORTS, a2065_interrupt, 0, dev, "a2065 Ethernet"))
-		return(-EAGAIN);
+	return 0;
+}
 
-	/* Make the LANCE read the Init Block */
-	board->Lance.RAP = CSR0;		/* LANCE Controller Status */
-	board->Lance.RDP = INEA|INIT;
+static int lance_rx (struct device *dev)
+{
+	struct lance_private *lp = (struct lance_private *) dev->priv;
+	volatile struct lance_init_block *ib = lp->init_block;
+	volatile struct lance_regs *ll = lp->ll;
+	volatile struct lance_rx_desc *rd;
+	unsigned char bits;
+	int len = 0;			/* XXX shut up gcc warnings */
+	struct sk_buff *skb = 0;	/* XXX shut up gcc warnings */
 
-	dev->tbusy = 0;
-	dev->interrupt = 0;
-	dev->start = 1;
+#ifdef TEST_HITS
+	printk ("[");
+	for (i = 0; i < RX_RING_SIZE; i++) {
+		if (i == lp->rx_new)
+			printk ("%s",
+				ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "_" : "X");
+		else
+			printk ("%s",
+				ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "." : "1");
+	}
+	printk ("]");
+#endif
+    
+	ll->rdp = LE_C0_RINT|LE_C0_INEA;
+	for (rd = &ib->brx_ring [lp->rx_new];
+	     !((bits = rd->rmd1_bits) & LE_R1_OWN);
+	     rd = &ib->brx_ring [lp->rx_new]) {
+
+		/* We got an incomplete frame? */
+		if ((bits & LE_R1_POK) != LE_R1_POK) {
+			lp->stats.rx_over_errors++;
+			lp->stats.rx_errors++;
+			continue;
+		} else if (bits & LE_R1_ERR) {
+			/* Count only the end frame as a tx error, not the beginning */
+			if (bits & LE_R1_BUF) lp->stats.rx_fifo_errors++;
+			if (bits & LE_R1_CRC) lp->stats.rx_crc_errors++;
+			if (bits & LE_R1_OFL) lp->stats.rx_over_errors++;
+			if (bits & LE_R1_FRA) lp->stats.rx_frame_errors++;
+			if (bits & LE_R1_EOP) lp->stats.rx_errors++;
+		} else {
+			len = rd->mblength;
+			skb = dev_alloc_skb (len+2);
 
-	MOD_INC_USE_COUNT;
+			if (skb == 0) {
+				printk ("%s: Memory squeeze, deferring packet.\n",
+					dev->name);
+				lp->stats.rx_dropped++;
+				rd->mblength = 0;
+				rd->rmd1_bits = LE_R1_OWN;
+				lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask;
+				return 0;
+			}
+	    
+			skb->dev = dev;
+			skb_reserve (skb, 2);		/* 16 byte align */
+			skb_put (skb, len);		/* make room */
+			eth_copy_and_sum(skb,
+					 (unsigned char *)&(ib->rx_buf [lp->rx_new][0]),
+					 len, 0);
+			skb->protocol = eth_type_trans (skb, dev);
+			netif_rx (skb);
+			lp->stats.rx_packets++;
+		}
 
-	return(0);
+		/* Return the packet to the pool */
+		rd->mblength = 0;
+		rd->rmd1_bits = LE_R1_OWN;
+		lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask;
+	}
+	return 0;
 }
 
-
-static void a2065_init_ring(struct device *dev)
+static int lance_tx (struct device *dev)
 {
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
-	struct A2065Board *board = priv->board;
-	struct lancedata *lancedata;		/* LANCE point of view */
-	struct lancedata *alancedata;		/* Amiga point of view */
-	int i;
+	struct lance_private *lp = (struct lance_private *) dev->priv;
+	volatile struct lance_init_block *ib = lp->init_block;
+	volatile struct lance_regs *ll = lp->ll;
+	volatile struct lance_tx_desc *td;
+	int i, j;
+	int status;
+
+	/* csr0 is 2f3 */
+	ll->rdp = LE_C0_TINT | LE_C0_INEA;
+	/* csr0 is 73 */
+
+	j = lp->tx_old;
+	for (i = j; i != lp->tx_new; i = j) {
+		td = &ib->btx_ring [i];
+
+		/* If we hit a packet not owned by us, stop */
+		if (td->tmd1_bits & LE_T1_OWN)
+			break;
+		
+		if (td->tmd1_bits & LE_T1_ERR) {
+			status = td->misc;
+	    
+			lp->stats.tx_errors++;
+			if (status & LE_T3_RTY)  lp->stats.tx_aborted_errors++;
+			if (status & LE_T3_LCOL) lp->stats.tx_window_errors++;
+
+			if (status & LE_T3_CLOS) {
+				lp->stats.tx_carrier_errors++;
+				if (lp->auto_select) {
+					lp->tpe = 1 - lp->tpe;
+					printk("%s: Carrier Lost, trying %s\n",
+					       dev->name, lp->tpe?"TPE":"AUI");
+					/* Stop the lance */
+					ll->rap = LE_CSR0;
+					ll->rdp = LE_C0_STOP;
+					lance_init_ring (dev);
+					load_csrs (lp);
+					init_restart_lance (lp);
+					return 0;
+				}
+			}
 
-	priv->lock = 0, priv->tx_full = 0;
-	priv->cur_rx = priv->cur_tx = 0;
-	priv->dirty_tx = 0;
-
-	lancedata = (struct lancedata *)offsetof(struct A2065Board, RAM);
-	alancedata = (struct lancedata *)board->RAM;
-
-	/* Set up TX Ring */
-	for (i = 0; i < TX_RING_SIZE; i++) {
-		alancedata->tx_ring[i].TMD0 = (u_long)lancedata->tx_buff[i];
-		alancedata->tx_ring[i].TMD1 = TF_STP|TF_ENP;
-		alancedata->tx_ring[i].TMD2 = -PKT_BUF_SIZE;
-		alancedata->tx_ring[i].TMD3 = 0x0000;
-		priv->tx_ring[i] = &alancedata->tx_ring[i];
-		priv->tx_buff[i] = alancedata->tx_buff[i];
-#if 0
-		printk("TX Entry %2d @ 0x%08x (LANCE 0x%08x), Buf @ 0x%08x (LANCE 0x%08x)\n", i,
-		       (int)&alancedata->tx_ring[i],
-		       (int)&lancedata->tx_ring[i],
-		       (int)alancedata->tx_buff[i],
-		       (int)lancedata->tx_buff[i]);
-#endif
-	}
+			/* buffer errors and underflows turn off the transmitter */
+			/* Restart the adapter */
+			if (status & (LE_T3_BUF|LE_T3_UFL)) {
+				lp->stats.tx_fifo_errors++;
+
+				printk ("%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
+					dev->name);
+				/* Stop the lance */
+				ll->rap = LE_CSR0;
+				ll->rdp = LE_C0_STOP;
+				lance_init_ring (dev);
+				load_csrs (lp);
+				init_restart_lance (lp);
+				return 0;
+			}
+		} else if ((td->tmd1_bits & LE_T1_POK) == LE_T1_POK) {
+			/*
+			 * So we don't count the packet more than once.
+			 */
+			td->tmd1_bits &= ~(LE_T1_POK);
+
+			/* One collision before packet was sent. */
+			if (td->tmd1_bits & LE_T1_EONE)
+				lp->stats.collisions++;
+
+			/* More than one collision, be optimistic. */
+			if (td->tmd1_bits & LE_T1_EMORE)
+				lp->stats.collisions += 2;
 
-	/* Set up RX Ring */
-	for (i = 0; i < RX_RING_SIZE; i++) {
-		alancedata->rx_ring[i].RMD0 = (u_long)lancedata->rx_buff[i];
-		alancedata->rx_ring[i].RMD1 = RF_OWN;
-		alancedata->rx_ring[i].RMD2 = -PKT_BUF_SIZE;
-		alancedata->rx_ring[i].RMD3 = 0x0000;
-		priv->rx_ring[i] = &alancedata->rx_ring[i];
-		priv->rx_buff[i] = alancedata->rx_buff[i];
-#if 0
-		printk("RX Entry %2d @ 0x%08x (LANCE 0x%08x), Buf @ 0x%08x (LANCE 0x%08x)\n", i,
-		       (int)&alancedata->rx_ring[i],
-		       (int)&lancedata->rx_ring[i],
-		       (int)alancedata->rx_buff[i],
-		       (int)lancedata->rx_buff[i]);
-#endif
+			lp->stats.tx_packets++;
+		}
+	
+		j = (j + 1) & lp->tx_ring_mod_mask;
 	}
+	lp->tx_old = j;
+	ll->rdp = LE_C0_TINT | LE_C0_INEA;
+	return 0;
 }
 
-
-static int a2065_close(struct device *dev)
+static void lance_interrupt (int irq, void *dev_id, struct pt_regs *regs)
 {
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
-	struct A2065Board *board = priv->board;
+	struct device *dev;
+	struct lance_private *lp;
+	volatile struct lance_regs *ll;
+	int csr0;
 
-	dev->start = 0;
-	dev->tbusy = 1;
+	dev = (struct device *) dev_id;
 
-	board->Lance.RAP = CSR0;		/* LANCE Controller Status */
+	lp = (struct lance_private *) dev->priv;
+	ll = lp->ll;
 
-	if (a2065_debug > 1) {
-	  printk("%s: Shutting down ethercard, status was %2.2x.\n",
-		 dev->name, board->Lance.RDP);
-	  printk("%s: %d packets missed\n", dev->name,
-		 priv->stats.rx_missed_errors);
-	}
+	ll->rap = LE_CSR0;		/* LANCE Controller Status */
+	csr0 = ll->rdp;
 
-	/* We stop the LANCE here - it occasionally polls memory if we don't */
-	board->Lance.RDP = STOP;
+	if (!(csr0 & LE_C0_INTR))	/* Check if any interrupt has */
+		return;			/* been generated by the Lance. */
 
-	remove_isr(IRQ_AMIGA_PORTS, a2065_interrupt, dev);
+	if (dev->interrupt)
+		printk ("%s: again", dev->name);
 
-	MOD_DEC_USE_COUNT;
+	dev->interrupt = 1;
 
-	return(0);
+	/* Acknowledge all the interrupt sources ASAP */
+	ll->rdp = csr0 & ~(LE_C0_INEA|LE_C0_TDMD|LE_C0_STOP|LE_C0_STRT|
+			   LE_C0_INIT);
+
+	if ((csr0 & LE_C0_ERR)) {
+		/* Clear the error condition */
+		ll->rdp = LE_C0_BABL|LE_C0_ERR|LE_C0_MISS|LE_C0_INEA;
+	}
+    
+	if (csr0 & LE_C0_RINT)
+		lance_rx (dev);
+
+	if (csr0 & LE_C0_TINT)
+		lance_tx (dev);
+
+	/* Log misc errors. */
+	if (csr0 & LE_C0_BABL)
+		lp->stats.tx_errors++;       /* Tx babble. */
+	if (csr0 & LE_C0_MISS)
+		lp->stats.rx_errors++;       /* Missed a Rx frame. */
+	if (csr0 & LE_C0_MERR) {
+		printk("%s: Bus master arbitration failure, status %4.4x.\n", dev->name, csr0);
+		/* Restart the chip. */
+		ll->rdp = LE_C0_STRT;
+	}
+
+	if ((TX_BUFFS_AVAIL >= 0) && dev->tbusy) {
+		dev->tbusy = 0;
+		mark_bh (NET_BH);
+	}
+	ll->rap = LE_CSR0;
+	ll->rdp = LE_C0_BABL|LE_C0_CERR|LE_C0_MISS|LE_C0_MERR|
+					LE_C0_IDON|LE_C0_INEA;
+
+	dev->interrupt = 0;
 }
 
+struct device *last_dev = 0;
 
-static void a2065_interrupt(int irq, struct pt_regs *fp, void *data)
+static int lance_open (struct device *dev)
 {
-	struct device *dev = (struct device *)data;
-	struct a2065_private *priv;
-	struct A2065Board *board;
-	int csr0, boguscnt = 10;
-
-	if (dev == NULL) {
-		printk("a2065_interrupt(): irq for unknown device.\n");
-		return;
-	}
+	struct lance_private *lp = (struct lance_private *)dev->priv;
+	volatile struct lance_regs *ll = lp->ll;
+	int status = 0;
 
-	priv = (struct a2065_private *)dev->priv;
-	board = priv->board;
+	last_dev = dev;
 
-	board->Lance.RAP = CSR0;	/* LANCE Controller Status */
+	/* Install the Interrupt handler */
+	if (request_irq(IRQ_AMIGA_PORTS, lance_interrupt, 0,
+			"a2065 Ethernet", dev))
+		return -EAGAIN;
+
+	/* Stop the Lance */
+	ll->rap = LE_CSR0;
+	ll->rdp = LE_C0_STOP;
 
-	if (!(board->Lance.RDP & INTR)) /* Check if any interrupt has
-					   been generated by the board. */
-		return;
+	load_csrs (lp);
+	lance_init_ring (dev);
 
-	if (dev->interrupt)
-		printk("%s: Re-entering the interrupt handler.\n", dev->name);
+	dev->tbusy = 0;
+	dev->interrupt = 0;
+	dev->start = 1;
 
-	dev->interrupt = 1;
+	status = init_restart_lance (lp);
 
-	while ((csr0 = board->Lance.RDP) & (ERR|RINT|TINT) && --boguscnt >= 0){
-		/* Acknowledge all of the current interrupt sources ASAP. */
-		board->Lance.RDP = csr0 & ~(INEA|TDMD|STOP|STRT|INIT);
-
-#if 0
-		if (a2065_debug > 5) {
-		  printk("%s: interrupt  csr0=%#2.2x new csr=%#2.2x.",
-			 dev->name, csr0, board->Lance.RDP);
-		  printk("[");
-		  if (csr0 & INTR)
-		    printk(" INTR");
-		  if (csr0 & INEA)
-		    printk(" INEA");
-		  if (csr0 & RXON)
-		    printk(" RXON");
-		  if (csr0 & TXON)
-		    printk(" TXON");
-		  if (csr0 & TDMD)
-		    printk(" TDMD");
-		  if (csr0 & STOP)
-		    printk(" STOP");
-		  if (csr0 & STRT)
-		    printk(" STRT");
-		  if (csr0 & INIT)
-		    printk(" INIT");
-		  if (csr0 & ERR)
-		    printk(" ERR");
-		  if (csr0 & BABL)
-		    printk(" BABL");
-		  if (csr0 & CERR)
-		    printk(" CERR");
-		  if (csr0 & MISS)
-		    printk(" MISS");
-		  if (csr0 & MERR)
-		    printk(" MERR");
-		  if (csr0 & RINT)
-		    printk(" RINT");
-		  if (csr0 & TINT)
-		    printk(" TINT");
-		  if (csr0 & IDON)
-		    printk(" IDON");
-		  printk(" ]\n");
-		}
-#endif
+	MOD_INC_USE_COUNT;
 
-		if (csr0 & RINT)			/* Rx interrupt */
-			a2065_rx(dev);
+	return status;
+}
 
-		if (csr0 & TINT) {			/* Tx-done interrupt */
-			int dirty_tx = priv->dirty_tx;
+static int lance_close (struct device *dev)
+{
+	struct lance_private *lp = (struct lance_private *) dev->priv;
+	volatile struct lance_regs *ll = lp->ll;
 
-			while (dirty_tx < priv->cur_tx) {
-				int entry = dirty_tx % TX_RING_SIZE;
-				int status =
-				  priv->tx_ring[entry]->TMD1 & 0xff00;
-
-				if (status & TF_OWN)
-					break;	/* It still hasn't been Txed */
-
-				priv->tx_ring[entry]->TMD1 &= 0x00ff;
-
-				if (status & TF_ERR) {
-					/* There was an major error, log it. */
-					int err_status =
-					  priv->tx_ring[entry]->TMD3;
-					priv->stats.tx_errors++;
-					if (err_status & EF_RTRY)
-					  priv->stats.tx_aborted_errors++;
-					if (err_status & EF_LCAR)
-					  priv->stats.tx_carrier_errors++;
-					if (err_status & EF_LCOL)
-					  priv->stats.tx_window_errors++;
-					if (err_status & EF_UFLO) {
-		         /* Ackk!  On FIFO errors the Tx unit is turned off! */
-					  priv->stats.tx_fifo_errors++;
-					  /* Remove this verbosity later! */
-					  printk("%s: Tx FIFO error! Status %4.4x.\n", dev->name, csr0);
-					  /* Restart the chip. */
-					  board->Lance.RDP = STRT;
-					}
-				} else {
-					if (status & (TF_MORE|TF_ONE))
-					  priv->stats.collisions++;
-					priv->stats.tx_packets++;
-				}
-				dirty_tx++;
-			}
+	dev->start = 0;
+	dev->tbusy = 1;
 
-#ifndef final_version
-			if (priv->cur_tx - dirty_tx >= TX_RING_SIZE) {
-				printk("out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
-				       dirty_tx, priv->cur_tx, priv->tx_full);
-				dirty_tx += TX_RING_SIZE;
-			}
-#endif
+	/* Stop the card */
+	ll->rap = LE_CSR0;
+	ll->rdp = LE_C0_STOP;
 
-			if (priv->tx_full && dev->tbusy && dirty_tx >
-			    priv->cur_tx - TX_RING_SIZE + 2) {
-				/* The ring is no longer full, clear tbusy. */
-				priv->tx_full = 0;
-				dev->tbusy = 0;
-				mark_bh(NET_BH);
-			}
+	free_irq(IRQ_AMIGA_PORTS, dev);
 
-			priv->dirty_tx = dirty_tx;
-		}
+	MOD_DEC_USE_COUNT;
 
-		/* Log misc errors. */
-		if (csr0 & BABL)
-			priv->stats.tx_errors++;       /* Tx babble. */
-		if (csr0 & MISS)
-			priv->stats.rx_errors++;       /* Missed a Rx frame. */
-		if (csr0 & MERR) {
-			printk("%s: Bus master arbitration failure, status %4.4x.\n", dev->name, csr0);
-			/* Restart the chip. */
-			board->Lance.RDP = STRT;
-		}
-	}
+	return 0;
+}
 
-	/* Clear any other interrupt, and set interrupt enable. */
-	board->Lance.RAP = CSR0;		/* LANCE Controller Status */
-	board->Lance.RDP = INEA|BABL|CERR|MISS|MERR|IDON;
-
-#if 0
-	if (a2065_debug > 4)
-		printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
-		       dev->name, board->Lance.RAP, board->Lance.RDP);
-#endif
+static inline int lance_reset (struct device *dev)
+{
+	struct lance_private *lp = (struct lance_private *)dev->priv;
+	volatile struct lance_regs *ll = lp->ll;
+	int status;
+    
+	/* Stop the lance */
+	ll->rap = LE_CSR0;
+	ll->rdp = LE_C0_STOP;
 
+	load_csrs (lp);
+	lance_init_ring (dev);
+	dev->trans_start = jiffies;
 	dev->interrupt = 0;
-	return;
+	dev->start = 1;
+	dev->tbusy = 0;
+	status = init_restart_lance (lp);
+#ifdef DEBUG_DRIVER
+	printk ("Lance restart=%d\n", status);
+#endif
+	return status;
 }
 
-
-static int a2065_start_xmit(struct sk_buff *skb, struct device *dev)
+static int lance_start_xmit (struct sk_buff *skb, struct device *dev)
 {
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
-	struct A2065Board *board = priv->board;
-	int entry;
+	struct lance_private *lp = (struct lance_private *)dev->priv;
+	volatile struct lance_regs *ll = lp->ll;
+	volatile struct lance_init_block *ib = lp->init_block;
+	int entry, skblen, len;
+	int status = 0;
+	static int outs;
 
-	/* Transmitter timeout, serious problems. */
+	/* Transmitter timeout, serious problems */
 	if (dev->tbusy) {
 		int tickssofar = jiffies - dev->trans_start;
-		if (tickssofar < 20)
-			return(1);
-		board->Lance.RAP = CSR0;	/* LANCE Controller Status */
-		printk("%s: transmit timed out, status %4.4x, resetting.\n", dev->name, board->Lance.RDP);
-		board->Lance.RDP = STOP;
-
-		/* Enable big endian byte ordering */
-		board->Lance.RAP = CSR3;			/* CSR3 */
-		board->Lance.RDP = BSWP;
-
-		priv->stats.tx_errors++;
-#ifndef final_version
-		{
-		  int i;
-		  printk(" Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
-			 priv->dirty_tx, priv->cur_tx, priv->tx_full ?
-			 " (full)" : "", priv->cur_rx);
-		  for (i = 0 ; i < RX_RING_SIZE; i++)
-		    printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
-			   ((priv->rx_ring[i]->RMD1)<<16) |
-			   priv->rx_ring[i]->RMD0,
-			   -priv->rx_ring[i]->RMD2, priv->rx_ring[i]->RMD3);
-		  for (i = 0 ; i < TX_RING_SIZE; i++)
-		    printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
-			   ((priv->tx_ring[i]->TMD1)<<16) |
-			   priv->tx_ring[i]->TMD0,
-			   -priv->tx_ring[i]->TMD2, priv->tx_ring[i]->TMD3);
-			printk("\n");
+	    
+		if (tickssofar < 100) {
+			status = -1;
+		} else {
+			printk ("%s: transmit timed out, status %04x, resetting\n",
+				dev->name, ll->rdp);
+			lance_reset (dev);
 		}
-#endif
-		a2065_init_ring(dev);
-		board->Lance.RDP = INEA|INIT;
-
-		dev->tbusy = 0;
-		dev->trans_start = jiffies;
-
-		return(0);
+		return status;
 	}
 
 	if (skb == NULL) {
-		dev_tint(dev);
-		return(0);
+		dev_tint (dev);
+		printk ("skb is NULL\n");
+		return 0;
 	}
 
-	if (skb->len <= 0)
-		return(0);
-
-#if 0
-	if (a2065_debug > 3) {
-		board->Lance.RAP = CSR0;	/* LANCE Controller Status */
-		printk("%s: a2065_start_xmit() called, csr0 %4.4x.\n",
-		       dev->name, board->Lance.RDP);
-		board->Lance.RDP = 0x0000;
+	if (skb->len <= 0) {
+		printk ("skb len is %id\n", skb->len);
+		return 0;
 	}
-#endif
-
-	/*
-	 * 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);
-		return(1);
-	}
-
-	if (set_bit(0, (void*)&priv->lock) != 0) {
-		if (a2065_debug > 0)
-			printk("%s: tx queue lock!.\n", dev->name);
-		/* don't clear dev->tbusy flag. */
-		return(1);
-	}
-
-	/* Fill in a Tx ring entry */
-
-#if 0
-	printk("TX pkt type 0x%04x from ", ((u_short *)skb->data)[6]);
-	{
-		int i;
-		u_char *ptr = &((u_char *)skb->data)[6];
-		for (i = 0; i < 6; i++)
-			printk("%02x", ptr[i]);
-	}
-	printk(" to ");
-	{
-		int i;
-		u_char *ptr = (u_char *)skb->data;
-		for (i = 0; i < 6; i++)
-			printk("%02x", ptr[i]);
+	/* Block a timer-based transmit from overlapping. */
+#ifdef OLD_METHOD
+	dev->tbusy = 1;
+#else
+	if (set_bit (0, (void *) &dev->tbusy) != 0) {
+		printk ("Transmitter access conflict.\n");
+		return -1;
 	}
-	printk(" data 0x%08x len %d\n", (int)skb->data, (int)skb->len);
 #endif
+	skblen = skb->len;
 
-	entry = priv->cur_tx % TX_RING_SIZE;
+	if (!TX_BUFFS_AVAIL)
+		return -1;
 
-	priv->tx_ring[entry]->TMD2 = -(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
-	priv->tx_ring[entry]->TMD3 = 0x0000;
-	memcpy(priv->tx_buff[entry], skb->data, skb->len);
-
-#if 0
+#ifdef DEBUG_DRIVER
+	/* dump the packet */
 	{
-		int i, len;
-
-		len = skb->len > 64 ? 64 : skb->len;
-		for (i = 0; i < len; i += 8) {
-			int j;
-			printk("%02x:", i);
-			for (j = 0; (j < 16) && ((i+j) < len); j++) {
-				if (!(j & 1))
-					printk(" ");
-				printk("%02x", priv->tx_buff[entry][i+j]);
-			}
-			printk("\n");
+		int i;
+	
+		for (i = 0; i < 64; i++) {
+			if ((i % 16) == 0)
+				printk ("\n");
+			printk ("%2.2x ", skb->data [i]);
 		}
 	}
 #endif
-
-	priv->tx_ring[entry]->TMD1 = (priv->tx_ring[entry]->TMD1 &
-				      0x00ff)|TF_OWN|TF_STP|TF_ENP;
-
-	dev_kfree_skb(skb, FREE_WRITE);
-
-	priv->cur_tx++;
-	if ((priv->cur_tx >= TX_RING_SIZE)&&(priv->dirty_tx >= TX_RING_SIZE)){
-
-#if 0
-	  printk("*** Subtracting TX_RING_SIZE from cur_tx (%d) and dirty_tx (%d)\n",
-		 priv->cur_tx, priv->dirty_tx);
-#endif
-
-		priv->cur_tx -= TX_RING_SIZE;
-		priv->dirty_tx -= TX_RING_SIZE;
-	}
-
-	/* Trigger an immediate send poll. */
-	board->Lance.RAP = CSR0;		/* LANCE Controller Status */
-	board->Lance.RDP = INEA|TDMD;
-
+	len = (skblen <= ETH_ZLEN) ? ETH_ZLEN : skblen;
+	entry = lp->tx_new & lp->tx_ring_mod_mask;
+	ib->btx_ring [entry].length = (-len) | 0xf000;
+	ib->btx_ring [entry].misc = 0;
+    
+	memcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
+
+	/* Clear the slack of the packet, do I need this? */
+	if (len != skblen)
+		memset ((char *) &ib->tx_buf [entry][skblen], 0, len - skblen);
+    
+	/* Now, give the packet to the lance */
+	ib->btx_ring [entry].tmd1_bits = (LE_T1_POK|LE_T1_OWN);
+	lp->tx_new = (lp->tx_new+1) & lp->tx_ring_mod_mask;
+
+	outs++;
+	/* Kick the lance: transmit now */
+	ll->rdp = LE_C0_INEA | LE_C0_TDMD;
 	dev->trans_start = jiffies;
-
-	cli();
-	priv->lock = 0;
-	if ((priv->tx_ring[(entry+1) % TX_RING_SIZE]->TMD1 & 0xff00) == 0)
+	dev_kfree_skb (skb, FREE_WRITE);
+    
+	if (TX_BUFFS_AVAIL)
 		dev->tbusy = 0;
-	else
-		priv->tx_full = 1;
-	sti();
 
-	return(0);
+	return status;
 }
 
-
-static int a2065_rx(struct device *dev)
+static struct enet_statistics *lance_get_stats (struct device *dev)
 {
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
-	int entry = priv->cur_rx % RX_RING_SIZE;
-	int i;
+	struct lance_private *lp = (struct lance_private *) dev->priv;
 
-	/* If we own the next entry, it's a new packet. Send it up. */
-	while (!(priv->rx_ring[entry]->RMD1 & RF_OWN)) {
-		int status = priv->rx_ring[entry]->RMD1 & 0xff00;
-
-		if (status != (RF_STP|RF_ENP)) {      /* There was an error. */
-		  /* There is a tricky error noted by John Murphy,
-		     <murf@perftech.com> to Russ Nelson: Even with full-sized
-		     buffers it's possible for a jabber packet to use two
-		     buffers, with only the last correctly noting the error. */
-			if (status & RF_ENP)
-			  /* Only count a general error at the */
-				priv->stats.rx_errors++; /* end of a packet.*/
-			if (status & RF_FRAM)
-				priv->stats.rx_frame_errors++;
-			if (status & RF_OFLO)
-				priv->stats.rx_over_errors++;
-			if (status & RF_CRC)
-				priv->stats.rx_crc_errors++;
-			if (status & RF_BUFF)
-				priv->stats.rx_fifo_errors++;
-			priv->rx_ring[entry]->RMD1 &= 0x00ff|RF_STP|RF_ENP;
-		} else {
-			/* Malloc up new buffer, compatible with net-3. */
-			short pkt_len = priv->rx_ring[entry]->RMD3;
-			struct sk_buff *skb;
+	return &lp->stats;
+}
 
-			if(pkt_len<60)
-			{
-				printk("%s: Runt packet!\n",dev->name);
-				priv->stats.rx_errors++;
-			}
-			else
+/* taken from the depca driver */
+static void lance_load_multicast (struct device *dev)
+{
+	struct lance_private *lp = (struct lance_private *) dev->priv;
+	volatile struct lance_init_block *ib = lp->init_block;
+	volatile u16 *mcast_table = (u16 *)&ib->filter;
+	struct dev_mc_list *dmi=dev->mc_list;
+	char *addrs;
+	int i, j, bit, byte;
+	u32 crc, poly = CRC_POLYNOMIAL_LE;
+	
+	/* set all multicast bits */
+	if (dev->flags & IFF_ALLMULTI){ 
+		ib->filter [0] = 0xffffffff;
+		ib->filter [1] = 0xffffffff;
+		return;
+	}
+	/* clear the multicast filter */
+	ib->filter [0] = 0;
+	ib->filter [1] = 0;
+
+	/* Add addresses */
+	for (i = 0; i < dev->mc_count; i++){
+		addrs = dmi->dmi_addr;
+		dmi   = dmi->next;
+
+		/* multicast address? */
+		if (!(*addrs & 1))
+			continue;
+		
+		crc = 0xffffffff;
+		for (byte = 0; byte < 6; byte++)
+			for (bit = *addrs++, j = 0; j < 8; j++, bit>>=1)
 			{
-				skb = dev_alloc_skb(pkt_len+2);
-				if (skb == NULL) {
-					printk("%s: Memory squeeze, deferring packet.\n", dev->name);
-					for (i = 0; i < RX_RING_SIZE; i++)
-						if (priv->rx_ring[(entry+i) % RX_RING_SIZE]->RMD1 & RF_OWN)
-							break;
-
-					if (i > RX_RING_SIZE-2) {
-						priv->stats.rx_dropped++;
-						priv->rx_ring[entry]->RMD1 |= RF_OWN;
-						priv->cur_rx++;
-					}
-					break;
-				}
-				skb->dev = dev;
-				skb_reserve(skb,2);	/* 16 byte align */
-				skb_put(skb,pkt_len);	/* Make room */
-				eth_copy_and_sum(skb,
-						 priv->rx_buff[entry],
-						 pkt_len,0);
-				skb->protocol=eth_type_trans(skb,dev);
-#if 0
-				printk("RX pkt type 0x%04x from ", 
-				       ((u_short *)skb->data)[6]);
-				{
-				  int i;
-				  u_char *ptr = &((u_char *)skb->data)[6];
-				  for (i = 0; i < 6; i++)
-				    printk("%02x", ptr[i]);
-				}
-				printk(" to ");
+				int test;
+
+				test = ((bit ^ crc) & 0x01);
+				crc >>= 1;
+
+				if (test)
 				{
-				  int i;
-				  u_char *ptr = (u_char *)skb->data;
-				  for (i = 0; i < 6; i++)
-				    printk("%02x", ptr[i]);
+					crc = crc ^ poly;
 				}
-				printk(" data 0x%08x len %d\n",
-				       (int)skb->data, (int)skb->len);
-#endif
-
-				netif_rx(skb);
-				priv->stats.rx_packets++;
 			}
-		}
-		priv->rx_ring[entry]->RMD1 |= RF_OWN;
-		entry = (++priv->cur_rx) % RX_RING_SIZE;
+		
+		crc = crc >> 26;
+		mcast_table [crc >> 4] |= 1 << (crc & 0xf);
 	}
+	return;
+}
 
-	priv->cur_rx = priv->cur_rx % RX_RING_SIZE;
-
-	/* We should check that at least two ring entries are free.
-	   If not, we should free one and mark stats->rx_dropped++. */
+static void lance_set_multicast (struct device *dev)
+{
+	struct lance_private *lp = (struct lance_private *) dev->priv;
+	volatile struct lance_init_block *ib = lp->init_block;
+	volatile struct lance_regs *ll = lp->ll;
+	char shown;
+
+	shown = 0;
+	while (dev->tbusy)
+		if (!shown++)
+			printk ("Waiting for tbusy to go down\n");
+	set_bit (0, (void *) &dev->tbusy);
+
+	shown = 0;
+	while (lp->tx_old != lp->tx_new)
+		if (!shown)
+			printk ("Waiting for buffer to empty\n");
+
+	ll->rap = LE_CSR0;
+	ll->rdp = LE_C0_STOP;
+	lance_init_ring (dev);
 
-	return(0);
+	if (dev->flags & IFF_PROMISC) {
+		ib->mode |= LE_MO_PROM;
+	} else {
+		ib->mode &= ~LE_MO_PROM;
+		lance_load_multicast (dev);
+	}
+	load_csrs (lp);
+	init_restart_lance (lp);
+	dev->tbusy = 0;
 }
 
 
-static struct enet_statistics *a2065_get_stats(struct device *dev)
+int a2065_probe(struct device *dev)
 {
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
+	int key1, key2 = 0;
+	struct ConfigDev *cd;
+	u_long board;
+	u_long sn;
+	struct lance_private *priv;
+	struct A2065Board *a2065;
 
-	return(&priv->stats);
-}
+	if ((key1 = zorro_find(MANUF_COMMODORE, PROD_A2065, 0, 0)) ||
+	    (key1 = zorro_find(MANUF_COMMODORE, PROD_A2065_2, 0, 0)) ||
+	    (key2 = zorro_find(MANUF_AMERISTAR, PROD_AMERISTAR2065, 0, 0))) {
+		cd = zorro_get_board(key1 ? key1 : key2);
+		if ((board = (u_long)cd->cd_BoardAddr)) {
+			sn = cd->cd_Rom.er_SerialNumber;
+			if (key1) {			/* Commodore */
+				dev->dev_addr[0] = 0x00;
+				dev->dev_addr[1] = 0x80;
+				dev->dev_addr[2] = 0x10;
+			} else {			/* Ameristar */
+				dev->dev_addr[0] = 0x00;
+				dev->dev_addr[1] = 0x00;
+				dev->dev_addr[2] = 0x9f;
+			}
+			dev->dev_addr[3] = (sn>>16) & 0xff;
+			dev->dev_addr[4] = (sn>>8) & 0xff;
+			dev->dev_addr[5] = sn & 0xff;
+			printk("%s: A2065 at 0x%08lx, Ethernet Address %02x:%02x:%02x:%02x:%02x:%02x\n",
+			       dev->name, board, dev->dev_addr[0],
+			       dev->dev_addr[1], dev->dev_addr[2],
+			       dev->dev_addr[3], dev->dev_addr[4],
+			       dev->dev_addr[5]);
 
+			init_etherdev(dev, 0);
 
-/* Set or clear the multicast filter for this adaptor.
- */
-static void set_multicast_list(struct device *dev)
-{
-	struct a2065_private *priv = (struct a2065_private *)dev->priv;
-	struct A2065Board *board = priv->board;
-	struct lancedata *alancedata;	      /* Amiga point of view */
-	alancedata = (struct lancedata *)board->RAM;
+			dev->priv = kmalloc(sizeof(struct
+						   lance_private),
+					    GFP_KERNEL);
+			priv = (struct lance_private *)dev->priv;
+			memset(priv, 0, sizeof(struct lance_private));
 
-	/* We take the simple way out and always enable promiscuous mode. */
-	board->Lance.RAP = CSR0;	      /* LANCE Controller Status */
-	board->Lance.RDP = STOP;	      /* Temporarily stop the lance. */
+			a2065 = (struct A2065Board *)ZTWO_VADDR(board);
+			priv->ll = &a2065->Lance;
+			priv->init_block =
+					(struct lance_init_block *)&a2065->RAM;
+			priv->lance_init_block = (struct lance_init_block *)
+					      offsetof(struct A2065Board, RAM);
+			priv->auto_select = 0;
+			priv->key = key1 ? key1 : key2;
+			priv->busmaster_regval = LE_C3_BSWP;
 
-	/* Enable big endian byte ordering */
-	board->Lance.RAP = CSR3;	      /* CSR3 */
-	board->Lance.RDP = BSWP;
+			priv->lance_log_rx_bufs = LANCE_LOG_RX_BUFFERS;
+			priv->lance_log_tx_bufs = LANCE_LOG_TX_BUFFERS;
+			priv->rx_ring_mod_mask = RX_RING_MOD_MASK;
+			priv->tx_ring_mod_mask = TX_RING_MOD_MASK;
+
+			dev->open = &lance_open;
+			dev->stop = &lance_close;
+			dev->hard_start_xmit = &lance_start_xmit;
+			dev->get_stats = &lance_get_stats;
+			dev->set_multicast_list = &lance_set_multicast;
+			dev->dma = 0;
 
-	if (dev->flags&IFF_PROMISC) {
-	  /* Log any net taps. */
-	  printk("%s: Promiscuous mode enabled.\n", dev->name);
-	  alancedata->init.Mode = PROM;	      /* Set promiscuous mode */
-	} else {
-	  short multicast_table[4];
-	  int num_addrs=dev->mc_count;
-	  if(dev->flags&IFF_ALLMULTI)
-		num_addrs=1;
-	  /*
-	   * We don't use the multicast table,
-	   * but rely on upper-layer filtering.
-	   */
-	  memset(multicast_table, (num_addrs == 0) ? 0 : -1,
-		 sizeof(multicast_table));
-	  alancedata->init.LADRF[0] = multicast_table[0]<<16 |
-	    multicast_table[1];
-	  alancedata->init.LADRF[1] = multicast_table[2]<<16 |
-	    multicast_table[3];
-	  alancedata->init.Mode = 0x0000;
+			ether_setup(dev);
+			zorro_config_board(key1 ? key1 : key2, 0);
+			return(0);
+		}
 	}
-
-	board->Lance.RAP = CSR0;	        /* LANCE Controller Status */
-	board->Lance.RDP = INEA|STRT|IDON|INIT;	/* Resume normal operation. */
+	return(ENODEV);
 }
 
 
@@ -826,7 +834,7 @@
 
 void cleanup_module(void)
 {
-	struct a2065_private *priv = (struct a2065_private *)a2065_dev.priv;
+	struct lance_private *priv = (struct lance_private *)a2065_dev.priv;
 
 	unregister_netdev(&a2065_dev);
 	zorro_unconfig_board(priv->key, 0);