 @@ -1,2243 +1,2243 @@
-/*	$NetBSD: adb_direct.c,v 1.71 2024/02/28 13:05:39 thorpej Exp $	*/
+/*	$NetBSD: adb_direct.c,v 1.72 2024/03/05 20:58:05 andvar Exp $	*/
 /* From: adb_direct.c 2.02 4/18/97 jpw */
 /*
  * Copyright (C) 1996, 1997 John P. Wittkoski
  * 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 John P. Wittkoski.
  * 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.
  */
 /*
  * This code is rather messy, but I don't have time right now
  * to clean it up as much as I would like.
  * But it works, so I'm happy. :-) jpw
  */
 /*
  * TO DO:
  *  - We could reduce the time spent in the adb_intr_* routines
  *    by having them save the incoming and outgoing data directly
  *    in the adbInbound and adbOutbound queues, as it would reduce
  *    the number of times we need to copy the data around. It
  *    would also make the code more readable and easier to follow.
  *  - (Related to above) Use the header part of adbCommand to
  *    reduce the number of copies we have to do of the data.
  *  - (Related to above) Actually implement the adbOutbound queue.
  *    This is fairly easy once you switch all the intr routines
  *    over to using adbCommand structs directly.
  *  - There is a bug in the state machine of adb_intr_cuda
  *    code that causes hangs, especially on 030 machines, probably
  *    because of some timing issues. Because I have been unable to
  *    determine the exact cause of this bug, I used the timeout function
  *    to check for and recover from this condition. If anyone finds
  *    the actual cause of this bug, the calls to timeout and the
  *    adb_cuda_tickle routine can be removed.
  */
 #ifdef __NetBSD__
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: adb_direct.c,v 1.71 2024/02/28 13:05:39 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: adb_direct.c,v 1.72 2024/03/05 20:58:05 andvar Exp $");
 #include "opt_adb.h"
 #include <sys/param.h>
 #include <sys/pool.h>
 #include <sys/queue.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/cpu.h>
 #include <sys/intr.h>
 #include <machine/viareg.h>
 #include <machine/adbsys.h>			/* required for adbvar.h */
 #include <machine/iopreg.h>			/* required for IOP support */
 #include <m68k/vectors.h>
 #include <mac68k/mac68k/macrom.h>
 #include <mac68k/dev/adbvar.h>
 #define printf_intr printf
 #else /* !__NetBSD__, i.e. Mac OS */
 #include "via.h"				/* for macos based testing */
 /* #define ADB_DEBUG */				/* more verbose for testing */
 /* Types of ADB hardware that we support */
 #define ADB_HW_UNKNOWN		0x0	/* don't know */
 #define ADB_HW_II		0x1	/* Mac II series */
 #define ADB_HW_IISI		0x2	/* Mac IIsi series */
 #define ADB_HW_PB		0x3	/* PowerBook series */
 #define ADB_HW_CUDA		0x4	/* Machines with a Cuda chip */
 #endif /* __NetBSD__ */
 /* some misc. leftovers */
 #define vPB		0x0000
 #define vPB3		0x08
 #define vPB4		0x10
 #define vPB5		0x20
 #define vSR_INT		0x04
 #define vSR_OUT		0x10
 /* the type of ADB action that we are currently preforming */
 #define ADB_ACTION_NOTREADY	0x1	/* has not been initialized yet */
 #define ADB_ACTION_IDLE		0x2	/* the bus is currently idle */
 #define ADB_ACTION_OUT		0x3	/* sending out a command */
 #define ADB_ACTION_IN		0x4	/* receiving data */
 #define ADB_ACTION_POLLING	0x5	/* polling - II only */
 #define ADB_ACTION_RUNNING	0x6	/* running - IOP only */
 /*
  * These describe the state of the ADB bus itself, although they
  * don't necessarily correspond directly to ADB states.
  * Note: these are not really used in the IIsi code.
  */
 #define ADB_BUS_UNKNOWN		0x1	/* we don't know yet - all models */
 #define ADB_BUS_IDLE		0x2	/* bus is idle - all models */
 #define ADB_BUS_CMD		0x3	/* starting a command - II models */
 #define ADB_BUS_ODD		0x4	/* the "odd" state - II models */
 #define ADB_BUS_EVEN		0x5	/* the "even" state - II models */
 #define ADB_BUS_ACTIVE		0x6	/* active state - IIsi models */
 #define ADB_BUS_ACK		0x7	/* currently ACKing - IIsi models */
 /*
  * Shortcuts for setting or testing the VIA bit states.
  * Not all shortcuts are used for every type of ADB hardware.
  */
 #define ADB_SET_STATE_IDLE_II()		via_reg(VIA1, vBufB) |= (vPB4 | vPB5)
 #define ADB_SET_STATE_IDLE_IISI()	via_reg(VIA1, vBufB) &= ~(vPB4 | vPB5)
 #define ADB_SET_STATE_IDLE_CUDA()	via_reg(VIA1, vBufB) |= (vPB4 | vPB5)
 #define ADB_SET_STATE_CMD()		via_reg(VIA1, vBufB) &= ~(vPB4 | vPB5)
 #define ADB_SET_STATE_EVEN()		via_reg(VIA1, vBufB) = ((via_reg(VIA1, \
 						vBufB) | vPB4) & ~vPB5)
 #define ADB_SET_STATE_ODD()		via_reg(VIA1, vBufB) = ((via_reg(VIA1, \
 						vBufB) | vPB5) & ~vPB4)
 #define ADB_SET_STATE_ACTIVE() 		via_reg(VIA1, vBufB) |= vPB5
 #define ADB_SET_STATE_INACTIVE()	via_reg(VIA1, vBufB) &= ~vPB5
 #define ADB_SET_STATE_TIP()		via_reg(VIA1, vBufB) &= ~vPB5
 #define ADB_CLR_STATE_TIP() 		via_reg(VIA1, vBufB) |= vPB5
 #define ADB_SET_STATE_ACKON()		via_reg(VIA1, vBufB) |= vPB4
 #define ADB_SET_STATE_ACKOFF()		via_reg(VIA1, vBufB) &= ~vPB4
 #define ADB_TOGGLE_STATE_ACK_CUDA()	via_reg(VIA1, vBufB) ^= vPB4
 #define ADB_SET_STATE_ACKON_CUDA()	via_reg(VIA1, vBufB) &= ~vPB4
 #define ADB_SET_STATE_ACKOFF_CUDA()	via_reg(VIA1, vBufB) |= vPB4
 #define ADB_SET_SR_INPUT()		via_reg(VIA1, vACR) &= ~vSR_OUT
 #define ADB_SET_SR_OUTPUT()		via_reg(VIA1, vACR) |= vSR_OUT
 #define ADB_SR()			via_reg(VIA1, vSR)
 #define ADB_VIA_INTR_ENABLE()		via_reg(VIA1, vIER) = 0x84
 #define ADB_VIA_INTR_DISABLE()		via_reg(VIA1, vIER) = 0x04
 #define ADB_VIA_CLR_INTR()		via_reg(VIA1, vIFR) = 0x04
 #define ADB_INTR_IS_OFF			(vPB3 == (via_reg(VIA1, vBufB) & vPB3))
 #define ADB_INTR_IS_ON			(0 == (via_reg(VIA1, vBufB) & vPB3))
 #define ADB_SR_INTR_IS_OFF		(0 == (via_reg(VIA1, vIFR) & vSR_INT))
 #define ADB_SR_INTR_IS_ON		(vSR_INT == (via_reg(VIA1, \
 						vIFR) & vSR_INT))
 /*
  * This is the delay that is required (in uS) between certain
  * ADB transactions. The actual timing delay for each uS is
  * calculated at boot time to account for differences in machine speed.
  */
 #define ADB_DELAY	150
 /*
  * Maximum ADB message length; includes space for data, result, and
  * device code - plus a little for safety.
  */
 #define ADB_MAX_MSG_LENGTH	16
 #define ADB_MAX_HDR_LENGTH	8
 #define ADB_QUEUE		32
 #define ADB_TICKLE_TICKS	4
 /*
  * A structure for storing information about each ADB device.
  */
 struct ADBDevEntry {
 	void	(*ServiceRtPtr)(void);
 	void	*DataAreaAddr;
 	int	devType;
 	int	origAddr;
 	int	currentAddr;
 };
 /*
  * Used to hold ADB commands that are waiting to be sent out.
  */
 struct adbCmdHoldEntry {
 	u_char	outBuf[ADB_MAX_MSG_LENGTH];	/* our message */
 	u_char	*saveBuf;	/* buffer to know where to save result */
 	u_char	*compRout;	/* completion routine pointer */
 	u_char	*data;		/* completion routine data pointer */
 };
 /*
  * Eventually used for two separate queues, the queue between
  * the upper and lower halves, and the outgoing packet queue.
  * TO DO: adbCommand can replace all of adbCmdHoldEntry eventually
  */
 struct adbCommand {
 	u_char	header[ADB_MAX_HDR_LENGTH];	/* not used yet */
 	u_char	data[ADB_MAX_MSG_LENGTH];	/* packet data only */
 	u_char	*saveBuf;	/* where to save result */
 	u_char	*compRout;	/* completion routine pointer */
 	u_char	*compData;	/* completion routine data pointer */
 	u_int	cmd;		/* the original command for this data */
 	u_int	unsol;		/* 1 if packet was unsolicited */
 	u_int	ack_only;	/* 1 for no special processing */
 };
 /*
  * Text representations of each hardware class
  */
 const char	*adbHardwareDescr[MAX_ADB_HW + 1] = {
 	"unknown",
 	"II series",
 	"IIsi series",
 	"PowerBook",
 	"Cuda",
 	"IOP",
 };
 /*
  * A few variables that we need and their initial values.
  */
 int	adbHardware = ADB_HW_UNKNOWN;
 int	adbActionState = ADB_ACTION_NOTREADY;
 int	adbBusState = ADB_BUS_UNKNOWN;
 int	adbWaiting = 0;		/* waiting for return data from the device */
 int	adbWriteDelay = 0;	/* working on (or waiting to do) a write */
 int	adbOutQueueHasData = 0;	/* something in the queue waiting to go out */
 int	adbNextEnd = 0;		/* the next incoming bute is the last (II) */
 int	adbSoftPower = 0;	/* machine supports soft power */
 int	adbWaitingCmd = 0;	/* ADB command we are waiting for */
 u_char	*adbBuffer = (long)0;	/* pointer to user data area */
 void	*adbCompRout = (long)0;	/* pointer to the completion routine */
 void	*adbCompData = (long)0;	/* pointer to the completion routine data */
 long	adbFakeInts = 0;	/* keeps track of fake ADB interrupts for
 				 * timeouts (II) */
 int	adbStarting = 1;	/* doing ADBReInit so do polling differently */
 int	adbSendTalk = 0;	/* the intr routine is sending the talk, not
 				 * the user (II) */
 int	adbPolling = 0;		/* we are polling for service request */
 int	adbPollCmd = 0;		/* the last poll command we sent */
 u_char	adbInputBuffer[ADB_MAX_MSG_LENGTH];	/* data input buffer */
 u_char	adbOutputBuffer[ADB_MAX_MSG_LENGTH];	/* data output buffer */
 struct	adbCmdHoldEntry adbOutQueue;		/* our 1 entry output queue */
 int	adbSentChars = 0;	/* how many characters we have sent */
 int	adbLastDevice = 0;	/* last ADB dev we heard from (II ONLY) */
 int	adbLastDevIndex = 0;	/* last ADB dev loc in dev table (II ONLY) */
 int	adbLastCommand = 0;	/* the last ADB command we sent (II) */
 struct	ADBDevEntry ADBDevTable[16];	/* our ADB device table */
 int	ADBNumDevices;		/* num. of ADB devices found with ADBReInit */
 struct	adbCommand adbInbound[ADB_QUEUE];	/* incoming queue */
 volatile int	adbInCount = 0;		/* how many packets in in queue */
 int	adbInHead = 0;			/* head of in queue */
 int	adbInTail = 0;			/* tail of in queue */
 struct	adbCommand adbOutbound[ADB_QUEUE]; /* outgoing queue - not used yet */
 int	adbOutCount = 0;		/* how many packets in out queue */
 int	adbOutHead = 0;			/* head of out queue */
 int	adbOutTail = 0;			/* tail of out queue */
 int	tickle_count = 0;		/* how many tickles seen for this packet? */
 int	tickle_serial = 0;		/* the last packet tickled */
 int	adb_cuda_serial = 0;		/* the current packet */
 callout_t adb_cuda_tickle_ch;
 void *adb_softintr_cookie;
 extern struct mac68k_machine_S mac68k_machine;
 void	pm_setup_adb(void);
 void	pm_hw_setup(void);
 void	pm_check_adb_devices(int);
 void	pm_intr(void *);
 int	pm_adb_op(u_char *, void *, void *, int);
 void	pm_init_adb_device(void);
 /*
  * The following are private routines.
  */
 #ifdef ADB_DEBUG
 void	print_single(u_char *);
 #endif
 void	adb_intr(void *);
 void	adb_intr_II(void *);
 void	adb_intr_IIsi(void *);
 void	adb_intr_cuda(void *);
 void	adb_soft_intr(void);
 int	send_adb_II(u_char *, u_char *, void *, void *, int);
 int	send_adb_IIsi(u_char *, u_char *, void *, void *, int);
 int	send_adb_cuda(u_char *, u_char *, void *, void *, int);
 void	adb_intr_cuda_test(void);
 void	adb_cuda_tickle(void);
 void	adb_pass_up(struct adbCommand *);
 void	adb_op_comprout(void);
 void	adb_reinit(void);
 int	count_adbs(void);
 int	get_ind_adb_info(ADBDataBlock *, int);
 int	get_adb_info(ADBDataBlock *, int);
 int	set_adb_info(ADBSetInfoBlock *, int);
 void	adb_setup_hw_type(void);
 int	adb_op(Ptr, Ptr, Ptr, short);
 void	adb_read_II(u_char *);
 void	adb_hw_setup(void);
 void	adb_hw_setup_IIsi(u_char *);
 void	adb_comp_exec(void);
 int	adb_cmd_result(u_char *);
 int	adb_cmd_extra(u_char *);
 int	adb_guess_next_device(void);
 int	adb_prog_switch_enable(void);
 int	adb_prog_switch_disable(void);
 /* we should create this and it will be the public version */
 int	send_adb(u_char *, void *, void *);
 void	adb_iop_recv(IOP *, struct iop_msg *);
 int	send_adb_iop(int, u_char *, void *, void *);
 #ifdef ADB_DEBUG
 /*
  * print_single
  * Diagnostic display routine. Displays the hex values of the
  * specified elements of the u_char. The length of the "string"
  * is in [0].
  */
 void
 print_single(u_char *str)
+{
 	int x;
 	if (str == 0) {
 		printf_intr("no data - null pointer\n");
 		return;
+	}
 	if (*str == 0) {
 		printf_intr("nothing returned\n");
 		return;
+	}
 	if (*str > 20) {
 		printf_intr("ADB: ACK > 20 no way!\n");
 		*str = (u_char)20;
+	}
 	printf_intr("(length=0x%x):", (u_int)*str);
 	for (x = 1; x <= *str; x++)
 		printf_intr("  0x%02x", (u_int)*(str + x));
 	printf_intr("\n");
+}
 #endif
 static inline void
 adb_process_serial_intrs(void)
+{
 	/* grab any serial interrupts (autovector IPL 4) */
 	struct clockframe dummy_frame = {
 		.cf_sr = PSL_S,
 		.cf_vo = VECI_TO_VECO(VECI_INTRAV4),
 	};
 	(void)intr_dispatch(dummy_frame);
+}
 void
 adb_cuda_tickle(void)
+{
 	volatile int s;
 	if (adbActionState == ADB_ACTION_IN) {
 		if (tickle_serial == adb_cuda_serial) {
 			if (++tickle_count > 0) {
 				s = splhigh();
 				adbActionState = ADB_ACTION_IDLE;
 				adbInputBuffer[0] = 0;
 				ADB_SET_STATE_IDLE_CUDA();
 				splx(s);
+			}
 		} else {
 			tickle_serial = adb_cuda_serial;
 			tickle_count = 0;
+		}
 	} else {
 		tickle_serial = adb_cuda_serial;
 		tickle_count = 0;
+	}
 	callout_reset(&adb_cuda_tickle_ch, ADB_TICKLE_TICKS,
 	    (void *)adb_cuda_tickle, NULL);
+}
 /*
- * called when when an adb interrupt happens
+ * called when an adb interrupt happens
+ *
  * Cuda version of adb_intr
  * TO DO: do we want to add some calls to intr_dispatch() here to
  * grab serial interrupts?
  */
 void
 adb_intr_cuda(void *arg)
+{
 	volatile int i __unused, ending;
 	volatile unsigned int s;
 	struct adbCommand packet;
 	s = splhigh();		/* can't be too careful - might be called */
 	/* from a routine, NOT an interrupt */
 	ADB_VIA_CLR_INTR();	/* clear interrupt */
 	ADB_VIA_INTR_DISABLE();	/* disable ADB interrupt on IIs. */
 switch_start:
 	switch (adbActionState) {
 	case ADB_ACTION_IDLE:
 		/*
 		 * This is an unexpected packet, so grab the first (dummy)
 		 * byte, set up the proper vars, and tell the chip we are
 		 * starting to receive the packet by setting the TIP bit.
 		 */
 		adbInputBuffer[1] = ADB_SR();
 		adb_cuda_serial++;
 		if (ADB_INTR_IS_OFF)	/* must have been a fake start */
 			break;
 		ADB_SET_SR_INPUT();
 		ADB_SET_STATE_TIP();
 		adbInputBuffer[0] = 1;
 		adbActionState = ADB_ACTION_IN;
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("idle 0x%02x ", adbInputBuffer[1]);
 #endif
 		break;
 	case ADB_ACTION_IN:
 		adbInputBuffer[++adbInputBuffer[0]] = ADB_SR();
 		/* intr off means this is the last byte (end of frame) */
 		if (ADB_INTR_IS_OFF)
 			ending = 1;
 		else
 			ending = 0;
 		if (1 == ending) {	/* end of message? */
 #ifdef ADB_DEBUG
 			if (adb_debug) {
 				printf_intr("in end 0x%02x ",
 				    adbInputBuffer[adbInputBuffer[0]]);
 				print_single(adbInputBuffer);
+			}
 #endif
 			/*
 			 * Are we waiting AND does this packet match what we
 			 * are waiting for AND is it coming from either the
 			 * ADB or RTC/PRAM sub-device? This section _should_
 			 * recognize all ADB and RTC/PRAM type commands, but
 			 * there may be more... NOTE: commands are always at
 			 * [4], even for RTC/PRAM commands.
 			 */
 			/* set up data for adb_pass_up */
 			memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
 			if ((adbWaiting == 1) &&
 			    (adbInputBuffer[4] == adbWaitingCmd) &&
 			    ((adbInputBuffer[2] == 0x00) ||
 			    (adbInputBuffer[2] == 0x01))) {
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.unsol = 0;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
 				adbWaitingCmd = 0;	/* reset "waiting" vars */
 				adbWaiting = 0;
 				adbBuffer = (long)0;
 				adbCompRout = (long)0;
 				adbCompData = (long)0;
 			} else {
 				packet.unsol = 1;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
+			}
 			/* reset vars and signal the end of this frame */
 			adbActionState = ADB_ACTION_IDLE;
 			adbInputBuffer[0] = 0;
 			ADB_SET_STATE_IDLE_CUDA();
 			/*ADB_SET_SR_INPUT();*/
 			/*
 			 * If there is something waiting to be sent out,
 			 * the set everything up and send the first byte.
 			 */
 			if (adbWriteDelay == 1) {
 				delay(ADB_DELAY);	/* required */
 				adbSentChars = 0;
 				adbActionState = ADB_ACTION_OUT;
 				/*
 				 * If the interrupt is on, we were too slow
 				 * and the chip has already started to send
 				 * something to us, so back out of the write
 				 * and start a read cycle.
 				 */
 				if (ADB_INTR_IS_ON) {
 					ADB_SET_SR_INPUT();
 					ADB_SET_STATE_IDLE_CUDA();
 					adbSentChars = 0;
 					adbActionState = ADB_ACTION_IDLE;
 					adbInputBuffer[0] = 0;
 					break;
+				}
 				/*
 				 * If we got here, it's ok to start sending
 				 * so load the first byte and tell the chip
 				 * we want to send.
 				 */
 				ADB_SET_STATE_TIP();
 				ADB_SET_SR_OUTPUT();
 				ADB_SR() = adbOutputBuffer[adbSentChars + 1];
+			}
 		} else {
 			ADB_TOGGLE_STATE_ACK_CUDA();
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("in 0x%02x ",
 				    adbInputBuffer[adbInputBuffer[0]]);
 #endif
+		}
 		break;
 	case ADB_ACTION_OUT:
 		i = ADB_SR();	/* reset SR-intr in IFR */
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("intr out 0x%02x ", i);
 #endif
 		adbSentChars++;
 		if (ADB_INTR_IS_ON) {	/* ADB intr low during write */
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("intr was on ");
 #endif
 			ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 			ADB_SET_STATE_IDLE_CUDA();
 			adbSentChars = 0;	/* must start all over */
 			adbActionState = ADB_ACTION_IDLE;	/* new state */
 			adbInputBuffer[0] = 0;
 			adbWriteDelay = 1;	/* must retry when done with
 						 * read */
 			delay(ADB_DELAY);
 			goto switch_start;	/* process next state right
 						 * now */
 			break;
+		}
 		if (adbOutputBuffer[0] == adbSentChars) {	/* check for done */
 			if (0 == adb_cmd_result(adbOutputBuffer)) {	/* do we expect data
 									 * back? */
 				adbWaiting = 1;	/* signal waiting for return */
 				adbWaitingCmd = adbOutputBuffer[2];	/* save waiting command */
 			} else {	/* no talk, so done */
 				/* set up stuff for adb_pass_up */
 				memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.cmd = adbWaitingCmd;
 				packet.unsol = 0;
 				packet.ack_only = 1;
 				adb_pass_up(&packet);
 				/* reset "waiting" vars, just in case */
 				adbWaitingCmd = 0;
 				adbBuffer = (long)0;
 				adbCompRout = (long)0;
 				adbCompData = (long)0;
+			}
 			adbWriteDelay = 0;	/* done writing */
 			adbActionState = ADB_ACTION_IDLE;	/* signal bus is idle */
 			ADB_SET_SR_INPUT();
 			ADB_SET_STATE_IDLE_CUDA();
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("write done ");
 #endif
 		} else {
 			ADB_SR() = adbOutputBuffer[adbSentChars + 1];	/* send next byte */
 			ADB_TOGGLE_STATE_ACK_CUDA();	/* signal byte ready to
 							 * shift */
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("toggle ");
 #endif
+		}
 		break;
 	case ADB_ACTION_NOTREADY:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("adb: not yet initialized\n");
 #endif
 		break;
 	default:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("intr: unknown ADB state\n");
 #endif
 		break;
+	}
 	ADB_VIA_INTR_ENABLE();	/* enable ADB interrupt on IIs. */
 	splx(s);		/* restore */
 	return;
 }				/* end adb_intr_cuda */
 int
 send_adb_cuda(u_char *in, u_char *buffer, void *compRout, void *data, int
 	command)
+{
 	int s, len;
 #ifdef ADB_DEBUG
 	if (adb_debug)
 		printf_intr("SEND\n");
 #endif
 	if (adbActionState == ADB_ACTION_NOTREADY)
 		return 1;
 	/* Don't interrupt while we are messing with the ADB */
 	s = splhigh();
 	if ((adbActionState == ADB_ACTION_IDLE) &&	/* ADB available? */
 	    (ADB_INTR_IS_OFF)) {	/* and no incoming interrupt? */
 	} else
 		if (adbWriteDelay == 0)	/* it's busy, but is anything waiting? */
 			adbWriteDelay = 1;	/* if no, then we'll "queue"
 						 * it up */
 		else {
 			splx(s);
 			return 1;	/* really busy! */
+		}
 #ifdef ADB_DEBUG
 	if (adb_debug)
 		printf_intr("QUEUE\n");
 #endif
 	if ((long)in == (long)0) {	/* need to convert? */
 		/*
 		 * Don't need to use adb_cmd_extra here because this section
 		 * will be called ONLY when it is an ADB command (no RTC or
 		 * PRAM)
 		 */
 		if ((command & 0x0c) == 0x08)	/* copy addl data ONLY if
 						 * doing a listen! */
 			len = buffer[0];	/* length of additional data */
 		else
 			len = 0;/* no additional data */
 		adbOutputBuffer[0] = 2 + len;	/* dev. type + command + addl.
 						 * data */
 		adbOutputBuffer[1] = 0x00;	/* mark as an ADB command */
 		adbOutputBuffer[2] = (u_char)command;	/* load command */
 		/* copy additional output data, if any */
 		memcpy(adbOutputBuffer + 3, buffer + 1, len);
 	} else
 		/* if data ready, just copy over */
 		memcpy(adbOutputBuffer, in, in[0] + 2);
 	adbSentChars = 0;	/* nothing sent yet */
 	adbBuffer = buffer;	/* save buffer to know where to save result */
 	adbCompRout = compRout;	/* save completion routine pointer */
 	adbCompData = data;	/* save completion routine data pointer */
 	adbWaitingCmd = adbOutputBuffer[2];	/* save wait command */
 	if (adbWriteDelay != 1) {	/* start command now? */
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("out start NOW");
 #endif
 		delay(ADB_DELAY);
 		adbActionState = ADB_ACTION_OUT;	/* set next state */
 		ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 		ADB_SR() = adbOutputBuffer[adbSentChars + 1];	/* load byte for output */
 		ADB_SET_STATE_ACKOFF_CUDA();
 		ADB_SET_STATE_TIP();	/* tell ADB that we want to send */
+	}
 	adbWriteDelay = 1;	/* something in the write "queue" */
 	splx(s);
 	if (0x0100 <= (s & 0x0700))	/* were VIA1 interrupts blocked? */
 		/* poll until byte done */
 		while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
 		    || (adbWaiting == 1))
 			if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
 				adb_intr_cuda(NULL); /* go process it */
 				if (adb_polling)
 					adb_soft_intr();
+			}
 	return 0;
 }				/* send_adb_cuda */
 void
 adb_intr_II(void *arg)
+{
 	struct adbCommand packet;
 	int i, intr_on = 0;
 	int send = 0;
 	unsigned int s;
 	s = splhigh();		/* can't be too careful - might be called */
 	/* from a routine, NOT an interrupt */
 	ADB_VIA_CLR_INTR();	/* clear interrupt */
 	ADB_VIA_INTR_DISABLE();	/* disable ADB interrupt on IIs. */
 	delay(ADB_DELAY);	/* yuck (don't remove) */
 	adb_process_serial_intrs();
 	if (ADB_INTR_IS_ON)
 		intr_on = 1;	/* save for later */
 switch_start:
 	switch (adbActionState) {
 	case ADB_ACTION_POLLING:
 		if (!intr_on) {
 			if (adbOutQueueHasData) {
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("POLL-doing-out-queue. ");
 #endif
 				ADB_SET_STATE_IDLE_II();
 				delay(ADB_DELAY);
 				/* copy over data */
 				memcpy(adbOutputBuffer, adbOutQueue.outBuf,
 				    adbOutQueue.outBuf[0] + 2);
 				adbBuffer = adbOutQueue.saveBuf;	/* user data area */
 				adbCompRout = adbOutQueue.compRout;	/* completion routine */
 				adbCompData = adbOutQueue.data;	/* comp. rout. data */
 				adbOutQueueHasData = 0;	/* currently processing
 							 * "queue" entry */
 				adbSentChars = 0;	/* nothing sent yet */
 				adbActionState = ADB_ACTION_OUT;	/* set next state */
 				ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 				ADB_SR() = adbOutputBuffer[1];	/* load byte for output */
 				adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 				ADB_SET_STATE_CMD();	/* tell ADB that we want to send */
 				break;
 			} else {
 #ifdef ADB_DEBUG
 				if (adb_debug)
 					printf_intr("pIDLE ");
 #endif
 				adbActionState = ADB_ACTION_IDLE;
+			}
 		} else {
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80)
 				printf_intr("pIN ");
 #endif
 			adbActionState = ADB_ACTION_IN;
+		}
 		delay(ADB_DELAY);
 		adb_process_serial_intrs();
 		goto switch_start;
 		break;
 	case ADB_ACTION_IDLE:
 		if (!intr_on) {
 			i = ADB_SR();
 			adbBusState = ADB_BUS_IDLE;
 			adbActionState = ADB_ACTION_IDLE;
 			ADB_SET_STATE_IDLE_II();
 			break;
+		}
 		adbInputBuffer[0] = 1;
 		adbInputBuffer[1] = ADB_SR();	/* get first byte */
 #ifdef ADB_DEBUG
 		if (adb_debug & 0x80)
 			printf_intr("idle 0x%02x ", adbInputBuffer[1]);
 #endif
 		ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 		adbActionState = ADB_ACTION_IN;	/* set next state */
 		ADB_SET_STATE_EVEN();	/* set bus state to even */
 		adbBusState = ADB_BUS_EVEN;
 		break;
 	case ADB_ACTION_IN:
 		adbInputBuffer[++adbInputBuffer[0]] = ADB_SR();	/* get byte */
 #ifdef ADB_DEBUG
 		if (adb_debug & 0x80)
 			printf_intr("in 0x%02x ",
 			    adbInputBuffer[adbInputBuffer[0]]);
 #endif
 		ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 		if (intr_on) {	/* process last byte of packet */
 			adbInputBuffer[0]--;	/* minus one */
 			/*
 			 * If intr_on was true, and it's the second byte, then
 			 * the byte we just discarded is really valid, so
 			 * adjust the count
 			 */
 			if (adbInputBuffer[0] == 2) {
 				adbInputBuffer[0]++;
+			}
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80) {
 				printf_intr("done: ");
 				print_single(adbInputBuffer);
+			}
 #endif
 			adbLastDevice = ADB_CMDADDR(adbInputBuffer[1]);
 			if (adbInputBuffer[0] == 1 && !adbWaiting) {	/* SRQ!!!*/
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr(" xSRQ! ");
 #endif
 				adb_guess_next_device();
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("try 0x%0x ",
 					    adbLastDevice);
 #endif
 				adbOutputBuffer[0] = 1;
 				adbOutputBuffer[1] = ADBTALK(adbLastDevice, 0);
 				adbSentChars = 0;	/* nothing sent yet */
 				adbActionState = ADB_ACTION_POLLING;	/* set next state */
 				ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 				ADB_SR() = adbOutputBuffer[1];	/* load byte for output */
 				adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 				ADB_SET_STATE_CMD();	/* tell ADB that we want to */
 				break;
+			}
 			/* set up data for adb_pass_up */
 			memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
 			if (!adbWaiting && (adbInputBuffer[0] != 0)) {
 				packet.unsol = 1;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
 			} else {
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.unsol = 0;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
+			}
 			adbWaiting = 0;
 			adbInputBuffer[0] = 0;
 			adbBuffer = (long)0;
 			adbCompRout = (long)0;
 			adbCompData = (long)0;
 			/*
 			 * Since we are done, check whether there is any data
 			 * waiting to do out. If so, start the sending the data.
 			 */
 			if (adbOutQueueHasData == 1) {
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("XXX: DOING OUT QUEUE\n");
 #endif
 				/* copy over data */
 				memcpy(adbOutputBuffer, adbOutQueue.outBuf,
 				    adbOutQueue.outBuf[0] + 2);
 				adbBuffer = adbOutQueue.saveBuf;	/* user data area */
 				adbCompRout = adbOutQueue.compRout;	/* completion routine */
 				adbCompData = adbOutQueue.data;	/* comp. rout. data */
 				adbOutQueueHasData = 0;	/* currently processing
 							 * "queue" entry */
 				send = 1;
 			} else {
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("XXending ");
 #endif
 				adb_guess_next_device();
 				adbOutputBuffer[0] = 1;
 				adbOutputBuffer[1] = ((adbLastDevice & 0x0f) << 4) | 0x0c;
 				adbSentChars = 0;	/* nothing sent yet */
 				adbActionState = ADB_ACTION_POLLING;	/* set next state */
 				ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 				ADB_SR() = adbOutputBuffer[1];	/* load byte for output */
 				adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 				ADB_SET_STATE_CMD();	/* tell ADB that we want to */
 				break;
+			}
+		}
 		/*
 		 * If send is true then something above determined that
 		 * the message has ended and we need to start sending out
 		 * a new message immediately. This could be because there
 		 * is data waiting to go out or because an SRQ was seen.
 		 */
 		if (send) {
 			adbSentChars = 0;	/* nothing sent yet */
 			adbActionState = ADB_ACTION_OUT;	/* set next state */
 			ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 			ADB_SR() = adbOutputBuffer[1];	/* load byte for output */
 			adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 			ADB_SET_STATE_CMD();	/* tell ADB that we want to
 						 * send */
 			break;
+		}
 		/* We only get this far if the message hasn't ended yet. */
 		switch (adbBusState) {	/* set to next state */
 		case ADB_BUS_EVEN:
 			ADB_SET_STATE_ODD();	/* set state to odd */
 			adbBusState = ADB_BUS_ODD;
 			break;
 		case ADB_BUS_ODD:
 			ADB_SET_STATE_EVEN();	/* set state to even */
 			adbBusState = ADB_BUS_EVEN;
 			break;
 		default:
 			printf_intr("strange state!!!\n");	/* huh? */
 			break;
+		}
 		break;
 	case ADB_ACTION_OUT:
 		i = ADB_SR();	/* clear interrupt */
 		adbSentChars++;
 		/*
 		 * If the outgoing data was a TALK, we must
 		 * switch to input mode to get the result.
 		 */
 		if ((adbOutputBuffer[1] & 0x0c) == 0x0c) {
 			adbInputBuffer[0] = 1;
 			adbInputBuffer[1] = i;
 			adbActionState = ADB_ACTION_IN;
 			ADB_SET_SR_INPUT();
 			adbBusState = ADB_BUS_EVEN;
 			ADB_SET_STATE_EVEN();
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80)
 				printf_intr("talk out 0x%02x ", i);
 #endif
 			/* we want something back */
 			adbWaiting = 1;
 			break;
+		}
 		/*
 		 * If it's not a TALK, check whether all data has been sent.
 		 * If so, call the completion routine and clean up. If not,
 		 * advance to the next state.
 		 */
 #ifdef ADB_DEBUG
 		if (adb_debug & 0x80)
 			printf_intr("non-talk out 0x%0x ", i);
 #endif
 		ADB_SET_SR_OUTPUT();
 		if (adbOutputBuffer[0] == adbSentChars) {	/* check for done */
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80)
 				printf_intr("done \n");
 #endif
 			/* set up stuff for adb_pass_up */
 			memcpy(packet.data, adbOutputBuffer, adbOutputBuffer[0] + 1);
 			packet.saveBuf = adbBuffer;
 			packet.compRout = adbCompRout;
 			packet.compData = adbCompData;
 			packet.cmd = adbWaitingCmd;
 			packet.unsol = 0;
 			packet.ack_only = 1;
 			adb_pass_up(&packet);
 			/* reset "waiting" vars, just in case */
 			adbBuffer = (long)0;
 			adbCompRout = (long)0;
 			adbCompData = (long)0;
 			if (adbOutQueueHasData == 1) {
 				/* copy over data */
 				memcpy(adbOutputBuffer, adbOutQueue.outBuf,
 				    adbOutQueue.outBuf[0] + 2);
 				adbBuffer = adbOutQueue.saveBuf;	/* user data area */
 				adbCompRout = adbOutQueue.compRout;	/* completion routine */
 				adbCompData = adbOutQueue.data;	/* comp. rout. data */
 				adbOutQueueHasData = 0;	/* currently processing
 							 * "queue" entry */
 				adbSentChars = 0;	/* nothing sent yet */
 				adbActionState = ADB_ACTION_OUT;	/* set next state */
 				ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 				ADB_SR() = adbOutputBuffer[1];	/* load byte for output */
 				adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 				ADB_SET_STATE_CMD();	/* tell ADB that we want to
 							 * send */
 				break;
 			} else {
 				/* send talk to last device instead */
 				adbOutputBuffer[0] = 1;
 				adbOutputBuffer[1] =
 				    ADBTALK(ADB_CMDADDR(adbOutputBuffer[1]), 0);
 				adbSentChars = 0;	/* nothing sent yet */
 				adbActionState = ADB_ACTION_IDLE;	/* set next state */
 				ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 				ADB_SR() = adbOutputBuffer[1];	/* load byte for output */
 				adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 				ADB_SET_STATE_CMD();	/* tell ADB that we want to */
 				break;
+			}
+		}
 		ADB_SR() = adbOutputBuffer[adbSentChars + 1];
 		switch (adbBusState) {	/* advance to next state */
 		case ADB_BUS_EVEN:
 			ADB_SET_STATE_ODD();	/* set state to odd */
 			adbBusState = ADB_BUS_ODD;
 			break;
 		case ADB_BUS_CMD:
 		case ADB_BUS_ODD:
 			ADB_SET_STATE_EVEN();	/* set state to even */
 			adbBusState = ADB_BUS_EVEN;
 			break;
 		default:
 #ifdef ADB_DEBUG
 			if (adb_debug) {
 				printf_intr("strange state!!! (0x%x)\n",
 				    adbBusState);
+			}
 #endif
 			break;
+		}
 		break;
 	default:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("adb: unknown ADB state (during intr)\n");
 #endif
 		break;
+	}
 	ADB_VIA_INTR_ENABLE();	/* enable ADB interrupt on IIs. */
 	splx(s);		/* restore */
 	return;
+}
 /*
  * send_adb version for II series machines
  */
 int
 send_adb_II(u_char *in, u_char *buffer, void *compRout, void *data, int command)
+{
 	int s, len;
 	if (adbActionState == ADB_ACTION_NOTREADY)	/* return if ADB not
 							 * available */
 		return 1;
 	/* Don't interrupt while we are messing with the ADB */
 	s = splhigh();
 	if (0 != adbOutQueueHasData) {	/* right now, "has data" means "full" */
 		splx(s);	/* sorry, try again later */
 		return 1;
+	}
 	if ((long)in == (long)0) {	/* need to convert? */
 		/*
 		 * Don't need to use adb_cmd_extra here because this section
 		 * will be called ONLY when it is an ADB command (no RTC or
 		 * PRAM), especially on II series!
 		 */
 		if ((command & 0x0c) == 0x08)	/* copy addl data ONLY if
 						 * doing a listen! */
 			len = buffer[0];	/* length of additional data */
 		else
 			len = 0;/* no additional data */
 		adbOutQueue.outBuf[0] = 1 + len;	/* command + addl. data */
 		adbOutQueue.outBuf[1] = (u_char)command;	/* load command */
 		/* copy additional output data, if any */
 		memcpy(adbOutQueue.outBuf + 2, buffer + 1, len);
 	} else
 		/* if data ready, just copy over */
 		memcpy(adbOutQueue.outBuf, in, in[0] + 2);
 	adbOutQueue.saveBuf = buffer;	/* save buffer to know where to save
 					 * result */
 	adbOutQueue.compRout = compRout;	/* save completion routine
 						 * pointer */
 	adbOutQueue.data = data;/* save completion routine data pointer */
 	if ((adbActionState == ADB_ACTION_IDLE) &&	/* is ADB available? */
 	    (ADB_INTR_IS_OFF)) {	/* and no incoming interrupts? */
 		/* then start command now */
 		memcpy(adbOutputBuffer, adbOutQueue.outBuf,
 		    adbOutQueue.outBuf[0] + 2);		/* copy over data */
 		adbBuffer = adbOutQueue.saveBuf;	/* pointer to user data
 							 * area */
 		adbCompRout = adbOutQueue.compRout;	/* pointer to the
 							 * completion routine */
 		adbCompData = adbOutQueue.data;	/* pointer to the completion
 						 * routine data */
 		adbSentChars = 0;	/* nothing sent yet */
 		adbActionState = ADB_ACTION_OUT;	/* set next state */
 		adbBusState = ADB_BUS_CMD;	/* set bus to cmd state */
 		ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 		ADB_SR() = adbOutputBuffer[adbSentChars + 1];	/* load byte for output */
 		ADB_SET_STATE_CMD();	/* tell ADB that we want to send */
 		adbOutQueueHasData = 0;	/* currently processing "queue" entry */
 	} else
 		adbOutQueueHasData = 1;	/* something in the write "queue" */
 	splx(s);
 	if (0x0100 <= (s & 0x0700))	/* were VIA1 interrupts blocked? */
 		/* poll until message done */
 		while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
 		    || (adbWaiting == 1))
 			if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
 				adb_intr_II(NULL); /* go process it */
 				if (adb_polling)
 					adb_soft_intr();
+			}
 	return 0;
+}
 /*
  * This routine is called from the II series interrupt routine
  * to determine what the "next" device is that should be polled.
  */
 int
 adb_guess_next_device(void)
+{
 	int last, i, dummy;
 	if (adbStarting) {
 		/*
 		 * Start polling EVERY device, since we can't be sure there is
 		 * anything in the device table yet
 		 */
 		if (adbLastDevice < 1 || adbLastDevice > 15)
 			adbLastDevice = 1;
 		if (++adbLastDevice > 15)	/* point to next one */
 			adbLastDevice = 1;
 	} else {
 		/* find the next device using the device table */
 		if (adbLastDevice < 1 || adbLastDevice > 15)	/* let's be parinoid */
 			adbLastDevice = 2;
 		last = 1;	/* default index location */
 		for (i = 1; i < 16; i++)	/* find index entry */
 			if (ADBDevTable[i].currentAddr == adbLastDevice) {	/* look for device */
 				last = i;	/* found it */
 				break;
+			}
 		dummy = last;	/* index to start at */
 		for (;;) {	/* find next device in index */
 			if (++dummy > 15)	/* wrap around if needed */
 				dummy = 1;
 			if (dummy == last) {	/* didn't find any other
 						 * device! This can happen if
 						 * there are no devices on the
 						 * bus */
 				dummy = 1;
 				break;
+			}
 			/* found the next device */
 			if (ADBDevTable[dummy].devType != 0)
 				break;
+		}
 		adbLastDevice = ADBDevTable[dummy].currentAddr;
+	}
 	return adbLastDevice;
+}
 /*
- * Called when when an adb interrupt happens.
+ * Called when an adb interrupt happens.
  * This routine simply transfers control over to the appropriate
  * code for the machine we are running on.
  */
 void
 adb_intr(void *arg)
+{
 	switch (adbHardware) {
 	case ADB_HW_II:
 		adb_intr_II(arg);
 		break;
 	case ADB_HW_IISI:
 		adb_intr_IIsi(arg);
 		break;
 	case ADB_HW_PB:		/* Should not come through here. */
 		break;
 	case ADB_HW_CUDA:
 		adb_intr_cuda(arg);
 		break;
 	case ADB_HW_IOP:	/* Should not come through here. */
 		break;
 	case ADB_HW_UNKNOWN:
 		break;
+	}
+}
 /*
- * called when when an adb interrupt happens
+ * called when an adb interrupt happens
+ *
  * IIsi version of adb_intr
+ *
  */
 void
 adb_intr_IIsi(void *arg)
+{
 	struct adbCommand packet;
 	int ending;
 	unsigned int s;
 	s = splhigh();		/* can't be too careful - might be called */
 	/* from a routine, NOT an interrupt */
 	ADB_VIA_CLR_INTR();	/* clear interrupt */
 	ADB_VIA_INTR_DISABLE();	/* disable ADB interrupt on IIs. */
 switch_start:
 	switch (adbActionState) {
 	case ADB_ACTION_IDLE:
 		delay(ADB_DELAY);	/* short delay is required before the
 					 * first byte */
 		ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 		ADB_SET_STATE_ACTIVE();	/* signal start of data frame */
 		adbInputBuffer[1] = ADB_SR();	/* get byte */
 		adbInputBuffer[0] = 1;
 		adbActionState = ADB_ACTION_IN;	/* set next state */
 		ADB_SET_STATE_ACKON();	/* start ACK to ADB chip */
 		delay(ADB_DELAY);	/* delay */
 		ADB_SET_STATE_ACKOFF();	/* end ACK to ADB chip */
 		adb_process_serial_intrs();
 		break;
 	case ADB_ACTION_IN:
 		ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 		adbInputBuffer[++adbInputBuffer[0]] = ADB_SR();	/* get byte */
 		if (ADB_INTR_IS_OFF)	/* check for end of frame */
 			ending = 1;
 		else
 			ending = 0;
 		ADB_SET_STATE_ACKON();	/* start ACK to ADB chip */
 		delay(ADB_DELAY);	/* delay */
 		ADB_SET_STATE_ACKOFF();	/* end ACK to ADB chip */
 		adb_process_serial_intrs();
 		if (1 == ending) {	/* end of message? */
 			ADB_SET_STATE_INACTIVE();	/* signal end of frame */
 			/*
 			 * This section _should_ handle all ADB and RTC/PRAM
 			 * type commands, but there may be more...  Note:
 			 * commands are always at [4], even for rtc/pram
 			 * commands
 			 */
 			/* set up data for adb_pass_up */
 			memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
 			if ((adbWaiting == 1) &&	/* are we waiting AND */
 			    (adbInputBuffer[4] == adbWaitingCmd) &&	/* the cmd we sent AND */
 			    ((adbInputBuffer[2] == 0x00) ||	/* it's from the ADB
 								 * device OR */
 				(adbInputBuffer[2] == 0x01))) {	/* it's from the
 								 * PRAM/RTC device */
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.unsol = 0;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
 				adbWaitingCmd = 0;	/* reset "waiting" vars */
 				adbWaiting = 0;
 				adbBuffer = (long)0;
 				adbCompRout = (long)0;
 				adbCompData = (long)0;
 			} else {
 				packet.unsol = 1;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
+			}
 			adbActionState = ADB_ACTION_IDLE;
 			adbInputBuffer[0] = 0;	/* reset length */
 			if (adbWriteDelay == 1) {	/* were we waiting to
 							 * write? */
 				adbSentChars = 0;	/* nothing sent yet */
 				adbActionState = ADB_ACTION_OUT;	/* set next state */
 				delay(ADB_DELAY);	/* delay */
 				adb_process_serial_intrs();
 				if (ADB_INTR_IS_ON) {	/* ADB intr low during
 							 * write */
 					ADB_SET_STATE_IDLE_IISI();	/* reset */
 					ADB_SET_SR_INPUT();	/* make sure SR is set
 								 * to IN */
 					adbSentChars = 0;	/* must start all over */
 					adbActionState = ADB_ACTION_IDLE;	/* new state */
 					adbInputBuffer[0] = 0;
 					/* may be able to take this out later */
 					delay(ADB_DELAY);	/* delay */
 					break;
+				}
 				ADB_SET_STATE_ACTIVE();	/* tell ADB that we want
 							 * to send */
 				ADB_SET_STATE_ACKOFF();	/* make sure */
 				ADB_SET_SR_OUTPUT();	/* set shift register
 							 * for OUT */
 				ADB_SR() = adbOutputBuffer[adbSentChars + 1];
 				ADB_SET_STATE_ACKON();	/* tell ADB byte ready
 							 * to shift */
+			}
+		}
 		break;
 	case ADB_ACTION_OUT:
 		(void)ADB_SR();	/* reset SR-intr in IFR */
 		ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 		ADB_SET_STATE_ACKOFF();	/* finish ACK */
 		adbSentChars++;
 		if (ADB_INTR_IS_ON) {	/* ADB intr low during write */
 			ADB_SET_STATE_IDLE_IISI();	/* reset */
 			ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 			adbSentChars = 0;	/* must start all over */
 			adbActionState = ADB_ACTION_IDLE;	/* new state */
 			adbInputBuffer[0] = 0;
 			adbWriteDelay = 1;	/* must retry when done with
 						 * read */
 			delay(ADB_DELAY);	/* delay */
 			adb_process_serial_intrs();
 			goto switch_start;	/* process next state right
 						 * now */
 			break;
+		}
 		delay(ADB_DELAY);	/* required delay */
 		adb_process_serial_intrs();
 		if (adbOutputBuffer[0] == adbSentChars) {	/* check for done */
 			if (0 == adb_cmd_result(adbOutputBuffer)) {	/* do we expect data
 									 * back? */
 				adbWaiting = 1;	/* signal waiting for return */
 				adbWaitingCmd = adbOutputBuffer[2];	/* save waiting command */
 			} else {/* no talk, so done */
 				/* set up stuff for adb_pass_up */
 				memcpy(packet.data, adbInputBuffer,
 				    adbInputBuffer[0] + 1);
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.cmd = adbWaitingCmd;
 				packet.unsol = 0;
 				packet.ack_only = 1;
 				adb_pass_up(&packet);
 				/* reset "waiting" vars, just in case */
 				adbWaitingCmd = 0;
 				adbBuffer = (long)0;
 				adbCompRout = (long)0;
 				adbCompData = (long)0;
+			}
 			adbWriteDelay = 0;	/* done writing */
 			adbActionState = ADB_ACTION_IDLE;	/* signal bus is idle */
 			ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 			ADB_SET_STATE_INACTIVE();	/* end of frame */
 		} else {
 			ADB_SR() = adbOutputBuffer[adbSentChars + 1];	/* send next byte */
 			ADB_SET_STATE_ACKON();	/* signal byte ready to shift */
+		}
 		break;
 	case ADB_ACTION_NOTREADY:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("adb: not yet initialized\n");
 #endif
 		break;
 	default:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("intr: unknown ADB state\n");
 #endif
 		break;
+	}
 	ADB_VIA_INTR_ENABLE();	/* enable ADB interrupt on IIs. */
 	splx(s);		/* restore */
 	return;
 }				/* end adb_intr_IIsi */
 /*****************************************************************************
  * if the device is currently busy, and there is no data waiting to go out, then
  * the data is "queued" in the outgoing buffer. If we are already waiting, then
  * we return.
  * in: if (in == 0) then the command string is built from command and buffer
  *     if (in != 0) then in is used as the command string
  * buffer: additional data to be sent (used only if in == 0)
  *         this is also where return data is stored
  * compRout: the completion routine that is called when then return value
  *	     is received (if a return value is expected)
  * data: a data pointer that can be used by the completion routine
  * command: an ADB command to be sent (used only if in == 0)
+ *
  */
 int
 send_adb_IIsi(u_char *in, u_char *buffer, void *compRout, void *data, int
 	command)
+{
 	int s, len;
 	if (adbActionState == ADB_ACTION_NOTREADY)
 		return 1;
 	/* Don't interrupt while we are messing with the ADB */
 	s = splhigh();
 	if ((adbActionState == ADB_ACTION_IDLE) &&	/* ADB available? */
 	    (ADB_INTR_IS_OFF)) {/* and no incoming interrupt? */
 	} else
 		if (adbWriteDelay == 0)	/* it's busy, but is anything waiting? */
 			adbWriteDelay = 1;	/* if no, then we'll "queue"
 						 * it up */
 		else {
 			splx(s);
 			return 1;	/* really busy! */
+		}
 	if ((long)in == (long)0) {	/* need to convert? */
 		/*
 		 * Don't need to use adb_cmd_extra here because this section
 		 * will be called ONLY when it is an ADB command (no RTC or
 		 * PRAM)
 		 */
 		if ((command & 0x0c) == 0x08)	/* copy addl data ONLY if
 						 * doing a listen! */
 			len = buffer[0];	/* length of additional data */
 		else
 			len = 0;/* no additional data */
 		adbOutputBuffer[0] = 2 + len;	/* dev. type + command + addl.
 						 * data */
 		adbOutputBuffer[1] = 0x00;	/* mark as an ADB command */
 		adbOutputBuffer[2] = (u_char)command;	/* load command */
 		/* copy additional output data, if any */
 		memcpy(adbOutputBuffer + 3, buffer + 1, len);
 	} else
 		/* if data ready, just copy over */
 		memcpy(adbOutputBuffer, in, in[0] + 2);
 	adbSentChars = 0;	/* nothing sent yet */
 	adbBuffer = buffer;	/* save buffer to know where to save result */
 	adbCompRout = compRout;	/* save completion routine pointer */
 	adbCompData = data;	/* save completion routine data pointer */
 	adbWaitingCmd = adbOutputBuffer[2];	/* save wait command */
 	if (adbWriteDelay != 1) {	/* start command now? */
 		adbActionState = ADB_ACTION_OUT;	/* set next state */
 		ADB_SET_STATE_ACTIVE();	/* tell ADB that we want to send */
 		ADB_SET_STATE_ACKOFF();	/* make sure */
 		ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 		ADB_SR() = adbOutputBuffer[adbSentChars + 1];	/* load byte for output */
 		ADB_SET_STATE_ACKON();	/* tell ADB byte ready to shift */
+	}
 	adbWriteDelay = 1;	/* something in the write "queue" */
 	splx(s);
 	if (0x0100 <= (s & 0x0700))	/* were VIA1 interrupts blocked? */
 		/* poll until byte done */
 		while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
 		    || (adbWaiting == 1))
 			if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
 				adb_intr_IIsi(NULL); /* go process it */
 				if (adb_polling)
 					adb_soft_intr();
+			}
 	 return 0;
 }				/* send_adb_IIsi */
 void
 adb_iop_recv(IOP *iop, struct iop_msg *msg)
+{
 	struct adbCommand	pkt;
 	unsigned		flags;
 	if (adbActionState != ADB_ACTION_RUNNING)
 		return;
 	switch (msg->status) {
 	case IOP_MSGSTAT_SENT:
 		if (0 == adb_cmd_result(msg->msg + 1)) {
 			adbWaiting = 1;
 			adbWaitingCmd = msg->msg[2];
+		}
 		break;
 	case IOP_MSGSTAT_RECEIVED:
 	case IOP_MSGSTAT_UNEXPECTED:
 		flags = msg->msg[0];
 		if (flags != 0) {
 			printf("ADB FLAGS 0x%x", flags);
 			break;
+		}
 		if (adbWaiting &&
 		    (msg->msg[2] == adbWaitingCmd)) {
 			pkt.saveBuf = msg->msg + 1;
 			pkt.compRout = adbCompRout;
 			pkt.compData = adbCompData;
 			pkt.unsol = 0;
 			pkt.ack_only = 0;
 			adb_pass_up(&pkt);
 			adbWaitingCmd = 0;
 			adbWaiting = 0;
 		} else {
 			pkt.unsol = 1;
 			pkt.ack_only = 0;
 			adb_pass_up(&pkt);
+		}
 		break;
 	default:
 		return;
+	}
+}
 int
 send_adb_iop(int cmd, u_char * buffer, void *compRout, void *data)
+{
 	u_char	buff[32];
 	int	cnt;
 	if (adbActionState != ADB_ACTION_RUNNING)
 		return -1;
 	buff[0] = IOP_ADB_FL_EXPLICIT;
 	buff[1] = buffer[0];
 	buff[2] = cmd;
 	cnt = (int) buff[1];
 	memcpy(buff + 3, buffer + 1, cnt);
 	return iop_send_msg(ISM_IOP, IOP_CHAN_ADB, buff, cnt+3,
 			    adb_iop_recv, NULL);
+}
 /*
  * adb_pass_up is called by the interrupt-time routines.
  * It takes the raw packet data that was received from the
  * device and puts it into the queue that the upper half
  * processes. It then signals for a soft ADB interrupt which
  * will eventually call the upper half routine (adb_soft_intr).
+ *
  * If in->unsol is 0, then this is either the notification
  * that the packet was sent (on a LISTEN, for example), or the
  * response from the device (on a TALK). The completion routine
  * is called only if the user specified one.
+ *
  * If in->unsol is 1, then this packet was unsolicited and
  * so we look up the device in the ADB device table to determine
  * what its default service routine is.
+ *
  * If in->ack_only is 1, then we really only need to call
  * the completion routine, so don't do any other stuff.
+ *
  * Note that in->data contains the packet header AND data,
  * while adbInbound[]->data contains ONLY data.
+ *
  * Note: Called only at interrupt time. Assumes this.
  */
 void
 adb_pass_up(struct adbCommand *in)
+{
 	int start = 0, len = 0, cmd = 0;
 	ADBDataBlock block;
 	/* temp for testing */
 	/*u_char *buffer = 0;*/
 	/*u_char *compdata = 0;*/
 	/*u_char *comprout = 0;*/
 	if (adbInCount >= ADB_QUEUE) {
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("adb: ring buffer overflow\n");
 #endif
 		return;
+	}
 	if (in->ack_only) {
 		len = in->data[0];
 		cmd = in->cmd;
 		start = 0;
 	} else {
 		switch (adbHardware) {
 		case ADB_HW_IOP:
 		case ADB_HW_II:
 			cmd = in->data[1];
 			if (in->data[0] < 2)
 				len = 0;
 			else
 				len = in->data[0]-1;
 			start = 1;
 			break;
 		case ADB_HW_IISI:
 		case ADB_HW_CUDA:
 			/* If it's unsolicited, accept only ADB data for now */
 			if (in->unsol)
 				if (0 != in->data[2])
 					return;
 			cmd = in->data[4];
 			if (in->data[0] < 5)
 				len = 0;
 			else
 				len = in->data[0]-4;
 			start = 4;
 			break;
 		case ADB_HW_PB:
 			cmd = in->data[1];
 			if (in->data[0] < 2)
 				len = 0;
 			else
 				len = in->data[0]-1;
 			start = 1;
 			break;
 		case ADB_HW_UNKNOWN:
 			return;
+		}
 		/* Make sure there is a valid device entry for this device */
 		if (in->unsol) {
 			/* ignore unsolicited data during adbreinit */
 			if (adbStarting)
 				return;
 			/* get device's comp. routine and data area */
 			if (-1 == get_adb_info(&block, ADB_CMDADDR(cmd)))
 				return;
+		}
+	}
 	/*
  	 * If this is an unsolicited packet, we need to fill in
  	 * some info so adb_soft_intr can process this packet
  	 * properly. If it's not unsolicited, then use what
  	 * the caller sent us.
  	 */
 	if (in->unsol) {
 		if (in->ack_only) panic("invalid ack-only pkg");
 		adbInbound[adbInTail].compRout = (void *)block.dbServiceRtPtr;
 		adbInbound[adbInTail].compData = (void *)block.dbDataAreaAddr;
 		adbInbound[adbInTail].saveBuf = (void *)adbInbound[adbInTail].data;
 	} else {
 		adbInbound[adbInTail].compRout = (void *)in->compRout;
 		adbInbound[adbInTail].compData = (void *)in->compData;
 		adbInbound[adbInTail].saveBuf = (void *)in->saveBuf;
+	}
 #ifdef ADB_DEBUG
 	if (adb_debug && in->data[1] == 2)
 		printf_intr("adb: caught error\n");
 #endif
 	/* copy the packet data over */
 	/*
 	 * TO DO: If the *_intr routines fed their incoming data
 	 * directly into an adbCommand struct, which is passed to
 	 * this routine, then we could eliminate this copy.
 	 */
 	memcpy(adbInbound[adbInTail].data + 1, in->data + start + 1, len);
 	adbInbound[adbInTail].data[0] = len;
 	adbInbound[adbInTail].cmd = cmd;
 	adbInCount++;
 	if (++adbInTail >= ADB_QUEUE)
 		adbInTail = 0;
 	/*
 	 * If the debugger is running, call upper half manually.
 	 * Otherwise, trigger a soft interrupt to handle the rest later.
 	 */
 	if (adb_polling)
 		adb_soft_intr();
 	else
 		softint_schedule(adb_softintr_cookie);
 	return;
+}
 /*
  * Called to process the packets after they have been
  * placed in the incoming queue.
+ *
  */
 void
 adb_soft_intr(void)
+{
 	int s;
 	int cmd = 0;
 	u_char *buffer = 0;
 	u_char *comprout = 0;
 	u_char *compdata = 0;
 #if 0
 	s = splhigh();
 	printf_intr("sr: %x\n", (s & 0x0700));
 	splx(s);
 #endif
 /*delay(2*ADB_DELAY);*/
 	while (adbInCount) {
 #ifdef ADB_DEBUG
 		if (adb_debug & 0x80)
 			printf_intr("%x %x %x ",
 			    adbInCount, adbInHead, adbInTail);
 #endif
 		/* get the data we need from the queue */
 		buffer = adbInbound[adbInHead].saveBuf;
 		comprout = adbInbound[adbInHead].compRout;
 		compdata = adbInbound[adbInHead].compData;
 		cmd = adbInbound[adbInHead].cmd;
 		/* copy over data to data area if it's valid */
 		/*
 		 * Note that for unsol packets we don't want to copy the
 	 	 * data anywhere, so buffer was already set to 0.
 	 	 * For ack_only buffer was set to 0, so don't copy.
 		 */
 		if (buffer)
 			memcpy(buffer, adbInbound[adbInHead].data,
 			    adbInbound[adbInHead].data[0] + 1);
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80) {
 				printf_intr("%p %p %p %x ",
 				    buffer, comprout, compdata, (short)cmd);
 				printf_intr("buf: ");
 				print_single(adbInbound[adbInHead].data);
+			}
 #endif
 		/* call default completion routine if it's valid */
 		if (comprout) {
 #ifdef __NetBSD__
 			__asm volatile (
 			"	movml #0xffff,%%sp@- \n" /* save all regs */
 			"	movl %0,%%a2	\n" 	/* compdata */
 			"	movl %1,%%a1	\n" 	/* comprout */
 			"	movl %2,%%a0 	\n"	/* buffer */
 			"	movl %3,%%d0 	\n"	/* cmd */
 			"	jbsr %%a1@ 	\n"	/* go call routine */
 			"	movml %%sp@+,#0xffff"	/* restore all regs */
+			    :
 			    : "g"(compdata), "g"(comprout),
 				"g"(buffer), "g"(cmd)
 			    : "d0", "a0", "a1", "a2");
 #else					/* for macos based testing */
 			asm
+			{
 				movem.l a0/a1/a2/d0, -(a7)
 				move.l compdata, a2
 				move.l comprout, a1
 				move.l buffer, a0
 				move.w cmd, d0
 				jsr(a1)
 				movem.l(a7)+, d0/a2/a1/a0
+			}
 #endif
+		}
 		s = splhigh();
 		adbInCount--;
 		if (++adbInHead >= ADB_QUEUE)
 			adbInHead = 0;
 		splx(s);
+	}
 	return;
+}
 /*
  * This is my version of the ADBOp routine. It mainly just calls the
  * hardware-specific routine.
+ *
  *   data 	: pointer to data area to be used by compRout
  *   compRout	: completion routine
  *   buffer	: for LISTEN: points to data to send - MAX 8 data bytes,
  *		  byte 0 = # of bytes
  *		: for TALK: points to place to save return data
  *   command	: the adb command to send
  *   result	: 0 = success
  *		: -1 = could not complete
  */
 int
 adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)
+{
 	int result;
 	switch (adbHardware) {
 	case ADB_HW_II:
 		result = send_adb_II((u_char *)0, (u_char *)buffer,
 		    (void *)compRout, (void *)data, (int)command);
 		if (result == 0)
 			return 0;
 		else
 			return -1;
 		break;
 	case ADB_HW_IOP:
 #ifdef __notyet__
 		result = send_adb_iop((int)command, (u_char *)buffer,
 		    (void *)compRout, (void *)data);
 		if (result == 0)
 			return 0;
 		else
 #endif
 			return -1;
 		break;
 	case ADB_HW_IISI:
 		result = send_adb_IIsi((u_char *)0, (u_char *)buffer,
 		    (void *)compRout, (void *)data, (int)command);
 		/*
 		 * I wish I knew why this delay is needed. It usually needs to
 		 * be here when several commands are sent in close succession,
 		 * especially early in device probes when doing collision
 		 * detection. It must be some race condition. Sigh. - jpw
 		 */
 		delay(100);
 		if (result == 0)
 			return 0;
 		else
 			return -1;
 		break;
 	case ADB_HW_PB:
 		result = pm_adb_op((u_char *)buffer, (void *)compRout,
 		    (void *)data, (int)command);
 		if (result == 0)
 			return 0;
 		else
 			return -1;
 		break;
 	case ADB_HW_CUDA:
 		result = send_adb_cuda((u_char *)0, (u_char *)buffer,
 		    (void *)compRout, (void *)data, (int)command);
 		if (result == 0)
 			return 0;
 		else
 			return -1;
 		break;
 	case ADB_HW_UNKNOWN:
 	default:
 		return -1;
+	}
+}
 /*
  * adb_hw_setup
  * This routine sets up the possible machine specific hardware
  * config (mainly VIA settings) for the various models.
  */
 void
 adb_hw_setup(void)
+{
 	volatile int i;
 	u_char send_string[ADB_MAX_MSG_LENGTH];
 	switch (adbHardware) {
 	case ADB_HW_II:
 		via1_register_irq(2, adb_intr_II, NULL);
 		via_reg(VIA1, vDirB) |= 0x30;	/* register B bits 4 and 5:
 						 * outputs */
 		via_reg(VIA1, vDirB) &= 0xf7;	/* register B bit 3: input */
 		via_reg(VIA1, vACR) &= ~vSR_OUT;	/* make sure SR is set
 							 * to IN (II, IIsi) */
 		adbActionState = ADB_ACTION_IDLE;	/* used by all types of
 							 * hardware (II, IIsi) */
 		adbBusState = ADB_BUS_IDLE;	/* this var. used in II-series
 						 * code only */
 		via_reg(VIA1, vIER) = 0x84;	/* make sure VIA interrupts
 						 * are on (II, IIsi) */
 		ADB_SET_STATE_IDLE_II();	/* set ADB bus state to idle */
 		ADB_VIA_CLR_INTR();	/* clear interrupt */
 		break;
 	case ADB_HW_IOP:
 		via_reg(VIA1, vIER) = 0x84;
 		via_reg(VIA1, vIFR) = 0x04;
 #ifdef __notyet__
 		adbActionState = ADB_ACTION_RUNNING;
 #endif
 		break;
 	case ADB_HW_IISI:
 		via1_register_irq(2, adb_intr_IIsi, NULL);
 		via_reg(VIA1, vDirB) |= 0x30;	/* register B bits 4 and 5:
 						 * outputs */
 		via_reg(VIA1, vDirB) &= 0xf7;	/* register B bit 3: input */
 		via_reg(VIA1, vACR) &= ~vSR_OUT;	/* make sure SR is set
 							 * to IN (II, IIsi) */
 		adbActionState = ADB_ACTION_IDLE;	/* used by all types of
 							 * hardware (II, IIsi) */
 		adbBusState = ADB_BUS_IDLE;	/* this var. used in II-series
 						 * code only */
 		via_reg(VIA1, vIER) = 0x84;	/* make sure VIA interrupts
 						 * are on (II, IIsi) */
 		ADB_SET_STATE_IDLE_IISI();	/* set ADB bus state to idle */
 		/* get those pesky clock ticks we missed while booting */
 		for (i = 0; i < 30; i++) {
 			delay(ADB_DELAY);
 			adb_hw_setup_IIsi(send_string);
 #ifdef ADB_DEBUG
 			if (adb_debug) {
 				printf_intr("adb: cleanup: ");
 				print_single(send_string);
+			}
 #endif
 			delay(ADB_DELAY);
 			if (ADB_INTR_IS_OFF)
 				break;
+		}
 		break;
 	case ADB_HW_PB:
 		/*
 		 * XXX - really PM_VIA_CLR_INTR - should we put it in
 		 * pm_direct.h?
 		 */
 		pm_hw_setup();
 		break;
 	case ADB_HW_CUDA:
 		via1_register_irq(2, adb_intr_cuda, NULL);
 		via_reg(VIA1, vDirB) |= 0x30;	/* register B bits 4 and 5:
 						 * outputs */
 		via_reg(VIA1, vDirB) &= 0xf7;	/* register B bit 3: input */
 		via_reg(VIA1, vACR) &= ~vSR_OUT;	/* make sure SR is set
 							 * to IN */
 		via_reg(VIA1, vACR) = (via_reg(VIA1, vACR) | 0x0c) & ~0x10;
 		adbActionState = ADB_ACTION_IDLE;	/* used by all types of
 							 * hardware */
 		adbBusState = ADB_BUS_IDLE;	/* this var. used in II-series
 						 * code only */
 		via_reg(VIA1, vIER) = 0x84;	/* make sure VIA interrupts
 						 * are on */
 		ADB_SET_STATE_IDLE_CUDA();	/* set ADB bus state to idle */
 		/* sort of a device reset */
 		i = ADB_SR();	/* clear interrupt */
 		ADB_VIA_INTR_DISABLE();	/* no interrupts while clearing */
 		ADB_SET_STATE_IDLE_CUDA();	/* reset state to idle */
 		delay(ADB_DELAY);
 		ADB_SET_STATE_TIP();	/* signal start of frame */
 		delay(ADB_DELAY);
 		ADB_TOGGLE_STATE_ACK_CUDA();
 		delay(ADB_DELAY);
 		ADB_CLR_STATE_TIP();
 		delay(ADB_DELAY);
 		ADB_SET_STATE_IDLE_CUDA();	/* back to idle state */
 		i = ADB_SR();	/* clear interrupt */
 		ADB_VIA_INTR_ENABLE();	/* ints ok now */
 		break;
 	case ADB_HW_UNKNOWN:
 	default:
 		via_reg(VIA1, vIER) = 0x04;	/* turn interrupts off - TO
 						 * DO: turn PB ints off? */
 		return;
 		break;
+	}
+}
 /*
  * adb_hw_setup_IIsi
  * This is sort of a "read" routine that forces the adb hardware through a read cycle
  * if there is something waiting. This helps "clean up" any commands that may have gotten
  * stuck or stopped during the boot process.
+ *
  */
 void
 adb_hw_setup_IIsi(u_char *buffer)
+{
 	int i;
 	int s;
 	long my_time;
 	int endofframe;
 	delay(ADB_DELAY);
 	i = 1;			/* skip over [0] */
 	s = splhigh();		/* block ALL interrupts while we are working */
 	ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 	ADB_VIA_INTR_DISABLE();	/* disable ADB interrupt on IIs. */
 	/* this is required, especially on faster machines */
 	delay(ADB_DELAY);
 	if (ADB_INTR_IS_ON) {
 		ADB_SET_STATE_ACTIVE();	/* signal start of data frame */
 		endofframe = 0;
 		while (0 == endofframe) {
 			/*
 			 * Poll for ADB interrupt and watch for timeout.
 			 * If time out, keep going in hopes of not hanging
 			 * the ADB chip - I think
 			 */
 			my_time = ADB_DELAY * 5;
 			while ((ADB_SR_INTR_IS_OFF) && (my_time-- > 0))
 				(void)via_reg(VIA1, vBufB);
 			buffer[i++] = ADB_SR();	/* reset interrupt flag by
 						 * reading vSR */
 			/*
 			 * Perhaps put in a check here that ignores all data
 			 * after the first ADB_MAX_MSG_LENGTH bytes ???
 			 */
 			if (ADB_INTR_IS_OFF)	/* check for end of frame */
 				endofframe = 1;
 			ADB_SET_STATE_ACKON();	/* send ACK to ADB chip */
 			delay(ADB_DELAY);	/* delay */
 			ADB_SET_STATE_ACKOFF();	/* send ACK to ADB chip */
+		}
 		ADB_SET_STATE_INACTIVE();	/* signal end of frame and
 						 * delay */
 		/* probably don't need to delay this long */
 		delay(ADB_DELAY);
+	}
 	buffer[0] = --i;	/* [0] is length of message */
 	ADB_VIA_INTR_ENABLE();	/* enable ADB interrupt on IIs. */
 	splx(s);		/* restore interrupts */
 	return;
 }				/* adb_hw_setup_IIsi */
 /*
  * adb_reinit sets up the adb stuff
+ *
  */
 void
 adb_reinit(void)
+{
 	u_char send_string[ADB_MAX_MSG_LENGTH];
 	ADBDataBlock data;	/* temp. holder for getting device info */
 	volatile int i, x;
 	int s;
 	int command;
 	int result;
 	int saveptr;		/* point to next free relocation address */
 	int device;
 	int nonewtimes;		/* times thru loop w/o any new devices */
 	static bool again;
 	if (!again) {
 		callout_init(&adb_cuda_tickle_ch, 0);
 		again = true;
+	}
 	adb_setup_hw_type();	/* setup hardware type */
 	/* Make sure we are not interrupted while building the table. */
 	/* ints must be on for PB & IOP (at least, for now) */
 	if (adbHardware != ADB_HW_PB && adbHardware != ADB_HW_IOP)
 		s = splhigh();
 	else
 		s = 0;		/* XXX shut the compiler up*/
 	ADBNumDevices = 0;	/* no devices yet */
 	/* Let intr routines know we are running reinit */
 	adbStarting = 1;
 	/*
 	 * Initialize the ADB table.  For now, we'll always use the same table
 	 * that is defined at the beginning of this file - no mallocs.
 	 */
 	for (i = 0; i < 16; i++) {
 		ADBDevTable[i].devType = 0;
 		ADBDevTable[i].origAddr = ADBDevTable[i].currentAddr = 0;
+	}
 	adb_hw_setup();		/* init the VIA bits and hard reset ADB */
 	delay(1000);
 	/* send an ADB reset first */
 	(void)adb_op_sync((Ptr)0, (Ptr)0, (Ptr)0, (short)0x00);
 	delay(3000);
 	/*
 	 * Probe for ADB devices. Probe devices 1-15 quickly to determine
 	 * which device addresses are in use and which are free. For each
 	 * address that is in use, move the device at that address to a higher
 	 * free address. Continue doing this at that address until no device
 	 * responds at that address. Then move the last device that was moved
 	 * back to the original address. Do this for the remaining addresses
 	 * that we determined were in use.
+	 *
 	 * When finished, do this entire process over again with the updated
 	 * list of in use addresses. Do this until no new devices have been
 	 * found in 20 passes though the in use address list. (This probably
 	 * seems long and complicated, but it's the best way to detect multiple
 	 * devices at the same address - sometimes it takes a couple of tries
 	 * before the collision is detected.)
 	 */
 	/* initial scan through the devices */
 	for (i = 1; i < 16; i++) {
 		command = ADBTALK(i, 3);
 		result = adb_op_sync((Ptr)send_string, (Ptr)0,
 		    (Ptr)0, (short)command);
 		if (result == 0 && send_string[0] != 0) {
 			/* found a device */
 			++ADBNumDevices;
 			KASSERT(ADBNumDevices < 16);
 			ADBDevTable[ADBNumDevices].devType =
 				(int)(send_string[2]);
 			ADBDevTable[ADBNumDevices].origAddr = i;
 			ADBDevTable[ADBNumDevices].currentAddr = i;
 			ADBDevTable[ADBNumDevices].DataAreaAddr =
 			    (long)0;
 			ADBDevTable[ADBNumDevices].ServiceRtPtr = (void *)0;
 			pm_check_adb_devices(i);	/* tell pm driver device
 							 * is here */
+		}
+	}
 	/* find highest unused address */
 	for (saveptr = 15; saveptr > 0; saveptr--)
 		if (-1 == get_adb_info(&data, saveptr))
 			break;
 #ifdef ADB_DEBUG
 	if (adb_debug & 0x80) {
 		printf_intr("first free is: 0x%02x\n", saveptr);
 		printf_intr("devices: %i\n", ADBNumDevices);
+	}
 #endif
 	nonewtimes = 0;		/* no loops w/o new devices */
 	while (saveptr > 0 && nonewtimes++ < 11) {
 		for (i = 1;saveptr > 0 && i <= ADBNumDevices; i++) {
 			device = ADBDevTable[i].currentAddr;
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80)
 				printf_intr("moving device 0x%02x to 0x%02x "
 				    "(index 0x%02x)  ", device, saveptr, i);
 #endif
 			/* send TALK R3 to address */
 			command = ADBTALK(device, 3);
 			(void)adb_op_sync((Ptr)send_string, (Ptr)0,
 			    (Ptr)0, (short)command);
 			/* move device to higher address */
 			command = ADBLISTEN(device, 3);
 			send_string[0] = 2;
 			send_string[1] = (u_char)(saveptr | 0x60);
 			send_string[2] = 0xfe;
 			(void)adb_op_sync((Ptr)send_string, (Ptr)0,
 			    (Ptr)0, (short)command);
 			delay(1000);
 			/* send TALK R3 - anything at new address? */
 			command = ADBTALK(saveptr, 3);
 			send_string[0] = 0;

 @@ -1,1321 +1,1321 @@
-/*	$NetBSD: adb_direct.c,v 1.45 2023/09/21 09:31:49 msaitoh Exp $	*/
+/*	$NetBSD: adb_direct.c,v 1.46 2024/03/05 20:58:05 andvar Exp $	*/
 /* From: adb_direct.c 2.02 4/18/97 jpw */
 /*
  * Copyright (C) 1996, 1997 John P. Wittkoski
  * 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 John P. Wittkoski.
  * 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.
  */
 /*
  * This code is rather messy, but I don't have time right now
  * to clean it up as much as I would like.
  * But it works, so I'm happy. :-) jpw
  */
 /*
  * TO DO:
  *  - We could reduce the time spent in the adb_intr_* routines
  *    by having them save the incoming and outgoing data directly
  *    in the adbInbound and adbOutbound queues, as it would reduce
  *    the number of times we need to copy the data around. It
  *    would also make the code more readable and easier to follow.
  *  - (Related to above) Use the header part of adbCommand to
  *    reduce the number of copies we have to do of the data.
  *  - (Related to above) Actually implement the adbOutbound queue.
  *    This is fairly easy once you switch all the intr routines
  *    over to using adbCommand structs directly.
  *  - There is a bug in the state machine of adb_intr_cuda
  *    code that causes hangs, especially on 030 machines, probably
  *    because of some timing issues. Because I have been unable to
  *    determine the exact cause of this bug, I used the timeout function
  *    to check for and recover from this condition. If anyone finds
  *    the actual cause of this bug, the calls to timeout and the
  *    adb_cuda_tickle routine can be removed.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: adb_direct.c,v 1.45 2023/09/21 09:31:49 msaitoh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: adb_direct.c,v 1.46 2024/03/05 20:58:05 andvar Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/device.h>
 #include <machine/cpu.h>
 #include <machine/autoconf.h>
 #include <machine/adbsys.h>
 #include <machine/pio.h>
 #include <macppc/dev/viareg.h>
 #include <macppc/dev/adbvar.h>
 #include <macppc/dev/pm_direct.h>
 #define printf_intr printf
 #ifdef DEBUG
 #ifndef ADB_DEBUG
 #define ADB_DEBUG
 #endif
 #endif
 /* some misc. leftovers */
 #define vPB		0x0000
 #define vPB3		0x08
 #define vPB4		0x10
 #define vPB5		0x20
 #define vSR_INT		0x04
 #define vSR_OUT		0x10
 /* the type of ADB action that we are currently preforming */
 #define ADB_ACTION_NOTREADY	0x1	/* has not been initialized yet */
 #define ADB_ACTION_IDLE		0x2	/* the bus is currently idle */
 #define ADB_ACTION_OUT		0x3	/* sending out a command */
 #define ADB_ACTION_IN		0x4	/* receiving data */
 #define ADB_ACTION_POLLING	0x5	/* polling - II only */
 /*
  * These describe the state of the ADB bus itself, although they
  * don't necessarily correspond directly to ADB states.
  * Note: these are not really used in the IIsi code.
  */
 #define ADB_BUS_UNKNOWN		0x1	/* we don't know yet - all models */
 #define ADB_BUS_IDLE		0x2	/* bus is idle - all models */
 #define ADB_BUS_CMD		0x3	/* starting a command - II models */
 #define ADB_BUS_ODD		0x4	/* the "odd" state - II models */
 #define ADB_BUS_EVEN		0x5	/* the "even" state - II models */
 #define ADB_BUS_ACTIVE		0x6	/* active state - IIsi models */
 #define ADB_BUS_ACK		0x7	/* currently ACKing - IIsi models */
 /*
  * Shortcuts for setting or testing the VIA bit states.
  * Not all shortcuts are used for every type of ADB hardware.
  */
 #define ADB_SET_STATE_IDLE_CUDA()   via_reg_or(VIA1, vBufB, (vPB4 | vPB5))
 #define ADB_SET_STATE_TIP()	    via_reg_and(VIA1, vBufB, ~vPB5)
 #define ADB_CLR_STATE_TIP() 	    via_reg_or(VIA1, vBufB, vPB5)
 #define ADB_TOGGLE_STATE_ACK_CUDA() via_reg_xor(VIA1, vBufB, vPB4)
 #define ADB_SET_STATE_ACKOFF_CUDA() via_reg_or(VIA1, vBufB, vPB4)
 #define ADB_SET_SR_INPUT()	    via_reg_and(VIA1, vACR, ~vSR_OUT)
 #define ADB_SET_SR_OUTPUT()	    via_reg_or(VIA1, vACR, vSR_OUT)
 #define ADB_SR()		    read_via_reg(VIA1, vSR)
 #define ADB_VIA_INTR_ENABLE()	    write_via_reg(VIA1, vIER, 0x84)
 #define ADB_VIA_INTR_DISABLE()	    write_via_reg(VIA1, vIER, 0x04)
 #define ADB_INTR_IS_OFF		   (vPB3 == (read_via_reg(VIA1, vBufB) & vPB3))
 #define ADB_INTR_IS_ON		   (0 == (read_via_reg(VIA1, vBufB) & vPB3))
 #define ADB_SR_INTR_IS_OFF	   (0 == (read_via_reg(VIA1, vIFR) & vSR_INT))
 #define ADB_SR_INTR_IS_ON	   (vSR_INT == (read_via_reg(VIA1, \
 						vIFR) & vSR_INT))
 /*
  * This is the delay that is required (in uS) between certain
  * ADB transactions. The actual timing delay for each uS is
  * calculated at boot time to account for differences in machine speed.
  */
 #define ADB_DELAY	150
 /*
  * Maximum ADB message length; includes space for data, result, and
  * device code - plus a little for safety.
  */
 #define ADB_MAX_MSG_LENGTH	16
 #define ADB_MAX_HDR_LENGTH	8
 #define ADB_QUEUE		32
 #define ADB_TICKLE_TICKS	4
 /*
  * A structure for storing information about each ADB device.
  */
 struct ADBDevEntry {
 	void	(*ServiceRtPtr)(void);
 	void	*DataAreaAddr;
 	int	devType;
 	int	origAddr;
 	int	currentAddr;
 };
 /*
  * Used to hold ADB commands that are waiting to be sent out.
  */
 struct adbCmdHoldEntry {
 	u_char	outBuf[ADB_MAX_MSG_LENGTH];	/* our message */
 	u_char	*saveBuf;	/* buffer to know where to save result */
 	adbComp	*compRout;	/* completion routine pointer */
 	int	*data;		/* completion routine data pointer */
 };
 /*
  * Eventually used for two separate queues, the queue between
  * the upper and lower halves, and the outgoing packet queue.
  * TO DO: adbCommand can replace all of adbCmdHoldEntry eventually
  */
 struct adbCommand {
 	u_char	header[ADB_MAX_HDR_LENGTH];	/* not used yet */
 	u_char	data[ADB_MAX_MSG_LENGTH];	/* packet data only */
 	u_char	*saveBuf;	/* where to save result */
 	adbComp *compRout;	/* completion routine pointer */
 	volatile int *compData;	/* completion routine data pointer */
 	u_int	cmd;		/* the original command for this data */
 	u_int	unsol;		/* 1 if packet was unsolicited */
 	u_int	ack_only;	/* 1 for no special processing */
 };
 /*
  * A few variables that we need and their initial values.
  */
 int	adbHardware = ADB_HW_UNKNOWN;
 int	adbActionState = ADB_ACTION_NOTREADY;
 int	adbWaiting = 0;		/* waiting for return data from the device */
 int	adbWriteDelay = 0;	/* working on (or waiting to do) a write */
 int	adbWaitingCmd = 0;	/* ADB command we are waiting for */
 u_char	*adbBuffer = (long)0;	/* pointer to user data area */
 adbComp *adbCompRout = NULL;	/* pointer to the completion routine */
 volatile int *adbCompData = NULL;	/* pointer to the completion routine data */
 int	adbStarting = 1;	/* doing ADBReInit so do polling differently */
 u_char	adbInputBuffer[ADB_MAX_MSG_LENGTH];	/* data input buffer */
 u_char	adbOutputBuffer[ADB_MAX_MSG_LENGTH];	/* data output buffer */
 int	adbSentChars = 0;	/* how many characters we have sent */
 struct	ADBDevEntry ADBDevTable[16];	/* our ADB device table */
 int	ADBNumDevices;		/* num. of ADB devices found with ADBReInit */
 struct	adbCommand adbInbound[ADB_QUEUE];	/* incoming queue */
 int	adbInCount = 0;			/* how many packets in in queue */
 int	adbInHead = 0;			/* head of in queue */
 int	adbInTail = 0;			/* tail of in queue */
 struct	adbCommand adbOutbound[ADB_QUEUE]; /* outgoing queue - not used yet */
 int	adbOutCount = 0;		/* how many packets in out queue */
 int	adbOutHead = 0;			/* head of out queue */
 int	adbOutTail = 0;			/* tail of out queue */
 int	tickle_count = 0;		/* how many tickles seen for this packet? */
 int	tickle_serial = 0;		/* the last packet tickled */
 int	adb_cuda_serial = 0;		/* the current packet */
 struct callout adb_cuda_tickle_ch;
 struct callout adb_soft_intr_ch;
 volatile uint8_t *Via1Base;
 extern int adb_polling;			/* Are we polling? */
 void	pm_setup_adb(void);
 void	pm_check_adb_devices(int);
 int	pm_adb_op(u_char *, void *, volatile void *, int);
 void	pm_init_adb_device(void);
 /*
  * The following are private routines.
  */
 #ifdef ADB_DEBUG
 void	print_single(u_char *);
 #endif
 void	adb_soft_intr(void);
 int	send_adb_cuda(u_char *, u_char *, adbComp *, volatile void *, int);
 void	adb_intr_cuda_test(void);
 void	adb_cuda_tickle(void);
 void	adb_pass_up(struct adbCommand *);
 void	adb_op_comprout(void *, volatile int *, int);
 void	adb_reinit(void);
 int	count_adbs(void);
 int	get_ind_adb_info(ADBDataBlock *, int);
 int	get_adb_info(ADBDataBlock *, int);
 int	set_adb_info(ADBSetInfoBlock *, int);
 void	adb_setup_hw_type(void);
 int	adb_op (Ptr, adbComp *, volatile void *, short);
 int	adb_op_sync(Ptr, adbComp *, Ptr, short);
 void	adb_hw_setup(void);
 int	adb_cmd_result(u_char *);
 int	adb_cmd_extra(u_char *);
 /* we should create this and it will be the public version */
 int	send_adb(u_char *, void *, void *);
 int	setsoftadb(void);
 #ifdef ADB_DEBUG
 /*
  * print_single
  * Diagnostic display routine. Displays the hex values of the
  * specified elements of the u_char. The length of the "string"
  * is in [0].
  */
 void
 print_single(u_char *str)
+{
 	int x;
 	if (str == 0) {
 		printf_intr("no data - null pointer\n");
 		return;
+	}
 	if (*str == 0) {
 		printf_intr("nothing returned\n");
 		return;
+	}
 	if (*str > 20) {
 		printf_intr("ADB: ACK > 20 no way!\n");
 		*str = 20;
+	}
 	printf_intr("(length=0x%x):", *str);
 	for (x = 1; x <= *str; x++)
 		printf_intr("  0x%02x", str[x]);
 	printf_intr("\n");
+}
 #endif
 void
 adb_cuda_tickle(void)
+{
 	volatile int s;
 	if (adbActionState == ADB_ACTION_IN) {
 		if (tickle_serial == adb_cuda_serial) {
 			if (++tickle_count > 0) {
 				s = splhigh();
 				adbActionState = ADB_ACTION_IDLE;
 				adbInputBuffer[0] = 0;
 				ADB_SET_STATE_IDLE_CUDA();
 				splx(s);
+			}
 		} else {
 			tickle_serial = adb_cuda_serial;
 			tickle_count = 0;
+		}
 	} else {
 		tickle_serial = adb_cuda_serial;
 		tickle_count = 0;
+	}
 	callout_reset(&adb_cuda_tickle_ch, ADB_TICKLE_TICKS,
 	    (void *)adb_cuda_tickle, NULL);
+}
 /*
- * called when when an adb interrupt happens
+ * called when an adb interrupt happens
+ *
  * Cuda version of adb_intr
  * TO DO: do we want to add some calls to intr_dispatch() here to
  * grab serial interrupts?
  */
 int
 adb_intr_cuda(void *arg)
+{
 	volatile int i, ending;
 	volatile unsigned int s;
 	struct adbCommand packet;
 	uint8_t reg;
 	s = splhigh();		/* can't be too careful - might be called */
 				/* from a routine, NOT an interrupt */
 	reg = read_via_reg(VIA1, vIFR);		/* Read the interrupts */
 	if ((reg & 0x80) == 0) {
 		splx(s);
 		return 0;			/* No interrupts to process */
+	}
 	write_via_reg(VIA1, vIFR, reg & 0x7f);	/* Clear 'em */
 	ADB_VIA_INTR_DISABLE();	/* disable ADB interrupt on IIs. */
 switch_start:
 	switch (adbActionState) {
 	case ADB_ACTION_IDLE:
 		/*
 		 * This is an unexpected packet, so grab the first (dummy)
 		 * byte, set up the proper vars, and tell the chip we are
 		 * starting to receive the packet by setting the TIP bit.
 		 */
 		adbInputBuffer[1] = ADB_SR();
 		adb_cuda_serial++;
 		if (ADB_INTR_IS_OFF)	/* must have been a fake start */
 			break;
 		ADB_SET_SR_INPUT();
 		ADB_SET_STATE_TIP();
 		adbInputBuffer[0] = 1;
 		adbActionState = ADB_ACTION_IN;
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("idle 0x%02x ", adbInputBuffer[1]);
 #endif
 		break;
 	case ADB_ACTION_IN:
 		adbInputBuffer[++adbInputBuffer[0]] = ADB_SR();
 		/* intr off means this is the last byte (end of frame) */
 		if (ADB_INTR_IS_OFF)
 			ending = 1;
 		else
 			ending = 0;
 		if (1 == ending) {	/* end of message? */
 #ifdef ADB_DEBUG
 			if (adb_debug) {
 				printf_intr("in end 0x%02x ",
 				    adbInputBuffer[adbInputBuffer[0]]);
 				print_single(adbInputBuffer);
+			}
 #endif
 			/*
 			 * Are we waiting AND does this packet match what we
 			 * are waiting for AND is it coming from either the
 			 * ADB or RTC/PRAM sub-device? This section _should_
 			 * recognize all ADB and RTC/PRAM type commands, but
 			 * there may be more... NOTE: commands are always at
 			 * [4], even for RTC/PRAM commands.
 			 */
 			/* set up data for adb_pass_up */
 			memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
 			if ((adbWaiting == 1) &&
 			    (adbInputBuffer[4] == adbWaitingCmd) &&
 			    ((adbInputBuffer[2] == 0x00) ||
 			    (adbInputBuffer[2] == 0x01))) {
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.unsol = 0;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
 				adbWaitingCmd = 0;	/* reset "waiting" vars */
 				adbWaiting = 0;
 				adbBuffer = (long)0;
 				adbCompRout = (long)0;
 				adbCompData = (long)0;
 			} else {
 				packet.unsol = 1;
 				packet.ack_only = 0;
 				adb_pass_up(&packet);
+			}
 			/* reset vars and signal the end of this frame */
 			adbActionState = ADB_ACTION_IDLE;
 			adbInputBuffer[0] = 0;
 			ADB_SET_STATE_IDLE_CUDA();
 			/*ADB_SET_SR_INPUT();*/
 			/*
 			 * If there is something waiting to be sent out,
 			 * the set everything up and send the first byte.
 			 */
 			if (adbWriteDelay == 1) {
 				delay(ADB_DELAY);	/* required */
 				adbSentChars = 0;
 				adbActionState = ADB_ACTION_OUT;
 				/*
 				 * If the interrupt is on, we were too slow
 				 * and the chip has already started to send
 				 * something to us, so back out of the write
 				 * and start a read cycle.
 				 */
 				if (ADB_INTR_IS_ON) {
 					ADB_SET_SR_INPUT();
 					ADB_SET_STATE_IDLE_CUDA();
 					adbSentChars = 0;
 					adbActionState = ADB_ACTION_IDLE;
 					adbInputBuffer[0] = 0;
 					break;
+				}
 				/*
 				 * If we got here, it's ok to start sending
 				 * so load the first byte and tell the chip
 				 * we want to send.
 				 */
 				ADB_SET_STATE_TIP();
 				ADB_SET_SR_OUTPUT();
 				write_via_reg(VIA1, vSR, adbOutputBuffer[adbSentChars + 1]);
+			}
 		} else {
 			ADB_TOGGLE_STATE_ACK_CUDA();
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("in 0x%02x ",
 				    adbInputBuffer[adbInputBuffer[0]]);
 #endif
+		}
 		break;
 	case ADB_ACTION_OUT:
 		i = ADB_SR();	/* reset SR-intr in IFR */
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("intr out 0x%02x ", i);
 #endif
 		adbSentChars++;
 		if (ADB_INTR_IS_ON) {	/* ADB intr low during write */
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("intr was on ");
 #endif
 			ADB_SET_SR_INPUT();	/* make sure SR is set to IN */
 			ADB_SET_STATE_IDLE_CUDA();
 			adbSentChars = 0;	/* must start all over */
 			adbActionState = ADB_ACTION_IDLE;	/* new state */
 			adbInputBuffer[0] = 0;
 			adbWriteDelay = 1;	/* must retry when done with
 						 * read */
 			delay(ADB_DELAY);
 			goto switch_start;	/* process next state right
 						 * now */
 			break;
+		}
 		if (adbOutputBuffer[0] == adbSentChars) {	/* check for done */
 			if (0 == adb_cmd_result(adbOutputBuffer)) {	/* do we expect data
 									 * back? */
 				adbWaiting = 1;	/* signal waiting for return */
 				adbWaitingCmd = adbOutputBuffer[2];	/* save waiting command */
 			} else {	/* no talk, so done */
 				/* set up stuff for adb_pass_up */
 				memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
 				packet.saveBuf = adbBuffer;
 				packet.compRout = adbCompRout;
 				packet.compData = adbCompData;
 				packet.cmd = adbWaitingCmd;
 				packet.unsol = 0;
 				packet.ack_only = 1;
 				adb_pass_up(&packet);
 				/* reset "waiting" vars, just in case */
 				adbWaitingCmd = 0;
 				adbBuffer = (long)0;
 				adbCompRout = NULL;
 				adbCompData = NULL;
+			}
 			adbWriteDelay = 0;	/* done writing */
 			adbActionState = ADB_ACTION_IDLE;	/* signal bus is idle */
 			ADB_SET_SR_INPUT();
 			ADB_SET_STATE_IDLE_CUDA();
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("write done ");
 #endif
 		} else {
 			write_via_reg(VIA1, vSR, adbOutputBuffer[adbSentChars + 1]);	/* send next byte */
 			ADB_TOGGLE_STATE_ACK_CUDA();	/* signal byte ready to
 							 * shift */
 #ifdef ADB_DEBUG
 			if (adb_debug)
 				printf_intr("toggle ");
 #endif
+		}
 		break;
 	case ADB_ACTION_NOTREADY:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("adb: not yet initialized\n");
 #endif
 		break;
 	default:
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("intr: unknown ADB state\n");
 #endif
 		break;
+	}
 	ADB_VIA_INTR_ENABLE();	/* enable ADB interrupt on IIs. */
 	splx(s);		/* restore */
 	return 1;
 }				/* end adb_intr_cuda */
 int
 send_adb_cuda(u_char * in, u_char * buffer, adbComp *compRout,
     volatile void *data, int command)
+{
 	int s, len;
 #ifdef ADB_DEBUG
 	if (adb_debug)
 		printf_intr("SEND\n");
 #endif
 	if (adbActionState == ADB_ACTION_NOTREADY)
 		return 1;
 	/* Don't interrupt while we are messing with the ADB */
 	s = splhigh();
 	if ((adbActionState == ADB_ACTION_IDLE) &&	/* ADB available? */
 	    (ADB_INTR_IS_OFF)) {	/* and no incoming interrupt? */
 	} else
 		if (adbWriteDelay == 0)	/* it's busy, but is anything waiting? */
 			adbWriteDelay = 1;	/* if no, then we'll "queue"
 						 * it up */
 		else {
 			splx(s);
 			return 1;	/* really busy! */
+		}
 #ifdef ADB_DEBUG
 	if (adb_debug)
 		printf_intr("QUEUE\n");
 #endif
 	if ((long)in == (long)0) {	/* need to convert? */
 		/*
 		 * Don't need to use adb_cmd_extra here because this section
 		 * will be called ONLY when it is an ADB command (no RTC or
 		 * PRAM)
 		 */
 		if ((command & 0x0c) == 0x08)	/* copy addl data ONLY if
 						 * doing a listen! */
 			len = buffer[0];	/* length of additional data */
 		else
 			len = 0;/* no additional data */
 		adbOutputBuffer[0] = 2 + len;	/* dev. type + command + addl.
 						 * data */
 		adbOutputBuffer[1] = 0x00;	/* mark as an ADB command */
 		adbOutputBuffer[2] = (u_char)command;	/* load command */
 		/* copy additional output data, if any */
 		memcpy(adbOutputBuffer + 3, buffer + 1, len);
 	} else
 		/* if data ready, just copy over */
 		memcpy(adbOutputBuffer, in, in[0] + 2);
 	adbSentChars = 0;	/* nothing sent yet */
 	adbBuffer = buffer;	/* save buffer to know where to save result */
 	adbCompRout = compRout;	/* save completion routine pointer */
 	adbCompData = data;	/* save completion routine data pointer */
 	adbWaitingCmd = adbOutputBuffer[2];	/* save wait command */
 	if (adbWriteDelay != 1) {	/* start command now? */
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("out start NOW");
 #endif
 		delay(ADB_DELAY);
 		adbActionState = ADB_ACTION_OUT;	/* set next state */
 		ADB_SET_SR_OUTPUT();	/* set shift register for OUT */
 		write_via_reg(VIA1, vSR, adbOutputBuffer[adbSentChars + 1]);	/* load byte for output */
 		ADB_SET_STATE_ACKOFF_CUDA();
 		ADB_SET_STATE_TIP();	/* tell ADB that we want to send */
+	}
 	adbWriteDelay = 1;	/* something in the write "queue" */
 	splx(s);
 	if ((s & (1 << 18)) || adb_polling) /* XXX were VIA1 interrupts blocked ? */
 		/* poll until byte done */
 		while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
 		    || (adbWaiting == 1))
 			if (ADB_SR_INTR_IS_ON) {	/* wait for "interrupt" */
 				adb_intr_cuda(NULL);	/* process it */
 				adb_soft_intr();
+			}
 	return 0;
 }				/* send_adb_cuda */
 int
 adb_intr(void *arg)
+{
 	switch (adbHardware) {
 	case ADB_HW_PMU:
 		return pm_intr(arg);
 		break;
 	case ADB_HW_CUDA:
 		return adb_intr_cuda(arg);
 		break;
 	case ADB_HW_UNKNOWN:
 		break;
+	}
 	return 0;
+}
 /*
  * adb_pass_up is called by the interrupt-time routines.
  * It takes the raw packet data that was received from the
  * device and puts it into the queue that the upper half
  * processes. It then signals for a soft ADB interrupt which
  * will eventually call the upper half routine (adb_soft_intr).
+ *
  * If in->unsol is 0, then this is either the notification
  * that the packet was sent (on a LISTEN, for example), or the
  * response from the device (on a TALK). The completion routine
  * is called only if the user specified one.
+ *
  * If in->unsol is 1, then this packet was unsolicited and
  * so we look up the device in the ADB device table to determine
  * what its default service routine is.
+ *
  * If in->ack_only is 1, then we really only need to call
  * the completion routine, so don't do any other stuff.
+ *
  * Note that in->data contains the packet header AND data,
  * while adbInbound[]->data contains ONLY data.
+ *
  * Note: Called only at interrupt time. Assumes this.
  */
 void
 adb_pass_up(struct adbCommand *in)
+{
 	int start = 0, len = 0, cmd = 0;
 	ADBDataBlock block;
 	/* temp for testing */
 	/*u_char *buffer = 0;*/
 	/*u_char *compdata = 0;*/
 	/*u_char *comprout = 0;*/
 	if (adbInCount >= ADB_QUEUE) {
 #ifdef ADB_DEBUG
 		if (adb_debug)
 			printf_intr("adb: ring buffer overflow\n");
 #endif
 		return;
+	}
 	if (in->ack_only) {
 		len = in->data[0];
 		cmd = in->cmd;
 		start = 0;
 	} else {
 		switch (adbHardware) {
 		case ADB_HW_CUDA:
 			/* If it's unsolicited, accept only ADB data for now */
 			if (in->unsol)
 				if (0 != in->data[2])
 					return;
 			cmd = in->data[4];
 			if (in->data[0] < 5)
 				len = 0;
 			else
 				len = in->data[0]-4;
 			start = 4;
 			break;
 		case ADB_HW_PMU:
 			cmd = in->data[1];
 			if (in->data[0] < 2)
 				len = 0;
 			else
 				len = in->data[0]-1;
 			start = 1;
 			break;
 		case ADB_HW_UNKNOWN:
 			return;
+		}
 		/* Make sure there is a valid device entry for this device */
 		if (in->unsol) {
 			/* ignore unsolicited data during adbreinit */
 			if (adbStarting)
 				return;
 			/* get device's comp. routine and data area */
 			if (-1 == get_adb_info(&block, ADB_CMDADDR(cmd)))
 				return;
+		}
+	}
 	/*
  	 * If this is an unsolicited packet, we need to fill in
  	 * some info so adb_soft_intr can process this packet
  	 * properly. If it's not unsolicited, then use what
  	 * the caller sent us.
  	 */
 	if (in->unsol) {
 		adbInbound[adbInTail].compRout = (void *)block.dbServiceRtPtr;
 		adbInbound[adbInTail].compData = (void *)block.dbDataAreaAddr;
 		adbInbound[adbInTail].saveBuf = (void *)adbInbound[adbInTail].data;
 	} else {
 		adbInbound[adbInTail].compRout = in->compRout;
 		adbInbound[adbInTail].compData = in->compData;
 		adbInbound[adbInTail].saveBuf = in->saveBuf;
+	}
 #ifdef ADB_DEBUG
 	if (adb_debug && in->data[1] == 2)
 		printf_intr("adb: caught error\n");
 #endif
 	/* copy the packet data over */
 	/*
 	 * TO DO: If the *_intr routines fed their incoming data
 	 * directly into an adbCommand struct, which is passed to
 	 * this routine, then we could eliminate this copy.
 	 */
 	memcpy(adbInbound[adbInTail].data + 1, in->data + start + 1, len);
 	adbInbound[adbInTail].data[0] = len;
 	adbInbound[adbInTail].cmd = cmd;
 	adbInCount++;
 	if (++adbInTail >= ADB_QUEUE)
 		adbInTail = 0;
 	/*
 	 * If the debugger is running, call upper half manually.
 	 * Otherwise, trigger a soft interrupt to handle the rest later.
 	 */
 	if (adb_polling)
 		adb_soft_intr();
 	else
 		setsoftadb();
 	return;
+}
 /*
  * Called to process the packets after they have been
  * placed in the incoming queue.
+ *
  */
 void
 adb_soft_intr(void)
+{
 	int s;
 	int cmd = 0;
 	u_char *buffer = 0;
 	adbComp *comprout = NULL;
 	volatile int *compdata = 0;
 #if 0
 	s = splhigh();
 	printf_intr("sr: %x\n", (s & 0x0700));
 	splx(s);
 #endif
 /*delay(2*ADB_DELAY);*/
 	while (adbInCount) {
 #ifdef ADB_DEBUG
 		if (adb_debug & 0x80)
 			printf_intr("%x %x %x ",
 			    adbInCount, adbInHead, adbInTail);
 #endif
 		/* get the data we need from the queue */
 		buffer = adbInbound[adbInHead].saveBuf;
 		comprout = adbInbound[adbInHead].compRout;
 		compdata = adbInbound[adbInHead].compData;
 		cmd = adbInbound[adbInHead].cmd;
 		/* copy over data to data area if it's valid */
 		/*
 		 * Note that for unsol packets we don't want to copy the
 		 * data anywhere, so buffer was already set to 0.
 		 * For ack_only buffer was set to 0, so don't copy.
 		 */
 		if (buffer)
 			memcpy(buffer, adbInbound[adbInHead].data,
 			    adbInbound[adbInHead].data[0] + 1);
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80) {
 				printf_intr("%p %p %p %x ",
 				    buffer, comprout, compdata, (short)cmd);
 				printf_intr("buf: ");
 				print_single(adbInbound[adbInHead].data);
+			}
 #endif
 		/* Remove the packet from the queue before calling
 		 * the completion routine, so that the completion
 		 * routine can reentrantly process the queue.  For
 		 * example, this happens when polling is turned on
 		 * by entering the debuger by keystroke.
 		 */
 		s = splhigh();
 		adbInCount--;
 		if (++adbInHead >= ADB_QUEUE)
 			adbInHead = 0;
 		splx(s);
 		/* call default completion routine if it's valid */
 		if (comprout)
 			(*comprout)(buffer, compdata, cmd);
+	}
 	return;
+}
 /*
  * This is my version of the ADBOp routine. It mainly just calls the
  * hardware-specific routine.
+ *
  *   data 	: pointer to data area to be used by compRout
  *   compRout	: completion routine
  *   buffer	: for LISTEN: points to data to send - MAX 8 data bytes,
  *		  byte 0 = # of bytes
  *		: for TALK: points to place to save return data
  *   command	: the adb command to send
  *   result	: 0 = success
  *		: -1 = could not complete
  */
 int
 adb_op(Ptr buffer, adbComp *compRout, volatile void *data, short command)
+{
 	int result;
 	switch (adbHardware) {
 	case ADB_HW_PMU:
 		result = pm_adb_op((u_char *)buffer, compRout,
 		    data, (int)command);
 		if (result == 0)
 			return 0;
 		else
 			return -1;
 		break;
 	case ADB_HW_CUDA:
 		result = send_adb_cuda((u_char *)0, (u_char *)buffer,
 		    compRout, data, (int)command);
 		if (result == 0)
 			return 0;
 		else
 			return -1;
 		break;
 	case ADB_HW_UNKNOWN:
 	default:
 		return -1;
+	}
+}
 /*
  * adb_hw_setup
  * This routine sets up the possible machine specific hardware
  * config (mainly VIA settings) for the various models.
  */
 void
 adb_hw_setup(void)
+{
 	volatile int i;
 	switch (adbHardware) {
 	case ADB_HW_PMU:
 		/*
 		 * XXX - really PM_VIA_CLR_INTR - should we put it in
 		 * pm_direct.h?
 		 */
 		write_via_reg(VIA1, vIFR, 0x90);	/* clear interrupt */
 		break;
 	case ADB_HW_CUDA:
 		via_reg_or(VIA1, vDirB, 0x30);	/* register B bits 4 and 5:
 						 * outputs */
 		via_reg_and(VIA1, vDirB, 0xf7);	/* register B bit 3: input */
 		via_reg_and(VIA1, vACR, ~vSR_OUT);	/* make sure SR is set
 							 * to IN */
 		write_via_reg(VIA1, vACR, (read_via_reg(VIA1, vACR) | 0x0c) & ~0x10);
 		adbActionState = ADB_ACTION_IDLE;	/* used by all types of
 							 * hardware */
 		write_via_reg(VIA1, vIER, 0x84);/* make sure VIA interrupts
 						 * are on */
 		ADB_SET_STATE_IDLE_CUDA();	/* set ADB bus state to idle */
 		/* sort of a device reset */
 		i = ADB_SR();	/* clear interrupt */
 		ADB_VIA_INTR_DISABLE();	/* no interrupts while clearing */
 		ADB_SET_STATE_IDLE_CUDA();	/* reset state to idle */
 		delay(ADB_DELAY);
 		ADB_SET_STATE_TIP();	/* signal start of frame */
 		delay(ADB_DELAY);
 		ADB_TOGGLE_STATE_ACK_CUDA();
 		delay(ADB_DELAY);
 		ADB_CLR_STATE_TIP();
 		delay(ADB_DELAY);
 		ADB_SET_STATE_IDLE_CUDA();	/* back to idle state */
 		i = ADB_SR();	/* clear interrupt */
 		ADB_VIA_INTR_ENABLE();	/* ints ok now */
 		break;
 	case ADB_HW_UNKNOWN:
 	default:
 		write_via_reg(VIA1, vIER, 0x04);/* turn interrupts off - TO
 						 * DO: turn PB ints off? */
 		return;
 		break;
+	}
+}
 /*
  * adb_reinit sets up the adb stuff
+ *
  */
 void
 adb_reinit(void)
+{
 	u_char send_string[ADB_MAX_MSG_LENGTH];
 	ADBDataBlock data;	/* temp. holder for getting device info */
 	volatile int i, x;
 	int s = 0;		/* XXX: gcc */
 	int command;
 	int result;
 	int saveptr;		/* point to next free relocation address */
 	int device;
 	int nonewtimes;		/* times thru loop w/o any new devices */
 	static bool callo;
 	if (!callo) {
 		callo = true;
 		callout_init(&adb_cuda_tickle_ch, 0);
 		callout_init(&adb_soft_intr_ch, 0);
+	}
 	/* Make sure we are not interrupted while building the table. */
 	if (adbHardware != ADB_HW_PMU)	/* ints must be on for PMU? */
 		s = splhigh();
 	ADBNumDevices = 0;	/* no devices yet */
 	/* Let intr routines know we are running reinit */
 	adbStarting = 1;
 	/*
 	 * Initialize the ADB table.  For now, we'll always use the same table
 	 * that is defined at the beginning of this file - no mallocs.
 	 */
 	for (i = 0; i < 16; i++)
 		ADBDevTable[i].devType = 0;
 	adb_setup_hw_type();	/* setup hardware type */
 	adb_hw_setup();		/* init the VIA bits and hard reset ADB */
 	delay(1000);
 	/* send an ADB reset first */
 	result = adb_op_sync((Ptr)0, NULL, (Ptr)0, (short)0x00);
 	delay(200000);
 #ifdef ADB_DEBUG
 	if (result && adb_debug) {
 		printf_intr("adb_reinit: failed to reset, result = %d\n",result);
+	}
 #endif
 	/*
 	 * Probe for ADB devices. Probe devices 1-15 quickly to determine
 	 * which device addresses are in use and which are free. For each
 	 * address that is in use, move the device at that address to a higher
 	 * free address. Continue doing this at that address until no device
 	 * responds at that address. Then move the last device that was moved
 	 * back to the original address. Do this for the remaining addresses
 	 * that we determined were in use.
+	 *
 	 * When finished, do this entire process over again with the updated
 	 * list of in use addresses. Do this until no new devices have been
 	 * found in 20 passes though the in use address list. (This probably
 	 * seems long and complicated, but it's the best way to detect multiple
 	 * devices at the same address - sometimes it takes a couple of tries
 	 * before the collision is detected.)
 	 */
 	/* initial scan through the devices */
 	for (i = 1; i < 16; i++) {
 		send_string[0] = 0;
 		command = ADBTALK(i, 3);
 		result = adb_op_sync((Ptr)send_string, NULL,
 		    (Ptr)0, (short)command);
 #ifdef ADB_DEBUG
 		if (result && adb_debug) {
 			printf_intr("adb_reinit: scan of device %d, result = %d, str = 0x%x\n",
 					i,result,send_string[0]);
+		}
 #endif
 		if (send_string[0] != 0) {
 			/* check for valid device handler */
 			switch (send_string[2]) {
 			case 0:
 			case 0xfd:
 			case 0xfe:
 			case 0xff:
 				continue;	/* invalid, skip */
+			}
 			/* found a device */
 			++ADBNumDevices;
 			KASSERT(ADBNumDevices < 16);
 			ADBDevTable[ADBNumDevices].devType =
 				(int)send_string[2];
 			ADBDevTable[ADBNumDevices].origAddr = i;
 			ADBDevTable[ADBNumDevices].currentAddr = i;
 			ADBDevTable[ADBNumDevices].DataAreaAddr =
 			    (long)0;
 			ADBDevTable[ADBNumDevices].ServiceRtPtr = (void *)0;
 			pm_check_adb_devices(i);	/* tell pm driver device
 							 * is here */
+		}
+	}
 	/* find highest unused address */
 	for (saveptr = 15; saveptr > 0; saveptr--)
 		if (-1 == get_adb_info(&data, saveptr))
 			break;
 #ifdef ADB_DEBUG
 	if (adb_debug & 0x80) {
 		printf_intr("first free is: 0x%02x\n", saveptr);
 		printf_intr("devices: %i\n", ADBNumDevices);
+	}
 #endif
 	nonewtimes = 0;		/* no loops w/o new devices */
 	while (saveptr > 0 && nonewtimes++ < 11) {
 		for (i = 1; i <= ADBNumDevices; i++) {
 			device = ADBDevTable[i].currentAddr;
 #ifdef ADB_DEBUG
 			if (adb_debug & 0x80)
 				printf_intr("moving device 0x%02x to 0x%02x "
 				    "(index 0x%02x)  ", device, saveptr, i);
 #endif
 			/* send TALK R3 to address */
 			command = ADBTALK(device, 3);
 			adb_op_sync((Ptr)send_string, NULL,
 			    (Ptr)0, (short)command);
 			/* move device to higher address */
 			command = ADBLISTEN(device, 3);
 			send_string[0] = 2;
 			send_string[1] = (u_char)(saveptr | 0x60);
 			send_string[2] = 0xfe;
 			adb_op_sync((Ptr)send_string, NULL,
 			    (Ptr)0, (short)command);
 			delay(500);
 			/* send TALK R3 - anything at new address? */
 			command = ADBTALK(saveptr, 3);
 			adb_op_sync((Ptr)send_string, NULL,
 			    (Ptr)0, (short)command);
 			delay(500);
 			if (send_string[0] == 0) {
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("failed, continuing\n");
 #endif
 				continue;
+			}
 			/* send TALK R3 - anything at old address? */
 			command = ADBTALK(device, 3);
 			result = adb_op_sync((Ptr)send_string, NULL,
 			    (Ptr)0, (short)command);
 			if (send_string[0] != 0) {
 				/* check for valid device handler */
 				switch (send_string[2]) {
 				case 0:
 				case 0xfd:
 				case 0xfe:
 				case 0xff:
 					continue;	/* invalid, skip */
+				}
 				/* new device found */
 				/* update data for previously moved device */
 				ADBDevTable[i].currentAddr = saveptr;
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("old device at index %i\n",i);
 #endif
 				/* add new device in table */
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("new device found\n");
 #endif
 				if (saveptr > ADBNumDevices) {
 					++ADBNumDevices;
 					KASSERT(ADBNumDevices < 16);
+				}
 				ADBDevTable[ADBNumDevices].devType =
 					(int)send_string[2];
 				ADBDevTable[ADBNumDevices].origAddr = device;
 				ADBDevTable[ADBNumDevices].currentAddr = device;
 				/* These will be set correctly in adbsys.c */
 				/* Until then, unsol. data will be ignored. */
 				ADBDevTable[ADBNumDevices].DataAreaAddr =
 				    (long)0;
 				ADBDevTable[ADBNumDevices].ServiceRtPtr =
 				    (void *)0;
 				/* find next unused address */
 				for (x = saveptr; x > 0; x--) {
 					if (-1 == get_adb_info(&data, x)) {
 						saveptr = x;
 						break;
+					}
+				}
 				if (x == 0)
 					saveptr = 0;
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("new free is 0x%02x\n",
 					    saveptr);
 #endif
 				nonewtimes = 0;
 				/* tell pm driver device is here */
 				pm_check_adb_devices(device);
 			} else {
 #ifdef ADB_DEBUG
 				if (adb_debug & 0x80)
 					printf_intr("moving back...\n");
 #endif
 				/* move old device back */
 				command = ADBLISTEN(saveptr, 3);
 				send_string[0] = 2;
 				send_string[1] = (u_char)(device | 0x60);
 				send_string[2] = 0xfe;
 				adb_op_sync((Ptr)send_string, NULL,
 				    (Ptr)0, (short)command);
 				delay(1000);
+			}
+		}
+	}
 #ifdef ADB_DEBUG
 	if (adb_debug) {
 		for (i = 1; i <= ADBNumDevices; i++) {
 			x = get_ind_adb_info(&data, i);
 			if (x != -1)
 				printf_intr("index 0x%x, addr 0x%x, type 0x%x\n",
 				    i, x, data.devType);
+		}
+	}
 #endif
 #ifdef ADB_DEBUG
 	if (adb_debug) {
 		if (0 == ADBNumDevices)	/* tell user if no devices found */
 			printf_intr("adb: no devices found\n");
+	}
 #endif
 	adbStarting = 0;	/* not starting anymore */
 #ifdef ADB_DEBUG
 	if (adb_debug)
 		printf_intr("adb: ADBReInit complete\n");
 #endif
 	if (adbHardware == ADB_HW_CUDA)
 		callout_reset(&adb_cuda_tickle_ch, ADB_TICKLE_TICKS,
 		    (void *)adb_cuda_tickle, NULL);
 	if (adbHardware != ADB_HW_PMU)	/* ints must be on for PMU? */
 		splx(s);
+}
 /*
  * adb_cmd_result
+ *
  * This routine lets the caller know whether the specified adb command string
  * should expect a returned result, such as a TALK command.
+ *
  * returns: 0 if a result should be expected
  *          1 if a result should NOT be expected
  */
 int
 adb_cmd_result(u_char *in)
+{
 	switch (adbHardware) {
 	case ADB_HW_CUDA:
 		/* was it an ADB talk command? */
 		if ((in[1] == 0x00) && ((in[2] & 0x0c) == 0x0c))
 			return 0;
 		/* was it an RTC/PRAM read date/time? */
 		if ((in[1] == 0x01) && (in[2] == 0x03))
 			return 0;
 		return 1;
 	case ADB_HW_PMU:
 		return 1;
 	case ADB_HW_UNKNOWN:
 	default:
 		return 1;
+	}
+}
 /*
  * adb_cmd_extra
+ *
  * This routine lets the caller know whether the specified adb command string
  * may have extra data appended to the end of it, such as a LISTEN command.
+ *
  * returns: 0 if extra data is allowed
  *          1 if extra data is NOT allowed
  */
 int
 adb_cmd_extra(u_char *in)
+{
 	switch (adbHardware) {
 	case ADB_HW_CUDA:
 		/*
 		 * TO DO: support needs to be added to recognize RTC and PRAM
 		 * commands
 		 */
 		if ((in[2] & 0x0c) == 0x08)	/* was it a listen command? */
 			return 0;
 		/* add others later */
 		return 1;
 	case ADB_HW_PMU:
 		return 1;
 	case ADB_HW_UNKNOWN:
 	default:
 		return 1;
+	}
+}
 /*
  * adb_op_sync
+ *
  * This routine does exactly what the adb_op routine does, except that after
  * the adb_op is called, it waits until the return value is present before
  * returning.
+ *
  * NOTE: The user specified compRout is ignored, since this routine specifies
  * its own to adb_op, which is why you really called this in the first place
  * anyway.
  */
 int
 adb_op_sync(Ptr buffer, adbComp *compRout, Ptr data, short command)

 @@ -1,2058 +1,2058 @@
-/*	$NetBSD: intr.c,v 1.166 2023/11/29 11:40:37 mlelstv Exp $	*/
+/*	$NetBSD: intr.c,v 1.167 2024/03/05 20:58:05 andvar Exp $	*/
 /*
  * Copyright (c) 2007, 2008, 2009, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran, and by Jason R. Thorpe.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, 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 THE FOUNDATION 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 2002 (c) Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Frank van der Linden for Wasabi Systems, Inc.
+ *
  * 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 for the NetBSD Project by
  *      Wasabi Systems, Inc.
  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
  * 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) 1991 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * William 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. 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.
+ *
  *	@(#)isa.c	7.2 (Berkeley) 5/13/91
  */
 /*-
  * Copyright (c) 1993, 1994 Charles Hannum.
+ *
  * 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.
+ *
  *	@(#)isa.c	7.2 (Berkeley) 5/13/91
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: intr.c,v 1.166 2023/11/29 11:40:37 mlelstv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: intr.c,v 1.167 2024/03/05 20:58:05 andvar Exp $");
 #include "opt_intrdebug.h"
 #include "opt_multiprocessor.h"
 #include "opt_acpi.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/syslog.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/errno.h>
 #include <sys/intr.h>
 #include <sys/cpu.h>
 #include <sys/xcall.h>
 #include <sys/interrupt.h>
 #include <sys/reboot.h> /* for AB_VERBOSE */
 #include <sys/sdt.h>
 #include <sys/kauth.h>
 #include <sys/conf.h>
 #include <uvm/uvm_extern.h>
 #include <machine/i8259.h>
 #include <machine/pio.h>
 #include <x86/intr_private.h>
 #include "ioapic.h"
 #include "lapic.h"
 #include "pci.h"
 #include "acpica.h"
 #ifndef XENPV
 #include "hyperv.h"
 #if NHYPERV > 0
 #include <dev/hyperv/hypervvar.h>
 extern void Xresume_hyperv_hypercall(void);
 extern void Xrecurse_hyperv_hypercall(void);
 #endif
 #endif
 #if NIOAPIC > 0 || NACPICA > 0
 #include <machine/i82093var.h>
 #include <machine/mpbiosvar.h>
 #include <machine/mpacpi.h>
 #endif
 #if NLAPIC > 0
 #include <machine/i82489var.h>
 #endif
 #if NPCI > 0
 #include <dev/pci/ppbreg.h>
 #endif
 #include <x86/pci/msipic.h>
 #include <x86/pci/pci_msi_machdep.h>
 #if NPCI == 0 || !defined(__HAVE_PCI_MSI_MSIX)
 #define msipic_is_msi_pic(PIC)	(false)
 #endif
 #include <ddb/db_active.h>
 #ifdef DDB
 #include <ddb/db_output.h>
 #endif
 #ifdef INTRDEBUG
 #define DPRINTF(msg) printf msg
 #else
 #define DPRINTF(msg)
 #endif
 static SIMPLEQ_HEAD(, intrsource) io_interrupt_sources =
 	SIMPLEQ_HEAD_INITIALIZER(io_interrupt_sources);
 static kmutex_t intr_distribute_lock;
 static int intr_allocate_slot_cpu(struct cpu_info *, struct pic *, int, int *,
 				  struct intrsource *);
 static int __noinline intr_allocate_slot(struct pic *, int, int,
 					 struct cpu_info **, int *, int *,
 					 struct intrsource *);
 static void intr_source_free(struct cpu_info *, int, struct pic *, int);
 static void intr_establish_xcall(void *, void *);
 static void intr_disestablish_xcall(void *, void *);
 static const char *legacy_intr_string(int, char *, size_t, struct pic *);
 static const char *xen_intr_string(int, char *, size_t, struct pic *);
 #if defined(INTRSTACKSIZE)
 static inline bool redzone_const_or_false(bool);
 static inline int redzone_const_or_zero(int);
 #endif
 static void intr_redistribute_xc_t(void *, void *);
 static void intr_redistribute_xc_s1(void *, void *);
 static void intr_redistribute_xc_s2(void *, void *);
 static bool intr_redistribute(struct cpu_info *);
 static struct intrsource *intr_get_io_intrsource(const char *);
 static void intr_free_io_intrsource_direct(struct intrsource *);
 static int intr_num_handlers(struct intrsource *);
 static int intr_find_unused_slot(struct cpu_info *, int *);
 static void intr_activate_xcall(void *, void *);
 static void intr_deactivate_xcall(void *, void *);
 static void intr_get_affinity(struct intrsource *, kcpuset_t *);
 static int intr_set_affinity(struct intrsource *, const kcpuset_t *);
 SDT_PROBE_DEFINE3(sdt, kernel, intr, entry,
     "int (*)(void *)"/*func*/,
     "void *"/*arg*/,
     "struct intrhand *"/*ih*/);
 SDT_PROBE_DEFINE4(sdt, kernel, intr, return,
     "int (*)(void *)"/*func*/,
     "void *"/*arg*/,
     "struct intrhand *"/*ih*/,
     "int"/*handled*/);
 /*
  * Fill in default interrupt table (in case of spurious interrupt
  * during configuration of kernel), setup interrupt control unit
  */
 void
 intr_default_setup(void)
+{
 	struct idt_vec *iv = &(cpu_info_primary.ci_idtvec);
 	int i;
 	/* icu vectors */
 	for (i = 0; i < NUM_LEGACY_IRQS; i++) {
 		idt_vec_reserve(iv, ICU_OFFSET + i);
 		idt_vec_set(iv, ICU_OFFSET + i, legacy_stubs[i].ist_entry);
+	}
 	/*
 	 * Eventually might want to check if it's actually there.
 	 */
 	i8259_default_setup();
 	mutex_init(&intr_distribute_lock, MUTEX_DEFAULT, IPL_NONE);
+}
 /*
  * Handle a NMI, possibly a machine check.
  * return true to panic system, false to ignore.
  */
 void
 x86_nmi(void)
+{
 	log(LOG_CRIT, "NMI port 61 %x, port 70 %x\n", inb(0x61), inb(0x70));
+}
 /*
  * Create an interrupt id such as "ioapic0 pin 9". This interrupt id is used
  * by MI code and intrctl(8).
  */
 const char *
 intr_create_intrid(int legacy_irq, struct pic *pic, int pin, char *buf,
     size_t len)
+{
 	int ih = 0;
 #if NPCI > 0
 #if defined(__HAVE_PCI_MSI_MSIX)
 	if ((pic->pic_type == PIC_MSI) || (pic->pic_type == PIC_MSIX)) {
 		uint64_t pih;
 		int dev, vec;
 		dev = msipic_get_devid(pic);
 		vec = pin;
 		pih = __SHIFTIN((uint64_t)dev, MSI_INT_DEV_MASK)
 			| __SHIFTIN((uint64_t)vec, MSI_INT_VEC_MASK)
 			| APIC_INT_VIA_MSI;
 		if (pic->pic_type == PIC_MSI)
 			MSI_INT_MAKE_MSI(pih);
 		else if (pic->pic_type == PIC_MSIX)
 			MSI_INT_MAKE_MSIX(pih);
 		return x86_pci_msi_string(NULL, pih, buf, len);
+	}
 #endif /* __HAVE_PCI_MSI_MSIX */
 #endif
 	if (pic->pic_type == PIC_XEN) {
 		ih = pin;	/* Port == pin */
 		return xen_intr_string(pin, buf, len, pic);
+	}
 	/*
 	 * If the device is pci, "legacy_irq" is always -1. Least 8 bit of "ih"
 	 * is only used in intr_string() to show the irq number.
 	 * If the device is "legacy"(such as floppy), it should not use
 	 * intr_string().
 	 */
 	if (pic->pic_type == PIC_I8259) {
 		ih = legacy_irq;
 		return legacy_intr_string(ih, buf, len, pic);
+	}
 #if NIOAPIC > 0 || NACPICA > 0
 	ih = ((pic->pic_apicid << APIC_INT_APIC_SHIFT) & APIC_INT_APIC_MASK)
 	    | ((pin << APIC_INT_PIN_SHIFT) & APIC_INT_PIN_MASK);
 	if (pic->pic_type == PIC_IOAPIC) {
 		ih |= APIC_INT_VIA_APIC;
+	}
 	ih |= pin;
 	return intr_string(ih, buf, len);
 #endif
 	return NULL; /* No pic found! */
+}
 /*
  * Find intrsource from io_interrupt_sources list.
  */
 static struct intrsource *
 intr_get_io_intrsource(const char *intrid)
+{
 	struct intrsource *isp;
 	KASSERT(mutex_owned(&cpu_lock));
 	SIMPLEQ_FOREACH(isp, &io_interrupt_sources, is_list) {
 		KASSERT(isp->is_intrid != NULL);
 		if (strncmp(intrid, isp->is_intrid, INTRIDBUF - 1) == 0)
 			return isp;
+	}
 	return NULL;
+}
 /*
  * Allocate intrsource and add to io_interrupt_sources list.
  */
 struct intrsource *
 intr_allocate_io_intrsource(const char *intrid)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	struct intrsource *isp;
 	struct percpu_evcnt *pep;
 	KASSERT(mutex_owned(&cpu_lock));
 	if (intrid == NULL)
 		return NULL;
 	isp = kmem_zalloc(sizeof(*isp), KM_SLEEP);
 	pep = kmem_zalloc(sizeof(*pep) * ncpu, KM_SLEEP);
 	isp->is_saved_evcnt = pep;
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		pep->cpuid = ci->ci_cpuid;
 		pep++;
+	}
 	strlcpy(isp->is_intrid, intrid, sizeof(isp->is_intrid));
 	SIMPLEQ_INSERT_TAIL(&io_interrupt_sources, isp, is_list);
 	return isp;
+}
 /*
  * Remove from io_interrupt_sources list and free by the intrsource pointer.
  */
 static void
 intr_free_io_intrsource_direct(struct intrsource *isp)
+{
 	KASSERT(mutex_owned(&cpu_lock));
 	SIMPLEQ_REMOVE(&io_interrupt_sources, isp, intrsource, is_list);
 	/* Is this interrupt established? */
 	if (isp->is_evname[0] != '\0') {
 		evcnt_detach(&isp->is_evcnt);
 		isp->is_evname[0] = '\0';
+	}
 	kmem_free(isp->is_saved_evcnt,
 	    sizeof(*(isp->is_saved_evcnt)) * ncpu);
 	kmem_free(isp, sizeof(*isp));
+}
 /*
  * Remove from io_interrupt_sources list and free by the interrupt id.
  * This function can be used by MI code.
  */
 void
 intr_free_io_intrsource(const char *intrid)
+{
 	struct intrsource *isp;
 	KASSERT(mutex_owned(&cpu_lock));
 	if (intrid == NULL)
 		return;
 	if ((isp = intr_get_io_intrsource(intrid)) == NULL) {
 		return;
+	}
 	/* If the interrupt uses shared IRQ, don't free yet. */
 	if (isp->is_handlers != NULL) {
 		return;
+	}
 	intr_free_io_intrsource_direct(isp);
+}
 static int
 intr_allocate_slot_cpu(struct cpu_info *ci, struct pic *pic, int pin,
 		       int *index, struct intrsource *chained)
+{
 	int slot, i;
 	struct intrsource *isp;
 	KASSERT(mutex_owned(&cpu_lock));
 	if (pic == &i8259_pic) {
 		KASSERT(CPU_IS_PRIMARY(ci));
 		slot = pin;
 	} else {
 		int start = 0;
 		int max = MAX_INTR_SOURCES;
 		slot = -1;
 		/* avoid reserved slots for legacy interrupts. */
 		if (CPU_IS_PRIMARY(ci) && msipic_is_msi_pic(pic))
 			start = NUM_LEGACY_IRQS;
 		/* don't step over Xen's slots */
 		if (vm_guest == VM_GUEST_XENPVH)
 			max = SIR_XENIPL_VM;
 		/*
 		 * intr_allocate_slot has checked for an existing mapping.
 		 * Now look for a free slot.
 		 */
 		for (i = start; i < max ; i++) {
 			if (ci->ci_isources[i] == NULL) {
 				slot = i;
 				break;
+			}
+		}
 		if (slot == -1) {
 			return EBUSY;
+		}
+	}
 	isp = ci->ci_isources[slot];
 	if (isp == NULL) {
 		const char *via;
 		isp = chained;
 		KASSERT(isp != NULL);
 		if (pic->pic_type == PIC_MSI || pic->pic_type == PIC_MSIX)
 			via = "vec";
 		else
 			via = "pin";
 		snprintf(isp->is_evname, sizeof (isp->is_evname),
 		    "%s %d", via, pin);
 		evcnt_attach_dynamic(&isp->is_evcnt, EVCNT_TYPE_INTR, NULL,
 		    pic->pic_name, isp->is_evname);
 		isp->is_active_cpu = ci->ci_cpuid;
 		ci->ci_isources[slot] = isp;
+	}
 	*index = slot;
 	return 0;
+}
 /*
  * A simple round-robin allocator to assign interrupts to CPUs.
  */
 static int __noinline
 intr_allocate_slot(struct pic *pic, int pin, int level,
 		   struct cpu_info **cip, int *index, int *idt_slot,
 		   struct intrsource *chained)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci, *lci;
 	struct intrsource *isp;
 	int slot = 0, idtvec, error;
 	KASSERT(mutex_owned(&cpu_lock));
 	/* First check if this pin is already used by an interrupt vector. */
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		for (slot = 0 ; slot < MAX_INTR_SOURCES ; slot++) {
 			if ((isp = ci->ci_isources[slot]) == NULL) {
 				continue;
+			}
 			if (isp->is_pic == pic &&
 			    pin != -1 && isp->is_pin == pin) {
 				*idt_slot = isp->is_idtvec;
 				*index = slot;
 				*cip = ci;
 				return 0;
+			}
+		}
+	}
 	/*
 	 * The pic/pin combination doesn't have an existing mapping.
 	 * Find a slot for a new interrupt source.  For the i8259 case,
 	 * we always use reserved slots of the primary CPU.  Otherwise,
 	 * we make an attempt to balance the interrupt load.
+	 *
 	 * PIC and APIC usage are essentially exclusive, so the reservation
 	 * of the ISA slots is ignored when assigning IOAPIC slots.
 	 */
 	if (pic == &i8259_pic) {
 		/*
 		 * Must be directed to BP.
 		 */
 		ci = &cpu_info_primary;
 		error = intr_allocate_slot_cpu(ci, pic, pin, &slot, chained);
 	} else {
 		/*
 		 * Find least loaded AP/BP and try to allocate there.
 		 */
 		ci = NULL;
 		for (CPU_INFO_FOREACH(cii, lci)) {
 			if ((lci->ci_schedstate.spc_flags & SPCF_NOINTR) != 0) {
 				continue;
+			}
 #if 0
 			if (ci == NULL ||
 			    ci->ci_nintrhand > lci->ci_nintrhand) {
 				ci = lci;
+			}
 #else
 			ci = &cpu_info_primary;
 #endif
+		}
 		KASSERT(ci != NULL);
 		error = intr_allocate_slot_cpu(ci, pic, pin, &slot, chained);
 		/*
 		 * If that did not work, allocate anywhere.
 		 */
 		if (error != 0) {
 			for (CPU_INFO_FOREACH(cii, ci)) {
 				if ((ci->ci_schedstate.spc_flags &
 				    SPCF_NOINTR) != 0) {
 					continue;
+				}
 				error = intr_allocate_slot_cpu(ci, pic,
 				    pin, &slot, chained);
 				if (error == 0) {
 					break;
+				}
+			}
+		}
+	}
 	if (error != 0) {
 		return error;
+	}
 	KASSERT(ci != NULL);
 	/*
 	 * Now allocate an IDT vector.
 	 * For the 8259 these are reserved up front.
 	 */
 	if (pic == &i8259_pic) {
 		idtvec = ICU_OFFSET + pin;
 	} else {
 		/*
 		 * TODO to support MSI (not MSI-X) multiple vectors
+		 *
 		 * PCI Local Bus Specification Revision 3.0 says the devices
 		 * which use MSI multiple vectors increment the low order bits
 		 * of MSI message data.
 		 * On the other hand, Intel SDM "10.11.2 Message Data Register
 		 * Format" says the 7:0 bits of MSI message data mean Interrupt
 		 * Descriptor Table(IDT) vector.
 		 * As the result of these two documents, the IDT vectors which
 		 * are used by a device using MSI multiple vectors must be
 		 * continuous.
 		 */
 		struct idt_vec *iv;
 		iv = idt_vec_ref(&ci->ci_idtvec);
 		idtvec = idt_vec_alloc(iv, APIC_LEVEL(level), IDT_INTR_HIGH);
+	}
 	if (idtvec < 0) {
 		evcnt_detach(&ci->ci_isources[slot]->is_evcnt);
 		ci->ci_isources[slot]->is_evname[0] = '\0';
 		ci->ci_isources[slot] = NULL;
 		return EBUSY;
+	}
 	ci->ci_isources[slot]->is_idtvec = idtvec;
 	*idt_slot = idtvec;
 	*index = slot;
 	*cip = ci;
 	return 0;
+}
 static void
 intr_source_free(struct cpu_info *ci, int slot, struct pic *pic, int idtvec)
+{
 	struct intrsource *isp;
 	struct idt_vec *iv;
 	isp = ci->ci_isources[slot];
 	iv = idt_vec_ref(&ci->ci_idtvec);
 	if (isp->is_handlers != NULL)
 		return;
 	ci->ci_isources[slot] = NULL;
 	if (pic != &i8259_pic)
 		idt_vec_free(iv, idtvec);
 	isp->is_recurse = NULL;
 	isp->is_resume = NULL;
+}
 #ifdef MULTIPROCESSOR
 static int intr_biglock_wrapper(void *);
 /*
  * intr_biglock_wrapper: grab biglock and call a real interrupt handler.
  */
 static int
 intr_biglock_wrapper(void *vp)
+{
 	struct intrhand *ih = vp;
 	int locks;
 	int ret;
 	KERNEL_LOCK(1, NULL);
 	locks = curcpu()->ci_biglock_count;
 	SDT_PROBE3(sdt, kernel, intr, entry,
 	    ih->ih_realfun, ih->ih_realarg, ih);
 	ret = (*ih->ih_realfun)(ih->ih_realarg);
 	SDT_PROBE4(sdt, kernel, intr, return,
 	    ih->ih_realfun, ih->ih_realarg, ih, ret);
 	KASSERTMSG(locks == curcpu()->ci_biglock_count,
 	    "%s @ %p slipped locks %d -> %d",
 	    ih->ih_xname, ih->ih_realfun, locks, curcpu()->ci_biglock_count);
 	KERNEL_UNLOCK_ONE(NULL);
 	return ret;
+}
 #endif /* MULTIPROCESSOR */
 #ifdef KDTRACE_HOOKS
 static int
 intr_kdtrace_wrapper(void *vp)
+{
 	struct intrhand *ih = vp;
 	int ret;
 	SDT_PROBE3(sdt, kernel, intr, entry,
 	    ih->ih_realfun, ih->ih_realarg, ih);
 	ret = (*ih->ih_realfun)(ih->ih_realarg);
 	SDT_PROBE4(sdt, kernel, intr, return,
 	    ih->ih_realfun, ih->ih_realarg, ih, ret);
 	return ret;
+}
 #endif
 /*
  * Append device name to intrsource. If device A and device B share IRQ number,
  * the device name of the interrupt id is "device A, device B".
  */
 static void
 intr_append_intrsource_xname(struct intrsource *isp, const char *xname)
+{
 	if (isp->is_xname[0] != '\0')
 		strlcat(isp->is_xname, ", ", sizeof(isp->is_xname));
 	strlcat(isp->is_xname, xname, sizeof(isp->is_xname));
+}
 /*
  * Called on bound CPU to handle calling pic_hwunmask from contexts
  * that are not already running on the bound CPU.
+ *
  * => caller (on initiating CPU) holds cpu_lock on our behalf
  * => arg1: struct intrhand *ih
  */
 static void
 intr_hwunmask_xcall(void *arg1, void *arg2)
+{
 	struct intrhand * const ih = arg1;
 	struct cpu_info * const ci = ih->ih_cpu;
 	KASSERT(ci == curcpu() || !mp_online);
 	const u_long psl = x86_read_psl();
 	x86_disable_intr();
 	struct intrsource * const source = ci->ci_isources[ih->ih_slot];
 	struct pic * const pic = source->is_pic;
 	if (source->is_mask_count == 0) {
 		(*pic->pic_hwunmask)(pic, ih->ih_pin);
+	}
 	x86_write_psl(psl);
+}
 /*
  * Handle per-CPU component of interrupt establish.
+ *
  * => caller (on initiating CPU) holds cpu_lock on our behalf
  * => arg1: struct intrhand *ih
  * => arg2: int idt_vec
  */
 static void
 intr_establish_xcall(void *arg1, void *arg2)
+{
 	struct idt_vec *iv;
 	struct intrsource *source;
 	struct intrstub *stubp;
 	struct intrhand *ih;
 	struct cpu_info *ci;
 	int idt_vec;
 	u_long psl;
 	ih = arg1;
 	KASSERT(ih->ih_cpu == curcpu() || !mp_online);
 	ci = ih->ih_cpu;
 	source = ci->ci_isources[ih->ih_slot];
 	idt_vec = (int)(intptr_t)arg2;
 	iv = idt_vec_ref(&ci->ci_idtvec);
 	/* Disable interrupts locally. */
 	psl = x86_read_psl();
 	x86_disable_intr();
 	/* Link in the handler and re-calculate masks. */
 	*(ih->ih_prevp) = ih;
 	x86_intr_calculatemasks(ci);
 	/* Hook in new IDT vector and SPL state. */
 	if (source->is_resume == NULL || source->is_idtvec != idt_vec) {
 		if (source->is_idtvec != 0 && source->is_idtvec != idt_vec)
 			idt_vec_free(iv, source->is_idtvec);
 		source->is_idtvec = idt_vec;
 		if (source->is_type == IST_LEVEL) {
 			stubp = &source->is_pic->pic_level_stubs[ih->ih_slot];
 		} else {
 			stubp = &source->is_pic->pic_edge_stubs[ih->ih_slot];
+		}
 		source->is_resume = stubp->ist_resume;
 		source->is_recurse = stubp->ist_recurse;
 		idt_vec_set(iv, idt_vec, stubp->ist_entry);
+	}
 	/* Re-enable interrupts locally. */
 	x86_write_psl(psl);
+}
 void *
 intr_establish_xname(int legacy_irq, struct pic *pic, int pin, int type,
 		     int level, int (*handler)(void *), void *arg,
 		     bool known_mpsafe, const char *xname)
+{
 	struct intrhand **p, *q, *ih;
 	struct cpu_info *ci;
 	int slot, error, idt_vec;
 	struct intrsource *chained, *source;
 #ifdef MULTIPROCESSOR
 	bool mpsafe = (known_mpsafe || level != IPL_VM);
 #endif /* MULTIPROCESSOR */
 	uint64_t where;
 	const char *intrstr;
 	char intrstr_buf[INTRIDBUF];
 	KASSERTMSG((legacy_irq == -1 || (0 <= legacy_irq && legacy_irq < 16)),
 	    "bad legacy IRQ value: %d", legacy_irq);
 	KASSERTMSG((legacy_irq != -1 || pic != &i8259_pic),
 	    "non-legacy IRQ on i8259");
 	ih = kmem_alloc(sizeof(*ih), KM_SLEEP);
 	intrstr = intr_create_intrid(legacy_irq, pic, pin, intrstr_buf,
 	    sizeof(intrstr_buf));
 	KASSERT(intrstr != NULL);
 	mutex_enter(&cpu_lock);
 	/* allocate intrsource pool, if not yet. */
 	chained = intr_get_io_intrsource(intrstr);
 	if (chained == NULL) {
 		if (msipic_is_msi_pic(pic)) {
 			mutex_exit(&cpu_lock);
 			kmem_free(ih, sizeof(*ih));
 			printf("%s: %s has no intrsource\n", __func__, intrstr);
 			return NULL;
+		}
 		chained = intr_allocate_io_intrsource(intrstr);
 		if (chained == NULL) {
 			mutex_exit(&cpu_lock);
 			kmem_free(ih, sizeof(*ih));
 			printf("%s: can't allocate io_intersource\n", __func__);
 			return NULL;
+		}
+	}
 	error = intr_allocate_slot(pic, pin, level, &ci, &slot, &idt_vec,
 	    chained);
 	if (error != 0) {
 		intr_free_io_intrsource_direct(chained);
 		mutex_exit(&cpu_lock);
 		kmem_free(ih, sizeof(*ih));
 		printf("failed to allocate interrupt slot for PIC %s pin %d\n",
 		    pic->pic_name, pin);
 		return NULL;
+	}
 	source = ci->ci_isources[slot];
 	if (source->is_handlers != NULL &&
 	    source->is_pic->pic_type != pic->pic_type) {
 		intr_free_io_intrsource_direct(chained);
 		mutex_exit(&cpu_lock);
 		kmem_free(ih, sizeof(*ih));
 		printf("%s: can't share intr source between "
 		       "different PIC types (legacy_irq %d pin %d slot %d)\n",
 		    __func__, legacy_irq, pin, slot);
 		return NULL;
+	}
 	source->is_pin = pin;
 	source->is_pic = pic;
 	intr_append_intrsource_xname(source, xname);
 	switch (source->is_type) {
 	case IST_NONE:
 		source->is_type = type;
 		break;
 	case IST_EDGE:
 	case IST_LEVEL:
 		if (source->is_type == type)
 			break;
 		/* FALLTHROUGH */
 	case IST_PULSE:
 		if (type != IST_NONE) {
 			int otype = source->is_type;
 			intr_source_free(ci, slot, pic, idt_vec);
 			intr_free_io_intrsource_direct(chained);
 			mutex_exit(&cpu_lock);
 			kmem_free(ih, sizeof(*ih));
 			printf("%s: pic %s pin %d: can't share "
 			       "type %d with %d\n",
 				__func__, pic->pic_name, pin,
 				otype, type);
 			return NULL;
+		}
 		break;
 	default:
 		panic("%s: bad intr type %d for pic %s pin %d\n",
 		    __func__, source->is_type, pic->pic_name, pin);
 		/* NOTREACHED */
+	}
 	/*
 	 * If the establishing interrupt uses shared IRQ, the interrupt uses
 	 * "ci->ci_isources[slot]" instead of allocated by the establishing
 	 * device's pci_intr_alloc() or this function.
 	 */
 	if (source->is_handlers != NULL) {
 		struct intrsource *isp, *nisp;
 		SIMPLEQ_FOREACH_SAFE(isp, &io_interrupt_sources,
 		    is_list, nisp) {
 			if (strncmp(intrstr, isp->is_intrid, INTRIDBUF - 1) == 0
 			    && isp->is_handlers == NULL)
 				intr_free_io_intrsource_direct(isp);
+		}
+	}
 	/*
 	 * We're now committed.  Mask the interrupt in hardware and
 	 * count it for load distribution.
 	 */
 	(*pic->pic_hwmask)(pic, pin);
 	(ci->ci_nintrhand)++;
 	/*
 	 * Figure out where to put the handler.
 	 * This is O(N^2), but we want to preserve the order, and N is
 	 * generally small.
 	 */
 	for (p = &ci->ci_isources[slot]->is_handlers;
 	     (q = *p) != NULL && q->ih_level > level;
 	     p = &q->ih_next) {
 		/* nothing */;
+	}
 	ih->ih_pic = pic;
 	ih->ih_fun = ih->ih_realfun = handler;
 	ih->ih_arg = ih->ih_realarg = arg;
 	ih->ih_prevp = p;
 	ih->ih_next = *p;
 	ih->ih_level = level;
 	ih->ih_pin = pin;
 	ih->ih_cpu = ci;
 	ih->ih_slot = slot;
 	strlcpy(ih->ih_xname, xname, sizeof(ih->ih_xname));
 #ifdef KDTRACE_HOOKS
 	/*
 	 * XXX i8254_clockintr is special -- takes a magic extra
 	 * argument.  This should be fixed properly in some way that
 	 * doesn't involve sketchy function pointer casts.  See also
 	 * the comments in x86/isa/clock.c.
 	 */
 	if (handler != __FPTRCAST(int (*)(void *), i8254_clockintr)) {
 		ih->ih_fun = intr_kdtrace_wrapper;
 		ih->ih_arg = ih;
+	}
 #endif
 #ifdef MULTIPROCESSOR
 	if (!mpsafe) {
 		KASSERT(handler !=			/* XXX */
 		    __FPTRCAST(int (*)(void *), i8254_clockintr));
 		ih->ih_fun = intr_biglock_wrapper;
 		ih->ih_arg = ih;
+	}
 #endif /* MULTIPROCESSOR */
 	/*
 	 * Call out to the remote CPU to update its interrupt state.
 	 * Only make RPCs if the APs are up and running.
 	 */
 	if (ci == curcpu() || !mp_online) {
 		intr_establish_xcall(ih, (void *)(intptr_t)idt_vec);
 	} else {
 		where = xc_unicast(0, intr_establish_xcall, ih,
 		    (void *)(intptr_t)idt_vec, ci);
 		xc_wait(where);
+	}
 	/* All set up, so add a route for the interrupt and unmask it. */
 	(*pic->pic_addroute)(pic, ci, pin, idt_vec, type);
 	if (ci == curcpu() || !mp_online) {
 		intr_hwunmask_xcall(ih, NULL);
 	} else {
 		where = xc_unicast(0, intr_hwunmask_xcall, ih, NULL, ci);
 		xc_wait(where);
+	}
 	mutex_exit(&cpu_lock);
 	if (bootverbose || cpu_index(ci) != 0)
 		aprint_verbose("allocated pic %s type %s pin %d level %d to "
 		    "%s slot %d idt entry %d\n",
 		    pic->pic_name, type == IST_EDGE ? "edge" : "level", pin,
 		    level, device_xname(ci->ci_dev), slot, idt_vec);
 	return ih;
+}
 void *
 intr_establish(int legacy_irq, struct pic *pic, int pin, int type, int level,
 	       int (*handler)(void *), void *arg, bool known_mpsafe)
+{
 	return intr_establish_xname(legacy_irq, pic, pin, type,
 	    level, handler, arg, known_mpsafe, "unknown");
+}
 /*
  * Called on bound CPU to handle intr_mask() / intr_unmask().
+ *
  * => caller (on initiating CPU) holds cpu_lock on our behalf
  * => arg1: struct intrhand *ih
  * => arg2: true -> mask, false -> unmask.
  */
 static void
 intr_mask_xcall(void *arg1, void *arg2)
+{
 	struct intrhand * const ih = arg1;
 	const uintptr_t mask = (uintptr_t)arg2;
 	struct cpu_info * const ci = ih->ih_cpu;
 	bool force_pending = false;
 	KASSERT(ci == curcpu() || !mp_online);
 	/*
 	 * We need to disable interrupts to hold off the interrupt
 	 * vectors.
 	 */
 	const u_long psl = x86_read_psl();
 	x86_disable_intr();
 	struct intrsource * const source = ci->ci_isources[ih->ih_slot];
 	struct pic * const pic = source->is_pic;
 	if (mask) {
 		source->is_mask_count++;
 		KASSERT(source->is_mask_count != 0);
 		if (source->is_mask_count == 1) {
 			(*pic->pic_hwmask)(pic, ih->ih_pin);
+		}
 	} else {
 		KASSERT(source->is_mask_count != 0);
 		if (--source->is_mask_count == 0) {
 			/*
 			 * If this interrupt source is being moved, don't
 			 * unmask it at the hw.
 			 */
 			if (! source->is_distribute_pending) {
 				(*pic->pic_hwunmask)(pic, ih->ih_pin);
+			}
 			/*
 			 * For level-sensitive interrupts, the hardware
 			 * will let us know.  For everything else, we
 			 * need to explicitly handle interrupts that
-			 * happened when when the source was masked.
+			 * happened when the source was masked.
 			 */
 			const uint64_t bit = (1U << ih->ih_slot);
 			if (ci->ci_imasked & bit) {
 				ci->ci_imasked &= ~bit;
 				if (source->is_type != IST_LEVEL) {
 					ci->ci_ipending |= bit;
 					force_pending = true;
+				}
+			}
+		}
+	}
 	/* Re-enable interrupts. */
 	x86_write_psl(psl);
 	if (force_pending) {
 		/* Force processing of any pending interrupts. */
 		splx(splhigh());
+	}
+}
 static void
 intr_mask_internal(struct intrhand * const ih, const bool mask)
+{
 	/*
 	 * Call out to the remote CPU to update its interrupt state.
 	 * Only make RPCs if the APs are up and running.
 	 */
 	mutex_enter(&cpu_lock);
 	struct cpu_info * const ci = ih->ih_cpu;
 	void * const mask_arg = (void *)(uintptr_t)mask;
 	if (ci == curcpu() || !mp_online) {
 		intr_mask_xcall(ih, mask_arg);
 	} else {
 		const uint64_t where =
 		    xc_unicast(0, intr_mask_xcall, ih, mask_arg, ci);
 		xc_wait(where);
+	}
 	mutex_exit(&cpu_lock);
+}
 void
 intr_mask(struct intrhand *ih)
+{
 	if (cpu_intr_p()) {
 		/*
 		 * Special case of calling intr_mask() from an interrupt
 		 * handler: we MUST be called from the bound CPU for this
 		 * interrupt (presumably from a handler we're about to
 		 * mask).
+		 *
 		 * We can't take the cpu_lock in this case, and we must
 		 * therefore be extra careful.
 		 */
 		KASSERT(ih->ih_cpu == curcpu() || !mp_online);
 		intr_mask_xcall(ih, (void *)(uintptr_t)true);
 		return;
+	}
 	intr_mask_internal(ih, true);
+}
 void
 intr_unmask(struct intrhand *ih)
+{
 	/*
 	 * This is not safe to call from an interrupt context because
 	 * we don't want to accidentally unmask an interrupt source
 	 * that's masked because it's being serviced.
 	 */
 	KASSERT(!cpu_intr_p());
 	intr_mask_internal(ih, false);
+}
 /*
  * Called on bound CPU to handle intr_disestablish().
+ *
  * => caller (on initiating CPU) holds cpu_lock on our behalf
  * => arg1: struct intrhand *ih
  * => arg2: unused
  */
 static void
 intr_disestablish_xcall(void *arg1, void *arg2)
+{
 	struct intrhand **p, *q;
 	struct cpu_info *ci;
 	struct pic *pic;
 	struct intrsource *source;
 	struct intrhand *ih;
 	u_long psl;
 	int idtvec;
 	ih = arg1;
 	ci = ih->ih_cpu;
 	KASSERT(ci == curcpu() || !mp_online);
 	/* Disable interrupts locally. */
 	psl = x86_read_psl();
 	x86_disable_intr();
 	pic = ci->ci_isources[ih->ih_slot]->is_pic;
 	source = ci->ci_isources[ih->ih_slot];
 	idtvec = source->is_idtvec;
 	(*pic->pic_hwmask)(pic, ih->ih_pin);
 	/*
 	 * ci_pending is stable on the current CPU while interrupts are
 	 * blocked, and we only need to synchronize with interrupt
 	 * vectors on the same CPU, so no need for atomics or membars.
 	 */
 	ci->ci_ipending &= ~(1ULL << ih->ih_slot);
 	/*
 	 * Remove the handler from the chain.
 	 */
 	for (p = &source->is_handlers; (q = *p) != NULL && q != ih;
 	     p = &q->ih_next)
+		;
 	if (q == NULL) {
 		x86_write_psl(psl);
 		panic("%s: handler not registered", __func__);
 		/* NOTREACHED */
+	}
 	*p = q->ih_next;
 	x86_intr_calculatemasks(ci);
 	/*
 	 * If there is no any handler, 1) do delroute because it has no
 	 * any source and 2) dont' hwunmask to prevent spurious interrupt.
+	 *
 	 * If there is any handler, 1) don't delroute because it has source
 	 * and 2) do hwunmask to be able to get interrupt again.
+	 *
 	 */
 	if (source->is_handlers == NULL)
 		(*pic->pic_delroute)(pic, ci, ih->ih_pin, idtvec,
 		    source->is_type);
 	else if (source->is_mask_count == 0)
 		(*pic->pic_hwunmask)(pic, ih->ih_pin);
 	/* If the source is free we can drop it now. */
 	intr_source_free(ci, ih->ih_slot, pic, idtvec);
 	/* Re-enable interrupts. */
 	x86_write_psl(psl);
 	DPRINTF(("%s: remove slot %d (pic %s pin %d vec %d)\n",
 	    device_xname(ci->ci_dev), ih->ih_slot, pic->pic_name,
 	    ih->ih_pin, idtvec));
+}
 static int
 intr_num_handlers(struct intrsource *isp)
+{
 	struct intrhand *ih;
 	int num;
 	num = 0;
 	for (ih = isp->is_handlers; ih != NULL; ih = ih->ih_next)
 		num++;
 	return num;
+}
 /*
  * Deregister an interrupt handler.
  */
 void
 intr_disestablish(struct intrhand *ih)
+{
 	struct cpu_info *ci;
 	struct intrsource *isp;
 	uint64_t where;
 	/*
 	 * Count the removal for load balancing.
 	 * Call out to the remote CPU to update its interrupt state.
 	 * Only make RPCs if the APs are up and running.
 	 */
 	mutex_enter(&cpu_lock);
 	ci = ih->ih_cpu;
 	(ci->ci_nintrhand)--;
 	KASSERT(ci->ci_nintrhand >= 0);
 	isp = ci->ci_isources[ih->ih_slot];
 	if (ci == curcpu() || !mp_online) {
 		intr_disestablish_xcall(ih, NULL);
 	} else {
 		where = xc_unicast(0, intr_disestablish_xcall, ih, NULL, ci);
 		xc_wait(where);
+	}
 	if (!msipic_is_msi_pic(isp->is_pic) && intr_num_handlers(isp) < 1) {
 		intr_free_io_intrsource_direct(isp);
+	}
 	mutex_exit(&cpu_lock);
 	kmem_free(ih, sizeof(*ih));
+}
 static const char *
 xen_intr_string(int port, char *buf, size_t len, struct pic *pic)
+{
 	KASSERT(pic->pic_type == PIC_XEN);
 	KASSERT(port >= 0);
 	snprintf(buf, len, "%s chan %d", pic->pic_name, port);
 	return buf;
+}
 static const char *
 legacy_intr_string(int ih, char *buf, size_t len, struct pic *pic)
+{
 	int legacy_irq;
 	KASSERT(pic->pic_type == PIC_I8259);
 #if NLAPIC > 0
 	KASSERT(APIC_IRQ_ISLEGACY(ih));
 	legacy_irq = APIC_IRQ_LEGACY_IRQ(ih);
 #else
 	legacy_irq = ih;
 #endif
 	KASSERT(legacy_irq >= 0 && legacy_irq < 16);
 	snprintf(buf, len, "%s pin %d", pic->pic_name, legacy_irq);
 	return buf;
+}
 const char *
 intr_string(intr_handle_t ih, char *buf, size_t len)
+{
 #if NIOAPIC > 0
 	struct ioapic_softc *pic;
 #endif
 	if (ih == 0)
 		panic("%s: bogus handle 0x%" PRIx64, __func__, ih);
 #if NIOAPIC > 0
 	if (ih & APIC_INT_VIA_APIC) {
 		pic = ioapic_find(APIC_IRQ_APIC(ih));
 		if (pic != NULL) {
 			snprintf(buf, len, "%s pin %d",
 			    device_xname(pic->sc_dev), APIC_IRQ_PIN(ih));
 		} else {
 			snprintf(buf, len,
 			    "apic %d int %d (irq %d)",
 			    APIC_IRQ_APIC(ih),
 			    APIC_IRQ_PIN(ih),
 			    APIC_IRQ_LEGACY_IRQ(ih));
+		}
 	} else
 		snprintf(buf, len, "irq %d", APIC_IRQ_LEGACY_IRQ(ih));
 #elif NLAPIC > 0
 	snprintf(buf, len, "irq %d", APIC_IRQ_LEGACY_IRQ(ih));
 #else
 	snprintf(buf, len, "irq %d", (int) ih);
 #endif
 	return buf;
+}
 /*
  * Fake interrupt handler structures for the benefit of symmetry with
  * other interrupt sources, and the benefit of x86_intr_calculatemasks()
  */
 struct intrhand fake_timer_intrhand;
 struct intrhand fake_ipi_intrhand;
 #if NHYPERV > 0
 struct intrhand fake_hyperv_intrhand;
 #endif
 #if NLAPIC > 0 && defined(MULTIPROCESSOR)
 static const char *x86_ipi_names[X86_NIPI] = X86_IPI_NAMES;
 #endif
 #if defined(INTRSTACKSIZE)
 static inline bool
 redzone_const_or_false(bool x)
+{
 #ifdef DIAGNOSTIC
 	return x;
 #else
 	return false;
 #endif /* !DIAGNOSTIC */
+}
 static inline int
 redzone_const_or_zero(int x)
+{
 	return redzone_const_or_false(true) ? x : 0;
+}
 #endif
 /*
  * Initialize all handlers that aren't dynamically allocated, and exist
  * for each CPU.
  */
 void
 cpu_intr_init(struct cpu_info *ci)
+{
 #if (NLAPIC > 0) || defined(MULTIPROCESSOR) || \
     (NHYPERV > 0)
 	struct intrsource *isp;
 #endif
 #if NLAPIC > 0
 	static int first = 1;
 #if defined(MULTIPROCESSOR)
 	int i;
 #endif
 #endif
 #if NLAPIC > 0
 	isp = kmem_zalloc(sizeof(*isp), KM_SLEEP);
 	isp->is_recurse = Xrecurse_lapic_ltimer;
 	isp->is_resume = Xresume_lapic_ltimer;
 	fake_timer_intrhand.ih_pic = &local_pic;
 	fake_timer_intrhand.ih_level = IPL_CLOCK;
 	isp->is_handlers = &fake_timer_intrhand;
 	isp->is_pic = &local_pic;
 	ci->ci_isources[LIR_TIMER] = isp;
 	evcnt_attach_dynamic(&isp->is_evcnt,
 	    first ? EVCNT_TYPE_INTR : EVCNT_TYPE_MISC, NULL,
 	    device_xname(ci->ci_dev), "timer");
 	first = 0;
 #ifdef MULTIPROCESSOR
 	isp = kmem_zalloc(sizeof(*isp), KM_SLEEP);
 	isp->is_recurse = Xrecurse_lapic_ipi;
 	isp->is_resume = Xresume_lapic_ipi;
 	fake_ipi_intrhand.ih_pic = &local_pic;
 	fake_ipi_intrhand.ih_level = IPL_HIGH;
 	isp->is_handlers = &fake_ipi_intrhand;
 	isp->is_pic = &local_pic;
 	ci->ci_isources[LIR_IPI] = isp;
 	for (i = 0; i < X86_NIPI; i++)
 		evcnt_attach_dynamic(&ci->ci_ipi_events[i], EVCNT_TYPE_MISC,
 		    NULL, device_xname(ci->ci_dev), x86_ipi_names[i]);
 #endif
 #if NHYPERV > 0
 	if (hyperv_hypercall_enabled()) {
 		isp = kmem_zalloc(sizeof(*isp), KM_SLEEP);
 		isp->is_recurse = Xrecurse_hyperv_hypercall;
 		isp->is_resume = Xresume_hyperv_hypercall;
 		fake_hyperv_intrhand.ih_level = IPL_NET;
 		isp->is_handlers = &fake_hyperv_intrhand;
 		isp->is_pic = &local_pic;
 		ci->ci_isources[LIR_HV] = isp;
 		evcnt_attach_dynamic(&isp->is_evcnt, EVCNT_TYPE_INTR, NULL,
 		    device_xname(ci->ci_dev), "Hyper-V hypercall");
+	}
 #endif
 #endif
 #if defined(__HAVE_PREEMPTION)
 	x86_init_preempt(ci);
 #endif
 	x86_intr_calculatemasks(ci);
 #if defined(INTRSTACKSIZE)
 	vaddr_t istack;
 	/*
 	 * If the red zone is activated, protect both the top and
 	 * the bottom of the stack with an unmapped page.
 	 */
 	istack = uvm_km_alloc(kernel_map,
 	    INTRSTACKSIZE + redzone_const_or_zero(2 * PAGE_SIZE), 0,
 	    UVM_KMF_WIRED | UVM_KMF_ZERO);
 	if (redzone_const_or_false(true)) {
 		pmap_kremove(istack, PAGE_SIZE);
 		pmap_kremove(istack + INTRSTACKSIZE + PAGE_SIZE, PAGE_SIZE);
 		pmap_update(pmap_kernel());
+	}
 	/*
 	 * 33 used to be 1.  Arbitrarily reserve 32 more register_t's
 	 * of space for ddb(4) to examine some subroutine arguments
 	 * and to hunt for the next stack frame.
 	 */
 	ci->ci_intrstack = (char *)istack + redzone_const_or_zero(PAGE_SIZE) +
 	    INTRSTACKSIZE - 33 * sizeof(register_t);
 #endif
 	ci->ci_idepth = -1;
+}
 #if defined(INTRDEBUG) || defined(DDB)
 void
 intr_printconfig(void)
+{
 	int i;
 	struct intrhand *ih;
 	struct intrsource *isp;
 	struct cpu_info *ci;
 	CPU_INFO_ITERATOR cii;
 	void (*pr)(const char *, ...);
 	pr = printf;
 #ifdef DDB
 	if (db_active) {
 		pr = db_printf;
+	}
 #endif
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		(*pr)("%s: interrupt masks:\n", device_xname(ci->ci_dev));
 		for (i = 0; i < NIPL; i++)
 			(*pr)("IPL %d mask %016"PRIx64" unmask %016"PRIx64"\n",
 			    i, ci->ci_imask[i], ci->ci_iunmask[i]);
 		for (i = 0; i < MAX_INTR_SOURCES; i++) {
 			isp = ci->ci_isources[i];
 			if (isp == NULL)
 				continue;
 			(*pr)("%s source %d is pin %d from pic %s type %d "
 			    "maxlevel %d\n", device_xname(ci->ci_dev), i,
 			    isp->is_pin, isp->is_pic->pic_name, isp->is_type,
 			    isp->is_maxlevel);
 			for (ih = isp->is_handlers; ih != NULL;
 			     ih = ih->ih_next)
 				(*pr)("\thandler %p level %d\n",
 				    ih->ih_fun, ih->ih_level);
 #if NIOAPIC > 0
 			if (isp->is_pic->pic_type == PIC_IOAPIC) {
 				struct ioapic_softc *sc;
 				sc = isp->is_pic->pic_ioapic;
 				(*pr)("\tioapic redir 0x%x\n",
 				    sc->sc_pins[isp->is_pin].ip_map->redir);
+			}
 #endif
+		}
+	}
+}
 #endif
 /*
  * Save current affinitied cpu's interrupt count.
  */
 static void
 intr_save_evcnt(struct intrsource *source, cpuid_t cpuid)
+{
 	struct percpu_evcnt *pep;
 	uint64_t curcnt;
 	int i;
 	curcnt = source->is_evcnt.ev_count;
 	pep = source->is_saved_evcnt;
 	for (i = 0; i < ncpu; i++) {
 		if (pep[i].cpuid == cpuid) {
 			pep[i].count = curcnt;
 			break;
+		}
+	}
+}
 /*
  * Restore current affinitied cpu's interrupt count.
  */
 static void
 intr_restore_evcnt(struct intrsource *source, cpuid_t cpuid)
+{
 	struct percpu_evcnt *pep;
 	int i;
 	pep = source->is_saved_evcnt;
 	for (i = 0; i < ncpu; i++) {
 		if (pep[i].cpuid == cpuid) {
 			source->is_evcnt.ev_count = pep[i].count;
 			break;
+		}
+	}
+}
 static void
 intr_redistribute_xc_t(void *arg1, void *arg2)
+{
 	struct cpu_info *ci;
 	struct intrsource *isp;
 	int slot;
 	u_long psl;
 	ci = curcpu();
 	isp = arg1;
 	slot = (int)(intptr_t)arg2;
 	/* Disable interrupts locally. */
 	psl = x86_read_psl();
 	x86_disable_intr();
 	/* Hook it in and re-calculate masks. */
 	ci->ci_isources[slot] = isp;
 	x86_intr_calculatemasks(curcpu());
 	/* Re-enable interrupts locally. */
 	x86_write_psl(psl);
+}
 static void
 intr_redistribute_xc_s1(void *arg1, void *arg2)
+{
 	struct pic *pic;
 	struct intrsource *isp;
 	struct cpu_info *nci;
 	u_long psl;
 	isp = arg1;
 	nci = arg2;
 	/*
 	 * Disable interrupts on-chip and mask the pin.  Back out
 	 * and let the interrupt be processed if one is pending.
 	 */
 	pic = isp->is_pic;
 	for (;;) {
 		psl = x86_read_psl();
 		x86_disable_intr();
 		if ((*pic->pic_trymask)(pic, isp->is_pin)) {
 			break;
+		}
 		x86_write_psl(psl);
 		DELAY(1000);
+	}
 	/* pic_addroute will unmask the interrupt. */
 	(*pic->pic_addroute)(pic, nci, isp->is_pin, isp->is_idtvec,
 	    isp->is_type);
 	x86_write_psl(psl);
+}
 static void
 intr_redistribute_xc_s2(void *arg1, void *arg2)
+{
 	struct cpu_info *ci;
 	u_long psl;
 	int slot;
 	ci = curcpu();
 	slot = (int)(uintptr_t)arg1;
 	/* Disable interrupts locally. */
 	psl = x86_read_psl();
 	x86_disable_intr();
 	/* Patch out the source and re-calculate masks. */
 	ci->ci_isources[slot] = NULL;
 	x86_intr_calculatemasks(ci);
 	/* Re-enable interrupts locally. */
 	x86_write_psl(psl);
+}
 static bool
 intr_redistribute(struct cpu_info *oci)
+{
 	struct intrsource *isp;
 	struct intrhand *ih;
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *nci, *ici;
 	int oslot, nslot;
 	uint64_t where;
 	KASSERT(mutex_owned(&cpu_lock));
 	/* Look for an interrupt source that we can migrate. */
 	for (oslot = 0; oslot < MAX_INTR_SOURCES; oslot++) {
 		if ((isp = oci->ci_isources[oslot]) == NULL) {
 			continue;
+		}
 		if (isp->is_pic->pic_type == PIC_IOAPIC) {
 			break;
+		}
+	}
 	if (oslot == MAX_INTR_SOURCES) {
 		return false;
+	}
 	/* Find least loaded CPU and try to move there. */
 	nci = NULL;
 	for (CPU_INFO_FOREACH(cii, ici)) {
 		if ((ici->ci_schedstate.spc_flags & SPCF_NOINTR) != 0) {
 			continue;
+		}
 		KASSERT(ici != oci);
 		if (nci == NULL || nci->ci_nintrhand > ici->ci_nintrhand) {
 			nci = ici;
+		}
+	}
 	if (nci == NULL) {
 		return false;
+	}
 	for (nslot = 0; nslot < MAX_INTR_SOURCES; nslot++) {
 		if (nci->ci_isources[nslot] == NULL) {
 			break;
+		}
+	}
 	/* If that did not work, allocate anywhere. */
 	if (nslot == MAX_INTR_SOURCES) {
 		for (CPU_INFO_FOREACH(cii, nci)) {
 			if ((nci->ci_schedstate.spc_flags & SPCF_NOINTR) != 0) {
 				continue;
+			}
 			KASSERT(nci != oci);
 			for (nslot = 0; nslot < MAX_INTR_SOURCES; nslot++) {
 				if (nci->ci_isources[nslot] == NULL) {
 					break;
+				}
+			}
 			if (nslot != MAX_INTR_SOURCES) {
 				break;
+			}
+		}
+	}
 	if (nslot == MAX_INTR_SOURCES) {
 		return false;
+	}
 	/*
 	 * Now we have new CPU and new slot.  Run a cross-call to set up
 	 * the new vector on the target CPU.
 	 */
 	where = xc_unicast(0, intr_redistribute_xc_t, isp,
 	    (void *)(intptr_t)nslot, nci);
 	xc_wait(where);
 	/*
 	 * We're ready to go on the target CPU.  Run a cross call to
 	 * reroute the interrupt away from the source CPU.
 	 */
 	where = xc_unicast(0, intr_redistribute_xc_s1, isp, nci, oci);
 	xc_wait(where);
 	/* Sleep for (at least) 10ms to allow the change to take hold. */
 	(void)kpause("intrdist", false, mstohz(10), NULL);
 	/* Complete removal from the source CPU. */
 	where = xc_unicast(0, intr_redistribute_xc_s2,
 	    (void *)(uintptr_t)oslot, NULL, oci);
 	xc_wait(where);
 	/* Finally, take care of book-keeping. */
 	for (ih = isp->is_handlers; ih != NULL; ih = ih->ih_next) {
 		oci->ci_nintrhand--;
 		nci->ci_nintrhand++;
 		ih->ih_cpu = nci;
+	}
 	intr_save_evcnt(isp, oci->ci_cpuid);
 	intr_restore_evcnt(isp, nci->ci_cpuid);
 	isp->is_active_cpu = nci->ci_cpuid;
 	return true;
+}
 void
 cpu_intr_redistribute(void)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	KASSERT(mutex_owned(&cpu_lock));
 	KASSERT(mp_online);
 	/* Direct interrupts away from shielded CPUs. */
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		if ((ci->ci_schedstate.spc_flags & SPCF_NOINTR) == 0) {
 			continue;
+		}
 		while (intr_redistribute(ci)) {
 			/* nothing */
+		}
+	}
 	/* XXX should now re-balance */
+}
 u_int
 cpu_intr_count(struct cpu_info *ci)
+{
 	KASSERT(ci->ci_nintrhand >= 0);
 	return ci->ci_nintrhand;
+}
 static int
 intr_find_unused_slot(struct cpu_info *ci, int *index)
+{
 	int slot, i;
 	KASSERT(mutex_owned(&cpu_lock));
 	slot = -1;
 	for (i = 0; i < MAX_INTR_SOURCES ; i++) {
 		if (ci->ci_isources[i] == NULL) {
 			slot = i;
 			break;
+		}
+	}
 	if (slot == -1) {
 		DPRINTF(("cannot allocate ci_isources\n"));
 		return EBUSY;
+	}
 	*index = slot;
 	return 0;
+}
 /*
  * Let cpu_info ready to accept the interrupt.
  */
 static void
 intr_activate_xcall(void *arg1, void *arg2)
+{
 	struct cpu_info *ci;
 	struct intrsource *source;
 	struct intrstub *stubp;
 	struct intrhand *ih;
 	struct idt_vec *iv;
 	u_long psl;
 	int idt_vec;
 	int slot;
 	ih = arg1;
 	kpreempt_disable();
 	KASSERT(ih->ih_cpu == curcpu() || !mp_online);
 	ci = ih->ih_cpu;
 	slot = ih->ih_slot;
 	source = ci->ci_isources[slot];
 	idt_vec = source->is_idtvec;
 	iv = idt_vec_ref(&ci->ci_idtvec);
 	psl = x86_read_psl();
 	x86_disable_intr();
 	x86_intr_calculatemasks(ci);
 	if (source->is_type == IST_LEVEL) {
 		stubp = &source->is_pic->pic_level_stubs[slot];
 	} else {
 		stubp = &source->is_pic->pic_edge_stubs[slot];
+	}
 	source->is_resume = stubp->ist_resume;
 	source->is_recurse = stubp->ist_recurse;
 	idt_vec_set(iv, idt_vec, stubp->ist_entry);
 	x86_write_psl(psl);
 	kpreempt_enable();
+}
 /*
  * Let cpu_info not accept the interrupt.
  */
 static void
 intr_deactivate_xcall(void *arg1, void *arg2)
+{
 	struct cpu_info *ci;
 	struct intrhand *ih, *lih;
 	struct intrsource *isp;
 	u_long psl;
 	int idt_vec;
 	int slot;
 	ih = arg1;
 	kpreempt_disable();
 	KASSERT(ih->ih_cpu == curcpu() || !mp_online);
 	ci = ih->ih_cpu;
 	slot = ih->ih_slot;
 	isp = ci->ci_isources[slot];
 	idt_vec = isp->is_idtvec;
 	psl = x86_read_psl();
 	x86_disable_intr();
 	/* Move all devices sharing IRQ number. */
 	ci->ci_isources[slot] = NULL;
 	for (lih = ih; lih != NULL; lih = lih->ih_next) {
 		ci->ci_nintrhand--;
+	}
 	x86_intr_calculatemasks(ci);
 	if (idt_vec_is_pcpu()) {
 		idt_vec_free(&ci->ci_idtvec, idt_vec);
 	} else {
 		/*
 		 * Skip unsetgate(), because the same idt[] entry is
 		 * overwritten in intr_activate_xcall().
 		 */
+	}
 	x86_write_psl(psl);
 	kpreempt_enable();
+}
 static void
 intr_get_affinity(struct intrsource *isp, kcpuset_t *cpuset)
+{
 	struct cpu_info *ci;
 	KASSERT(mutex_owned(&cpu_lock));
 	if (isp == NULL) {
 		kcpuset_zero(cpuset);
 		return;
+	}
 	KASSERTMSG(isp->is_handlers != NULL,
 	    "Don't get affinity for the device which is not established.");
 	ci = isp->is_handlers->ih_cpu;
 	if (ci == NULL) {
 		kcpuset_zero(cpuset);
 		return;
+	}
 	kcpuset_set(cpuset, cpu_index(ci));
 	return;
+}
 static int
 intr_set_affinity(struct intrsource *isp, const kcpuset_t *cpuset)
+{
 	struct cpu_info *oldci, *newci;
 	struct intrhand *ih, *lih;
 	struct pic *pic;
 	u_int cpu_idx;
 	int old_idtvec, new_idtvec;
 	int oldslot, newslot;
 	int err;
 	int pin;
 	KASSERT(mutex_owned(&intr_distribute_lock));
 	KASSERT(mutex_owned(&cpu_lock));
 	/* XXX
 	 * logical destination mode is not supported, use lowest index cpu.
 	 */
 	cpu_idx = kcpuset_ffs(cpuset) - 1;
 	newci = cpu_lookup(cpu_idx);
 	if (newci == NULL) {
 		DPRINTF(("invalid cpu index: %u\n", cpu_idx));
 		return EINVAL;
+	}
 	if ((newci->ci_schedstate.spc_flags & SPCF_NOINTR) != 0) {
 		DPRINTF(("the cpu is set nointr shield. index:%u\n", cpu_idx));
 		return EINVAL;
+	}
 	if (isp == NULL) {
 		DPRINTF(("invalid intrctl handler\n"));
 		return EINVAL;
+	}
 	/* i8259_pic supports only primary cpu, see i8259.c. */
 	pic = isp->is_pic;
 	if (pic == &i8259_pic) {
 		DPRINTF(("i8259 pic does not support set_affinity\n"));
 		return ENOTSUP;
+	}
 	ih = isp->is_handlers;
 	KASSERTMSG(ih != NULL,
 	    "Don't set affinity for the device which is not established.");
 	oldci = ih->ih_cpu;
 	if (newci == oldci) /* nothing to do */
 		return 0;
 	oldslot = ih->ih_slot;
 	err = intr_find_unused_slot(newci, &newslot);
 	if (err) {
 		DPRINTF(("failed to allocate interrupt slot for PIC %s intrid "
 			"%s\n", isp->is_pic->pic_name, isp->is_intrid));
 		return err;
+	}
 	old_idtvec = isp->is_idtvec;
 	if (idt_vec_is_pcpu()) {
 		new_idtvec = idt_vec_alloc(&newci->ci_idtvec,
 		    APIC_LEVEL(ih->ih_level), IDT_INTR_HIGH);
 		if (new_idtvec == 0)
 			return EBUSY;
 		DPRINTF(("interrupt from cpu%d vec %d to cpu%d vec %d\n",
 		    cpu_index(oldci), old_idtvec, cpu_index(newci),
 			new_idtvec));
 	} else {
 		new_idtvec = isp->is_idtvec;
+	}
 	/* Prevent intr_unmask() from reenabling the source at the hw. */
 	isp->is_distribute_pending = true;
 	pin = isp->is_pin;
 	(*pic->pic_hwmask)(pic, pin); /* for ci_ipending check */
 	membar_sync();
 	while (oldci->ci_ipending & (1ULL << oldslot)) {
 		(void)kpause("intrdist", false, 1, &cpu_lock);
 		membar_sync();
+	}
 	kpreempt_disable();
 	/* deactivate old interrupt setting */
 	if (oldci == curcpu() || !mp_online) {
 		intr_deactivate_xcall(ih, NULL);
 	} else {
 		uint64_t where;
 		where = xc_unicast(0, intr_deactivate_xcall, ih,
 				   NULL, oldci);
 		xc_wait(where);
+	}
 	intr_save_evcnt(isp, oldci->ci_cpuid);
 	(*pic->pic_delroute)(pic, oldci, pin, old_idtvec, isp->is_type);
 	/* activate new interrupt setting */
 	isp->is_idtvec =  new_idtvec;
 	newci->ci_isources[newslot] = isp;
 	for (lih = ih; lih != NULL; lih = lih->ih_next) {
 		newci->ci_nintrhand++;
 		lih->ih_cpu = newci;
 		lih->ih_slot = newslot;
+	}
 	if (newci == curcpu() || !mp_online) {
 		intr_activate_xcall(ih, NULL);
 	} else {
 		uint64_t where;
 		where = xc_unicast(0, intr_activate_xcall, ih,
 				   NULL, newci);
 		xc_wait(where);
+	}
 	intr_restore_evcnt(isp, newci->ci_cpuid);
 	isp->is_active_cpu = newci->ci_cpuid;
 	(*pic->pic_addroute)(pic, newci, pin, new_idtvec, isp->is_type);
 	isp->is_distribute_pending = false;
 	if (newci == curcpu() || !mp_online) {
 		intr_hwunmask_xcall(ih, NULL);
 	} else {
 		uint64_t where;
 		where = xc_unicast(0, intr_hwunmask_xcall, ih, NULL, newci);
 		xc_wait(where);
+	}
 	kpreempt_enable();
 	return err;
+}
 static bool
 intr_is_affinity_intrsource(struct intrsource *isp, const kcpuset_t *cpuset)
+{
 	struct cpu_info *ci;
 	KASSERT(mutex_owned(&cpu_lock));
 	/*
 	 * The device is already pci_intr_alloc'ed, however it is not
 	 * established yet.
 	 */
 	if (isp->is_handlers == NULL)
 		return false;
 	ci = isp->is_handlers->ih_cpu;
 	KASSERT(ci != NULL);
 	return kcpuset_isset(cpuset, cpu_index(ci));
+}
 static struct intrhand *
 intr_get_handler(const char *intrid)
+{
 	struct intrsource *isp;