*sonic/natsemi/ns83829: Move the National Semi-conductor drivers

Move the National Semi-conductor drivers into drivers/net/ethernet/natsemi/
and make the necessary Kconfig and Makefile changes.  Also moved the 8390
(National Semi-conductor) devices as a sub-menu of National Semi-conductor
devices.

- moved the ibmlana driver as well into this directory since it is a
  "SONIC" driver

CC: Alfred Arnold <alfred.arnold@lancom.de>
CC: Thomas Bogendoerfer <tsbogend@alpha.franken.de>
CC: Harald Welte <laforge@gnumonks.org>
CC: Tim Hockin <thockin@hockin.org>
CC: <linux-ns83820@kvack.org>
CC: Kevin Chea <kchea@yahoo.com>
CC: Marc Gauthier <marc@linux-xtensa.org>
CC: Chris Zankel <chris@zankel.net>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Acked-by: Marc Gauthier <marc@tensilica.com>

1 files changed, 1075 insertions, 0 deletions

diff --git a/drivers/net/ethernet/natsemi/ibmlana.c b/drivers/net/ethernet/natsemi/ibmlana.c
new file mode 100644
index 000000000000..a7d6cad32953
--- /dev/null
+++ b/drivers/net/ethernet/natsemi/ibmlana.c
@@ -0,0 +1,1075 @@
+/*
+net-3-driver for the IBM LAN Adapter/A
+
+This is an extension to the Linux operating system, and is covered by the
+same GNU General Public License that covers that work.
+
+Copyright 1999 by Alfred Arnold (alfred@ccac.rwth-aachen.de,
+                                 alfred.arnold@lancom.de)
+
+This driver is based both on the SK_MCA driver, which is itself based on the
+SK_G16 and 3C523 driver.
+
+paper sources:
+  'PC Hardware: Aufbau, Funktionsweise, Programmierung' by
+  Hans-Peter Messmer for the basic Microchannel stuff
+
+  'Linux Geraetetreiber' by Allesandro Rubini, Kalle Dalheimer
+  for help on Ethernet driver programming
+
+  'DP83934CVUL-20/25 MHz SONIC-T Ethernet Controller Datasheet' by National
+  Semiconductor for info on the MAC chip
+
+  'LAN Technical Reference Ethernet Adapter Interface Version 1 Release 1.0
+   Document Number SC30-3661-00' by IBM for info on the adapter itself
+
+  Also see http://www.national.com/analog 
+
+special acknowledgements to:
+  - Bob Eager for helping me out with documentation from IBM
+  - Jim Shorney for his endless patience with me while I was using
+    him as a beta tester to trace down the address filter bug ;-)
+
+  Missing things:
+
+  -> set debug level via ioctl instead of compile-time switches
+  -> I didn't follow the development of the 2.1.x kernels, so my
+     assumptions about which things changed with which kernel version
+     are probably nonsense
+
+History:
+  Nov 6th, 1999
+  	startup from SK_MCA driver
+  Dec 6th, 1999
+	finally got docs about the card.  A big thank you to Bob Eager!
+  Dec 12th, 1999
+	first packet received
+  Dec 13th, 1999
+	recv queue done, tcpdump works
+  Dec 15th, 1999
+	transmission part works
+  Dec 28th, 1999
+	added usage of the isa_functions for Linux 2.3 .  Things should
+	still work with 2.0.x....
+  Jan 28th, 2000
+	in Linux 2.2.13, the version.h file mysteriously didn't get
+	included.  Added a workaround for this.  Furthermore, it now
+	not only compiles as a modules ;-)
+  Jan 30th, 2000
+	newer kernels automatically probe more than one board, so the
+	'startslot' as a variable is also needed here
+  Apr 12th, 2000
+	the interrupt mask register is not set 'hard' instead of individually
+	setting registers, since this seems to set bits that shouldn't be
+	set
+  May 21st, 2000
+	reset interrupt status immediately after CAM load
+	add a recovery delay after releasing the chip's reset line
+  May 24th, 2000
+	finally found the bug in the address filter setup - damned signed
+        chars!
+  June 1st, 2000
+	corrected version codes, added support for the latest 2.3 changes
+  Oct 28th, 2002
+	cleaned up for the 2.5 tree <alan@lxorguk.ukuu.org.uk>
+
+ *************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/time.h>
+#include <linux/mca.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/if_ether.h>
+#include <linux/skbuff.h>
+#include <linux/bitops.h>
+
+#include <asm/processor.h>
+#include <asm/io.h>
+
+#define _IBM_LANA_DRIVER_
+#include "ibmlana.h"
+
+#undef DEBUG
+
+#define DRV_NAME "ibmlana"
+
+/* ------------------------------------------------------------------------
+ * global static data - not more since we can handle multiple boards and
+ * have to pack all state info into the device struct!
+ * ------------------------------------------------------------------------ */
+
+static char *MediaNames[Media_Count] = {
+	"10BaseT", "10Base5", "Unknown", "10Base2"
+};
+
+/* ------------------------------------------------------------------------
+ * private subfunctions
+ * ------------------------------------------------------------------------ */
+
+#ifdef DEBUG
+  /* dump all registers */
+
+static void dumpregs(struct net_device *dev)
+{
+	int z;
+
+	for (z = 0; z < 160; z += 2) {
+		if (!(z & 15))
+			printk("REGS: %04x:", z);
+		printk(" %04x", inw(dev->base_addr + z));
+		if ((z & 15) == 14)
+			printk("\n");
+	}
+}
+
+/* dump parts of shared memory - only needed during debugging */
+
+static void dumpmem(struct net_device *dev, u32 start, u32 len)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	int z;
+
+	printk("Address %04x:\n", start);
+	for (z = 0; z < len; z++) {
+		if ((z & 15) == 0)
+			printk("%04x:", z);
+		printk(" %02x", readb(priv->base + start + z));
+		if ((z & 15) == 15)
+			printk("\n");
+	}
+	if ((z & 15) != 0)
+		printk("\n");
+}
+
+/* print exact time - ditto */
+
+static void PrTime(void)
+{
+	struct timeval tv;
+
+	do_gettimeofday(&tv);
+	printk("%9d:%06d: ", (int) tv.tv_sec, (int) tv.tv_usec);
+}
+#endif				/* DEBUG */
+
+/* deduce resources out of POS registers */
+
+static void getaddrs(struct mca_device *mdev, int *base, int *memlen,
+		     int *iobase, int *irq, ibmlana_medium *medium)
+{
+	u_char pos0, pos1;
+
+	pos0 = mca_device_read_stored_pos(mdev, 2);
+	pos1 = mca_device_read_stored_pos(mdev, 3);
+
+	*base = 0xc0000 + ((pos1 & 0xf0) << 9);
+	*memlen = (pos1 & 0x01) ? 0x8000 : 0x4000;
+	*iobase = (pos0 & 0xe0) << 7;
+	switch (pos0 & 0x06) {
+	case 0:
+		*irq = 5;
+		break;
+	case 2:
+		*irq = 15;
+		break;
+	case 4:
+		*irq = 10;
+		break;
+	case 6:
+		*irq = 11;
+		break;
+	}
+	*medium = (pos0 & 0x18) >> 3;
+}
+
+/* wait on register value with mask and timeout */
+
+static int wait_timeout(struct net_device *dev, int regoffs, u16 mask,
+			u16 value, int timeout)
+{
+	unsigned long fin = jiffies + timeout;
+
+	while (time_before(jiffies,fin))
+		if ((inw(dev->base_addr + regoffs) & mask) == value)
+			return 1;
+
+	return 0;
+}
+
+
+/* reset the whole board */
+
+static void ResetBoard(struct net_device *dev)
+{
+	unsigned char bcmval;
+
+	/* read original board control value */
+
+	bcmval = inb(dev->base_addr + BCMREG);
+
+	/* set reset bit for a while */
+
+	bcmval |= BCMREG_RESET;
+	outb(bcmval, dev->base_addr + BCMREG);
+	udelay(10);
+	bcmval &= ~BCMREG_RESET;
+	outb(bcmval, dev->base_addr + BCMREG);
+
+	/* switch over to RAM again */
+
+	bcmval |= BCMREG_RAMEN | BCMREG_RAMWIN;
+	outb(bcmval, dev->base_addr + BCMREG);
+}
+
+/* calculate RAM layout & set up descriptors in RAM */
+
+static void InitDscrs(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	u32 addr, baddr, raddr;
+	int z;
+	tda_t tda;
+	rda_t rda;
+	rra_t rra;
+
+	/* initialize RAM */
+
+	memset_io(priv->base, 0xaa,
+		      dev->mem_start - dev->mem_start);	/* XXX: typo? */
+
+	/* setup n TX descriptors - independent of RAM size */
+
+	priv->tdastart = addr = 0;
+	priv->txbufstart = baddr = sizeof(tda_t) * TXBUFCNT;
+	for (z = 0; z < TXBUFCNT; z++) {
+		tda.status = 0;
+		tda.config = 0;
+		tda.length = 0;
+		tda.fragcount = 1;
+		tda.startlo = baddr;
+		tda.starthi = 0;
+		tda.fraglength = 0;
+		if (z == TXBUFCNT - 1)
+			tda.link = priv->tdastart;
+		else
+			tda.link = addr + sizeof(tda_t);
+		tda.link |= 1;
+		memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
+		addr += sizeof(tda_t);
+		baddr += PKTSIZE;
+	}
+
+	/* calculate how many receive buffers fit into remaining memory */
+
+	priv->rxbufcnt = (dev->mem_end - dev->mem_start - baddr) / (sizeof(rra_t) + sizeof(rda_t) + PKTSIZE);
+
+	/* calculate receive addresses */
+
+	priv->rrastart = raddr = priv->txbufstart + (TXBUFCNT * PKTSIZE);
+	priv->rdastart = addr = priv->rrastart + (priv->rxbufcnt * sizeof(rra_t));
+	priv->rxbufstart = baddr = priv->rdastart + (priv->rxbufcnt * sizeof(rda_t));
+
+	for (z = 0; z < priv->rxbufcnt; z++) {
+		rra.startlo = baddr;
+		rra.starthi = 0;
+		rra.cntlo = PKTSIZE >> 1;
+		rra.cnthi = 0;
+		memcpy_toio(priv->base + raddr, &rra, sizeof(rra_t));
+
+		rda.status = 0;
+		rda.length = 0;
+		rda.startlo = 0;
+		rda.starthi = 0;
+		rda.seqno = 0;
+		if (z < priv->rxbufcnt - 1)
+			rda.link = addr + sizeof(rda_t);
+		else
+			rda.link = 1;
+		rda.inuse = 1;
+		memcpy_toio(priv->base + addr, &rda, sizeof(rda_t));
+
+		baddr += PKTSIZE;
+		raddr += sizeof(rra_t);
+		addr += sizeof(rda_t);
+	}
+
+	/* initialize current pointers */
+
+	priv->nextrxdescr = 0;
+	priv->lastrxdescr = priv->rxbufcnt - 1;
+	priv->nexttxdescr = 0;
+	priv->currtxdescr = 0;
+	priv->txusedcnt = 0;
+	memset(priv->txused, 0, sizeof(priv->txused));
+}
+
+/* set up Rx + Tx descriptors in SONIC */
+
+static int InitSONIC(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+
+	/* set up start & end of resource area */
+
+	outw(0, SONIC_URRA);
+	outw(priv->rrastart, dev->base_addr + SONIC_RSA);
+	outw(priv->rrastart + (priv->rxbufcnt * sizeof(rra_t)), dev->base_addr + SONIC_REA);
+	outw(priv->rrastart, dev->base_addr + SONIC_RRP);
+	outw(priv->rrastart, dev->base_addr + SONIC_RWP);
+
+	/* set EOBC so that only one packet goes into one buffer */
+
+	outw((PKTSIZE - 4) >> 1, dev->base_addr + SONIC_EOBC);
+
+	/* let SONIC read the first RRA descriptor */
+
+	outw(CMDREG_RRRA, dev->base_addr + SONIC_CMDREG);
+	if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_RRRA, 0, 2)) {
+		printk(KERN_ERR "%s: SONIC did not respond on RRRA command - giving up.", dev->name);
+		return 0;
+	}
+
+	/* point SONIC to the first RDA */
+
+	outw(0, dev->base_addr + SONIC_URDA);
+	outw(priv->rdastart, dev->base_addr + SONIC_CRDA);
+
+	/* set upper half of TDA address */
+
+	outw(0, dev->base_addr + SONIC_UTDA);
+
+	return 1;
+}
+
+/* stop SONIC so we can reinitialize it */
+
+static void StopSONIC(struct net_device *dev)
+{
+	/* disable interrupts */
+
+	outb(inb(dev->base_addr + BCMREG) & (~BCMREG_IEN), dev->base_addr + BCMREG);
+	outb(0, dev->base_addr + SONIC_IMREG);
+
+	/* reset the SONIC */
+
+	outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
+	udelay(10);
+	outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
+}
+
+/* initialize card and SONIC for proper operation */
+
+static void putcam(camentry_t * cams, int *camcnt, char *addr)
+{
+	camentry_t *pcam = cams + (*camcnt);
+	u8 *uaddr = (u8 *) addr;
+
+	pcam->index = *camcnt;
+	pcam->addr0 = (((u16) uaddr[1]) << 8) | uaddr[0];
+	pcam->addr1 = (((u16) uaddr[3]) << 8) | uaddr[2];
+	pcam->addr2 = (((u16) uaddr[5]) << 8) | uaddr[4];
+	(*camcnt)++;
+}
+
+static void InitBoard(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	int camcnt;
+	camentry_t cams[16];
+	u32 cammask;
+	struct netdev_hw_addr *ha;
+	u16 rcrval;
+
+	/* reset the SONIC */
+
+	outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
+	udelay(10);
+
+	/* clear all spurious interrupts */
+
+	outw(inw(dev->base_addr + SONIC_ISREG), dev->base_addr + SONIC_ISREG);
+
+	/* set up the SONIC's bus interface - constant for this adapter -
+	   must be done while the SONIC is in reset */
+
+	outw(DCREG_USR1 | DCREG_USR0 | DCREG_WC1 | DCREG_DW32, dev->base_addr + SONIC_DCREG);
+	outw(0, dev->base_addr + SONIC_DCREG2);
+
+	/* remove reset form the SONIC */
+
+	outw(0, dev->base_addr + SONIC_CMDREG);
+	udelay(10);
+
+	/* data sheet requires URRA to be programmed before setting up the CAM contents */
+
+	outw(0, dev->base_addr + SONIC_URRA);
+
+	/* program the CAM entry 0 to the device address */
+
+	camcnt = 0;
+	putcam(cams, &camcnt, dev->dev_addr);
+
+	/* start putting the multicast addresses into the CAM list.  Stop if
+	   it is full. */
+
+	netdev_for_each_mc_addr(ha, dev) {
+		putcam(cams, &camcnt, ha->addr);
+		if (camcnt == 16)
+			break;
+	}
+
+	/* calculate CAM mask */
+
+	cammask = (1 << camcnt) - 1;
+
+	/* feed CDA into SONIC, initialize RCR value (always get broadcasts) */
+
+	memcpy_toio(priv->base, cams, sizeof(camentry_t) * camcnt);
+	memcpy_toio(priv->base + (sizeof(camentry_t) * camcnt), &cammask, sizeof(cammask));
+
+#ifdef DEBUG
+	printk("CAM setup:\n");
+	dumpmem(dev, 0, sizeof(camentry_t) * camcnt + sizeof(cammask));
+#endif
+
+	outw(0, dev->base_addr + SONIC_CAMPTR);
+	outw(camcnt, dev->base_addr + SONIC_CAMCNT);
+	outw(CMDREG_LCAM, dev->base_addr + SONIC_CMDREG);
+	if (!wait_timeout(dev, SONIC_CMDREG, CMDREG_LCAM, 0, 2)) {
+		printk(KERN_ERR "%s:SONIC did not respond on LCAM command - giving up.", dev->name);
+		return;
+	} else {
+		/* clear interrupt condition */
+
+		outw(ISREG_LCD, dev->base_addr + SONIC_ISREG);
+
+#ifdef DEBUG
+		printk("Loading CAM done, address pointers %04x:%04x\n",
+		       inw(dev->base_addr + SONIC_URRA),
+		       inw(dev->base_addr + SONIC_CAMPTR));
+		{
+			int z;
+
+			printk("\n-->CAM: PTR %04x CNT %04x\n",
+			       inw(dev->base_addr + SONIC_CAMPTR),
+			       inw(dev->base_addr + SONIC_CAMCNT));
+			outw(CMDREG_RST, dev->base_addr + SONIC_CMDREG);
+			for (z = 0; z < camcnt; z++) {
+				outw(z, dev->base_addr + SONIC_CAMEPTR);
+				printk("Entry %d: %04x %04x %04x\n", z,
+				       inw(dev->base_addr + SONIC_CAMADDR0),
+				       inw(dev->base_addr + SONIC_CAMADDR1),
+				       inw(dev->base_addr + SONIC_CAMADDR2));
+			}
+			outw(0, dev->base_addr + SONIC_CMDREG);
+		}
+#endif
+	}
+
+	rcrval = RCREG_BRD | RCREG_LB_NONE;
+
+	/* if still multicast addresses left or ALLMULTI is set, set the multicast
+	   enable bit */
+
+	if ((dev->flags & IFF_ALLMULTI) || netdev_mc_count(dev) > camcnt)
+		rcrval |= RCREG_AMC;
+
+	/* promiscuous mode ? */
+
+	if (dev->flags & IFF_PROMISC)
+		rcrval |= RCREG_PRO;
+
+	/* program receive mode */
+
+	outw(rcrval, dev->base_addr + SONIC_RCREG);
+#ifdef DEBUG
+	printk("\nRCRVAL: %04x\n", rcrval);
+#endif
+
+	/* set up descriptors in shared memory + feed them into SONIC registers */
+
+	InitDscrs(dev);
+	if (!InitSONIC(dev))
+		return;
+
+	/* reset all pending interrupts */
+
+	outw(0xffff, dev->base_addr + SONIC_ISREG);
+
+	/* enable transmitter + receiver interrupts */
+
+	outw(CMDREG_RXEN, dev->base_addr + SONIC_CMDREG);
+	outw(IMREG_PRXEN | IMREG_RBEEN | IMREG_PTXEN | IMREG_TXEREN, dev->base_addr + SONIC_IMREG);
+
+	/* turn on card interrupts */
+
+	outb(inb(dev->base_addr + BCMREG) | BCMREG_IEN, dev->base_addr + BCMREG);
+
+#ifdef DEBUG
+	printk("Register dump after initialization:\n");
+	dumpregs(dev);
+#endif
+}
+
+/* start transmission of a descriptor */
+
+static void StartTx(struct net_device *dev, int descr)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	int addr;
+
+	addr = priv->tdastart + (descr * sizeof(tda_t));
+
+	/* put descriptor address into SONIC */
+
+	outw(addr, dev->base_addr + SONIC_CTDA);
+
+	/* trigger transmitter */
+
+	priv->currtxdescr = descr;
+	outw(CMDREG_TXP, dev->base_addr + SONIC_CMDREG);
+}
+
+/* ------------------------------------------------------------------------
+ * interrupt handler(s)
+ * ------------------------------------------------------------------------ */
+
+/* receive buffer area exhausted */
+
+static void irqrbe_handler(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+
+	/* point the SONIC back to the RRA start */
+
+	outw(priv->rrastart, dev->base_addr + SONIC_RRP);
+	outw(priv->rrastart, dev->base_addr + SONIC_RWP);
+}
+
+/* receive interrupt */
+
+static void irqrx_handler(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	rda_t rda;
+	u32 rdaaddr, lrdaaddr;
+
+	/* loop until ... */
+
+	while (1) {
+		/* read descriptor that was next to be filled by SONIC */
+
+		rdaaddr = priv->rdastart + (priv->nextrxdescr * sizeof(rda_t));
+		lrdaaddr = priv->rdastart + (priv->lastrxdescr * sizeof(rda_t));
+		memcpy_fromio(&rda, priv->base + rdaaddr, sizeof(rda_t));
+
+		/* iron out upper word halves of fields we use - SONIC will duplicate
+		   bits 0..15 to 16..31 */
+
+		rda.status &= 0xffff;
+		rda.length &= 0xffff;
+		rda.startlo &= 0xffff;
+
+		/* stop if the SONIC still owns it, i.e. there is no data for us */
+
+		if (rda.inuse)
+			break;
+
+		/* good packet? */
+
+		else if (rda.status & RCREG_PRX) {
+			struct sk_buff *skb;
+
+			/* fetch buffer */
+
+			skb = dev_alloc_skb(rda.length + 2);
+			if (skb == NULL)
+				dev->stats.rx_dropped++;
+			else {
+				/* copy out data */
+
+				memcpy_fromio(skb_put(skb, rda.length),
+					       priv->base +
+					       rda.startlo, rda.length);
+
+				/* set up skb fields */
+
+				skb->protocol = eth_type_trans(skb, dev);
+				skb_checksum_none_assert(skb);
+
+				/* bookkeeping */
+				dev->stats.rx_packets++;
+				dev->stats.rx_bytes += rda.length;
+
+				/* pass to the upper layers */
+				netif_rx(skb);
+			}
+		}
+
+		/* otherwise check error status bits and increase statistics */
+
+		else {
+			dev->stats.rx_errors++;
+			if (rda.status & RCREG_FAER)
+				dev->stats.rx_frame_errors++;
+			if (rda.status & RCREG_CRCR)
+				dev->stats.rx_crc_errors++;
+		}
+
+		/* descriptor processed, will become new last descriptor in queue */
+
+		rda.link = 1;
+		rda.inuse = 1;
+		memcpy_toio(priv->base + rdaaddr, &rda,
+			     sizeof(rda_t));
+
+		/* set up link and EOL = 0 in currently last descriptor. Only write
+		   the link field since the SONIC may currently already access the
+		   other fields. */
+
+		memcpy_toio(priv->base + lrdaaddr + 20, &rdaaddr, 4);
+
+		/* advance indices */
+
+		priv->lastrxdescr = priv->nextrxdescr;
+		if ((++priv->nextrxdescr) >= priv->rxbufcnt)
+			priv->nextrxdescr = 0;
+	}
+}
+
+/* transmit interrupt */
+
+static void irqtx_handler(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	tda_t tda;
+
+	/* fetch descriptor (we forgot the size ;-) */
+	memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
+
+	/* update statistics */
+	dev->stats.tx_packets++;
+	dev->stats.tx_bytes += tda.length;
+
+	/* update our pointers */
+	priv->txused[priv->currtxdescr] = 0;
+	priv->txusedcnt--;
+
+	/* if there are more descriptors present in RAM, start them */
+	if (priv->txusedcnt > 0)
+		StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
+
+	/* tell the upper layer we can go on transmitting */
+	netif_wake_queue(dev);
+}
+
+static void irqtxerr_handler(struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	tda_t tda;
+
+	/* fetch descriptor to check status */
+	memcpy_fromio(&tda, priv->base + priv->tdastart + (priv->currtxdescr * sizeof(tda_t)), sizeof(tda_t));
+
+	/* update statistics */
+	dev->stats.tx_errors++;
+	if (tda.status & (TCREG_NCRS | TCREG_CRSL))
+		dev->stats.tx_carrier_errors++;
+	if (tda.status & TCREG_EXC)
+		dev->stats.tx_aborted_errors++;
+	if (tda.status & TCREG_OWC)
+		dev->stats.tx_window_errors++;
+	if (tda.status & TCREG_FU)
+		dev->stats.tx_fifo_errors++;
+
+	/* update our pointers */
+	priv->txused[priv->currtxdescr] = 0;
+	priv->txusedcnt--;
+
+	/* if there are more descriptors present in RAM, start them */
+	if (priv->txusedcnt > 0)
+		StartTx(dev, (priv->currtxdescr + 1) % TXBUFCNT);
+
+	/* tell the upper layer we can go on transmitting */
+	netif_wake_queue(dev);
+}
+
+/* general interrupt entry */
+
+static irqreturn_t irq_handler(int dummy, void *device)
+{
+	struct net_device *dev = device;
+	u16 ival;
+
+	/* in case we're not meant... */
+	if (!(inb(dev->base_addr + BCMREG) & BCMREG_IPEND))
+		return IRQ_NONE;
+
+	/* loop through the interrupt bits until everything is clear */
+	while (1) {
+		ival = inw(dev->base_addr + SONIC_ISREG);
+
+		if (ival & ISREG_RBE) {
+			irqrbe_handler(dev);
+			outw(ISREG_RBE, dev->base_addr + SONIC_ISREG);
+		}
+		if (ival & ISREG_PKTRX) {
+			irqrx_handler(dev);
+			outw(ISREG_PKTRX, dev->base_addr + SONIC_ISREG);
+		}
+		if (ival & ISREG_TXDN) {
+			irqtx_handler(dev);
+			outw(ISREG_TXDN, dev->base_addr + SONIC_ISREG);
+		}
+		if (ival & ISREG_TXER) {
+			irqtxerr_handler(dev);
+			outw(ISREG_TXER, dev->base_addr + SONIC_ISREG);
+		}
+		break;
+	}
+	return IRQ_HANDLED;
+}
+
+/* ------------------------------------------------------------------------
+ * driver methods
+ * ------------------------------------------------------------------------ */
+
+/* MCA info */
+
+#if 0 /* info available elsewhere, but this is kept for reference */
+static int ibmlana_getinfo(char *buf, int slot, void *d)
+{
+	int len = 0, i;
+	struct net_device *dev = (struct net_device *) d;
+	ibmlana_priv *priv;
+
+	/* can't say anything about an uninitialized device... */
+
+	if (dev == NULL)
+		return len;
+	priv = netdev_priv(dev);
+
+	/* print info */
+
+	len += sprintf(buf + len, "IRQ: %d\n", priv->realirq);
+	len += sprintf(buf + len, "I/O: %#lx\n", dev->base_addr);
+	len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start, dev->mem_end - 1);
+	len += sprintf(buf + len, "Transceiver: %s\n", MediaNames[priv->medium]);
+	len += sprintf(buf + len, "Device: %s\n", dev->name);
+	len += sprintf(buf + len, "MAC address:");
+	for (i = 0; i < 6; i++)
+		len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
+	buf[len++] = '\n';
+	buf[len] = 0;
+
+	return len;
+}
+#endif
+
+/* open driver.  Means also initialization and start of LANCE */
+
+static int ibmlana_open(struct net_device *dev)
+{
+	int result;
+	ibmlana_priv *priv = netdev_priv(dev);
+
+	/* register resources - only necessary for IRQ */
+
+	result = request_irq(priv->realirq, irq_handler, IRQF_SHARED,
+			     dev->name, dev);
+	if (result != 0) {
+		printk(KERN_ERR "%s: failed to register irq %d\n", dev->name, dev->irq);
+		return result;
+	}
+	dev->irq = priv->realirq;
+
+	/* set up the card and SONIC */
+	InitBoard(dev);
+
+	/* initialize operational flags */
+	netif_start_queue(dev);
+	return 0;
+}
+
+/* close driver.  Shut down board and free allocated resources */
+
+static int ibmlana_close(struct net_device *dev)
+{
+	/* turn off board */
+
+	/* release resources */
+	if (dev->irq != 0)
+		free_irq(dev->irq, dev);
+	dev->irq = 0;
+	return 0;
+}
+
+/* transmit a block. */
+
+static netdev_tx_t ibmlana_tx(struct sk_buff *skb, struct net_device *dev)
+{
+	ibmlana_priv *priv = netdev_priv(dev);
+	int tmplen, addr;
+	unsigned long flags;
+	tda_t tda;
+	int baddr;
+
+	/* find out if there are free slots for a frame to transmit. If not,
+	   the upper layer is in deep desperation and we simply ignore the frame. */
+
+	if (priv->txusedcnt >= TXBUFCNT) {
+		dev->stats.tx_dropped++;
+		goto tx_done;
+	}
+
+	/* copy the frame data into the next free transmit buffer - fillup missing */
+	tmplen = skb->len;
+	if (tmplen < 60)
+		tmplen = 60;
+	baddr = priv->txbufstart + (priv->nexttxdescr * PKTSIZE);
+	memcpy_toio(priv->base + baddr, skb->data, skb->len);
+
+	/* copy filler into RAM - in case we're filling up...
+	   we're filling a bit more than necessary, but that doesn't harm
+	   since the buffer is far larger...
+	   Sorry Linus for the filler string but I couldn't resist ;-) */
+
+	if (tmplen > skb->len) {
+		char *fill = "NetBSD is a nice OS too! ";
+		unsigned int destoffs = skb->len, l = strlen(fill);
+
+		while (destoffs < tmplen) {
+			memcpy_toio(priv->base + baddr + destoffs, fill, l);
+			destoffs += l;
+		}
+	}
+
+	/* set up the new frame descriptor */
+	addr = priv->tdastart + (priv->nexttxdescr * sizeof(tda_t));
+	memcpy_fromio(&tda, priv->base + addr, sizeof(tda_t));
+	tda.length = tda.fraglength = tmplen;
+	memcpy_toio(priv->base + addr, &tda, sizeof(tda_t));
+
+	/* if there were no active descriptors, trigger the SONIC */
+	spin_lock_irqsave(&priv->lock, flags);
+
+	priv->txusedcnt++;
+	priv->txused[priv->nexttxdescr] = 1;
+
+	/* are all transmission slots used up ? */
+	if (priv->txusedcnt >= TXBUFCNT)
+		netif_stop_queue(dev);
+
+	if (priv->txusedcnt == 1)
+		StartTx(dev, priv->nexttxdescr);
+	priv->nexttxdescr = (priv->nexttxdescr + 1) % TXBUFCNT;
+
+	spin_unlock_irqrestore(&priv->lock, flags);
+tx_done:
+	dev_kfree_skb(skb);
+	return NETDEV_TX_OK;
+}
+
+/* switch receiver mode. */
+
+static void ibmlana_set_multicast_list(struct net_device *dev)
+{
+	/* first stop the SONIC... */
+	StopSONIC(dev);
+	/* ...then reinit it with the new flags */
+	InitBoard(dev);
+}
+
+/* ------------------------------------------------------------------------
+ * hardware check
+ * ------------------------------------------------------------------------ */
+
+static int ibmlana_irq;
+static int ibmlana_io;
+static int startslot;		/* counts through slots when probing multiple devices */
+
+static short ibmlana_adapter_ids[] __initdata = {
+	IBM_LANA_ID,
+	0x0000
+};
+
+static char *ibmlana_adapter_names[] __devinitdata = {
+	"IBM LAN Adapter/A",
+	NULL
+};
+
+
+static const struct net_device_ops ibmlana_netdev_ops = {
+	.ndo_open 		= ibmlana_open,
+	.ndo_stop 		= ibmlana_close,
+	.ndo_start_xmit		= ibmlana_tx,
+	.ndo_set_multicast_list = ibmlana_set_multicast_list,
+	.ndo_change_mtu		= eth_change_mtu,
+	.ndo_set_mac_address 	= eth_mac_addr,
+	.ndo_validate_addr	= eth_validate_addr,
+};
+
+static int __devinit ibmlana_init_one(struct device *kdev)
+{
+	struct mca_device *mdev = to_mca_device(kdev);
+	struct net_device *dev;
+	int slot = mdev->slot, z, rc;
+	int base = 0, irq = 0, iobase = 0, memlen = 0;
+	ibmlana_priv *priv;
+	ibmlana_medium medium;
+
+	dev = alloc_etherdev(sizeof(ibmlana_priv));
+	if (!dev)
+		return -ENOMEM;
+
+	dev->irq = ibmlana_irq;
+	dev->base_addr = ibmlana_io;
+
+	base = dev->mem_start;
+	irq = dev->irq;
+
+	/* deduce card addresses */
+	getaddrs(mdev, &base, &memlen, &iobase, &irq, &medium);
+
+	/* were we looking for something different ? */
+	if (dev->irq && dev->irq != irq) {
+		rc = -ENODEV;
+		goto err_out;
+	}
+	if (dev->mem_start && dev->mem_start != base) {
+		rc = -ENODEV;
+		goto err_out;
+	}
+
+	/* announce success */
+	printk(KERN_INFO "%s: IBM LAN Adapter/A found in slot %d\n", dev->name, slot + 1);
+
+	/* try to obtain I/O range */
+	if (!request_region(iobase, IBM_LANA_IORANGE, DRV_NAME)) {
+		printk(KERN_ERR "%s: cannot allocate I/O range at %#x!\n", DRV_NAME, iobase);
+		startslot = slot + 1;
+		rc = -EBUSY;
+		goto err_out;
+	}
+
+	priv = netdev_priv(dev);
+	priv->slot = slot;
+	priv->realirq = mca_device_transform_irq(mdev, irq);
+	priv->medium = medium;
+	spin_lock_init(&priv->lock);
+
+	/* set base + irq for this device (irq not allocated so far) */
+
+	dev->irq = 0;
+	dev->mem_start = base;
+	dev->mem_end = base + memlen;
+	dev->base_addr = iobase;
+
+	priv->base = ioremap(base, memlen);
+	if (!priv->base) {
+		printk(KERN_ERR "%s: cannot remap memory!\n", DRV_NAME);
+		startslot = slot + 1;
+		rc = -EBUSY;
+		goto err_out_reg;
+	}
+
+	mca_device_set_name(mdev, ibmlana_adapter_names[mdev->index]);
+	mca_device_set_claim(mdev, 1);
+
+	/* set methods */
+	dev->netdev_ops = &ibmlana_netdev_ops;
+	dev->flags |= IFF_MULTICAST;
+
+	/* copy out MAC address */
+
+	for (z = 0; z < ETH_ALEN; z++)
+		dev->dev_addr[z] = inb(dev->base_addr + MACADDRPROM + z);
+
+	/* print config */
+
+	printk(KERN_INFO "%s: IRQ %d, I/O %#lx, memory %#lx-%#lx, "
+	       "MAC address %pM.\n",
+	       dev->name, priv->realirq, dev->base_addr,
+	       dev->mem_start, dev->mem_end - 1,
+	       dev->dev_addr);
+	printk(KERN_INFO "%s: %s medium\n", dev->name, MediaNames[priv->medium]);
+
+	/* reset board */
+
+	ResetBoard(dev);
+
+	/* next probe will start at next slot */
+
+	startslot = slot + 1;
+
+	rc = register_netdev(dev);
+	if (rc)
+		goto err_out_claimed;
+
+	dev_set_drvdata(kdev, dev);
+	return 0;
+
+err_out_claimed:
+	mca_device_set_claim(mdev, 0);
+	iounmap(priv->base);
+err_out_reg:
+	release_region(iobase, IBM_LANA_IORANGE);
+err_out:
+	free_netdev(dev);
+	return rc;
+}
+
+static int ibmlana_remove_one(struct device *kdev)
+{
+	struct mca_device *mdev = to_mca_device(kdev);
+	struct net_device *dev = dev_get_drvdata(kdev);
+	ibmlana_priv *priv = netdev_priv(dev);
+
+	unregister_netdev(dev);
+	/*DeinitBoard(dev); */
+	release_region(dev->base_addr, IBM_LANA_IORANGE);
+	mca_device_set_claim(mdev, 0);
+	iounmap(priv->base);
+	free_netdev(dev);
+	return 0;
+}
+
+/* ------------------------------------------------------------------------
+ * modularization support
+ * ------------------------------------------------------------------------ */
+
+module_param_named(irq, ibmlana_irq, int, 0);
+module_param_named(io, ibmlana_io, int, 0);
+MODULE_PARM_DESC(irq, "IBM LAN/A IRQ number");
+MODULE_PARM_DESC(io, "IBM LAN/A I/O base address");
+MODULE_LICENSE("GPL");
+
+static struct mca_driver ibmlana_driver = {
+	.id_table = ibmlana_adapter_ids,
+	.driver = {
+		.name	= "ibmlana",
+		.bus	= &mca_bus_type,
+		.probe	= ibmlana_init_one,
+		.remove	= ibmlana_remove_one,
+	},
+};
+
+static int __init ibmlana_init_module(void)
+{
+	return mca_register_driver(&ibmlana_driver);
+}
+
+static void __exit ibmlana_cleanup_module(void)
+{
+	mca_unregister_driver(&ibmlana_driver);
+}
+
+module_init(ibmlana_init_module);
+module_exit(ibmlana_cleanup_module);