 @@ -1,752 +1,752 @@
-/* $NetBSD: if_xb.c,v 1.22 2009/03/14 21:04:01 dsl Exp $ */
+/* $NetBSD: if_xb.c,v 1.23 2009/03/17 18:19:15 dsl Exp $ */
 /* [Notice revision 2.2]
  * Copyright (c) 1997, 1998 Avalon Computer Systems, Inc.
  * All rights reserved.
+ *
  * Author: Ross Harvey
+ *
  * 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 and
  *    author 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. Neither the name of Avalon Computer Systems, Inc. nor the names of
  *    its contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
  * 4. This copyright will be assigned to The NetBSD Foundation on
  *    1/1/2000 unless these terms (including possibly the assignment
  *    date) are updated in writing by Avalon prior to the latest specified
  *    assignment date.
+ *
  * THIS SOFTWARE IS PROVIDED BY AVALON COMPUTER SYSTEMS, INC. AND CONTRIBUTORS
  * ``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 AVALON OR THE CONTRIBUTORS
  * 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.
  */
 /*
  * Notes.
+ *
  * Since the NetBSD build rules force the use of function prototypes, even on
  * functions that are defined before they are called, I've taken advantage of
  * the opportunity and organized this module in top down fashion, with
  * functions generally calling down the page rather than up. It's different.
  * I think I'm getting to like it this way.
+ *
  * The crossbar interface is not exactly a peripheral device, and it cannot
  * appear on anything other than an alpha-based Avalon A12.  The crossbar
  * controller is built into the core logic.
+ *
  * If this version of the driver supports MPS transport, it may have some
  * large static data declarations. Don't worry about it, as Avalon a12
  * support should not appear in a GENERIC or INSTALL kernel.
+ *
  * (Every A12 ever shipped had 512 MB per CPU except one site, which had 256
  * MB.  Partly has a result of this, it is unlikely that a kernel configured
  * for an A12 would be exactly the thing to use on most workstations, so we
  * don't really need to worry that we might be configured in a generic or
  * site-wide kernel image.)
+ *
  * This preliminary crossbar driver supports IP transport using PIO.  Although
  * it would be nice to have a DMA driver, do note that the crossbar register
  * port is 128 bits wide, so we have 128-bit PIO.  (The 21164 write buffer
  * will combine two 64-bit stores before they get off-chip.) Also, the rtmon
  * driver wasn't DMA either, so at least the NetBSD driver is as good as any
  * other that exists now.
+ *
  * We'll do DMA and specialized transport ops later. Given the high speed of
  * the PIO mode, no current applications require DMA bandwidth, but everyone
  * benefits from low latency. The PIO mode is actually lower in latency
  * anyway.
  */
 #include "opt_avalon_a12.h"		/* Config options headers */
 #include <sys/cdefs.h>			/* RCS ID & Copyright macro defns */
-__KERNEL_RCSID(0, "$NetBSD: if_xb.c,v 1.22 2009/03/14 21:04:01 dsl Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_xb.c,v 1.23 2009/03/17 18:19:15 dsl Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/device.h>
 #include <sys/socket.h>
 #include <sys/mbuf.h>
 #include <sys/sockio.h>
 #include <uvm/uvm_extern.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
 #include <net/route.h>
 #include <netinet/in.h>
 #include <netinet/in_var.h>
 #include <machine/autoconf.h>
 #include <machine/rpb.h>
 #include <dev/isa/isareg.h>
 #include <dev/isa/isavar.h>
 #include <dev/pci/pcireg.h>
 #include <dev/pci/pcivar.h>
 #include <alpha/pci/a12creg.h>
 #include <alpha/pci/a12cvar.h>
 #include <alpha/pci/pci_a12.h>
 #if 1
 #define	XB_DEBUG xb_debug
 #else
 #define	XB_DEBUG 0
 #endif
 #undef	Static
 #if 1
 #define	Static
 #else
 #define	Static static
 #endif
 #define	IF_XB()	/* Generate ctags(1) key */
 #define	XBAR_MTU	   (9*1024)	/* Quite an arbitrary number */
 #define	XBAR_MAXFRAMEHDR   48		/* Used to compute if_mtu */
 #define	XB_DEFAULT_MTU() (XBAR_MTU - XBAR_MAXFRAMEHDR)
 #define	FIFO_WORDCOUNT 60
 static int  xb_put_blk(struct mbuf *);
 static int  xb_put(struct mbuf *);
 static long xb_fifo_empty(void);
 int	xbmatch(struct device *, struct cfdata *, void *);
 void	xbattach(struct device *, struct device *, void *);
 struct xb_softc {
 	struct	device d;
 } xb_softc;
 CFATTACH_DECL(xb, sizeof(struct xb_softc),
     xbmatch, xbattach, NULL, NULL);
 extern struct cfdriver xb_cd;
 long	*xb_incoming;
 int	xb_incoming_max = XBAR_MTU;
 typedef struct ccode_struct {
 	int64_t	lo64,		/* magic channel address s-word, high part*/
 		hi64;		/* magic channel address s-word, low part */
 } ccode_type;
 /*
  * Switch channel codes.  Prepending one of these words will get you through
  * the switch, which will eat the word, open the addressed channel, and
  * forward the rest of the switch frame.  Obviously, this helps if the second
  * switch word in the frame is the address word for a cascaded switch. (This
  * can be repeated for an arbitrary depth of MSN.) The words aren't quite as
  * weird as they look: the switch is really lots of narrow switches in an
  * array, and they don't switch an even number of hex digits.  Also, there is
  * a parity bit on most of the subunits.
  */
 ccode_type channel[]={
 	    { 0x0000000000000000, 0x0000000000000000  },
 	    { 0x8882108421084210, 0x1104210842108421  },
 	    { 0x4441084210842108, 0x2208421084210842  },
 	    { 0xccc318c6318c6318, 0x330c6318c6318c63  },
 	    { 0x2220842108421084, 0x4410842108421084  },
 	    { 0xaaa294a5294a5294, 0x5514a5294a5294a5  },
 	    { 0x66618c6318c6318c, 0x6618c6318c6318c6  },
 	    { 0xeee39ce739ce739c, 0x771ce739ce739ce7  },
 	    { 0x1110421084210842, 0x8821084210842108  },
 	    { 0x99925294a5294a52, 0x9925294a5294a529  },
 	    { 0x55514a5294a5294a, 0xaa294a5294a5294a  },
 	    { 0xddd35ad6b5ad6b5a, 0xbb2d6b5ad6b5ad6b  },
 	    { 0x3330c6318c6318c6, 0xcc318c6318c6318c  },
 	    { 0xbbb2d6b5ad6b5ad6, 0xdd35ad6b5ad6b5ad  }
 };
 Static enum xb_intr_rcv_state_t {
 	XBIR_PKTHDR = 0, XBIR_TRANS
 } xb_intr_rcv_state;
 struct xb_config { int am_i_used; } xb_configuration;
 Static struct ifnet xbi;
 Static int frame_len;
 static int xb_debug;
 Static void xb_start(struct ifnet *);
 Static void xb_mcrp_write(long *, int, int);
 static inline void xb_onefree(void);
 static long set_interrupt_on_fifo_empty(void);
 static void xb_init(struct ifnet *);
 static int  xb_intr(void *);
 static void xb_intr_rcv(void);
 Static void quickload(volatile long *, long *);
 static void xb_init_config(struct xb_config *, int);
 static int  xb_output(struct ifnet *, struct mbuf *,
 			const struct sockaddr *, struct rtentry *);
 static int  xb_ioctl(struct ifnet *, u_long, void *);
 static void xb_stop(void);
 static void a12_xbar_setup(void);
 /* There Can Be Only One */
 int xbfound;
 int
 xbmatch(struct device *parent, struct cfdata *match, void *aux)
+{
 	return	cputype == ST_AVALON_A12
 		&& !xbfound;
+}
 void
 xbattach(struct device *parent, struct device *self, void *aux)
+{
 	struct xb_config *ccp;
 	strcpy(xbi.if_xname, self->dv_xname);
 	xbfound = 1;
 	ccp = &xb_configuration;
 	xb_init_config(ccp, 1);
-	printf(": driver %s mtu %lu\n", "$Revision: 1.22 $", xbi.if_mtu);
+	printf(": driver %s mtu %lu\n", "$Revision: 1.23 $", xbi.if_mtu);
+}
 static void
 xb_init_config(struct xb_config *ccp, int mallocsafe)
+{
 	/*
 	 * The driver actually only needs about 64 bytes of buffer but with a
 	 * nice contiguous frame we can call m_devget()
 	 */
 	if (mallocsafe && xb_incoming == NULL) {
 		xb_incoming = malloc(xb_incoming_max, M_DEVBUF, M_NOWAIT);
 		if (xb_incoming == NULL)
 			DIE();
+	}
 	a12_xbar_setup();
 	a12_intr_register_xb(xb_intr);
+}
 /*
  * From The A12 Theory of Operation. Used with permission.
  *      --- --- ------ -- ---------
+ *
  *	 Message Channel Status Register
+ *
  *     31                                 0
  *      |                                 |
  *      10987654 32109876 54321098 76543210
+ *
  *      ........ ........ 0oiefaAr TR...... MCSR
+ *
  *     Field   Type    Name    Function
+ *
  *      R      R,W1C   RBC     Receive Block Complete
  *      T      R,W1C   TBC     Transmit Block Complete
  *      r      R       IMP     Incoming message pending
  *      A      R       IMFAE   Incoming message fifo almost empty
  *      a      R       OMFAF   Outgoing message fifo almost full
  *      f      R       OMFF    Outgoing message fifo full
  *      e      R       OMFE    Outgoing message fifo empty
  *      i      R       DMAin   Incoming DMA channel armed
  *      o      R       DMAout  Outgoing DMA channel armed
+ *
  *	     Interrupts Generated from MCSR
+ *
  *     IMChInt <= (RBC or IMP) and not DMAin
  *     OMChInt <= ((TBC and not OMFAF) or (OMFE and OMR.E(6))
  *		) and not DMAout
+ *
  */
 static int
 xb_intr(void *p)
+{
 	int	n;
 	long	mcsrval;
 	/*
 	 * The actual conditions under which this interrupt is generated are
 	 * a bit complicated, and no status flag is available that reads out
 	 * the final values of the interrupt inputs. But, it doesn't really
 	 * matter. Simply check for receive data and transmitter IFF_OACTIVE.
 	 */
 	while ((mcsrval = REGVAL(A12_MCSR)) & A12_MCSR_IMP)
 		for(n = mcsrval & A12_MCSR_IMFAE ? 1 : 5; n; --n)
 			xb_intr_rcv();
 	if (xbi.if_flags & IFF_OACTIVE
 	&&  mcsrval & A12_MCSR_OMFE) {
 		xbi.if_flags &= ~IFF_OACTIVE;
 		REGVAL(A12_OMR) &= ~A12_OMR_OMF_ENABLE;
 		alpha_wmb();
 		xb_start(&xbi);
+	}
 	return 0;
+}
 /*
  * The interface logic will shoot us down with MCE (Missing Close Error) or
  * ECE (Embedded Close Error) if we aren't in sync with the hardware w.r.t.
  * frame boundaries. As those are panic-level errors: Don't Get Them.
  */
 static void
 xb_intr_rcv()
+{
 struct	mbuf *m;
 long	frameword[2];
 static	long *xb_ibp;
 int	s = 0;	/* XXX gcc */
 	switch (xb_intr_rcv_state) {
 	    case XBIR_PKTHDR:
 		xb_ibp = xb_incoming;
 		quickload(REGADDR(A12_FIFO), frameword); /* frame_len >= 16 */
 		frame_len = frameword[0];
 		if (!(20 <= frame_len && frame_len+16 <= xb_incoming_max))
 			DIE();
 		/*
 		 * The extra word when frames are of an aligned size is due
 		 * to the way the output routines work. After the mbuf is
 		 * sent xb_put_blk(NULL) is called. If there is a leftover
 		 * 127-bit-or-less fragment then the close word rides on it,
 		 * otherwise it gets an entire 128 bits of zeroes.
 		 */
 		if (frame_len & 0xf)
 			frame_len = (frame_len + 0xf) >> 4;
 		else	frame_len = (frame_len >> 4) + 1;
 	      --frame_len; /* we read the frame len + the first packet int64 */
 		*xb_ibp++ = frameword[1];
 		xb_intr_rcv_state = XBIR_TRANS;
 		break;
 	    case XBIR_TRANS:
 		if (frame_len > 1)
 			quickload(REGADDR(A12_FIFO), frameword);
 		else if (frame_len == 1) {
 			quickload(REGADDR(A12_FIFO_LWE), frameword);
 			xb_intr_rcv_state = XBIR_PKTHDR;
 		} else if (XB_DEBUG)
 			DIE();
 	      --frame_len;
 		xb_ibp[0] = frameword[0];
 		xb_ibp[1] = frameword[1];
 		xb_ibp   += 2;
 		if (xb_intr_rcv_state == XBIR_PKTHDR) {
 			if (XB_DEBUG) {
 				s = splnet();
 				if (s != splnet())
 					DIE();
+			}
 		      ++xbi.if_ipackets;
 			if (IF_QFULL(&ipintrq)) {
 				IF_DROP(&ipintrq);
 			      ++xbi.if_iqdrops;
 			} else {
 				m = m_devget((void *)xb_incoming,
 					(char *)xb_ibp - (char *)xb_incoming,
 , &xbi, 0L);
 				if (m) {
 					xbi.if_ibytes += m->m_pkthdr.len;
 					IF_ENQUEUE(&ipintrq, m);
 				} else
 				      ++xbi.if_ierrors;
+			}
 			if (XB_DEBUG)
 				splx(s);
+		}
 		break;
 	    default:
 		DIE();
+	}
+}
 /*
  * Make it easy for gcc to load a[0..1] without interlocking between
  * a[0] and a[1]. (If it did, that would be two external bus cycles.)
  */
 Static void
 quickload(volatile long *a, long *b)
+{
 long	t1,t2;
 	t1 = a[0];
 	t2 = a[1];
 	b[0] = t1;
 	b[1] = t2;
+}
 /*
  * Verify during debugging that we have not overflowed the FIFO
  */
 static inline void
 xb_onefree()
+{
 	if (XB_DEBUG && REGVAL(A12_MCSR) & A12_MCSR_OMFF)
 		DIE();
+}
 static void
 xb_init(struct ifnet *ifp)
+{
 	ifp->if_flags |= IFF_RUNNING;
+}
 static void
 xb_stop()
+{
+}
 static int
 xb_ioctl(struct ifnet *ifp, unsigned long cmd, void *data)
+{
 	struct ifaddr *ifa = (struct ifaddr *)data;
 	int s, error = 0;
 	s = splnet();
 	switch (cmd) {
 	case SIOCINITIFADDR:
 		xbi.if_flags |= IFF_UP;
 		xb_init(ifp);
 		break;
 	case SIOCSIFFLAGS:
 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 			break;
 		if ((ifp->if_flags & IFF_UP) == 0 &&
 		    (ifp->if_flags & IFF_RUNNING) != 0) {
 			xb_stop();
 			ifp->if_flags &= ~IFF_RUNNING;
 		} else if ((ifp->if_flags & IFF_UP) != 0 &&
 		           (ifp->if_flags & IFF_RUNNING) == 0) {
 			xb_start(ifp);
 		} else
 			xb_init(ifp);
 		if (ifp->if_flags & IFF_DEBUG)
 			xb_debug = 1;
 		break;
 	default:
 		error = ifioctl_common(ifp, cmd, data);
 		break;
+	}
 	splx(s);
 	return error;
+}
 /*
  * XXX - someday, keep a software copy of A12_OMR. We can execute up to
  * 200 or 300 instructions in the time it takes to do the read part of an
  * external bus cycle RMW op. (Or 10 - 20 cache cycles.)
  */
 static inline long
 xb_fifo_empty(void)
+{
 	return REGVAL(A12_MCSR) & A12_MCSR_OMFE;
+}
 /*
  * rtmon frames
+ *
  * [ (... data) : commid : sourcepid : dstpid : ktype : length : frametype ]
+ *
  * At the moment, NetBSD ip frames are not compatible with rtmon frames:
+ *
  * [ ... data : length ]
  */
 static int
 xb_output(struct ifnet *ifp, struct mbuf *m0, const struct sockaddr *dst, struct rtentry *rt0)
+{
 	int	i,s;
 	struct	mbuf *m = m0;
 	const char	*lladdr;
 	char	*xbh;
 	long	xbo_framesize;
 	const struct	sockaddr_dl *llsa;
 	int	xbaddr;
 #ifdef DIAGNOSTIC
 	if (ifp != &xbi)
 		DIE();
 #endif
 	if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
 		m_freem(m);
 		return ENETDOWN;
+	}
 	/*
 	 * We want an IP packet with a link level route, on a silver platter.
 	 */
 	if (rt0 == NULL
 	|| (rt0->rt_flags & (RTF_GATEWAY | RTF_LLINFO))
 	|| (llsa = satocsdl(rt0->rt_gateway)) == NULL
 	||  llsa->sdl_family != AF_LINK
 	||  llsa->sdl_slen   != 0) {
 	      ++ifp->if_oerrors;
 		m_freem(m);
 		return EHOSTUNREACH;
+	}
 	if (dst == NULL
 	||  dst->sa_family != AF_INET) {
 		/*
 		 * This is because we give all received packets to ipintrq
 		 * right now.
 		 */
 		What();
 		m_freem(m);
 	      ++ifp->if_noproto;
 		return EAFNOSUPPORT;
+	}
 	/*
 	 * The a12MppSwitch is a wormhole routed MSN consisting of a number
 	 * (usually n==1) of 14 channel crossbar switches.  Each route through
 	 * a switch requires a 128 bit address word that specifies the channel
 	 * to emerge on. The address word is eaten by the switch and the
 	 * rest of the packet is routed through.
 	 */
 	lladdr = CLLADDR(llsa);
 	if (llsa->sdl_alen != 1)			/* XXX */
 		DIE();	/* OK someday, but totally unexpected right now */
 	/*
 	 * Alternatively, we could lookup the address word and output
 	 * it with PIO when the mbuf is dequeued
 	 */
 	xbo_framesize = m->m_pkthdr.len + 8;
 	M_PREPEND(m, 16 * llsa->sdl_alen + 8, M_DONTWAIT);
 	if (m == NULL)
 		return ENOBUFS;
 	xbh = mtod(m, char *);
 	for (i=0; i<llsa->sdl_alen; ++i) {
 		xbaddr = (lladdr[i] & 0xff) - 1;
 		if (!(0 <= xbaddr && xbaddr <= 11))	/* XXX */
 			DIE();		/* 12 or 13 will be OK later */
 		memcpy(xbh, &channel[xbaddr].lo64, 16);
 		xbh += 16;
+	}
 	memcpy(xbh, &xbo_framesize, 8);
 	s = splnet();
 	if (IF_QFULL(&ifp->if_snd)) {
 		IF_DROP(&ifp->if_snd);
 	      ++ifp->if_oerrors;
 		splx(s);
 		m_freem(m);
 		return ENOBUFS;
+	}
 	ifp->if_obytes += m->m_pkthdr.len;
       ++ifp->if_opackets;
 	IF_ENQUEUE(&ifp->if_snd, m);
 	if ((ifp->if_flags & IFF_OACTIVE) == 0)
 		xb_start(ifp);
 	splx(s);
 	if (m->m_flags & M_MCAST)
 		ifp->if_omcasts++;
 	return 0;
+}
 void
 xb_start(struct ifnet *ifp)
+{
 	struct	mbuf *m;
 	if ((xbi.if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
 		return;
 	for (;;) {
 		IF_DEQUEUE(&xbi.if_snd, m);
 		if (m == 0)
 			return;
 		/*
 		 * XXX The variable-length switch address words cause problems
 		 * for bpf, for now, leave it out. XXX It's not too hard to
 		 * fix, though, as there are lots of techniques that will
 		 * identify the number of switch address words.
 		 */
 		if (!xb_put(m)) {
 			xbi.if_flags |= IFF_OACTIVE;
 			return;
+		}
+	}
+}
 static int
 xb_put(struct mbuf *m)
+{
 	struct mbuf *n;
 	int len;
 	if (XB_DEBUG && (alpha_pal_rdps() & 7) < 3)
 		DIE();	/* this "cannot happen", of course */
 	for (; m; m = n) {
 		len = m->m_len;
 		if (len == 0 || xb_put_blk(m))
 			MFREE(m, n);
 		else	return 0;
+	}
 	xb_put_blk(NULL);
 	return 1;
+}
 /*
  * Write a single mbuf to the transmit channel fifo. We can only write 128-bit
  * words. Right now, we pad at the end.  It is possible to pad at the
  * beginning, especially since lots of games can be played at the receiver
  * with the mbuf data pointer. Padding at the beginning requires a pad-count
  * field in a header, but it means you can always DMA the data, regardless of
  * alignment. Of course, we don't DMA at all, right now.
  */
 static int
 xb_put_blk(struct mbuf *m)
+{
 	static	long leftover[2];	/* 0-15 bytes from last xb_put_blk() */
 	static	int  leftover_len;	/* non-aligned amount from last call */
 	long	xfertmp[8];	/* aligned switch word buffer */
 	int 	frag_len,	/* fifo stream unit */
 		fifo_len,	/* space left in fifo */
 		fillin,		/* amount needed to complete a switch word */
 		full,		/* remember to restart on fifo full */
 		len;		/* amount of mbuf left to do */
 	char	*blk;		/* location we are at in mbuf */
 	static	int fifo_free;	/* current # of switch words free in fifo */
 #define	XFERADJ() ((char *)xfertmp + leftover_len)
 	/* There is always room for the close word */
 	if (m == NULL) {
 		if (leftover_len)
 			leftover_len = 0;
 		else	leftover[0]  = leftover[1] = 0;
 		xb_mcrp_write(leftover, 1, 1);
 	      --fifo_free;
 		return 1;
+	}
 restart:
 	if (fifo_free < 2) {
 		if (!xb_fifo_empty()) {
 			if(!set_interrupt_on_fifo_empty())  {
 				/* still empty */
 				xbi.if_flags |= IFF_OACTIVE;
 				IF_PREPEND(&xbi.if_snd, m);
 				return 0;
+			}
+		}
 		fifo_free = FIFO_WORDCOUNT;
+	}
 	len = m->m_len;
 	if (len == 0)
 		return 1;	/* clean finish, nothing left over */
 	blk = mtod(m, char *);
 	if (leftover_len) {
 		/* See function intro comment regarding padding */
 		if (leftover_len + len < sizeof leftover) {
 			/* Heh, not even enough to write out */
 			memcpy(XFERADJ(), blk, len);
 			leftover_len += len;
 			return 1;
+		}
 		xfertmp[0] = leftover[0];
 		xfertmp[1] = leftover[1];
 		fillin = sizeof leftover - leftover_len;
 		memcpy(XFERADJ(), blk, fillin);
 		blk += fillin;
 		len -= fillin;
 		xb_mcrp_write(xfertmp, 1, 0);
 		leftover_len = 0;
 	      --fifo_free;
+	}
 	/* fifo_free is known to be >= 1 at this point */
 	while (len >= 16) {
 		full = 0;
 		frag_len = sizeof xfertmp;
 		if (frag_len > len)
 			frag_len = len;
 		fifo_len = fifo_free * 16;
 		if (frag_len > fifo_len) {
 			frag_len = fifo_len;
 			full = 1;
+		}
 		frag_len &= ~0xf;
 		memcpy(xfertmp, blk, frag_len);
 		frag_len >>= 4;		/* Round down to switch word size */
 		xb_mcrp_write(xfertmp, frag_len, 0);
 		fifo_free -= frag_len;
 		frag_len <<= 4;
 		len -= frag_len;
 		blk += frag_len;
 		if (full) {
 			m_adj(m, blk - mtod(m, char *));
 			goto restart;
+		}
+	}
 	memcpy(leftover, blk, len);
 	leftover_len = len;
 	return 1;
+}
 static long
 set_interrupt_on_fifo_empty(void)
+{
 	REGVAL(A12_OMR) |= A12_OMR_OMF_ENABLE;
 	alpha_mb();
 	if(xb_fifo_empty()) {
 		REGVAL(A12_OMR) &= ~A12_OMR_OMF_ENABLE;
 		alpha_mb();
 		return 1;
+	}
 	return 0;
+}
 /*
  * Write an aligned block of switch words to the FIFO
  */
 Static void
-xb_mcrp_write(long *d, n, islast)
+xb_mcrp_write(long *d, int n, int islast)
+{
 	volatile long *xb_fifo = islast ? REGADDR(A12_FIFO_LWE)
 					: REGADDR(A12_FIFO);
 	int i;
 	if (XB_DEBUG && islast && n != 1)
 		DIE();
 	n <<= 1;
 	for (i = 0; i < n; i += 2) {
 		xb_onefree();
 		xb_fifo[0] = d[i];
 		xb_fifo[1] = d[i+1];
 		alpha_wmb();
+	}
+}
 /*
 const
 int32_t	xbar_bc_addr = XBAR_BROADCAST;
  */
 static void
 a12_xbar_setup()
+{
 	xbi.if_softc    = &xb_softc;
 	xbi.if_start    = xb_start;
 	xbi.if_ioctl    = xb_ioctl;
 	xbi.if_flags    = IFF_BROADCAST	/* ha ha */
 		        | IFF_SIMPLEX;
 	xbi.if_type     = IFT_A12MPPSWITCH;
 	xbi.if_addrlen  = 32;
 	xbi.if_hdrlen   = 32;
 	xbi.if_mtu      = XB_DEFAULT_MTU();
 	xbi.if_output   = xb_output;
 	/* xbi.if_broadcastaddr = (u_int8_t)&xbar_bc_addr; */
 	if_attach(&xbi);
 	if_alloc_sadl(&xbi);
 #if NBPFILTER > 0
 	bpfattach(&xbi, DLT_NULL, 0);
 #endif
+}

 @@ -1,655 +1,655 @@
-/*	$NetBSD: mfm.c,v 1.8 2009/03/14 21:04:16 dsl Exp $	*/
+/*	$NetBSD: mfm.c,v 1.9 2009/03/17 18:19:15 dsl Exp $	*/
 /*
  * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Ludd by
  * Bertram Barth.
+ *
  * 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 at Ludd, University of
  *	Lule}, Sweden and its contributors.
  * 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.
  */
 /*
  * ToDo:
+ *
  * - insert appropriate delays for diskette-drive where needed
  * - allow more than one sector per diskette-read
  * - check for and handle bad sectors
  * - ???
  */
 #include <sys/param.h>
 #include <sys/reboot.h>
 #include <sys/disklabel.h>
 #include <lib/libsa/stand.h>
 #include <lib/libsa/ufs.h>
 #include <lib/libkern/libkern.h>
 #include "../include/pte.h"
 #include "../include/sid.h"
 #include "../include/mtpr.h"
 #include "../include/reg.h"
 #include "../include/rpb.h"
 #include "ka410.h"
 #include "../vsa/hdc9224.h"
 #include "data.h"
 #include "vaxstand.h"
 #define MAX_WAIT	(1000*1000)	/* # of loop-instructions in seconds */
 struct mfm_softc {
 	int		part;
 	int		unit;
 };
 static struct disklabel mfmlabel;
 static struct mfm_softc mfm_softc;
 static char io_buf[DEV_BSIZE];
 /*
  * These should probably be somewhere else, but ka410 is the only
  * one with mfm disks anyway...
  */
 volatile unsigned char *ka410_intreq = (void*)0x2008000f;
 volatile unsigned char *ka410_intclr = (void*)0x2008000f;
 volatile unsigned char *ka410_intmsk = (void*)0x2008000c;
 static volatile struct hdc9224_DKCreg *dkc = (void *) 0x200c0000;
 static volatile struct hdc9224_UDCreg sreg;	/* input */
 static volatile struct hdc9224_UDCreg creg;	/* output */
 static void sreg_read(void);
 static void creg_write(void);
 static int mfm_rxprepare(void);
 static int mfm_command(int cmd);
 static int mfm_rxselect(int unit);
 static int mfm_rdselect(int unit);
 static int mfm_rxstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize);
 static int mfm_rdstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize);
 /*
  * we have to wait 0.7 usec between two accesses to any of the
  * dkc-registers, on a VS2000 with 1 MIPS, this is roughly one
  * instruction. Thus the loop-overhead will be enough...
  */
 static void
 sreg_read()
+{
 	int	i;
 	char    *p;
 	dkc->dkc_cmd = 0x40;	/* set internal counter to zero */
 	p = (void *) &sreg;
 	for (i = 0; i < 10; i++)
 		*p++ = dkc->dkc_reg;	/* dkc_reg auto-increments */
+}
 static void
 creg_write()
+{
 	int	i;
 	char    *p;
 	dkc->dkc_cmd = 0x40;	/* set internal counter to zero */
 	p = (void *) &creg;
 	for (i = 0; i < 10; i++)
 		dkc->dkc_reg = *p++;	/* dkc_reg auto-increments */
+}
 /*
  * floppies are handled in a quite strange way by this controller...
+ *
  * before reading/writing a sector from/to floppy, we use the SEEK/READ_ID
  * command to place the head at the desired location. Then we wait some
  * time before issuing the real command in order to let the drive become
  * ready...
  */
 int
 mfm_rxprepare()
+{
 	int	error;
 	error = mfm_command(DKC_CMD_SEEKREADID | 0x04); /* step=1, verify=0 */
 	if (error) {
 		printf("error while stepping to position %d/%d/%x. Retry...\n",
 		    creg.udc_dsect, creg.udc_dhead, creg.udc_dcyl);
 		error = mfm_command(DKC_CMD_SEEKREADID | 0x04);
+	}
 	return error;
+}
 int
 mfm_rxselect(int unit)
+{
 	int	error;
 	/*
 	 * bring "creg" in some known-to-work state and
 	 * select the drive with the DRIVE SELECT command.
 	 */
 	creg.udc_dma7 = 0;
 	creg.udc_dma15 = 0;
 	creg.udc_dma23 = 0;
 	creg.udc_dsect = 1;	/* sectors are numbered 1..15 !!! */
 	creg.udc_dhead = 0;
 	creg.udc_dcyl = 0;
 	creg.udc_scnt = 0;
 	creg.udc_rtcnt = UDC_RC_RX33READ;
 	creg.udc_mode = UDC_MD_RX33;
 	creg.udc_term = UDC_TC_FDD;
 	/*
 	 * this is ...
 	 */
 	error = mfm_command(DKC_CMD_DRSEL_RX33 | unit);
 	if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 0)) {
 		printf("\nfloppy-drive not ready (new floppy inserted?)\n\n");
 		creg.udc_rtcnt &= ~UDC_RC_INVRDY;	/* clear INVRDY-flag */
 		error = mfm_command(DKC_CMD_DRSEL_RX33 | unit);
 		if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 0)) {
 			printf("diskette not ready(1): %x/%x\n",
 			       error, sreg.udc_dstat);
 			printf("floppy-drive offline?\n");
 			return (-1);
+		}
 		if (sreg.udc_dstat & UDC_DS_TRK00)
 			error = mfm_command(DKC_CMD_STEPIN_FDD);
 		else
 			error = mfm_command(DKC_CMD_STEPOUT_FDD);
 		/*
 		 * now ready should be 0, cause INVRDY is not set
 		 * (retrying a command makes this fail...)
 		 */
 		if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 1)) {
 			printf("diskette not ready(2): %x/%x\n",
 			       error, sreg.udc_dstat);
+		}
 		creg.udc_rtcnt |= UDC_RC_INVRDY;
 		error = mfm_command(DKC_CMD_DRSEL_RX33 | unit);
 		if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 0)) {
 			printf("diskette not ready(3): %x/%x\n",
 			       error, sreg.udc_dstat);
 			printf("no floppy inserted or floppy-door open\n");
 			return (-1);
+		}
 		printf("floppy-drive reselected.\n");
+	}
 	return (error);
+}
 int
 mfm_rdselect(int unit)
+{
 	int	error;
 	/*
 	 * bring "creg" in some known-to-work state and
 	 * select the drive with the DRIVE SELECT command.
 	 */
 	creg.udc_dma7 = 0;
 	creg.udc_dma15 = 0;
 	creg.udc_dma23 = 0;
 	creg.udc_dsect = 0;	/* sectors are numbered 0..16 */
 	creg.udc_dhead = 0;
 	creg.udc_dcyl = 0;
 	creg.udc_scnt = 0;
 	creg.udc_rtcnt = UDC_RC_HDD_READ;
 	creg.udc_mode = UDC_MD_HDD;
 	creg.udc_term = UDC_TC_HDD;
 	error = mfm_command(DKC_CMD_DRSEL_HDD | unit);
 	return (error);
+}
 static int	mfm_retry = 0;
 int
 mfm_command(int	cmd)
+{
 	int	termcode, ready, i;
 	creg_write();		/* write command-registers */
 	*ka410_intclr = INTR_DC;
 	dkc->dkc_cmd = cmd;	/* issue command */
 	for (i = 0; i < MAX_WAIT; i++) {
 		if (*ka410_intreq & INTR_DC)	/* wait for interrupt */
 			break;
+	}
 	if ((*ka410_intreq & INTR_DC) == 0)
 		printf("timeout in mfm_command...\n");
 	sreg_read();		/* read status-registers */
 	if (dkc->dkc_stat == (DKC_ST_DONE | DKC_TC_SUCCESS))
 		return (0);
 	if (sreg.udc_cstat & UDC_CS_ECCERR) {
 		printf(
 "\nspurious(?) ECC/CRC error at s%d/t%d/c%d [s%d/t%d/c%d(%d)]\n",
 		   sreg.udc_csect, sreg.udc_chead, sreg.udc_ccyl,
 		   creg.udc_dsect, creg.udc_dhead, creg.udc_dcyl,creg.udc_scnt);
 		if (sreg.udc_csect != creg.udc_dsect + creg.udc_scnt - 1) {
 			printf("DMA: %x %x %x [%x]\n",
 			    sreg.udc_dma23, sreg.udc_dma15,
 			    sreg.udc_dma7, 512 * (sreg.udc_csect -
 			    creg.udc_dsect));
 			creg.udc_scnt = creg.udc_scnt -
 			    (sreg.udc_csect - creg.udc_dsect) - 1;
 			creg.udc_dsect = sreg.udc_csect + 1;
 			creg.udc_dma23 = sreg.udc_dma23;
 			creg.udc_dma15 = sreg.udc_dma15 + 2;
 			creg.udc_dma7 = 0;
 			printf("Retry starting from s%d/t%d/c%d (%d). ",
 			    creg.udc_dsect, creg.udc_dhead, creg.udc_dcyl,
 			    creg.udc_scnt);
+		}
 		goto retry;
+	}
 	termcode = (dkc->dkc_stat & DKC_ST_TERMCOD) >> 3;
 	ready = sreg.udc_dstat & UDC_DS_READY;
 	printf("cmd:0x%x: termcode=0x%x, status=0x%x, cstat=0x%x, dstat=0x%x\n",
 	       cmd, termcode, dkc->dkc_stat, sreg.udc_cstat, sreg.udc_dstat);
 	if (dkc->dkc_stat & DKC_ST_BADSECT)
 		printf("bad sector found: s%d/t%d/c%d\n", creg.udc_dsect,
 		       creg.udc_dhead, creg.udc_dcyl);
 retry:
 	if ((mfm_retry == 0) && (sreg.udc_cstat & UDC_CS_RETREQ)) {
 		mfm_retry = 1;
 		printf("Retrying... ");
 		mfm_command(cmd);
 		printf("Retry done.\n");
 		mfm_retry = 0;
+	}
 	return ((dkc->dkc_stat & DKC_ST_TERMCOD) >> 3);
+}
 /*
  * on-disk geometry block
  */
 #define _aP	__attribute__ ((packed))	/* force byte-alignment */
 volatile struct mfm_xbn {
 	char		mbz[10];/* 10 bytes of zero */
 	long xbn_count	_aP;	/* number of XBNs */
 	long dbn_count	_aP;	/* number of DBNs */
 	long lbn_count	_aP;	/* number of LBNs (Logical-Block-Numbers) */
 	long rbn_count	_aP;	/* number of RBNs (Replacement-Block-Numbers) */
 	short		nspt;	/* number of sectors per track */
 	short		ntracks;/* number of tracks */
 	short		ncylinders;	/* number of cylinders */
 	short		precomp;/* first cylinder for write precompensation */
 	short		reduced;/* first cylinder for reduced write current */
 	short		seek_rate;	/* seek rate or zero for buffered
 					 * seeks */
 	short		crc_eec;/* 0 if CRC is being used or 1 if ECC is
 				 * being used */
 	short		rct;	/* "replacement control table" (RCT) */
 	short		rct_ncopies;	/* number of copies of the RCT */
 	long media_id	_aP;	/* media identifier */
 	short		interleave;	/* sector-to-sector interleave */
 	short		headskew;	/* head-to-head skew */
 	short		cylskew;/* cylinder-to-cylinder skew */
 	short		gap0_size;	/* size of GAP 0 in the MFM format */
 	short		gap1_size;	/* size of GAP 1 in the MFM format */
 	short		gap2_size;	/* size of GAP 2 in the MFM format */
 	short		gap3_size;	/* size of GAP 3 in the MFM format */
 	short		sync_value;	/* sync value used to start a track
 					 * when formatting */
 	char		reserved[32];	/* reserved for use by the RQDX1/2/3
 					 * formatter */
 	short		serial_number;	/* serial number */
 	char		fill[412];	/* Filler bytes to the end of the
 					 * block */
 	short		checksum;	/* checksum over the XBN */
 } mfm_xbn;
 #ifdef verbose
 display_xbn(struct mfm_xbn *p)
+{
 	printf("**DiskData**	XBNs: %d, DBNs: %d, LBNs: %d, RBNs: %d\n",
 	    p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count);
 	printf("sect/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n",
 	    p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced);
 	printf("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n",
 	    p->seek_rate, p->crc_eec ? "EEC" : "CRC", p->rct, p->rct_ncopies);
 	printf("media-ID: 0x%x, interleave: %d, headskew: %d, cylskew: %d\n",
 	    &p->media_id, p->interleave, p->headskew, p->cylskew);
 	printf("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n",
 	    p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size,
 	    p->sync_value);
 	printf("serial: %d, checksum: %d, size: %d, reserved: %32c\n",
 	    p->serial_number, p->checksum, sizeof(*p), p->reserved);
+}
 #endif
 int
-mfmopen(struct open_file *f, adapt, int ctlr, int unit, int part)
+mfmopen(struct open_file *f, int adapt, int ctlr, int unit, int part)
+{
 	char *msg;
 	struct disklabel *lp = &mfmlabel;
 	struct mfm_softc *msc = &mfm_softc;
 	int err;
 	size_t i;
 	bzero(lp, sizeof(struct disklabel));
 	msc->unit = unit;
 	msc->part = part;
 	err = mfmstrategy(msc, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i);
 	if (err) {
 		printf("reading disklabel: %s\n", strerror(err));
 		return 0;
+	}
 	msg = getdisklabel(io_buf + LABELOFFSET, lp);
 	if (msg)
 		printf("getdisklabel: %s\n", msg);
 	f->f_devdata = (void *) msc;
+	{
 #ifdef verbose
 		int		k;
 		unsigned char  *ucp;
 		struct mfm_xbn *xp;
 #endif
 		/* mfmstrategy(msc, F_READ, -16, 8192, io_buf, &i); */
 		mfmstrategy(msc, F_READ, -16, 512, io_buf, &i);
 #ifdef verbose
 		printf("dumping raw disk-block #0:\n");
 		ucp = io_buf;
 		for (k = 0; k < 128; k++) {
 			if (ucp[k] < 0x10)
 				printf("0");
 			printf("%x ", ucp[k]);
 			if (k % 8 == 7)
 				printf("  ");
 			if (k % 16 == 15)
 				printf("\n");
+		}
 		printf("\n");
 		xp = (void *) io_buf;
 		display_xbn(xp);
 		printf("\n");
 #endif
+	}
 	if (unit == 2) {	/* floppy! */
 		if (lp->d_ntracks != 2) {
 #ifdef verbose
 			printf("changing number of tracks from %d to %d.\n",
 			       lp->d_ntracks, 2);
 #endif
 			lp->d_ntracks = 2;
+		}
 	} else {		/* hard-disk */
 		unsigned short *usp = (void *) io_buf;
 #ifdef verbose
 		printf("label says: s/t/c = %d/%d/%d\n",
 		       lp->d_nsectors, lp->d_ntracks, lp->d_ncylinders);
 #endif
 		if (lp->d_nsectors != usp[13]) {
 #ifdef verbose
 			printf("changing number of sectors from %d to %d.\n",
 			       lp->d_nsectors, usp[13]);
 #endif
 			lp->d_nsectors = usp[13];
+		}
 		if (lp->d_ntracks != usp[14]) {
 #ifdef verbose
 			printf("changing number of heads/tracks from %d to %d.\n",
 			       lp->d_ntracks, usp[14]);
 #endif
 			lp->d_ntracks = usp[14];
+		}
 		if (lp->d_ncylinders != usp[15]) {
 #ifdef verbose
 			printf("changing number of cylinders from %d to %d.\n",
 			       lp->d_ncylinders, usp[15]);
 #endif
 			lp->d_ncylinders = usp[15];
+		}
 		lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
+	}
 	return (0);
+}
 int
 mfm_rxstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize) {
 	struct mfm_softc *msc = f;
 	struct disklabel *lp;
 	int	block, sect, head, cyl, scount, res;
 	char *cbuf;
 	cbuf = (char*)buf;
 	lp = &mfmlabel;
 	block = (dblk < 0 ? 0 : dblk + lp->d_partitions[msc->part].p_offset);
 	mfm_rxselect(msc->unit);
 	/*
 	 * if label is empty, assume RX33
 	 */
 	if (lp->d_nsectors == 0)
 		lp->d_nsectors = 15;
 	if (lp->d_ntracks == 0)
 		lp->d_ntracks = 2;
 	if (lp->d_secpercyl == 0)
 		lp->d_secpercyl = 30;
 	bzero((void *) 0x200D0000, size);
 	scount = size / 512;
 	while (scount) {
 		/*
 		 * prepare drive/operation parameter
 		 */
 		cyl = block / lp->d_secpercyl;
 		sect = block % lp->d_secpercyl;
 		head = sect / lp->d_nsectors;
 		sect = sect % lp->d_nsectors;
 		/*
 		 * *rsize = 512;		one sector after the other
 		 * ...
 		 */
 		*rsize = 512 * min(scount, lp->d_nsectors - sect);
 		/*
 		 * now initialize the register values ...
 		 */
 		creg.udc_dma7 = 0;
 		creg.udc_dma15 = 0;
 		creg.udc_dma23 = 0;
 		creg.udc_dsect = sect + 1;	/* sectors are numbered 1..15
 						 * !!! */
 		head |= (cyl >> 4) & 0x70;
 		creg.udc_dhead = head;
 		creg.udc_dcyl = cyl;
 		creg.udc_scnt = *rsize / 512;
 		if (func == F_WRITE) {
 			creg.udc_rtcnt = UDC_RC_RX33WRT;
 			creg.udc_mode = UDC_MD_RX33;
 			creg.udc_term = UDC_TC_FDD;
 			mfm_rxprepare();
 			/* copy from buf */
 			bcopy(cbuf, (void *) 0x200D0000, *rsize);
 			res = mfm_command(DKC_CMD_WRITE_RX33);
 		} else {
 			creg.udc_rtcnt = UDC_RC_RX33READ;
 			creg.udc_mode = UDC_MD_RX33;
 			creg.udc_term = UDC_TC_FDD;
 			mfm_rxprepare();
 			/* clear disk buffer */
 			bzero((void *) 0x200D0000, *rsize);
 			res = mfm_command(DKC_CMD_READ_RX33);
 			/* copy to buf */
 			bcopy((void *) 0x200D0000, cbuf, *rsize);
+		}
 		scount -= *rsize / 512;
 		block += *rsize / 512;
 		cbuf += *rsize;
+	}
 	*rsize = size;
 	return 0;
+}
 int
 mfm_rdstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize) {
 	struct mfm_softc *msc = f;
 	struct disklabel *lp;
 	int	block, sect, head, cyl, scount, cmd, res;
 	char *cbuf;
 	cbuf = (char *)buf;
 	lp = &mfmlabel;
 	block = (dblk < 0 ? 0 : dblk + lp->d_partitions[msc->part].p_offset);
 	/*
 	 * if label is empty, assume RD32 (XXX this must go away!!!)
 	 */
 	if (lp->d_nsectors == 0)
 		lp->d_nsectors = 17;
 	if (lp->d_ntracks == 0)
 		lp->d_ntracks = 6;
 	if (lp->d_secpercyl == 0)
 		lp->d_secpercyl = 102;
 	mfm_rdselect(msc->unit);
 	bzero((void *) 0x200D0000, size);
 	scount = size / 512;
 	while (scount) {
 		/*
 		 * prepare drive/operation parameter
 		 */
 		cyl = block / lp->d_secpercyl;
 		sect = block % lp->d_secpercyl;
 		head = sect / lp->d_nsectors;
 		sect = sect % lp->d_nsectors;
 		if (dblk < 0) {
 #ifdef verbose
 			printf("using raw diskblock-data!\n");
 			printf("block %d, dblk %d ==> cyl %d, head %d, sect %d\n",
 			       block, dblk, cyl, sect, head);
 #endif
 		} else
 			cyl += 1;	/* first cylinder is reserved for
 					 * controller! */
 		*rsize = 512 * min(scount, lp->d_nsectors - sect);
 		/*
 		 * now re-initialize the register values ...
 		 */
 		creg.udc_dma7 = 0;
 		creg.udc_dma15 = 0;
 		creg.udc_dma23 = 0;
 		creg.udc_dsect = sect;
 		head |= (cyl >> 4) & 0x70;
 		creg.udc_dhead = head;
 		creg.udc_dcyl = cyl;
 		creg.udc_scnt = *rsize / 512;
 		if (func == F_WRITE) {
 			creg.udc_rtcnt = UDC_RC_HDD_WRT;
 			creg.udc_mode = UDC_MD_HDD;
 			creg.udc_term = UDC_TC_HDD;
 			cmd = DKC_CMD_WRITE_HDD;
 			bcopy(cbuf, (void *) 0x200D0000, *rsize);
 			res = mfm_command(cmd);
 		} else {
 			creg.udc_rtcnt = UDC_RC_HDD_READ;
 			creg.udc_mode = UDC_MD_HDD;
 			creg.udc_term = UDC_TC_HDD;
 			cmd = DKC_CMD_READ_HDD;
 			bzero((void *) 0x200D0000, *rsize);
 			res = mfm_command(cmd);
 			bcopy((void *) 0x200D0000, cbuf, *rsize);
+		}
 		scount -= *rsize / 512;
 		block += *rsize / 512;
 		cbuf += *rsize;
+	}
 	/*
 	 * unselect the drive ...
 	 */
 	mfm_command(DKC_CMD_DRDESELECT);
 	*rsize = size;
 	return 0;
+}
 int
 mfmstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize)
+{
 	struct mfm_softc *msc = f;
 	int	res = -1;
 	switch (msc->unit) {
 	case 0:
 	case 1:
 		res = mfm_rdstrategy(f, func, dblk, size, buf, rsize);
 		break;
 	case 2:
 		res = mfm_rxstrategy(f, func, dblk, size, buf, rsize);
 		break;
 	default:
 		printf("invalid unit %d in mfmstrategy()\n", msc->unit);
+	}
 	return (res);
+}

 @@ -1,196 +1,196 @@
-/*	$NetBSD: tmscp.c,v 1.7 2009/03/14 21:04:16 dsl Exp $ */
+/*	$NetBSD: tmscp.c,v 1.8 2009/03/17 18:19:15 dsl Exp $ */
 /*
  * Copyright (c) 1995 Ludd, University of Lule}, Sweden.
  * 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 at Ludd, University of Lule}.
  * 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.
  */
  /* All bugs are subject to removal without further notice */
 #define NRSP 0 /* Kludge */
 #define NCMD 0 /* Kludge */
 #include <sys/param.h>
 #include <sys/disklabel.h>
 #include <lib/libsa/stand.h>
 #include "../include/pte.h"
 #include <dev/mscp/mscp.h>
 #include <dev/mscp/mscpreg.h>
 #include "vaxstand.h"
 static command(int,int);
 /*
  * These routines for TMSCP tape standalone boot is very simple,
  * assuming a lots of thing like that we only working at one tape at
  * a time, no separate routines for uba driver etc..
  * This code is directly copied from ra disk driver.
  */
 struct ra_softc {
 	int udaddr;
 	int ubaddr;
 	int unit;
 };
 static volatile struct uda {
         struct  mscp_1ca uda_ca;           /* communications area */
         struct  mscp uda_rsp;     /* response packets */
         struct  mscp uda_cmd;     /* command packets */
 } uda;
 struct  udadevice {
 	short udaip;
 	short udasa;
 };
 static volatile struct uda *ubauda;
 static volatile struct udadevice *udacsr;
 static struct ra_softc ra_softc;
 static int curblock;
-tmscpopen(struct open_file *f, adapt, int ctlr, int unit, int part)
+tmscpopen(struct open_file *f, int adapt, int ctlr, int unit, int part)
+{
 	char *msg;
 	extern u_int tmsaddr;
 	volatile struct ra_softc *ra=&ra_softc;
 	volatile u_int *nisse;
 	unsigned short johan;
 	int i,err;
 	curblock = 0;
 	if(adapt>nuba) return(EADAPT);
 	if(ctlr>nuda) return(ECTLR);
 	ra->udaddr=uioaddr[adapt]+tmsaddr;
 	ra->ubaddr=(int)ubaaddr[adapt];
 	ra->unit=unit;
 	udacsr=(void*)ra->udaddr;
 	nisse=((u_int *)ubaaddr[adapt]) + 512;
 	nisse[494]=PG_V|(((u_int)&uda)>>9);
 	nisse[495]=nisse[494]+1;
 	ubauda=(void*)0x3dc00+(((u_int)(&uda))&0x1ff);
 	/*
 	 * Init of this tmscp ctlr.
 	 */
 	udacsr->udaip=0; /* Start init */
 	while((udacsr->udasa&MP_STEP1) == 0);
 	udacsr->udasa=0x8000;
 	while((udacsr->udasa&MP_STEP2) == 0);
 	johan=(((u_int)ubauda)&0xffff)+8;
 	udacsr->udasa=johan;
 	while((udacsr->udasa&MP_STEP3) == 0);
 	udacsr->udasa=3;
 	while((udacsr->udasa&MP_STEP4) == 0);
 	udacsr->udasa=0x0001;
 	uda.uda_ca.ca_rspdsc=(int)&ubauda->uda_rsp.mscp_cmdref;
 	uda.uda_ca.ca_cmddsc=(int)&ubauda->uda_cmd.mscp_cmdref;
 	uda.uda_cmd.mscp_un.un_seq.seq_addr = (long *)&uda.uda_ca.ca_cmddsc;
 	uda.uda_rsp.mscp_un.un_seq.seq_addr = (long *)&uda.uda_ca.ca_rspdsc;
 	uda.uda_cmd.mscp_vcid = 1;
 	uda.uda_cmd.mscp_un.un_sccc.sccc_ctlrflags = 0;
 	command(M_OP_SETCTLRC, 0);
 	uda.uda_cmd.mscp_unit=ra->unit;
 	command(M_OP_ONLINE, 0);
 	if (part) {
 		uda.uda_cmd.mscp_un.un_seq.seq_buffer = part;
 		command(M_OP_POS, 0);
 		uda.uda_cmd.mscp_un.un_seq.seq_buffer = 0;
+	}
 	f->f_devdata=(void *)ra;
 	return(0);
+}
 static
 command(cmd, arg)
+{
 	volatile int hej;
 	uda.uda_cmd.mscp_opcode = cmd;
 	uda.uda_cmd.mscp_modifier = arg;
 	uda.uda_cmd.mscp_msglen = MSCP_MSGLEN;
 	uda.uda_rsp.mscp_msglen = MSCP_MSGLEN;
 	uda.uda_ca.ca_rspdsc |= MSCP_OWN|MSCP_INT;
 	uda.uda_ca.ca_cmddsc |= MSCP_OWN|MSCP_INT;
 	hej = udacsr->udaip;
 	while (uda.uda_ca.ca_rspdsc < 0) {
 		if (uda.uda_ca.ca_cmdint)
 			uda.uda_ca.ca_cmdint = 0;
+	}
+}
 tmscpstrategy(struct ra_softc *ra, int func, daddr_t dblk, u_int size, char *buf, u_int *rsize)
+{
 	u_int i,j,pfnum, mapnr, nsize, bn, cn, sn, tn;
 	volatile struct udadevice *udadev=(void*)ra->udaddr;
 	volatile u_int *ptmapp = (u_int *)ra->ubaddr + 512;
 	volatile int hej;
 	pfnum=(u_int)buf>>VAX_PGSHIFT;
 	for(mapnr=0, nsize=size;(nsize+VAX_NBPG)>0;nsize-=VAX_NBPG)
 		ptmapp[mapnr++]=PG_V|pfnum++;
 	/*
 	 * First position tape. Remember where we are.
 	 */
 	if (dblk < curblock) {
 		uda.uda_cmd.mscp_seq.seq_bytecount = curblock - dblk;
 		command(M_OP_POS, 12); /* 12 == step block backward */
 	} else {
 		uda.uda_cmd.mscp_seq.seq_bytecount = dblk - curblock;
 		command(M_OP_POS, 4); /* 4 == step block forward */
+	}
 	curblock = size/512 + dblk;
 	/*
 	 * Read in the number of blocks we need.
 	 * Why doesn't read of multiple blocks work?????
 	 */
 	for (i = 0 ; i < size/512 ; i++) {
 		uda.uda_cmd.mscp_seq.seq_lbn = 1;
 		uda.uda_cmd.mscp_seq.seq_bytecount = 512;
 		uda.uda_cmd.mscp_seq.seq_buffer =
 		    (((u_int)buf) & 0x1ff) + i * 512;
 		uda.uda_cmd.mscp_unit = ra->unit;
 		command(M_OP_READ, 0);
+	}
 	*rsize=size;
 	return 0;
+}

 @@ -1,1012 +1,1012 @@
-/*	$NetBSD: if_hp.c,v 1.47 2009/03/14 21:04:20 dsl Exp $	*/
+/*	$NetBSD: if_hp.c,v 1.48 2009/03/17 18:19:15 dsl Exp $	*/
 /* XXX THIS DRIVER IS BROKEN.  IT WILL NOT EVEN COMPILE. */
 /*-
  * Copyright (c) 1990 The Regents of the University of California.
  * 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. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
  */
 /*-
  * Copyright (c) 1990, 1991 William F. Jolitz.
+ *
  * 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 the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
  */
 /*
  * HP LAN Ethernet driver
+ *
  * Parts inspired from Tim Tucker's if_wd driver for the wd8003,
  * insight on the ne2000 gained from Robert Clements PC/FTP driver.
+ *
  * receive bottom end totally rewritten by Curt Mayer, Dec 1992.
  * no longer loses back to back packets.
  * note to driver writers: RTFM!
+ *
  * hooks for packet filter added by Charles Hannum, 29DEC1992.
+ *
  * Mostly rewritten for HP-labelled EISA controllers by Charles Hannum,
  * 18JAN1993.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_hp.c,v 1.47 2009/03/14 21:04:20 dsl Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_hp.c,v 1.48 2009/03/17 18:19:15 dsl Exp $");
 #include "hp.h"
 #if NHP > 0
 #include "opt_inet.h"
 #include "rnd.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/buf.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/errno.h>
 #include <sys/syslog.h>
 #if NRND > 0
 #include <sys/rnd.h>
 #endif
 #include <net/if.h>
 #include <net/if_ether.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/in_var.h>
 #include <netinet/ip.h>
 #include <netinet/if_inarp.h>
 #endif
 #include "bpfilter.h"
 #if NBPFILTER > 0
 #include <sys/select.h>
 #include <net/bpf.h>
 #include <net/bpfdesc.h>
 #endif
 #include <sys/cpu.h>
 #include <machine/pio.h>
 #include <i386/isa/isa_device.h>	/* XXX BROKEN */
 #include <dev/isa/if_nereg.h>
 #include <i386/isa/icu.h>		/* XXX BROKEN */
 int     hpprobe(), hpattach(), hpintr();
 int     hpstart(), hpinit(), ether_output(), hpioctl();
 struct isa_driver hpdriver =
+{
 	hpprobe, hpattach, "hp",
 };
 struct mbuf *hpget();
 /*
  * Ethernet software status per interface.
+ *
  * Each interface is referenced by a network interface structure,
  * ns_if, which the routing code uses to locate the interface.
  * This structure contains the output queue for the interface, its address, ...
  */
 struct hp_softc {
 	struct ethercom ns_ec;	/* Ethernet common part */
 #define	ns_if		ns_ac.ac_if	/* network-visible interface */
 	int     ns_flags;
 #define	DSF_LOCK	1	/* block re-entering enstart */
 	int     ns_oactive;
 	int     ns_mask;
 	struct prhdr ns_ph;	/* hardware header of incoming packet */
 	u_char  ns_pb[2048];
 	u_char  ns_txstart;	/* transmitter buffer start */
 	u_char  ns_rxstart;	/* receiver buffer start */
 	u_char  ns_rxend;	/* receiver buffer end */
 	u_char  hp_type;	/* HP board type */
 	u_char  hp_irq;		/* interrupt vector */
 	short   ns_port;	/* i/o port base */
 	short   ns_mode;	/* word/byte mode */
 	short   ns_rcr;
 #if NBPFILTER > 0
 	void *ns_bpf;
 #endif
 	u_int8_t ns_addrp[ETHER_ADDR_LEN]; /* hardware Ethernet address */
 #if NRND > 0
 	rndsource_element_t rnd_source;
 #endif
+}
         hp_softc[NHP];
 #define	ENBUFSIZE	(sizeof(struct ether_header) + ETHERMTU + 2 + ETHER_MIN_LEN)
 #define	PAT(n)	(0xa55a + 37*(n))
 u_short boarddata[16];
 #define hp_option (-8)
 #define hp_data (-4)
 #define HP_RUN (0x01)
 #define HP_DATA (0x10)
 hpprobe(struct isa_device *dvp)
+{
 	int     val, i, s, sum, pat;
 	struct hp_softc *ns = &hp_softc[0];
 	int hpc;
 #ifdef lint
 	hpintr(0);
 #endif
 	hpc = (ns->ns_port = dvp->id_iobase + 0x10);
 	s = splnet();
 	ns->hp_irq = ffs(dvp->id_irq) - 1;
 	/* Extract board address */
 	for (i = 0; i < 6; i++)
 		ns->ns_addrp[i] = inb(hpc - 0x10 + i);
 	ns->hp_type = inb(hpc - 0x10 + 7);
 	if (ns->ns_addrp[0] != 0x08 ||
 	    ns->ns_addrp[1] != 0x00 ||
 	    ns->ns_addrp[2] != 0x09) {
 		splx(s);
 		return 0;
+	}
 	/* Word Transfers, Burst Mode Select, Fifo at 8 bytes */
 	/* On this board, WTS means 32-bit transfers, which is still
 	 * experimental.  - mycroft, 18JAN93 */
 #ifdef HP_32BIT
 	ns->ns_mode = DSDC_WTS | DSDC_BMS | DSDC_FT1;
 #else
 	ns->ns_mode = DSDC_BMS | DSDC_FT1;
 #endif
 	ns->ns_txstart = 0 * 1024 / DS_PGSIZE;
 	ns->ns_rxend = 32 * 1024 / DS_PGSIZE;
 	ns->ns_rxstart = ns->ns_txstart + (PKTSZ / DS_PGSIZE);
 	outb(hpc + hp_option, HP_RUN);
 #if 0
 	outb(hpc + ds0_isr, 0xff);
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_STOP);
 	delay(1000);
 	/* Check cmd reg and fail if not right */
 	if ((i = inb(hpc + ds_cmd)) != (DSCM_NODMA | DSCM_PG0 | DSCM_STOP)) {
 		splx(s);
 		return (0);
+	}
 #endif
 	outb(hpc + hp_option, 0);
 	splx(s);
 	return (32);
+}
 /*
  * Fetch from onboard ROM/RAM
  */
-hpfetch(struct hp_softc *ns, void *up, ad, len)
+hpfetch(struct hp_softc *ns, void *up, int ad, int len)
+{
 	u_char  cmd;
 	int	hpc = ns->ns_port;
 	int     counter = 100000;
 	outb(hpc + hp_option, inb(hpc + hp_option) | HP_DATA);
 	cmd = inb(hpc + ds_cmd);
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	/* Setup remote DMA */
 	outb(hpc + ds0_isr, DSIS_RDC);
 	if (ns->ns_mode & DSDC_WTS)
 		len = (len + 3) & ~3;
 	else
 		len = (len + 1) & ~1;
 	outb(hpc + ds0_rbcr0, len);
 	outb(hpc + ds0_rbcr1, len >> 8);
 	outb(hpc + ds0_rsar0, ad);
 	outb(hpc + ds0_rsar1, ad >> 8);
 #ifdef HP_DEBUG
 	printf("hpfetch: len=%d ioaddr=0x%03x addr=0x%04x option=0x%02x %d-bit\n",
 	    len, hpc + hp_data, ad, inb(hpc + hp_option),
 	    ns->ns_mode & DSDC_WTS ? 32 : 16);
 	printf("hpfetch: cmd=0x%02x isr=0x%02x ",
 	    inb(hpc + ds_cmd), inb(hpc + ds0_isr));
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG2 | DSCM_START);
 	printf("imr=0x%02x rcr=0x%02x tcr=0x%02x dcr=0x%02x\n",
 	    inb(hpc + ds0_imr), inb(hpc + ds0_rcr), inb(hpc + ds0_tcr),
 	    inb(hpc + ds0_dcr));
 #endif
 	/* Execute & extract from card */
 	outb(hpc + ds_cmd, DSCM_RREAD | DSCM_PG0 | DSCM_START);
 #ifdef HP_32BIT
 	if (ns->ns_mode & DSDC_WTS)
 		len = (void *) insd(hpc + hp_data, up, len >> 2) - up;
 	else
 #endif
 		len = (void *) insw(hpc + hp_data, up, len >> 1) - up;
 #ifdef HP_DEBUG
 	printf("hpfetch: done len=%d\n", len);
 #endif
 	/* Wait till done, then shutdown feature */
 	while ((inb(hpc + ds0_isr) & DSIS_RDC) == 0 && counter-- > 0);
 	outb(hpc + ds0_isr, DSIS_RDC);
 	outb(hpc + ds_cmd, cmd);
 	outb(hpc + hp_option, inb(hpc + hp_option) & ~HP_DATA);
+}
 /*
  * Put to onboard RAM
  */
-hpput(struct hp_softc *ns, void *up, ad, len)
+hpput(struct hp_softc *ns, void *up, int ad, int len)
+{
 	u_char  cmd;
 	int	hpc = ns->ns_port;
 	int     counter = 100000;
 	outb(hpc + hp_option, inb(hpc + hp_option) | HP_DATA);
 	cmd = inb(hpc + ds_cmd);
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	/* Setup for remote DMA */
 	outb(hpc + ds0_isr, DSIS_RDC);
 	if (ns->ns_mode & DSDC_WTS)
 		len = (len + 3) & ~3;
 	else
 		len = (len + 1) & ~1;
 #ifdef HP_DEBUG
 	printf("hpput: len=%d ioaddr=0x%03x addr=0x%04x option=0x%02x %d-bit\n",
 	    len, hpc + hp_data, ad, inb(hpc + hp_option),
 	    ns->ns_mode & DSDC_WTS ? 32 : 16);
 	printf("hpput: cmd=0x%02x isr=0x%02x ",
 	    inb(hpc + ds_cmd), inb(hpc + ds0_isr));
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG2 | DSCM_START);
 	printf("imr=0x%02x rcr=0x%02x tcr=0x%02x dcr=0x%02x\n",
 	    inb(hpc + ds0_imr), inb(hpc + ds0_rcr), inb(hpc + ds0_tcr),
 	    inb(hpc + ds0_dcr));
+	{
 		unsigned char *p = (unsigned char *) up;
 		int     n = len;
 		printf("hpput:");
 		while (n--)
 			printf(" %02x", *(p++));
 		printf("\n");
+	}
 #endif
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	outb(hpc + ds0_rbcr0, 0xff);
 	outb(hpc + ds_cmd, DSCM_RREAD | DSCM_PG0 | DSCM_START);
 	outb(hpc + ds0_rbcr0, len);
 	outb(hpc + ds0_rbcr1, len >> 8);
 	outb(hpc + ds0_rsar0, ad);
 	outb(hpc + ds0_rsar1, ad >> 8);
 	/* Execute & stuff to card */
 	outb(hpc + ds_cmd, DSCM_RWRITE | DSCM_PG0 | DSCM_START);
 #ifdef HP_32BIT
 	if (ns->ns_mode & DSDC_WTS)
 		len = (void *) outsd(hpc + hp_data, up, len >> 2) - up;
 	else
 #endif
 		len = (void *) outsw(hpc + hp_data, up, len >> 1) - up;
 #ifdef HP_DEBUG
 	printf("hpput: done len=%d\n", len);
 #endif
 	/* Wait till done, then shutdown feature */
 	while ((inb(hpc + ds0_isr) & DSIS_RDC) == 0 && counter-- > 0);
 	outb(hpc + ds0_isr, DSIS_RDC);
 	outb(hpc + ds_cmd, cmd);
 	outb(hpc + hp_option, inb(hpc + hp_option) & ~HP_DATA);
+}
 /*
  * Reset of interface.
  */
 hpreset(int unit, int uban)
+{
 	struct hp_softc *ns = &hp_softc[unit];
 	int	hpc = ns->ns_port;
 	if (unit >= NHP)
 		return;
 	printf("hp%d: reset\n", unit);
 	outb(hpc + hp_option, 0);
 	ns->ns_flags &= ~DSF_LOCK;
 	hpinit(unit);
+}
 static char *
 hp_id(u_char type)
+{
 	static struct {
 		u_char  type;
 		char   *name;
 	} boards[] = {
+		{
 x00, "hp27240"
 		}, {
 x10, "hp24240"
 		}, {
 x01, "hp27245"
 		}, {
 x02, "hp27250"
 		}, {
 x81, "hp27247"
 		}, {
 x91, "hp27247r1"
+		}
 	};
 	int     n = sizeof(boards) / sizeof(boards[0]);
 	while (n)
 		if (boards[--n].type == type)
 			return boards[n].name;
 	return "UNKNOWN";
+}
 /*
  * Interface exists: make available by filling in network interface
  * record.  System will initialize the interface when it is ready
  * to accept packets.  We get the ethernet address here.
  */
 hpattach(struct isa_device *dvp)
+{
 	int     unit = dvp->id_unit;
 	struct hp_softc *ns = &hp_softc[unit];
 	struct ifnet *ifp = &ns->ns_if;
 	ifp->if_unit = unit;
 	ifp->if_name = hpdriver.name;
 	ifp->if_mtu = ETHERMTU;
 	printf("hp%d: %s %d-bit ethernet address %s\n", unit,
 	    hp_id(ns->hp_type), ns->ns_mode & DSDC_WTS ? 32 : 16,
 	    ether_sprintf(ns->ns_addrp));
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
 	ifp->if_output = ether_output;
 	ifp->if_start = hpstart;
 	ifp->if_ioctl = hpioctl;
 	ifp->if_reset = hpreset;
 	ifp->if_watchdog = 0;
 	IFQ_SET_READY(&ifp->if_snd);
 	if_attach(ifp);
 #if NBPFILTER > 0
 	bpfattach(&ns->ns_bpf, ifp, DLT_EN10MB,
 	    sizeof(struct ether_header));
 #endif
 #if NRND > 0
 	rnd_attach_source(&ns->rnd_source, device_xname(&ns->sc_dev),
 			  RND_TYPE_NET, 0);
 #endif
+}
 /*
  * Initialization of interface; set up initialization block
  * and transmit/receive descriptor rings.
  */
 hpinit(int unit)
+{
 	struct hp_softc *ns = &hp_softc[unit];
 	struct ifnet *ifp = &ns->ns_if;
 	int     s;
 	int     i;
 	char   *cp;
 	int hpc = ns->ns_port;
 	if (IFADDR_EMPTY(ifp))
 		return;
 	if (ifp->if_flags & IFF_RUNNING)
 		return;
 	s = splnet();
 #ifdef HP_DEBUG
 	printf("hpinit: hp%d at 0x%x irq %d\n", unit, hpc, (int) ns->hp_irq);
 	printf("hpinit: promiscuous mode %s\n",
 	    ns->ns_if.if_flags & IFF_PROMISC ? "on" : "off");
 #endif
 	ns->ns_rcr = (ns->ns_if.if_flags & IFF_BROADCAST ? DSRC_AB : 0) |
 	    (ns->ns_if.if_flags & IFF_PROMISC ? DSRC_PRO : 0);
 #ifdef HP_LOG_ERRORS
 	ns->ns_rcr |= DSRC_SEP;
 #endif
 	/* set irq and turn on board */
 	outb(hpc + hp_option, HP_RUN | (ns->hp_irq << 1));
 	/* init regs */
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_STOP);
 	outb(hpc + ds0_dcr, 0);
 	outb(hpc + ds0_rbcr0, 0);
 	outb(hpc + ds0_rbcr1, 0);
 	outb(hpc + ds0_rcr, DSRC_MON);
 	outb(hpc + ds0_tpsr, ns->ns_txstart);
 	outb(hpc + ds0_imr, 0);
 	outb(hpc + ds0_tcr, DSTC_LB0);
 	outb(hpc + ds0_pstart, ns->ns_rxstart);
 	outb(hpc + ds0_bnry, ns->ns_rxend - 1);
 	outb(hpc + ds0_pstop, ns->ns_rxend);
 	outb(hpc + ds0_isr, 0xff);
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG1 | DSCM_STOP);
 	outb(hpc + ds1_curr, ns->ns_rxstart);
 	/* set physical address on ethernet */
 	for (i = 0; i < 6; i++)
 		outb(hpc + ds1_par0 + i, ns->ns_addrp[i]);
 	/* clr logical address hash filter for now */
 	for (i = 0; i < 8; i++)
 		outb(hpc + ds1_mar0 + i, 0xff);
 	/* fire it up */
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	outb(hpc + ds0_dcr, ns->ns_mode);
 	outb(hpc + ds0_rcr, ns->ns_rcr);
 	outb(hpc + ds0_tcr, 0);
 	outb(hpc + ds0_imr, 0xff);
 	ns->ns_if.if_flags |= IFF_RUNNING;
 	ns->ns_flags &= ~DSF_LOCK;
 	ns->ns_oactive = 0;
 	ns->ns_mask = ~0;
 	hpstart(ifp);
 #ifdef HP_DEBUG
 	printf("hpinit: done\n", unit, hpc);
 #endif
 	splx(s);
+}
 /*
  * Setup output on interface.
  * Get another datagram to send off of the interface queue,
  * and map it to the interface before starting the output.
  * called only at splnet or interrupt level.
  */
 hpstart(struct ifnet *ifp)
+{
 	struct hp_softc *ns = &hp_softc[ifp->if_unit];
 	struct mbuf *m0, *m;
 	int     buffer;
 	int     len, i, total;
 	int	hpc = ns->ns_port;
 	/*
 	       * The DS8390 has only one transmit buffer, if it is busy we
 	       * must wait until the transmit interrupt completes.
 	       */
 	if (ns->ns_flags & DSF_LOCK)
 		return;
 	if (inb(hpc + ds_cmd) & DSCM_TRANS)
 		return;
 	if ((ns->ns_if.if_flags & IFF_RUNNING) == 0)
 		return;
 	IFQ_DEQUEUE(&ns->ns_if.if_snd, m);
 	if (m == 0)
 		return;
 	/*
 	       * Copy the mbuf chain into the transmit buffer
 	       */
 	ns->ns_flags |= DSF_LOCK;	/* prevent entering hpstart */
 	buffer = ns->ns_txstart * DS_PGSIZE;
 	i = 0;
 	total = len = m->m_pkthdr.len;
 #ifdef HP_DEBUG
 	printf("hpstart: len=%d\n", len);
 #endif
 #if NBPFILTER > 0
 	if (ns->ns_bpf)
 		bpf_mtap(ns->ns_bpf, m);
 #endif
 	for (m0 = m; m != 0;) {
 		if (m->m_len & 1 && t > m->m_len) {
 			m->m_len -= 1;
 			hpput(ns, mtod(m, void *), buffer, m->m_len);
 			t -= m->m_len;
 			buffer += m->m_len;
 			m->m_data += m->m_len;
 			m->m_len = 1;
 			m = m_pullup(m, 2);
 		} else {
 			hpput(ns, mtod(m, void *), buffer, m->m_len);
 			t -= m->m_len;
 			buffer += m->m_len;
 			MFREE(m, m0);
 			m = m0;
+		}
+	}
 	/*
 	       * Init transmit length registers, and set transmit start flag.
 	       */
 	len = total;
 	if (len < ETHER_MIN_LEN)
 		len = ETHER_MIN_LEN;
 #error broken here ! need to set to 0 the pad space in buffer !
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	outb(hpc + ds0_tbcr0, len & 0xff);
 	outb(hpc + ds0_tbcr1, (len >> 8) & 0xff);
 	outb(hpc + ds0_tpsr, ns->ns_txstart);
 	outb(hpc + ds_cmd, DSCM_TRANS | DSCM_NODMA | DSCM_PG0 | DSCM_START);
 #ifdef HP_DEBUG
 	printf("hpstart: done\n", hpc);
 #endif
+}
 /*
  * Controller interrupt.
  */
 hpintr(unit)
+{
 	struct hp_softc *ns = &hp_softc[unit];
 	u_char  cmd, isr;
 	int	hpc = ns->ns_port;
 	u_char  err;
 	/* Save cmd, clear interrupt */
 	cmd = inb(hpc + ds_cmd);
 loop:
 	isr = inb(hpc + ds0_isr);
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	outb(hpc + ds0_isr, isr);
 	/* Receiver error */
 	if (isr & DSIS_RXE) {
 		/* need to read these registers to clear status */
 		err = inb(hpc + ds0_rsr);
 		(void) inb(hpc + 0xD);
 		(void) inb(hpc + 0xE);
 		(void) inb(hpc + 0xF);
 		ns->ns_if.if_ierrors++;
 #ifdef HP_LOG_ERRORS
 		isr |= DSIS_RX;
 #endif
+	}
 	/* We received something */
 	if (isr & DSIS_RX) {
 		u_char  bnry;
 		u_char  curr;
 		u_short addr;
 		int     len;
 		int     i;
 		unsigned char c;
 		while (1) {
 			outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG0);
 			bnry = inb(hpc + ds0_bnry);
 			outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG1);
 			curr = inb(hpc + ds1_curr);
 #ifdef HP_DEBUG
 			printf("hpintr: receive isr=0x%02x bnry=0x%02x curr=0x%02x\n",
 			    isr, bnry, curr);
 #endif
 			if (++bnry >= ns->ns_rxend)
 				bnry = ns->ns_rxstart;
 			/* if ring empty, done! */
 			if (bnry == curr)
 				break;
 			addr = bnry * DS_PGSIZE;
 			outb(hpc + hp_option, inb(hpc + hp_option) | HP_DATA);
 #if 0
 			/* send packet with auto packet release */
 			outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG0);
 			outb(hpc + ds0_rbcr1, 0x0f);
 			outb(hpc + ds0_dcr, ns->ns_mode | DSDC_AR);
 			outb(hpc + ds_cmd, DSCM_SENDP | DSCM_PG0 | DSCM_START);
 #endif
 			/* get length */
 			hpfetch(ns, (void *) & ns->ns_ph, addr, sizeof ns->ns_ph);
 			addr += sizeof ns->ns_ph;
 #ifdef HP_DEBUG
 			printf("hpintr: sendp packet hdr: %x %x %x %x\n",
 			    ns->ns_ph.pr_status,
 			    ns->ns_ph.pr_nxtpg,
 			    ns->ns_ph.pr_sz0,
 			    ns->ns_ph.pr_sz1);
 #endif
 #ifdef HP_LOG_ERRORS
 			if (ns->ns_ph.pr_status & (DSRS_CRC | DSRS_FO | DSRS_DFR)) {
 				/* Get packet header */
 				if (len > 14)
 					len = 14;
 				hpfetch(ns, (void *) (ns->ns_pb), addr, len);
 				/* move boundary up */
 				bnry = ns->ns_ph.pr_nxtpg;
 				if (--bnry < ns->ns_rxstart)
 					bnry = ns->ns_rxend - 1;
 				outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG0);
 				outb(hpc + ds0_bnry, bnry);
 				printf("hp%d: receive error status=0x%02x\n", unit,
 				    ns->ns_ph.pr_status);
 				printf("hp%d: packet header:", unit);
+				{
 					int     n;
 					for (n = 0; n < len; n++)
 						printf(" %02x", ns->ns_pb[n]);
+				}
 				printf("\n");
 				continue;
+			}
 #endif
 			ns->ns_if.if_ipackets++;
 			len = ns->ns_ph.pr_sz0 + (ns->ns_ph.pr_sz1 << 8);
 			if (len < ETHER_MIN_LEN || len > ETHER_MAX_LEN) {
 				printf("hpintr: bnry %x curr %x\n", bnry, curr);
 				printf("hpintr: packet hdr: %x %x %x %x\n",
 				    ns->ns_ph.pr_status,
 				    ns->ns_ph.pr_nxtpg,
 				    ns->ns_ph.pr_sz0,
 				    ns->ns_ph.pr_sz1);
 				printf("isr = 0x%x reg_isr=0x%x\n",
 				    isr, inb(hpc + ds0_isr));
 				outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG0);
 				bnry = inb(hpc + ds0_bnry);
 				outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG1);
 				curr = inb(hpc + ds1_curr);
 				printf("hpintr: new bnry %x curr %x\n", bnry, curr);
 				printf("hpintr: bad len %d\n-hanging-\n",
 				    len);
 				while (1);
+			}
 			/* read packet */
 			hpfetch(ns, (void *) (ns->ns_pb), addr, len);
 			/* move boundary up */
 			bnry = ns->ns_ph.pr_nxtpg;
 			if (--bnry < ns->ns_rxstart)
 				bnry = ns->ns_rxend - 1;
 			outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA | DSCM_PG0);
 			outb(hpc + ds0_bnry, bnry);
 #ifdef HP_DEBUG
 			printf("hpintr: receive done bnry=0x%02x\n", bnry);
 #endif
 			outb(hpc + hp_option, inb(hpc + hp_option) & ~HP_DATA);
 			/* adjust for ether header and checksum */
 			len -= sizeof(struct ether_header) + sizeof(long);
 			/* process packet */
 			hpread(ns, (void *) (ns->ns_pb), len);
+		}
+	}
 	/* Transmit error */
 	if (isr & DSIS_TXE) {
 		ns->ns_flags &= ~DSF_LOCK;
 		/* Need to read these registers to clear status */
 		ns->ns_if.if_collisions += inb(hpc + ds0_tbcr0);
 		ns->ns_if.if_oerrors++;
+	}
 	/* Packet Transmitted */
 	if (isr & DSIS_TX) {
 		ns->ns_flags &= ~DSF_LOCK;
 		++ns->ns_if.if_opackets;
 		ns->ns_if.if_collisions += inb(hpc + ds0_tbcr0);
+	}
 	/* Receiver ovverun? */
 	if (isr & DSIS_ROVRN) {
 		log(LOG_ERR, "hp%d: error: isr %x\n", ns - hp_softc, isr
 		     /* , DSIS_BITS */ );
 		outb(hpc + ds0_rbcr0, 0);
 		outb(hpc + ds0_rbcr1, 0);
 		outb(hpc + ds0_tcr, DSTC_LB0);
 		outb(hpc + ds0_rcr, DSRC_MON);
 		outb(hpc + ds_cmd, DSCM_START | DSCM_NODMA);
 		outb(hpc + ds0_rcr, ns->ns_rcr);
 		outb(hpc + ds0_tcr, 0);
+	}
 	/* Any more to send? */
 	outb(hpc + ds_cmd, DSCM_NODMA | DSCM_PG0 | DSCM_START);
 	hpstart(&ns->ns_if);
 	outb(hpc + ds_cmd, cmd);
 	outb(hpc + ds0_imr, 0xff);
 #if NRND > 0
 	if (irs)
 		rnd_add_uint32(&sc->rnd_source, isr);
 #endif
 	/* Still more to do? */
 	isr = inb(hpc + ds0_isr);
 	if (isr)
 		goto loop;
+}
 /*
  * Pass a packet to the higher levels.
  * We deal with the trailer protocol here.
  */
 hpread(struct hp_softc *ns, char *buf, int len)
+{
 	struct ether_header *eh;
 	struct mbuf *m;
 	int     off, resid;
 	struct ifqueue *inq;
 	u_short etype;
 	/*
 	 * Deal with trailer protocol: if type is trailer type
 	 * get true type from first 16-bit word past data.
 	 * Remember that type was trailer by setting off.
 	 */
 	eh = (struct ether_header *) buf;
 	etype = ntohs((u_short) eh->ether_type);
 #define	hpdataaddr(eh, off, type)	((type)(((void *)((eh)+1)+(off))))
 	if (etype >= ETHERTYPE_TRAIL &&
 	    etype < ETHERTYPE_TRAIL + ETHERTYPE_NTRAILER) {
 		off = (etype - ETHERTYPE_TRAIL) * 512;
 		if (off >= ETHERMTU)
 			return;	/* sanity */
 		eh->ether_type = *hpdataaddr(eh, off, u_short *);
 		resid = ntohs(*(hpdataaddr(eh, off + 2, u_short *)));
 		if (off + resid > len)
 			return;	/* sanity */
 		len = off + resid;
 	} else
 		off = 0;
 	if (len == 0)
 		return;
 #if NBPFILTER > 0
 	if (ns->ns_bpf)
 		bpf_tap(ns->ns_bpf, buf, len + sizeof(struct ether_header));
 #endif
 	if ((ns->ns_if.if_flags & IFF_PROMISC)
 	    && memcmp(eh->ether_dhost, ns->ns_addrp,
 		sizeof(eh->ether_dhost)) != 0
 	    && memcmp(eh->ether_dhost, etherbroadcastaddr,
 		sizeof(eh->ether_dhost)) != 0)
 		return;
 	/*
 	       * Pull packet off interface.  Off is nonzero if packet
 	       * has trailing header; hpget will then force this header
 	       * information to be at the front, but we still have to drop
 	       * the type and length which are at the front of any trailer data.
 	       */
 	m = hpget(buf, len, off, &ns->ns_if);
 	if (m == 0)
 		return;
 	ether_input(&ns->ns_if, eh, m);
+}
 /*
  * Supporting routines
  */
 /*
  * Pull read data off a interface.
  * Len is length of data, with local net header stripped.
  * Off is non-zero if a trailer protocol was used, and
  * gives the offset of the trailer information.
  * We copy the trailer information and then all the normal
  * data into mbufs.  When full cluster sized units are present
  * we copy into clusters.
  */
 struct mbuf *
 hpget(void *buf, int totlen, int off0, struct ifnet *ifp)
+{
 	struct mbuf *top, **mp, *m, *p;
 	int     off = off0, len;
 	void *cp = buf;
 	char   *epkt;
 	buf += sizeof(struct ether_header);
 	cp = buf;
 	epkt = cp + totlen;
 	if (off) {
 		cp += off + 2 * sizeof(u_short);
 		totlen -= 2 * sizeof(u_short);
+	}
 	MGETHDR(m, M_DONTWAIT, MT_DATA);
 	if (m == 0)
 		return (0);
 	m->m_pkthdr.rcvif = ifp;
 	m->m_pkthdr.len = totlen;
 	m->m_len = MHLEN;
 	top = 0;
 	mp = &top;
 	while (totlen > 0) {
 		if (top) {
 			MGET(m, M_DONTWAIT, MT_DATA);
 			if (m == 0) {
 				m_freem(top);
 				return (0);
+			}
 			m->m_len = MLEN;
+		}
 		len = min(totlen, epkt - cp);
 		if (len >= MINCLSIZE) {
 			MCLGET(m, M_DONTWAIT);
 			if (m->m_flags & M_EXT)
 				m->m_len = len = min(len, MCLBYTES);
 			else
 				len = m->m_len;
 		} else {
 			/*
 				       * Place initial small packet/header at end of mbuf.
 				       */
 			if (len < m->m_len) {
 				if (top == 0 && len + max_linkhdr <= m->m_len)
 					m->m_data += max_linkhdr;
 				m->m_len = len;
 			} else
 				len = m->m_len;
+		}
 		memcpy(mtod(m, void *), cp, (unsigned) len);
 		cp += len;
 		*mp = m;
 		mp = &m->m_next;
 		totlen -= len;
 		if (cp == epkt)
 			cp = buf;
+	}
 	return (top);
+}
 /*
  * Process an ioctl request.
  */
 hpioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct ifaddr *ifa = (struct ifaddr *) data;
 	struct hp_softc *ns = &hp_softc[ifp->if_unit];
 	struct ifreq *ifr = (struct ifreq *) data;
 	int     s = splnet(), error = 0;
 	switch (cmd) {
 	case SIOCINITIFADDR:
 		ifp->if_flags |= IFF_UP;
 		hpinit(ifp->if_unit);
 		switch (ifa->ifa_addr->sa_family) {
 #ifdef INET
 		case AF_INET:
 			((struct arpcom *) ifp)->ac_ipaddr =
 			    IA_SIN(ifa)->sin_addr;
 			arpwhohas((struct arpcom *) ifp, &IA_SIN(ifa)->sin_addr);
 			break;
 #endif
 		default:
 			break;
+		}
 		break;
 	case SIOCSIFFLAGS:
 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
 			break;
 #ifdef HP_DEBUG
 		printf("hp: setting flags, up: %s, running: %s\n",
 		    ifp->if_flags & IFF_UP ? "yes" : "no",
 		    ifp->if_flags & IFF_RUNNING ? "yes" : "no");
 #endif
 		/* XXX re-use ether_ioctl() */
 		switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
 		case IFF_RUNNING:
 			ifp->if_flags &= ~IFF_RUNNING;
 			outb(ns->ns_port + ds_cmd, DSCM_STOP | DSCM_NODMA);
 			break;
 		case IFF_UP:
 			hpinit(ifp->if_unit);
 			break;
 		default:
 			break;
+		}
 		break;
 #ifdef notdef
 	case SIOCGHWADDR:
 		memcpy((void *) & ifr->ifr_data, (void *) ns->ns_addrp,
 		    sizeof(ns->ns_addrp));
 		break;
 #endif
 	default:
 		error = ether_ioctl(ifp, cmd, data);
+	}
 	splx(s);
 	return (error);
+}
 #endif