partial sync with netbsd 960418, more to come

1 files changed, 1231 insertions, 0 deletions

diff --git a/sys/dev/ic/smc90cx6.c b/sys/dev/ic/smc90cx6.c
new file mode 100644
index 00000000000..afa12df2b80
--- /dev/null
+++ b/sys/dev/ic/smc90cx6.c
@@ -0,0 +1,1231 @@
+/*	$NetBSD: smc90cx6.c,v 1.16 1996/03/20 13:28:50 is Exp $ */
+
+/*
+ * Copyright (c) 1994, 1995 Ignatios Souvatzis
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Ignatios Souvatzis
+ *      for the NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Driver for the Commodore Busines Machines ARCnet card.
+ */
+
+#define BAHASMCOPY /**/
+#define BAHSOFTCOPY /**/
+#define BAHRETRANSMIT /**/
+/* #define BAHTIMINGS */
+/* #define BAH_DEBUG 3 */
+
+/* zeroth version of M68060 support */
+
+#if defined(M68060) && defined(BAHASMCOPY)
+#undef BAHASMCOPY
+#endif
+
+#include "bpfilter.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/mbuf.h>
+#include <sys/buf.h>
+#include <sys/device.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/syslog.h>
+#include <sys/ioctl.h>
+#include <sys/errno.h>
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/if_types.h>
+#include <net/netisr.h>
+
+#ifdef INET
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/if_ether.h>
+#include <netinet/if_arc.h>
+#endif
+
+#if NBPFILTER > 0
+#include <net/bpf.h>
+#include <net/bpfdesc.h>
+#endif
+
+#include <sys/kernel.h>
+#include <machine/cpu.h>
+#include <machine/mtpr.h>
+
+#include <amiga/amiga/device.h>
+#include <amiga/amiga/isr.h>
+#include <amiga/dev/zbusvar.h>
+#include <amiga/dev/if_bahreg.h>
+
+/* these should be elsewhere */
+
+#define ARC_MIN_LEN 1
+#define ARC_MIN_FORBID_LEN 254
+#define ARC_MAX_FORBID_LEN 256
+#define ARC_MAX_LEN 508
+#define ARC_ADDR_LEN 1
+
+/* for watchdog timer. This should be more than enough. */
+#define ARCTIMEOUT (5*IFNET_SLOWHZ)
+
+/*
+ * This currently uses 2 bufs for tx, 2 for rx
+ *
+ * New rx protocol:
+ *
+ * rx has a fillcount variable. If fillcount > (NRXBUF-1), 
+ * rx can be switched off from rx hard int. 
+ * Else rx is restarted on the other receiver.
+ * rx soft int counts down. if it is == (NRXBUF-1), it restarts
+ * the receiver.
+ * To ensure packet ordering (we need that for 1201 later), we have a counter
+ * which is incremented modulo 256 on each receive and a per buffer
+ * variable, which is set to the counter on filling. The soft int can
+ * compare both values to determine the older packet.
+ *
+ * Transmit direction:
+ * 
+ * bah_start checks tx_fillcount
+ * case 2: return
+ *
+ * else fill tx_act ^ 1 && inc tx_fillcount
+ *
+ * check tx_fillcount again.
+ * case 2: set IFF_OACTIVE to stop arc_output from filling us.
+ * case 1: start tx
+ *
+ * tint clears IFF_OCATIVE, decrements and checks tx_fillcount
+ * case 1: start tx on tx_act ^ 1, softcall bah_start
+ * case 0: softcall bah_start
+ *
+ * #define fill(i) get mbuf && copy mbuf to chip(i)
+ */
+
+#ifdef BAHTIMINGS
+/*
+ * ARCnet stats; per interface.
+ */
+struct bah_stats {
+	u_long	mincopyin;
+	u_long	maxcopyin;		/* divided by byte count */
+	u_long	mincopyout;
+	u_long	maxcopyout;
+	u_long	minsend;
+	u_long	maxsend;
+	u_long	lasttxstart_mics;
+	struct	timeval lasttxstart_tv;
+};
+
+#error BAHTIMINGS CODE IS BROKEN; use of clkread() is bogus
+#endif
+
+/*
+ * Arcnet software status per interface
+ */
+struct bah_softc {
+	struct	device	sc_dev;
+	struct	arccom	sc_arccom;	/* Common arcnet structures */
+	struct	isr	sc_isr;
+	struct	a2060	*sc_base;
+	u_long	sc_recontime;		/* seconds only, I'm lazy */
+	u_long	sc_reconcount;		/* for the above */
+	u_long	sc_reconcount_excessive; /* for the above */
+#define ARC_EXCESSIVE_RECONS 20
+#define ARC_EXCESSIVE_RECONS_REWARN 400
+	u_char	sc_intmask;
+	u_char	sc_rx_act;		/* 2..3 */
+	u_char	sc_tx_act;		/* 0..1 */
+	u_char	sc_rx_fillcount;
+	u_char	sc_tx_fillcount;
+	u_char	sc_broadcast[2];	/* is it a broadcast packet? */
+	u_char	sc_retransmits[2];	/* unused at the moment */
+#ifdef BAHTIMINGS
+	struct	bah_stats sc_stats;
+#endif
+};
+
+int	bah_zbus_match __P((struct device *, void *, void *));
+void	bah_zbus_attach __P((struct device *, struct device *, void *));
+void	bah_init __P((struct bah_softc *));
+void	bah_reset __P((struct bah_softc *));
+void	bah_stop __P((struct bah_softc *));
+void	bah_start __P((struct ifnet *));
+int	bahintr __P((struct bah_softc *sc));
+int	bah_ioctl __P((struct ifnet *, unsigned long, caddr_t));
+void	bah_watchdog __P((int));
+void	movepout __P((u_char *from, u_char __volatile *to, int len));
+void	movepin __P((u_char __volatile *from, u_char *to, int len));
+void	bah_srint __P((void *vsc, void *dummy));
+void	callstart __P((void *vsc, void *dummy));
+
+#ifdef BAHTIMINGS
+int	clkread();
+#endif
+
+struct cfattach bah_zbus_ca = {
+	sizeof(struct bah_softc), bah_zbus_match, bah_zbus_attach
+};
+
+struct cfdriver bah_cd = {
+	NULL, "bah", DV_IFNET
+};
+
+int
+bah_zbus_match(parent, match, aux)
+	struct device *parent;
+	void *match, *aux;
+{
+	struct zbus_args *zap = aux;
+
+	if ((zap->manid == 514 || zap->manid == 1053) && zap->prodid == 9)
+		return (1);
+
+	return (0);
+}
+
+void
+bah_zbus_attach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct bah_softc *sc = (void *)self;
+	struct zbus_args *zap = aux;
+	struct ifnet *ifp = &sc->sc_arccom.ac_if;
+	int s, linkaddress;
+
+#if (defined(BAH_DEBUG) && (BAH_DEBUG > 2))
+	printf("\n%s: attach(0x%x, 0x%x, 0x%x)\n",
+	    sc->sc_dev.dv_xname, parent, self, aux);
+#endif
+	s = splhigh();
+	sc->sc_base = zap->va;
+
+	/*
+	 * read the arcnet address from the board
+	 */
+
+	sc->sc_base->kick1 = 0x0;
+	sc->sc_base->kick2 = 0x0;
+	DELAY(200);
+
+	sc->sc_base->kick1 = 0xFF;
+	sc->sc_base->kick2 = 0xFF;
+	do {
+		DELAY(200);
+	} while (!(sc->sc_base->status & ARC_POR)); 
+
+	linkaddress = sc->sc_base->dipswitches;
+
+#ifdef BAHTIMINGS
+	printf(": link addr 0x%02x(%ld), with timer\n",
+	    linkaddress, linkaddress);
+#else
+	printf(": link addr 0x%02x(%ld)\n", linkaddress, linkaddress);
+#endif
+
+	sc->sc_arccom.ac_anaddr = linkaddress;
+
+	/* clear the int mask... */
+
+	sc->sc_base->status = sc->sc_intmask = 0;
+
+	sc->sc_base->command = ARC_CONF(CONF_LONG);
+	sc->sc_base->command = ARC_CLR(CLR_POR|CLR_RECONFIG);
+	sc->sc_recontime = sc->sc_reconcount = 0;
+
+	/* and reenable kernel int level */
+	splx(s);
+
+	/*
+	 * set interface to stopped condition (reset)
+	 */
+	bah_stop(sc); 
+
+	ifp->if_unit = sc->sc_dev.dv_unit;
+	ifp->if_name = bah_cd.cd_name;
+	ifp->if_output = arc_output;
+	ifp->if_start = bah_start;
+	ifp->if_ioctl = bah_ioctl;
+	ifp->if_timer = 0;
+	ifp->if_watchdog  = bah_watchdog;
+
+	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX |
+	    IFF_NOTRAILERS | IFF_NOARP;
+
+	ifp->if_mtu = ARCMTU;
+
+	if_attach(ifp);
+	arc_ifattach(ifp);
+
+#if NBPFILTER > 0
+	bpfattach(&ifp->if_bpf, ifp, DLT_ARCNET, ARC_HDRLEN);
+#endif
+	/* under heavy load we need four of them: */
+	alloc_sicallback();
+	alloc_sicallback();
+	alloc_sicallback();
+	alloc_sicallback();
+
+	sc->sc_isr.isr_intr = bahintr;
+	sc->sc_isr.isr_arg = sc;
+	sc->sc_isr.isr_ipl = 2;
+	add_isr(&sc->sc_isr);
+}
+
+/*
+ * Initialize device
+ *
+ */
+void
+bah_init(sc)
+	struct bah_softc *sc;
+{
+	struct ifnet *ifp;
+	int s;
+
+	ifp = &sc->sc_arccom.ac_if;
+
+	if ((ifp->if_flags & IFF_RUNNING) == 0) {
+		s = splnet();
+		ifp->if_flags |= IFF_RUNNING;
+		bah_reset(sc);
+		bah_start(ifp);
+		splx(s);
+	}
+}
+
+/*
+ * Reset the interface...
+ *
+ * this assumes that it is called inside a critical section...
+ *
+ */
+void
+bah_reset(sc)
+	struct bah_softc *sc;
+{
+	struct ifnet *ifp;
+	int linkaddress;
+
+	ifp = &sc->sc_arccom.ac_if;
+
+#ifdef BAH_DEBUG
+	printf("%s: reset\n", sc->sc_dev.dv_xname);
+#endif
+	/* stop hardware in case it still runs */
+
+	sc->sc_base->kick1 = 0;
+	sc->sc_base->kick2 = 0;
+	DELAY(200);
+
+	/* and restart it */
+	sc->sc_base->kick1 = 0xFF;
+	sc->sc_base->kick2 = 0xFF;
+
+	do {
+		DELAY(200);
+	} while (!(sc->sc_base->status & ARC_POR)); 
+
+	linkaddress = sc->sc_base->dipswitches;
+
+#if defined(BAH_DEBUG) && (BAH_DEBUG > 2)
+	printf("bah%ld: reset: card reset, link addr = 0x%02x (%ld)\n",
+	    ifp->if_unit, linkaddress, linkaddress);
+#endif
+	sc->sc_arccom.ac_anaddr = linkaddress;
+
+	/* tell the routing level about the (possibly changed) link address */
+	arc_ifattach(ifp);
+
+	/* POR is NMI, but we need it below: */
+	sc->sc_intmask = ARC_RECON|ARC_POR;
+	sc->sc_base->status	= sc->sc_intmask;
+	sc->sc_base->command = ARC_CONF(CONF_LONG);
+	
+#ifdef BAH_DEBUG
+	printf("%s: reset: chip configured, status=0x%02x\n",
+	    sc->sc_dev.dv_xname, sc->sc_base->status);
+#endif
+
+	sc->sc_base->command = ARC_CLR(CLR_POR|CLR_RECONFIG);
+
+#ifdef BAH_DEBUG
+	printf("%s: reset: bits cleared, status=0x%02x\n",
+	    sc->sc_dev.dv_xname, sc->sc_base->status);
+#endif
+
+	sc->sc_reconcount_excessive = ARC_EXCESSIVE_RECONS;
+
+	/* start receiver */
+
+	sc->sc_intmask  |= ARC_RI;
+	sc->sc_rx_fillcount = 0;
+	sc->sc_rx_act = 2;
+
+	sc->sc_base->command = ARC_RXBC(2);
+	sc->sc_base->status	= sc->sc_intmask;
+
+#ifdef BAH_DEBUG
+	printf("%s: reset: started receiver, status=0x%02x\n",
+	    sc->sc_dev.dv_xname, sc->sc_base->status);
+#endif
+
+	/* and init transmitter status */
+	sc->sc_tx_act = 0;
+	sc->sc_tx_fillcount = 0;
+
+	ifp->if_flags |= IFF_RUNNING;
+	ifp->if_flags &= ~IFF_OACTIVE;
+
+#ifdef BAHTIMINGS
+	bzero((caddr_t)&(sc->sc_stats), sizeof(sc->sc_stats));
+	sc->sc_stats.mincopyin =
+	    sc->sc_stats.mincopyout =
+	    sc->sc_stats.minsend = ULONG_MAX;
+#endif
+
+	bah_start(ifp);
+}
+
+/*
+ * Take interface offline
+ */
+void
+bah_stop(sc)
+	struct bah_softc *sc;
+{
+	/* Stop the interrupts */
+	sc->sc_base->status = 0;
+
+	/* Stop the interface */
+	sc->sc_base->kick1 = 0;
+	sc->sc_base->kick2 = 0;
+
+	/* Stop watchdog timer */
+	sc->sc_arccom.ac_if.if_timer = 0;
+
+#ifdef BAHTIMINGS
+	log(LOG_DEBUG,"%s: to board: %6lu .. %6lu ns/byte\n",
+	    sc->sc_dev.dv_xname,
+	    sc->sc_stats.mincopyout, sc->sc_stats.maxcopyout);
+
+	log(LOG_DEBUG,"%s: from board: %6lu .. %6lu ns/byte\n",
+	    sc->sc_dev.dv_xname,
+	    sc->sc_stats.mincopyin, sc->sc_stats.maxcopyin);
+	
+	log(LOG_DEBUG,"%s: send time: %6lu .. %6lu mics/byte\n",
+	    sc->sc_dev.dv_xname,
+	    sc->sc_stats.minsend, sc->sc_stats.maxsend);
+
+	sc->sc_stats.minsend = 
+	    sc->sc_stats.mincopyout = 
+	    sc->sc_stats.mincopyin = ULONG_MAX;
+	sc->sc_stats.maxsend = 
+	    sc->sc_stats.maxcopyout = 
+	    sc->sc_stats.maxcopyin = 0;
+#endif
+}
+
+__inline void 
+movepout(from, to, len)
+	u_char *from;
+	__volatile u_char *to;
+	int len;
+{
+#ifdef BAHASMCOPY
+	u_short shortd;
+	u_long longd, longd1, longd2, longd3, longd4;
+
+	if ((len > 3) && ((long)from) & 3) {
+		switch (((long)from) & 3) {
+		case 3:
+			*to = *from++;
+			to += 2; --len;
+			break;
+		case 1:
+			*to = *from++;
+			to += 2; --len;
+		case 2:
+			shortd = *((u_short *)from)++;
+			asm("movepw %0,%1@(0)" : : "d"(shortd), "a"(to));
+			to += 4; len -= 2;
+			break;
+		default:
+		}
+
+		while (len >= 32) {
+			longd1 = *((u_long *)from)++;
+			longd2 = *((u_long *)from)++;
+			longd3 = *((u_long *)from)++;
+			longd4 = *((u_long *)from)++;
+			asm("movepl %0,%1@(0)"  : : "d"(longd1), "a"(to));
+			asm("movepl %0,%1@(8)"  : : "d"(longd2), "a"(to));
+			asm("movepl %0,%1@(16)" : : "d"(longd3), "a"(to));
+			asm("movepl %0,%1@(24)" : : "d"(longd4), "a"(to));
+
+			longd1 = *((u_long *)from)++;
+			longd2 = *((u_long *)from)++;
+			longd3 = *((u_long *)from)++;
+			longd4 = *((u_long *)from)++;
+			asm("movepl %0,%1@(32)" : : "d"(longd1), "a"(to));
+			asm("movepl %0,%1@(40)" : : "d"(longd2), "a"(to));
+			asm("movepl %0,%1@(48)" : : "d"(longd3), "a"(to));
+			asm("movepl %0,%1@(56)" : : "d"(longd4), "a"(to));
+
+			to += 64; len -= 32;
+		}
+		while (len > 0) {
+			longd = *((u_long *)from)++;
+			asm("movepl %0,%1@(0)" : : "d"(longd), "a"(to));
+			to += 8; len -= 4;
+		}
+	}
+#endif
+	while (len > 0) {
+		*to = *from++;
+		to += 2;
+		--len;
+	}
+}
+
+/*
+ * Start output on interface. Get another datagram to send
+ * off the interface queue, and copy it to the
+ * interface becore starting the output
+ *
+ * this assumes that it is called inside a critical section...
+ * XXX hm... does it still?
+ *
+ */
+void
+bah_start(ifp)
+	struct ifnet *ifp;
+{
+	struct bah_softc *sc;
+	struct mbuf *m,*mp;
+	__volatile u_char *bah_ram_ptr;
+	int len, tlen, offset, s, buffer;
+#ifdef BAHTIMINGS
+	u_long copystart, lencopy, perbyte;
+#endif
+
+	sc = bah_cd.cd_devs[ifp->if_unit];
+
+#if defined(BAH_DEBUG) && (BAH_DEBUG > 3)
+	printf("%s: start(0x%x)\n", sc->sc_dev.dv_xname, ifp);
+#endif
+
+	if ((ifp->if_flags & IFF_RUNNING) == 0)
+		return;
+
+	s = splnet();
+
+	if (sc->sc_tx_fillcount >= 2) {
+		splx(s);
+		return;
+	}
+
+	IF_DEQUEUE(&ifp->if_snd, m);
+	buffer = sc->sc_tx_act ^ 1;
+
+	splx(s);
+
+	if (m == 0)
+		return;
+
+#if NBPFILTER > 0
+	/*
+	 * If bpf is listening on this interface, let it
+	 * see the packet before we commit it to the wire
+	 *
+	 * (can't give the copy in A2060 card RAM to bpf, because
+	 * that RAM is just accessed as on every other byte)
+	 */
+	if (ifp->if_bpf)
+		bpf_mtap(ifp->if_bpf, m);
+#endif
+
+#ifdef BAH_DEBUG
+	m = m_pullup(m,3);	/* gcc does structure padding */
+	printf("%s: start: filling %ld from %ld to %ld type %ld\n",
+	    sc->sc_dev.dv_xname, buffer, mtod(m, u_char *)[0],
+	    mtod(m, u_char *)[1], mtod(m, u_char *)[2]);
+#else
+	m = m_pullup(m, 2);
+#endif
+	bah_ram_ptr = sc->sc_base->buffers + buffer*512*2;
+
+	/* write the addresses to RAM and throw them away */
+
+	/*
+	 * Hardware does this: Yet Another Microsecond Saved.
+	 * (btw, timing code says usually 2 microseconds)
+	 * bah_ram_ptr[0*2] = mtod(m, u_char *)[0];
+	 */
+	bah_ram_ptr[1 * 2] = mtod(m, u_char *)[1];
+	m_adj(m, 2);
+		
+	/* get total length left at this point */
+	tlen = m->m_pkthdr.len;
+	if (tlen < ARC_MIN_FORBID_LEN) {
+		offset = 256 - tlen;
+		bah_ram_ptr[2 * 2] = offset;
+	} else {
+		bah_ram_ptr[2 * 2] = 0;
+		if (tlen <= ARC_MAX_FORBID_LEN)
+			offset = 255;		/* !!! */
+		else {
+			if (tlen > ARC_MAX_LEN)
+				tlen = ARC_MAX_LEN;
+			offset = 512 - tlen;
+		}
+		bah_ram_ptr[3 * 2] = offset;
+
+	}
+	bah_ram_ptr += offset * 2;
+
+	/* lets loop through the mbuf chain */
+
+	for (mp = m; mp; mp = mp->m_next) {
+		if ((len = mp->m_len)) {		/* YAMS */
+#ifdef BAHTIMINGS
+			lencopy = len;
+			copystart = clkread();
+#endif
+			movepout(mtod(mp, caddr_t), bah_ram_ptr, len);
+
+#ifdef BAHTIMINGS
+			perbyte = 1000 * (clkread() - copystart) / lencopy;
+			sc->sc_stats.mincopyout = 
+			    ulmin(sc->sc_stats.mincopyout, perbyte);
+			sc->sc_stats.maxcopyout =
+			    ulmax(sc->sc_stats.maxcopyout, perbyte);
+#endif
+			bah_ram_ptr += len*2;
+		}
+	}
+
+	sc->sc_broadcast[buffer] = (m->m_flags & M_BCAST) != 0;
+	sc->sc_retransmits[buffer] = (m->m_flags & M_BCAST) ? 1 : 5;
+
+	/* actually transmit the packet */
+	s = splnet();
+
+	if (++sc->sc_tx_fillcount > 1) { 
+		/*
+		 * We are filled up to the rim. No more bufs for the moment,
+		 * please.
+		 */
+		ifp->if_flags |= IFF_OACTIVE;
+	} else {
+#ifdef BAH_DEBUG
+		printf("%s: start: starting transmitter on buffer %d\n", 
+		    sc->sc_dev.dv_xname, buffer);
+#endif
+		/* Transmitter was off, start it */
+		sc->sc_tx_act = buffer;
+
+		/*
+		 * We still can accept another buf, so don't:
+		 * ifp->if_flags |= IFF_OACTIVE;
+		 */
+		sc->sc_intmask |= ARC_TA;
+		sc->sc_base->command = ARC_TX(buffer);
+		sc->sc_base->status  = sc->sc_intmask;
+
+		sc->sc_arccom.ac_if.if_timer = ARCTIMEOUT;
+#ifdef BAHTIMINGS
+		bcopy((caddr_t)&time,
+		    (caddr_t)&(sc->sc_stats.lasttxstart_tv),
+		    sizeof(struct timeval));
+
+		sc->sc_stats.lasttxstart_mics = clkread();
+#endif
+	}
+	splx(s);
+	m_freem(m);
+
+	/*
+	 * After 10 times reading the docs, I realized
+	 * that in the case the receiver NAKs the buffer request,
+	 * the hardware retries till shutdown.
+	 * This is integrated now in the code above.
+	 */
+
+	return;
+}
+
+void 
+callstart(vsc, dummy)
+	void *vsc, *dummy;
+{
+	struct bah_softc *sc;
+
+	sc = (struct bah_softc *)vsc;
+	bah_start(&sc->sc_arccom.ac_if);
+}
+
+__inline void
+movepin(from, to, len)
+	__volatile u_char *from;
+	u_char *to;
+	int len;
+{
+#ifdef BAHASMCOPY
+	unsigned long	longd, longd1, longd2, longd3, longd4;
+	ushort		shortd;
+
+	if ((len > 3) && (((long)to) & 3)) {
+		switch (((long)to) & 3) {
+		case 3: *to++ = *from;
+			from += 2; --len;
+			break;
+		case 1: *to++ = *from;
+			from += 2; --len;
+		case 2:	asm ("movepw %1@(0),%0": "=d" (shortd) : "a" (from));
+			*((ushort *)to)++ = shortd;
+			from += 4; len -= 2;
+			break;
+		default:
+		}
+
+		while (len >= 32) {
+			asm("movepl %1@(0),%0"  : "=d"(longd1) : "a" (from));
+			asm("movepl %1@(8),%0"  : "=d"(longd2) : "a" (from));
+			asm("movepl %1@(16),%0" : "=d"(longd3) : "a" (from));
+			asm("movepl %1@(24),%0" : "=d"(longd4) : "a" (from));
+			*((unsigned long *)to)++ = longd1;
+			*((unsigned long *)to)++ = longd2;
+			*((unsigned long *)to)++ = longd3;
+			*((unsigned long *)to)++ = longd4;
+
+			asm("movepl %1@(32),%0" : "=d"(longd1) : "a" (from));
+			asm("movepl %1@(40),%0" : "=d"(longd2) : "a" (from));
+			asm("movepl %1@(48),%0" : "=d"(longd3) : "a" (from));
+			asm("movepl %1@(56),%0" : "=d"(longd4) : "a" (from));
+			*((unsigned long *)to)++ = longd1;
+			*((unsigned long *)to)++ = longd2;
+			*((unsigned long *)to)++ = longd3;
+			*((unsigned long *)to)++ = longd4;
+
+			from += 64; len -= 32;
+		}
+		while (len > 0) {
+			asm("movepl %1@(0),%0" : "=d"(longd) : "a" (from));
+			*((unsigned long *)to)++ = longd;
+			from += 8; len -= 4;
+		}
+
+	}
+#endif /* BAHASMCOPY */
+	while (len > 0) {
+		*to++ = *from;
+		from += 2;
+		--len;
+	}
+
+}
+
+/*
+ * Arcnet interface receiver soft interrupt:
+ * get the stuff out of any filled buffer we find.
+ */
+void
+bah_srint(vsc, dummy)
+	void *vsc, *dummy;
+{
+	struct bah_softc *sc;
+	int buffer, len, len1, amount, offset, s, i, type;
+	u_char __volatile *bah_ram_ptr;
+	struct mbuf *m, *dst, *head;
+	struct arc_header *ah;
+	struct ifnet *ifp;
+#ifdef BAHTIMINGS
+	u_long copystart, lencopy, perbyte;
+#endif
+	sc = (struct bah_softc *)vsc;
+	ifp = &sc->sc_arccom.ac_if;
+	head = 0;
+
+	s = splnet();
+	buffer = sc->sc_rx_act ^ 1;
+	splx(s);
+
+	/* Allocate header mbuf */
+	MGETHDR(m, M_DONTWAIT, MT_DATA);
+
+	if (m == 0) {
+		/* 
+	 	 * in case s.th. goes wrong with mem, drop it
+	 	 * to make sure the receiver can be started again
+		 * count it as input error (we dont have any other
+		 * detectable)
+	 	 */
+		ifp->if_ierrors++;
+		goto cleanup;
+	}
+			
+	m->m_pkthdr.rcvif = ifp;
+
+	/*
+	 * Align so that IP packet will be longword aligned. Here we
+	 * assume that m_data of new packet is longword aligned.
+	 * When implementing PHDS, we might have to change it to 2,
+	 * (2*sizeof(ulong) - ARC_HDRNEWLEN)), packet type dependent.
+	 */
+
+	bah_ram_ptr = sc->sc_base->buffers + buffer*512*2;
+	offset = bah_ram_ptr[2*2];
+	if (offset)
+		len = 256 - offset;
+	else {
+		offset = bah_ram_ptr[3*2];
+		len = 512 - offset;
+	}
+	type = bah_ram_ptr[offset*2];
+	m->m_data += 1 + arc_isphds(type);
+
+	head = m;
+	ah = mtod(head, struct arc_header *);
+		
+	ah->arc_shost = bah_ram_ptr[0*2];
+	ah->arc_dhost = bah_ram_ptr[1*2];
+
+	m->m_pkthdr.len = len+2; /* whole packet length */
+	m->m_len = 2;		 /* mbuf filled with ARCnet addresses */
+	bah_ram_ptr += offset*2; /* ram buffer continues there */
+
+	while (len > 0) {
+	
+		len1 = len;
+		amount = M_TRAILINGSPACE(m);
+
+		if (amount == 0) {
+			dst = m;
+			MGET(m, M_DONTWAIT, MT_DATA);
+		
+			if (m == 0) {
+				ifp->if_ierrors++;
+				goto cleanup;
+			}
+		
+			if (len1 >= MINCLSIZE)
+				MCLGET(m, M_DONTWAIT);
+	
+			m->m_len = 0;
+			dst->m_next = m;
+			amount = M_TRAILINGSPACE(m);
+		}
+
+		if (amount < len1)
+			len1 = amount;
+
+#ifdef BAHTIMINGS
+		lencopy = len;
+		copystart = clkread();
+#endif
+
+		movepin(bah_ram_ptr, mtod(m, u_char *) + m->m_len, len1);
+
+#ifdef BAHTIMINGS
+		perbyte = 1000 * (clkread() - copystart) / lencopy;
+		sc->sc_stats.mincopyin =
+		    ulmin(sc->sc_stats.mincopyin, perbyte);
+		sc->sc_stats.maxcopyin =
+		    ulmax(sc->sc_stats.maxcopyin, perbyte);
+#endif
+
+		m->m_len += len1;
+		bah_ram_ptr += len1*2;
+		len -= len1;
+	}
+
+#if NBPFILTER > 0
+	if (ifp->if_bpf)
+		bpf_mtap(ifp->if_bpf, head);
+#endif
+
+	arc_input(&sc->sc_arccom.ac_if, head);
+
+	/* arc_input has freed it, we dont need to... */
+
+	head = NULL;
+	ifp->if_ipackets++;
+	
+cleanup:
+
+	if (head != NULL)
+		m_freem(head);
+
+	/* mark buffer as invalid by source id 0 */
+	sc->sc_base->buffers[buffer*512*2] = 0;
+	s = splnet();
+
+	if (--sc->sc_rx_fillcount == 2 - 1) {
+
+		/* was off, restart it on buffer just emptied */
+		sc->sc_rx_act = buffer;
+		sc->sc_intmask |= ARC_RI;
+
+		/* this also clears the RI flag interupt: */
+		sc->sc_base->command = ARC_RXBC(buffer);
+		sc->sc_base->status = sc->sc_intmask;
+
+#ifdef BAH_DEBUG
+		printf("%s: srint: restarted rx on buf %ld\n",
+		    sc->sc_dev.dv_xname, buffer);
+#endif
+	}
+	splx(s);
+}
+
+__inline static void
+bah_tint(sc, isr)
+	struct bah_softc *sc;
+	int isr;
+{
+	struct ifnet *ifp;
+
+	int buffer;
+#ifdef BAHTIMINGS
+	int clknow;
+#endif
+
+	ifp = &(sc->sc_arccom.ac_if);
+	buffer = sc->sc_tx_act;
+
+	/*
+	 * retransmit code:  
+	 * Normal situtations first for fast path:
+	 * If acknowledgement received ok or broadcast, we're ok.
+	 * else if 
+	 */ 
+
+	if (isr & ARC_TMA || sc->sc_broadcast[buffer])
+		sc->sc_arccom.ac_if.if_opackets++;
+#ifdef BAHRETRANSMIT
+	else if (ifp->if_flags & IFF_LINK2 && ifp->if_timer > 0 
+	    && --sc->sc_retransmits[buffer] > 0) {
+		/* retransmit same buffer */
+		sc->sc_base->command = ARC_TX(buffer);
+		return;
+	}
+#endif
+	else
+		ifp->if_oerrors++;
+		
+		
+#ifdef BAHTIMINGS
+	clknow = clkread();
+
+	sc->sc_stats.minsend = ulmin(sc->sc_stats.minsend,
+	    clknow - sc->sc_stats.lasttxstart_mics);
+
+	sc->sc_stats.maxsend = ulmax(sc->sc_stats.maxsend,
+	    clknow - sc->sc_stats.lasttxstart_mics);
+#endif
+
+	/* We know we can accept another buffer at this point. */
+	ifp->if_flags &= ~IFF_OACTIVE;
+
+	if (--sc->sc_tx_fillcount > 0) {
+
+		/* 
+		 * start tx on other buffer.
+		 * This also clears the int flag
+		 */
+		buffer ^= 1;
+		sc->sc_tx_act = buffer;
+
+		/*
+		 * already given:
+		 * sc->sc_intmask |= ARC_TA; 
+		 * sc->sc_base->status = sc->sc_intmask;
+		 */
+		sc->sc_base->command = ARC_TX(buffer);
+		/* init watchdog timer */
+		ifp->if_timer = ARCTIMEOUT;
+
+#ifdef BAHTIMINGS
+		bcopy((caddr_t)&time,
+		    (caddr_t)&(sc->sc_stats.lasttxstart_tv),
+		    sizeof(struct timeval));
+
+		sc->sc_stats.lasttxstart_mics = clkread();
+#endif
+ 
+#if defined(BAH_DEBUG) && (BAH_DEBUG > 1)
+		printf("%s: tint: starting tx on buffer %d, status 0x%02x\n", 
+		    sc->sc_dev.dv_xname, buffer, sc->sc_base->status);
+#endif
+	} else {
+		/* have to disable TX interrupt */
+		sc->sc_intmask &= ~ARC_TA;
+		sc->sc_base->status = sc->sc_intmask;
+		/* ... and watchdog timer */
+		ifp->if_timer = 0;
+
+#ifdef BAH_DEBUG
+		printf("%s: tint: no more buffers to send, status 0x%02x\n",
+		    sc->sc_dev.dv_xname, sc->sc_base->status);
+#endif
+	}
+
+#ifdef BAHSOFTCOPY
+	/* schedule soft int to fill a new buffer for us */
+	add_sicallback((sifunc_t)callstart, sc, NULL);
+#else
+	/* call it directly */
+	callstart(sc, NULL);
+#endif
+}
+
+/*
+ * Our interrupt routine
+ */
+int
+bahintr(sc)
+	struct bah_softc *sc;
+{
+	u_char isr, maskedisr;
+	int buffer;
+	u_long newsec;
+
+	isr = sc->sc_base->status;
+	maskedisr = isr & sc->sc_intmask;
+	if (!maskedisr) 
+		return (0);
+
+#if defined(BAH_DEBUG) && (BAH_DEBUG>1)
+	printf("%s: intr: status 0x%02x, intmask 0x%02x\n",
+	    sc->sc_dev.dv_xname, isr, sc->sc_intmask);
+#endif
+
+	if (maskedisr & ARC_POR) {
+		sc->sc_arccom.ac_anaddr = sc->sc_base->dipswitches;
+		sc->sc_base->command = ARC_CLR(CLR_POR);
+		log(LOG_WARNING, "%s: intr: got spurious power on reset int\n",
+		    sc->sc_dev.dv_xname);
+	}
+
+	if (maskedisr & ARC_RECON) {
+		/*
+		 * we dont need to:
+		 * sc->sc_base->command = ARC_CONF(CONF_LONG);
+		 */
+		sc->sc_base->command = ARC_CLR(CLR_RECONFIG);
+		sc->sc_arccom.ac_if.if_collisions++;
+
+		/*
+		 * If more than 2 seconds per reconfig:
+		 *	Reset time and counter.
+		 * else:
+		 *	If more than ARC_EXCESSIVE_RECONFIGS reconfigs
+		 *	since last burst, complain and set treshold for
+		 *	warnings to ARC_EXCESSIVE_RECONS_REWARN.
+		 *
+		 * This allows for, e.g., new stations on the cable, or
+		 * cable switching as long as it is over after (normally)
+		 * 16 seconds.
+		 *
+		 * XXX TODO: check timeout bits in status word and double
+		 * time if necessary.
+		 */
+
+		newsec = time.tv_sec;
+		if (newsec - sc->sc_recontime > 2 * sc->sc_reconcount) {
+			sc->sc_recontime = newsec;
+			sc->sc_reconcount = 0;
+			sc->sc_reconcount_excessive = ARC_EXCESSIVE_RECONS;
+		} else if (++sc->sc_reconcount > sc->sc_reconcount_excessive) {
+			sc->sc_reconcount_excessive = 
+			    ARC_EXCESSIVE_RECONS_REWARN;
+			log(LOG_WARNING,
+			    "%s: excessive token losses, cable problem?\n",
+			    sc->sc_dev.dv_xname);
+			sc->sc_recontime = newsec;
+			sc->sc_reconcount = 0;
+		}
+	}
+
+	if (maskedisr & ARC_RI) {
+
+#if defined(BAH_DEBUG) && (BAH_DEBUG > 1)
+		printf("%s: intr: hard rint, act %ld\n",
+		    sc->sc_dev.dv_xname, sc->sc_rx_act);
+#endif
+	
+		buffer = sc->sc_rx_act;
+		/* look if buffer is marked invalid: */
+		if (sc->sc_base->buffers[buffer*512*2] == 0) {
+	/* invalid marked buffer (or illegally configured sender) */
+			log(LOG_WARNING, 
+			    "%s: spurious RX interrupt or sender 0 (ignored)\n",
+			    sc->sc_dev.dv_xname);
+			/*
+			 * restart receiver on same buffer.
+			 */
+			sc->sc_base->command = ARC_RXBC(buffer);
+
+		} else if (++sc->sc_rx_fillcount > 1) {
+			sc->sc_intmask &= ~ARC_RI;
+			sc->sc_base->status = sc->sc_intmask;
+		} else {
+
+			buffer ^= 1;
+			sc->sc_rx_act = buffer;
+
+			/*
+			 * Start receiver on other receive buffer.
+			 * This also clears the RI interupt flag.
+			 */
+			sc->sc_base->command = ARC_RXBC(buffer);
+			/* we are in the RX intr, so mask is ok for RX */
+
+#ifdef BAH_DEBUG
+			printf("%s: started rx for buffer %ld, status 0x%02x\n",
+			    sc->sc_dev.dv_xname, sc->sc_rx_act,
+			    sc->sc_base->status);
+#endif
+		}
+
+#ifdef BAHSOFTCOPY
+		/* this one starts a soft int to copy out of the hw */
+		add_sicallback((sifunc_t)bah_srint, sc,NULL);
+#else
+		/* this one does the copy here */
+		bah_srint(sc,NULL);
+#endif
+	}
+
+	if (maskedisr & ARC_TA) 
+		bah_tint(sc, isr);
+
+	return (1);
+}
+
+/*
+ * Process an ioctl request. 
+ * This code needs some work - it looks pretty ugly.
+ */
+int
+bah_ioctl(ifp, command, data)
+	register struct ifnet *ifp;
+	u_long command;
+	caddr_t data;
+{
+	struct bah_softc *sc;
+	register struct ifaddr *ifa;
+	int s, error;
+
+	error = 0;
+	sc = bah_cd.cd_devs[ifp->if_unit];
+	ifa = (struct ifaddr *)data;
+	s = splnet();
+
+#if defined(BAH_DEBUG) && (BAH_DEBUG > 2) 
+	printf("%s: ioctl() called, cmd = 0x%x\n",
+	    sc->sc_dev.dv_xname, command);
+#endif
+
+	switch (command) {
+	case SIOCSIFADDR:
+		ifp->if_flags |= IFF_UP;
+		switch (ifa->ifa_addr->sa_family) {
+#ifdef INET
+		case AF_INET:
+			bah_init(sc);
+			break;
+#endif
+		default:
+			bah_init(sc);
+			break;
+		}
+
+	case SIOCSIFFLAGS:
+		if ((ifp->if_flags & IFF_UP) == 0 &&
+		    (ifp->if_flags & IFF_RUNNING) != 0) {
+			/*
+			 * If interface is marked down and it is running, 
+			 * then stop it.
+			 */
+			bah_stop(sc);
+			ifp->if_flags &= ~IFF_RUNNING;
+		} else if ((ifp->if_flags & IFF_UP) != 0 &&
+			   (ifp->if_flags & IFF_RUNNING) == 0) {
+			/*
+			 * If interface is marked up and it is stopped, then
+			 * start it.
+			 */
+			bah_init(sc);
+		} 
+		break;
+
+		/* Multicast not supported */
+
+	default:
+		error = EINVAL;
+	}
+
+	splx(s);
+	return (error);
+}
+
+/*
+ * watchdog routine for transmitter.
+ *
+ * We need this, because else a receiver whose hardware is alive, but whose
+ * software has not enabled the Receiver, would make our hardware wait forever
+ * Discovered this after 20 times reading the docs.
+ *
+ * Only thing we do is disable transmitter. We'll get an transmit timeout,
+ * and the int handler will have to decide not to retransmit (in case
+ * retransmission is implemented).
+ *
+ * This one assumes being called inside splnet(), and that net >= ipl2
+ */
+
+void
+bah_watchdog(unit)
+int unit;
+{
+	struct bah_softc *sc;
+	struct ifnet *ifp;
+
+	sc = bah_cd.cd_devs[unit];
+	ifp = &(sc->sc_arccom.ac_if);
+
+	sc->sc_base->command = ARC_TXDIS;
+	return;
+}