xref: /src/sys/arch/mac68k/dev/adb_direct.c

/*	$NetBSD: adb_direct.c,v 1.4 1997/04/18 05:53:41 scottr Exp $	*/

/*
 * 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.
 */
/* From: adb_direct.c 1.91 1/20/97 jpw */

/* 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 */

#ifdef __NetBSD__
#include "opt_mrg_adb.h"

#include <sys/param.h>
#include <sys/cdefs.h>
#include <sys/systm.h>

#include <machine/viareg.h>
#include <machine/param.h>
#include <machine/cpu.h>
#include <machine/adbsys.h>			/* required for adbvar.h */

#include <arch/mac68k/mac68k/macrom.h>
#include "adb_direct.h"
#include "adbvar.h"
#define printf_intr printf
#else
#include "via.h"				/* for macos based testing */
typedef unsigned char	u_char;
#endif

/* more verbose for testing */
/*#define DEBUG*/

/* some misc. leftovers */
#define vPB		0x0000
#define vPB3		0x08
#define vPB4		0x10
#define vPB5		0x20
#define vSR_INT		0x04
#define vSR_OUT		0x10

/* types of adb hardware that we (will eventually) support */
#define ADB_HW_UNKNOWN		0x01	/* don't know */
#define ADB_HW_II		0x02	/* Mac II series */
#define ADB_HW_IISI		0x03	/* Mac IIsi series */
#define ADB_HW_PB		0x04	/* PowerBook series */
#define ADB_HW_CUDA		0x05	/* Machines with a Cuda chip */

/* the type of ADB action that we are currently preforming */
#define ADB_ACTION_NOTREADY	0x01	/* has not been initialized yet */
#define ADB_ACTION_IDLE		0x02	/* the bus is currently idle */
#define ADB_ACTION_OUT		0x03	/* sending out a command */
#define ADB_ACTION_IN		0x04	/* receiving data */

/*
 * 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		0x01	/* we don't know yet - all models */
#define ADB_BUS_IDLE		0x02	/* bus is idle - all models */
#define ADB_BUS_CMD		0x03	/* starting a command - II models */
#define ADB_BUS_ODD		0x04	/* the "odd" state - II models */
#define ADB_BUS_EVEN		0x05	/* the "even" state - II models */
#define ADB_BUS_ACTIVE		0x06	/* active state - IIsi models */
#define ADB_BUS_ACK		0x07	/* 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 for each uS is
 * calculated at boot time to account for differences in machine speed.
 */
#define ADB_ACK_DELAY	150

/*
 * Maximum ADB message length; includes space for data, result, and
 * device code - plus a little for safety.
 */
#define MAX_ADB_MSG_LENGTH	20

/*
 * A structure for storing information about each ADB device.
 */
struct ADBDevEntry	{
	void	(*ServiceRtPtr) __P((void));
	void	*DataAreaAddr;
	char	devType;
	char	origAddr;
	char	currentAddr;
};

/*
 * Used to hold ADB commands that are waiting to be sent out.
 */
struct adbCmdHoldEntry {
	u_char	outBuf[MAX_ADB_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 */
};

/*
 * 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	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 = 0;	/* doing ADB reinit, 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[MAX_ADB_MSG_LENGTH];	/* data input buffer */
u_char adbOutputBuffer[MAX_ADB_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 device we heard from (II ONLY) */
int	adbLastDevIndex = 0;	/* last ADB device loc. in device table (II ONLY) */
int	adbLastCommand = 0;	/* the last ADB command we sent (II) */
int	adbWaitingSubDev = 0;	/* ADB sub-device (RTC, PRAM, etc) - IIsi ONLY - unused */
int	adbWaitingDevice = 0;	/* ADB device we are waiting for - unused */

struct ADBDevEntry ADBDevTable[16];	/* our ADB device table */
int	ADBNumDevices;		/* number of ADB devices found with ADBReInit */

extern struct mac68k_machine_S mac68k_machine;

int	zshard __P((int));

void	pm_setup_adb __P((void));
void	pm_check_adb_devices __P((int));
void	pm_intr __P((void));
int	pm_adb_op __P((u_char *, void *, void *, int));
void	pm_init_adb_device __P((void));

/*
 * The following are private routines.
 */
void	print_single __P((u_char *));
void	adb_intr __P((void));
void	adb_intr_II __P((void));
void	adb_intr_IIsi __P((void));
void	adb_intr_cuda __P((void));
int	send_adb_II __P((u_char *, u_char *, void *, void *, int));
int	send_adb_IIsi __P((u_char *, u_char *, void *, void *, int));
int	send_adb_cuda __P((u_char *, u_char *, void *, void *, int));
void	adb_intr_cuda_test __P((void));
void	adb_handle_unsol __P((u_char *));
void	adb_op_comprout __P((void));
void	adb_reinit __P((void));
int	count_adbs __P((void));
int	get_ind_adb_info __P((ADBDataBlock *, int));
int	get_adb_info __P((ADBDataBlock *, int));
int	set_adb_info __P((ADBSetInfoBlock *, int));
void	adb_setup_hw_type __P((void));
int	adb_op __P((Ptr, Ptr, Ptr, short));
void	adb_handle_unsol __P((u_char *));
int	adb_op_sync __P((Ptr, Ptr, Ptr, short));
void	adb_read_II __P((u_char *));
void	adb_cleanup __P((u_char *));
void	adb_cleanup_IIsi __P((u_char *));
void	adb_comp_exec __P((void));
int	adb_cmd_result __P((u_char *));
int	adb_cmd_extra __P((u_char *));
int	adb_guess_next_device __P((void));
int	adb_prog_switch_enable __P((void));
int	adb_prog_switch_disable __P((void));
/* we should create this and it will be the public version */
int	send_adb __P((u_char *, void *, void *));


/*
 * 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(thestring)
	u_char *thestring;
{
	int x;

	if (thestring == 0) {
		printf_intr("no data - null pointer\n");
		return;
	}
	if ((int)(thestring[0]) == 0) {
		printf_intr("nothing returned\n");
		return;
	}
	if (thestring[0] > 20) {
		printf_intr("ADB: ACK > 20 no way!\n");
		thestring[0] = 20;
	}
	printf_intr("(length=0x%x):", thestring[0]);
	for (x = 0; x < thestring[0]; x++)
		printf_intr("  0x%02x", thestring[x + 1]);
	printf_intr("\n");
}


/*
 * called when when an adb interrupt happens
 *
 * Cuda version of adb_intr
 * TO DO: can probably reduce the number of zshard calls in here
 */
void
adb_intr_cuda(void)
{
	int i, ending, len;
	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:
                adbInputBuffer[1] = ADB_SR();   /* get byte */
                ADB_SET_SR_INPUT();		/* make sure SR is set to IN */
                ADB_SET_STATE_TIP();		/* signal start of data frame */
        	printf_intr("idle 0x%02x ", adbInputBuffer[1]);
                adbInputBuffer[0] = 1;
                adbActionState = ADB_ACTION_IN; /* set next state */
                break;

        case ADB_ACTION_IN:
                adbInputBuffer[++adbInputBuffer[0]] = ADB_SR(); /* get byte */
                ADB_SET_SR_INPUT();		/* make sure SR is set to IN */
                if (ADB_INTR_IS_OFF)		/* check for end of frame */
                        ending = 1;
                else
                        ending = 0;

                if (1 == ending) {      /* end of message? */
                        ADB_CLR_STATE_TIP();       /* signal end of frame */
                	printf_intr("in end 0x%02x ", adbInputBuffer[adbInputBuffer[0]]);
                	print_single(adbInputBuffer);
                        /* 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 */
                        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 */

                                /* is this data we are waiting for? */
                                if (adbBuffer != (long) 0) {    /* if valid return data pointer */
					/* get return length minus extras */
                                        len = adbInputBuffer[0] - 4;
                                        /* if adb_op is ever made to be called from a user
                                         * routine, we should use a copyout or copyin
                                         * here to be sure we're in the correct context */
                                        for (i = 1; i <= len; i++)
                                                adbBuffer[i] = adbInputBuffer[4 + i];
                                        if (len < 0)
                                                len = 0;
                                        adbBuffer[0] = len;
                                }
                                adb_comp_exec();        /* call completion routine */

                                adbWaitingCmd = 0;      /* reset "waiting" vars */
                                adbWaiting = 0;
                                adbBuffer = (long) 0;
                                adbCompRout = (long) 0;
                                adbCompData = (long) 0;
                        } else {
                                /* pass the data off to the handler */
                                /* This section IGNORES all data that is not from
                                 * the ADB sub-device. That is, not from rtc or pram.
                                 * Maybe we  should fix later, but do the other
                                 * devices every send things without
                                 * being asked? */
                                if (adbStarting == 0)   /* ignore if during adbreinit */
                                        if (adbInputBuffer[2] == 0x00)
                                                adb_handle_unsol(adbInputBuffer);
                        }

                        adbActionState = ADB_ACTION_IDLE;
                        adbInputBuffer[0] = 0;  /* reset length */

                        if (adbWriteDelay == 1) {       /* were we waiting to write? */\
                        	printf_intr("WRITE DELAY ");
                                adbSentChars = 0;       /* nothing sent yet */
                                adbActionState = ADB_ACTION_OUT;        /* set next state */

                                if (ADB_INTR_IS_ON) {   /* ADB intr low during write */
                                        ADB_CLR_STATE_TIP();      /* 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;
                                        break;
                                }
                                ADB_SET_SR_OUTPUT();    /* set shift register for OUT */
                                ADB_SR() = adbOutputBuffer[adbSentChars + 1];
                                ADB_SET_STATE_TIP();	/* tell ADB that we want to send */
                        }
                } else {
                	ADB_TOGGLE_STATE_ACK_CUDA();
                	printf_intr("in 0x%02x ", adbInputBuffer[adbInputBuffer[0]]);
                }

                break;

        case ADB_ACTION_OUT:
                i = ADB_SR();		/* reset SR-intr in IFR */
        	printf_intr("intr out 0x%02x ", i);
                ADB_SET_SR_OUTPUT();    /* set shift register for OUT */

                adbSentChars++;
                if (ADB_INTR_IS_ON) {		/* ADB intr low during write */
                printf_intr("intr was on ");
                        ADB_CLR_STATE_TIP();      /* 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_ACK_DELAY);   /* delay */
                        /* TO DO: not sure if this is the right thing to do for Cuda */
                        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 */
                                adb_comp_exec();        /* call completion routine */
                                adbWaitingCmd = 0;      /* reset "waiting" vars, just in case */
                                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_TOGGLE_STATE_ACK_CUDA();
                        ADB_CLR_STATE_TIP();       	/* end of frame */
                	printf_intr("write done ");
                } else {
                        ADB_SR() = adbOutputBuffer[adbSentChars + 1];   /* send next byte */
                        ADB_TOGGLE_STATE_ACK_CUDA();  /* signal byte ready to shift */
                        printf_intr("toggle ");
                }
                break;

        case ADB_ACTION_NOTREADY:
                printf_intr("adb: not yet initialized\n");
                break;

        default:
                printf_intr("intr: unknown ADB state\n");
        }

        ADB_VIA_INTR_ENABLE();  /* enable ADB interrupt on IIs. */

        splx(s);                /* restore */

        return;
}                               /* end adb_intr_IIsi */


int
send_adb_cuda(u_char *in, u_char *buffer, void *compRout, void *data, int
command)
{
        int     i, s, len;

        if (adbActionState == ADB_ACTION_NOTREADY)
                return 1;

        s = splhigh();          /* don't interrupt while we are messing with the ADB */

        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 */

                for (i = 1; i <= len; i++)      /* copy additional output data, if any */
                        adbOutputBuffer[2 + i] = buffer[i];
        } else
                for (i = 0; i <= (adbOutputBuffer[0] + 1); i++)
                        adbOutputBuffer[i] = in[i];

        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? */
        printf_intr("out start ");
                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();     /* go process "interrupt" */

        return 0;
}                               /* send_adb_cuda */


/*
 * called when when an adb interrupt happens
 *
 * Cuda version of adb_intr
 *
 */
void
adb_intr_cuda_test(void)
{
        int     i, 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. */

printf_intr("intr ");
switch_start:
        switch (adbActionState) {
        case ADB_ACTION_IDLE:
                adbInputBuffer[1] = ADB_SR();   /* get byte */
                ADB_SET_SR_INPUT();		/* make sure SR is set to IN */
                ADB_SET_STATE_TIP();		/* signal start of data frame */
        	printf_intr("idle 0x%02x ", adbInputBuffer[1]);
                adbInputBuffer[0] = 1;
                adbActionState = ADB_ACTION_IN; /* set next state */
                break;

        case ADB_ACTION_IN:
                adbInputBuffer[++adbInputBuffer[0]] = ADB_SR(); /* get byte */
                if (ADB_INTR_IS_OFF)		/* check for end of frame */
                        ending = 1;
                else
                        ending = 0;

                if (1 == ending) {      /* end of message? */
                        ADB_CLR_STATE_TIP();       /* signal end of frame */

                	printf_intr("in end 0x%02x ", adbInputBuffer[adbInputBuffer[0]]);
                	print_single(adbInputBuffer);

                        adbActionState = ADB_ACTION_IDLE;
                        adbInputBuffer[0] = 0;  /* reset length */
                } else {
                	ADB_TOGGLE_STATE_ACK_CUDA();
                	printf_intr("in 0x%02x ", adbInputBuffer[adbInputBuffer[0]]);
                }


#if 0
                        /* 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 */
                        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 */

                                /* is this data we are waiting for? */
                                if (adbBuffer != (long) 0) {    /* if valid return data pointer */
					/* get return length minus extras */
                                        len = adbInputBuffer[0] - 4;
                                        /* if adb_op is ever made to be called from a user
                                         * routine, we should use a copyout or copyin
                                         * here to be sure we're in the correct context */
                                        for (i = 1; i <= len; i++)
                                                adbBuffer[i] = adbInputBuffer[4 + i];
                                        if (len < 0)
                                                len = 0;
                                        adbBuffer[0] = len;
                                }
                                adb_comp_exec();        /* call completion routine */
                                print_single(adbInputBuffer);

                                adbWaitingCmd = 0;      /* reset "waiting" vars */
                                adbWaiting = 0;
                                adbBuffer = (long) 0;
                                adbCompRout = (long) 0;
                                adbCompData = (long) 0;
                        } else {
                                /* pass the data off to the handler */
                                /* This section IGNORES all data that is not from
                                 * the ADB sub-device. That is, not from rtc or pram.
                                 * Maybe we  should fix later, but do the other
                                 * devices every send things without
                                 * being asked? */
                                if (adbStarting == 0)   /* ignore if during adbreinit */
                                        if (adbInputBuffer[2] == 0x00)
                                                adb_handle_unsol(adbInputBuffer);
                        }

                        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 */

                                zshard(0);      	/* grab any serial interrupts */

                                if (ADB_INTR_IS_ON) {   /* ADB intr low during write */
                                        ADB_SET_STATE_IDLE_CUDA();      /* 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_ACK_DELAY);   /* delay */
                                        break;
                                }
                                ADB_SET_STATE_TIP(); /* tell ADB that we want to send */
                                ADB_SET_SR_OUTPUT();    /* set shift register for OUT */
                                ADB_SR() = adbOutputBuffer[adbSentChars + 1];
                                ADB_TOGGLE_STATE_ACK_CUDA();
                        }
                }
#endif
                break;

        case ADB_ACTION_OUT:
                i = ADB_SR();		/* reset SR-intr in IFR */
                ADB_SET_SR_OUTPUT();    /* set shift register for OUT */

                adbSentChars++;
                if (ADB_INTR_IS_ON) {		/* ADB intr low during write */
                        ADB_SET_STATE_IDLE_CUDA();      /* 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_ACK_DELAY);   /* delay */
                        zshard(0);              /* grab any serial interrupts */
                        goto switch_start;      /* process next state  right now */
                        break;
                }
                delay(ADB_ACK_DELAY);   /* required delay */
                zshard(0);		/* grab any serial interrupts */

                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 */
                                adb_comp_exec();        /* call completion routine */
                                adbWaitingCmd = 0;      /* reset "waiting" vars, just in case */
                                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_IDLE_CUDA();       /* end of frame */
                } else {
                        ADB_SR() = adbOutputBuffer[adbSentChars + 1];   /* send next byte */
                        ADB_TOGGLE_STATE_ACK_CUDA();
                }
                break;

        case ADB_ACTION_NOTREADY:
                printf_intr("adb: not yet initialized\n");
                break;

        default:
                printf_intr("intr: unknown ADB state\n");
        }

        ADB_VIA_INTR_ENABLE();  /* enable ADB interrupt on IIs. */

        splx(s);                /* restore */

        return;
}                               /* end adb_intr_cuda_test */


/* TO DO: add one or two zshard calls in here */
void
adb_intr_II(void)
{
        int	i, len, intr_on = 0;
        int	send = 0, do_srq = 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. */

/*if (ADB_INTR_IS_ON)*/
/*	printf_intr("INTR ON ");*/
if (ADB_INTR_IS_ON)
	intr_on=1;	/* save for later */

        switch (adbActionState) {
        case ADB_ACTION_IDLE:
        	if ( !intr_on ) {
        		/*printf_intr("FAKE DROPPED \n");*/
        		/*printf_intr(" XX ");*/
        		i=ADB_SR();
        		break;
        	}
        	adbNextEnd=0;
        	/*printf_intr("idle ");*/
                adbInputBuffer[0] = 1;
                adbInputBuffer[1] = ADB_SR();   /* get first byte */
		/*printf_intr("0x%02x ", adbInputBuffer[1]);*/
                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 */
		/*printf_intr("in 0x%02x ", adbInputBuffer[adbInputBuffer[0]]);*/
                ADB_SET_SR_INPUT();     /* make sure SR is set to IN */

                /*
                 * Check for an unsolicited Service Request (SRQ).
                 * An empty SRQ packet NEVER ends, so we must manually
                 * check for the following condition.
                 */
                if ( adbInputBuffer[0]==4 && adbInputBuffer[2]==0xff &&
                    adbInputBuffer[3]==0xff && adbInputBuffer[4]==0xff &&
                    intr_on && !adbNextEnd )
                    	do_srq=1;

                if (adbNextEnd==1) {	/* process last byte of packet */
                 	adbNextEnd=0;
                	/*printf_intr("done: ");*/

                	/*
                	 * If the following conditions are true (4 byte
                	 * message, last 3 bytes are 0xff) then we
                	 * basically got a "no response" from the ADB chip,
                	 * so change the message to an empty one.
                	 * We also clear intr_on to stop the SRQ send later
                	 * on because these packets normally have the SRQ
                	 * bit set even when there is NOT a pending SRQ.
                	 */
                	if ( adbInputBuffer[0]==4 && adbInputBuffer[2]==0xff &&
                	    adbInputBuffer[3]==0xff && adbInputBuffer[4]==0xff ) {
                	    	/*printf_intr("NO RESP ");*/
                	    	intr_on=0;
                		adbInputBuffer[0]=0;
                	}

                	adbLastDevice=(adbInputBuffer[1] & 0xf0) >> 4;

                	if ((!adbWaiting || adbPolling )
                	    && (adbInputBuffer[0] != 0)) {
                		/* unsolicided - ignore if starting */
                		if (!adbStarting)
                			adb_handle_unsol(adbInputBuffer);
                	} else if ( !adbPolling ) { /* someone asked for it */
                		/*printf_intr("SOL: ");*/
                		/*print_single(adbInputBuffer);*/
                                if (adbBuffer != (long) 0) {	/* if valid return data pointer */
					/* get return length minus extras */
                                        len = adbInputBuffer[0] - 1;

                                        /* if adb_op is ever made to be called from a user
                                         * routine, we should  use a copyout or copyin
                                         * here to be sure we're in the correct context. */
                                        for (i = 1; i <= len; i++)
                                                adbBuffer[i] = adbInputBuffer[i + 1];
                                        if (len < 0)
                                                len = 0;
                                        adbBuffer[0] = len;
                                }
                		adb_comp_exec();
                	}

                	adbWaiting=0;
                	adbPolling=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) {
                        /*printf_intr("XXX: DOING OUT QUEUE\n");*/
                                /* copy over data */
                                for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)
                                        adbOutputBuffer[i] = adbOutQueue.outBuf[i];
                                adbBuffer = adbOutQueue.saveBuf;	/* user data area */
                                adbCompRout = adbOutQueue.compRout;     /* completion routine */
                                adbCompData = adbOutQueue.data; 	/* comp. rout. data */
                                adbOutQueueHasData = 0; /* currently processing "queue" entry */
                                adbPolling=0;
                                send=1;
                	/* if intr_on is true, then it's a SRQ
                	 * so poll other devices. */
                	} else if (intr_on) {
                		/*printf_intr("starting POLL ");*/
                		do_srq=1;
                		adbPolling=1;
                	} else if ( (adbInputBuffer[1] & 0x0f) != 0x0c) {
                		/*printf_intr("xC HACK ");*/
                		adbPolling=1;
                 		send=1;
                		adbOutputBuffer[0]=1;
                		adbOutputBuffer[1]=(adbInputBuffer[1] & 0xf0) | 0x0c;
                	} else {
                		/*printf_intr("ending ");*/
                		adbBusState=ADB_BUS_IDLE;
                		adbActionState=ADB_ACTION_IDLE;
                		ADB_SET_STATE_IDLE_II();
                		break;
                	}
                }

                /*
                 * If do_srq is true then something above determined that
                 * the message has ended and some device is sending a
                 * service request. So we need to determine the next device
                 * and send a poll to it. (If the device we send to isn't the
                 * one that sent the SRQ, that ok as it will be caught
                 * the next time though.)
                 */
                if ( do_srq ) {
                	/*printf_intr("SRQ! ");*/
                	adbPolling=1;
                	adb_guess_next_device();
			adbOutputBuffer[0]=1;
			adbOutputBuffer[1]=((adbLastDevice & 0x0f) << 4) | 0x0c;
			send=1;
                }

                /*
                 * 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 ) {
                	adbNextEnd = 0;
        		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.
		 */
                if (!intr_on)			/* if adb intr. on then the */
                	adbNextEnd=1;		/* NEXT byte is the last */

               	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:
               	adbNextEnd=0;
               	if (!adbPolling)
               		adbWaiting=1;		/* not unsolicited */
        	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();
        		/*printf_intr("talk out 0x%02x ", i);*/
        		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.
        	 */
        	/*printf_intr("non-talk out 0x%0x ", i);*/
        	ADB_SET_SR_OUTPUT();
                if (adbOutputBuffer[0] == adbSentChars) {       /* check for done */
			/*printf_intr("done \n");*/
			adb_comp_exec();
                        adbBuffer = (long) 0;
                        adbCompRout = (long) 0;
                        adbCompData = (long) 0;
                        if (adbOutQueueHasData == 1) {
                                /* copy over data */
                                for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)
                                        adbOutputBuffer[i] = adbOutQueue.outBuf[i];
                                adbBuffer = adbOutQueue.saveBuf;	/* user data area */
                                adbCompRout = adbOutQueue.compRout;     /* completion routine */
                                adbCompData = adbOutQueue.data; 	/* comp. rout. data */
                                adbOutQueueHasData = 0; /* currently processing "queue" entry */
                                adbPolling=0;
                        } else {
                        	adbOutputBuffer[0]=1;
                        	adbOutputBuffer[1]=(adbOutputBuffer[1] & 0xf0) | 0x0c;
        			adbPolling=1;			/* non-user poll */
        		}
                        adbNextEnd = 0;
        		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;
               }

        	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:
                        printf_intr("strange state!!! (0x%x)\n", adbBusState);
                        break;
                }
        	break;

        default:
                printf_intr("adb: unknown ADB state (during intr)\n");
        }

        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     i, s, len;

        if (adbActionState == ADB_ACTION_NOTREADY)      /* return if ADB not available */
                return 1;

        s = splhigh();          /* don't interrupt while we are messing with the ADB */

        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 */

                for (i = 1; i <= len; i++)      /* copy additional output data, if any */
                        adbOutQueue.outBuf[1 + i] = buffer[i];
        } else
      			/* if data ready, just copy over */
      		for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)
                        adbOutQueue.outBuf[i] = in[i];

        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? */
            (adbPolling == 0)) {			/* and we are not currently polling */
            						/* then start command now */
                for (i = 0; i <= (adbOutQueue.outBuf[0] + 1); i++)      /* copy over data */
                        adbOutputBuffer[i] = adbOutQueue.outBuf[i];

                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) || (adbPolling == 1))
                        if (ADB_SR_INTR_IS_ON)		/* wait for "interrupt" */
                                adb_intr_II();       /* go process "interrupt" */

        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 = 2;
				break;
			}
			/* found the next device */
			if (ADBDevTable[dummy].devType != 0)
				break;
		}
		adbLastDevice=ADBDevTable[dummy].currentAddr;
	}
	return adbLastDevice;
}

/*
 * Called when 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)
{
        switch (adbHardware) {
        case ADB_HW_II:
                adb_intr_II();
                break;

        case ADB_HW_IISI:
                adb_intr_IIsi();
                break;

        case ADB_HW_PB:
                break;

	case ADB_HW_CUDA:
		adb_intr_cuda();
		break;

        case ADB_HW_UNKNOWN:
                break;
        }
}


/*
 * called when when an adb interrupt happens
 *
 * IIsi version of adb_intr
 *
 */
void
adb_intr_IIsi(void)
{
        int     i, ending, len;
        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_ACK_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_ACK_DELAY);		/* delay */
                ADB_SET_STATE_ACKOFF();		/* end ACK to ADB chip */
                zshard(0);			/* grab any serial interrupts */
                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_ACK_DELAY);   /* delay */
                ADB_SET_STATE_ACKOFF(); /* end ACK to ADB chip */
                zshard(0);              /* grab any serial interrupts */

                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 */
                        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 */

                                /* is this data we are waiting for? */
                                if (adbBuffer != (long) 0) {    /* if valid return data pointer */
					/* get return length minus extras */
                                        len = adbInputBuffer[0] - 4;
                                        /* if adb_op is ever made to be called from a user
                                         * routine, we should use a copyout or copyin
                                         * here to be sure we're in the correct context */
                                        for (i = 1; i <= len; i++)
                                                adbBuffer[i] = adbInputBuffer[4 + i];
                                        if (len < 0)
                                                len = 0;
                                        adbBuffer[0] = len;
                                }
                                adb_comp_exec();        /* call completion routine */

                                adbWaitingCmd = 0;      /* reset "waiting" vars */
                                adbWaiting = 0;
                                adbBuffer = (long) 0;
                                adbCompRout = (long) 0;
                                adbCompData = (long) 0;
                        } else {
                                /* pass the data off to the handler */
                                /* This section IGNORES all data that is not from
                                 * the ADB sub-device. That is, not from rtc or pram.
                                 * Maybe we  should fix later, but do the other
                                 * devices every send things without
                                 * being asked? */
                                if (adbStarting == 0)   /* ignore if during adbreinit */
                                        if (adbInputBuffer[2] == 0x00)
                                                adb_handle_unsol(adbInputBuffer);
                        }

                        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_ACK_DELAY);   /* delay */
                                zshard(0);      	/* grab any serial interrupts */

                                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_ACK_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:
                i = 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_ACK_DELAY);   /* delay */
                        zshard(0);              /* grab any serial interrupts */
                        goto switch_start;      /* process next state  right now */
                        break;
                }
                delay(ADB_ACK_DELAY);   /* required delay */
                zshard(0);		/* grab any serial interrupts */

                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 */
                                adb_comp_exec();        /* call completion routine */
                                adbWaitingCmd = 0;      /* reset "waiting" vars, just in case */
                                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:
                printf_intr("adb: not yet initialized\n");
                break;

        default:
                printf_intr("intr: unknown ADB state\n");
        }

        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 i, s, len;

        if (adbActionState == ADB_ACTION_NOTREADY)
                return 1;

        s = splhigh();          /* don't interrupt while we are messing with the ADB */

        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 */

                for (i = 1; i <= len; i++)      /* copy additional output data, if any */
                        adbOutputBuffer[2 + i] = buffer[i];
        } else
                for (i = 0; i <= (adbOutputBuffer[0] + 1); i++)
                        adbOutputBuffer[i] = in[i];

        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();     /* go process "interrupt" */

        return 0;
}                               /* send_adb_IIsi */


/*
 * adb_comp_exec
 * This is a general routine that calls the completion routine if there is one.
 */
void adb_comp_exec(void)
{
	if ( (long)0 != adbCompRout )			/* don't call if empty return location */
		#ifdef __NetBSD__
		asm ( "
			movml   #0xffff, sp@-   | save all registers
			movl    %0,a2       	| adbCompData
			movl    %1,a1       	| adbCompRout
			movl    %2,a0       	| adbBuffer
			movl    %3,d0       	| adbWaitingCmd
			jbsr    a1@     	| go call the routine
			movml   sp@+, #0xffff   | restore all registers"
			:  : "g" (adbCompData), "g" (adbCompRout), "g" (adbBuffer), "g" (adbWaitingCmd) );
		#else					/* for macos based testing */
		asm
			{
			movem.l	a0/a1/a2/d0,-(a7)
			move.l	adbCompData,a2
			move.l	adbCompRout,a1
			move.l	adbBuffer,a0
			move.w	adbWaitingCmd,d0
			jsr		(a1)
			movem.l	(a7)+,d0/a2/a1/a0
			}
		#endif
}


/*
 * this routine handles what needs to be done after a message is read
 * from the adb data points to the raw data received from the device,
 * including device number (on IIsi) and result code.
 */
void
adb_handle_unsol(u_char *in)
{
        int     i, cmd;
        u_char	data[MAX_ADB_MSG_LENGTH];

	/* make local copy so we don't destroy the real one - it may
	 * be needed later. */
        for (i = 0; i <= (in[0] + 1); i++)
        	data[i] = in[i];

        switch (adbHardware) {
        case ADB_HW_II:
                /* adjust the "length" byte */
                cmd = data[1];
                if (data[0] < 2)
                        data[1] = 0;
                else
                        data[1] = data[0] - 1;

                adb_complete((data + 1), (long) 0, cmd);

                break;

        case ADB_HW_IISI:
        case ADB_HW_CUDA:
                /* only handles ADB for now */
                if (0 != *(data + 2))
                        return;

                /* adjust the "length" byte */
                cmd = data[4];
                if (data[0] < 5)
                        data[4] = 0;
                else
                        data[4] = data[0] - 4;

                adb_complete((data + 4), (long) 0, cmd);

                break;

        case ADB_HW_PB:
		return;		/* how does PM handle "unsolicited" messages? */

        case ADB_HW_UNKNOWN:
                return;
        }

        return;

#if 0
        /* this should really be used later, once it is set up properly */
        /* AND we need to make sure that we DON'T call it if it is zero! */
        if ( 0 != ADBDevTable[i].devType )
                (*(ADBDevTable[i].ServiceRtPtr))();
#endif
}


/*
 * 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_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_cleanup
 * This routine simply calls the appropriate version of the adb_cleanup routine.
 */
void
adb_cleanup(u_char *in)
{
        switch (adbHardware) {
        case ADB_HW_II:
                ADB_VIA_CLR_INTR();     /* clear interrupt */
                break;

        case ADB_HW_IISI:
                /* get those pesky clock ticks we missed while booting */
                adb_cleanup_IIsi(in);
                break;

        case ADB_HW_PB:
		/* TO DO: really PM_VIA_CLR_INTR - should we put it in pm_direct.h? */
                via_reg(VIA1, vIFR) = 0x90;   /* clear interrupt */
                break;

        case ADB_HW_CUDA:
        	/* TO DO: probably need some sort of cleanup for Cuda */
		ADB_VIA_CLR_INTR();
		ADB_SET_STATE_IDLE_CUDA();
                break;

        case ADB_HW_UNKNOWN:
                return;
        }
}


/*
 * adb_cleanup_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_cleanup_IIsi(u_char *buffer)
{
        int     i;
        int     dummy;
        int     s;
        long    my_time;
        int     endofframe;

        delay(ADB_ACK_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_ACK_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_ACK_DELAY * 5;
                        while ((ADB_SR_INTR_IS_OFF) && (my_time-- > 0))
                                dummy = 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 MAX_ADB_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_ACK_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_ACK_DELAY);
        }
        buffer[0] = --i;        /* [0] is length of message */
        ADB_VIA_INTR_ENABLE();  /* enable ADB interrupt on IIs. */
        splx(s);                /* restore interrupts */

        return;
}                               /* adb_cleanup_IIsi */


/*
 * adb_reinit sets up the adb stuff
 *
 */
void
adb_reinit(void)
{
        u_char send_string[MAX_ADB_MSG_LENGTH];
        int     s;
        int     i, x;
        int     command;
        int     result;
	int	saveptr;	/* point to next free relocation address */
	int	device;
	int	nonewtimes;	/* times thru loop w/o any new devices */
	ADBDataBlock data;	/* temp. holder for getting device info */

	(void)(&s);		/* work around lame GCC bug */

        /* Make sure we are not interrupted while building the table. */
	if (adbHardware != ADB_HW_PB )	/* ints must be on for PB? */
       		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 */

        /* Set up all the VIA bits we need to do the ADB stuff.
         */
        switch (adbHardware) {
       	case ADB_HW_II:
        	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 */
               	break;

       	case ADB_HW_IISI:
        	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 */
               	break;

       	case ADB_HW_PB:
		break;				/* there has to be more than this? */

        case ADB_HW_CUDA:
        	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 */
        	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 */
                break;

        case ADB_HW_UNKNOWN:			/* if type unknown then skip out */
	default:
               	via_reg(VIA1, vIER) = 0x04;     /* turn interrupts off - TO DO: turn PB ints off? */
               	return;
		break;
        }

        /*
         * Clear out any "leftover" commands.  Remember that up until this
         * point, the interrupt routine will be either off or it should be
         * able to ignore inputs until the device table is built.
         */
        for (i = 0; i < 30; i++) {
                delay(ADB_ACK_DELAY);
                adb_cleanup(send_string);
                printf_intr("adb: cleanup: ");
                print_single(send_string);
                delay(ADB_ACK_DELAY);
                if (ADB_INTR_IS_OFF)
                        break;
        }

        /* send an ADB reset first */
        adb_op_sync((Ptr) 0, (Ptr) 0, (Ptr) 0, (short) 0x00);

	/*
	 * 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 = (int) (0x0f | ((int) (i & 0x000f) << 4));	/* talk R3 */
		result = adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);
		if (0x00 != send_string[0]) {   /* anything come back ?? */
			ADBDevTable[++ADBNumDevices].devType = (u_char) send_string[2];
			ADBDevTable[ADBNumDevices].origAddr = i;
			ADBDevTable[ADBNumDevices].currentAddr = i;
			ADBDevTable[ADBNumDevices].DataAreaAddr = (long) 0;
			ADBDevTable[ADBNumDevices].ServiceRtPtr = NULL;
			/*printf_intr("initial device found (at index %i)\n", ADBNumDevices);*/
		}
	}

	/* find highest unused address */
	for ( saveptr=15; saveptr>0; saveptr-- )
		if ( -1 == get_adb_info(&data, saveptr) )
			break;

	if ( saveptr==0 )	/* no free addresses??? */
		saveptr=15;

	/*printf_intr("first free is: 0x%02x\n", saveptr);*/
	/*printf_intr("devices: %i\n", ADBNumDevices);*/

	nonewtimes=0;		/* no loops w/o new devices */
	while ( nonewtimes++ < 11 ) {
		for ( i=1; i <= ADBNumDevices; i++ ) {
			device=ADBDevTable[i].currentAddr;
			/*printf_intr("moving device 0x%02x to 0x%02x (index 0x%02x)  ", device, saveptr, i);*/

			/* send TALK R3 to address */
			command = (int) (0x0f | ((int) (device & 0x000f) << 4));
			adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

			/* move device to higher address */
	        	command = (int) (0x0b | ((int) (device & 0x000f) << 4));
	        	send_string[0]=2;
	        	send_string[1]=(u_char) (saveptr | 0x60 );
	        	send_string[2]=0xfe;
                	adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);

			/* send TALK R3 - anything at old address? */
			command = (int) (0x0f | ((int) (device & 0x000f) << 4));
			result = adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);
			if ( send_string[0] != 0 ) {
				/* new device found */
				/* update data for previously moved device */
				ADBDevTable[i].currentAddr=saveptr;
				/*printf_intr("old device at index %i\n",i);*/
				/* add new device in table */
				/*printf_intr("new device found\n");*/
				ADBDevTable[++ADBNumDevices].devType = (u_char) send_string[2];
				ADBDevTable[ADBNumDevices].origAddr = device;
				ADBDevTable[ADBNumDevices].currentAddr = device;
				ADBDevTable[ADBNumDevices].DataAreaAddr = (long) 0;
				ADBDevTable[ADBNumDevices].ServiceRtPtr = NULL;
				/* find next unused address */
				for ( x=saveptr; x>0; x-- )
					if ( -1 == get_adb_info(&data, x) ) {
						saveptr=x;
						break;
					}
				/*printf_intr("new free is 0x%02x\n", saveptr);*/
				nonewtimes=0;
			} else {
				/*printf_intr("moving back...\n");*/
				/* move old device back */
	        		command = (int) (0x0b | ((int) (saveptr & 0x000f) << 4));
	        		send_string[0]=2;
	        		send_string[1]=(u_char) (device | 0x60 );
	        		send_string[2]=0xfe;
                		adb_op_sync((Ptr) send_string, (Ptr) 0, (Ptr) 0, (short) command);
			}
		}
	}

        adb_prog_switch_enable();       /* enable the programmer's switch, if we have one */

        if (0 == ADBNumDevices)         /* tell user if no devices found */
                printf_intr("adb: no devices found\n");

        adbStarting = 0;        /* not starting anymore */
        printf_intr("adb: ADBReInit complete\n");

	if (adbHardware != ADB_HW_PB )	/* ints must be on for PB? */
        	splx(s);
        return;
}


/* 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_II:
        	/* was it an ADB talk command? */
                if ((in[1] & 0x0c) == 0x0c)
                        return 0;
                else
                        return 1;
                break;

        case ADB_HW_IISI:
        case ADB_HW_CUDA:
		/* was is an ADB talk command? */
                if ((in[1] == 0x00) && ((in[2] & 0x0c) == 0x0c))
                	return 0;
                else
                	/* was is an RTC/PRAM read date/time? */
                        if ((in[1] == 0x01) && (in[2] == 0x03))
                                return 0;
                        else
                                return 1;
                break;

        case ADB_HW_PB:
                return 1;
                break;

        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_II:
                if ((in[1] & 0x0c) == 0x08)     /* was it a listen command? */
                        return 0;
                else
                        return 1;
                break;

        case ADB_HW_IISI:
        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;
                else    /* add others later */
                        return 1;
                break;

        case ADB_HW_PB:
                return 1;
                break;

        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
 */
int
adb_op_sync(Ptr buffer, Ptr compRout, Ptr data, short command)
{
        int     result;
        int     flag;

        flag = 0;
        result = adb_op(buffer, (void *) adb_op_comprout,
            (void *) &flag, command);   /* send command */
        if (result == 0) {              /* send ok? */
                /* Don't need to use adb_cmd_result since this section is
                 * hardware independent, and for ADB commands only (no RTC or PRAM) */
                /*if ((command & 0x0c) == 0x0c)*/   /* was it a talk? */
                        while (0 == flag) ;

                return 0;
        } else
                return result;
}


/* adb_op_comprout
 * This function is used by the adb_op_sync routine so it knows when the function is
 * done.
 */
void adb_op_comprout(void)
{
	#ifdef __NetBSD__
    	asm ( "movw    #1,a2@			| update flag value" );
	#else					/* for macos based testing */
	asm	{ move.w #1,(a2) }		/* update flag value */
	#endif
}

void
adb_setup_hw_type(void)
{
        long    response;

        response = mac68k_machine.machineid;

        switch (response) {
        case 6:         /* II */
        case 7:         /* IIx */
        case 8:         /* IIcx */
        case 9:         /* SE/30 */
        case 11:        /* IIci */
        case 22:        /* Quadra 700 */
        case 30:        /* Centris 650 */
        case 35:        /* Quadra 800 */
        case 36:        /* Quadra 650 */
        case 52:        /* Centris 610 */
        case 53:        /* Centris 650 */
                adbHardware = ADB_HW_II;
                printf_intr("adb: using II series hardware support\n");
                break;
        case 18:        /* IIsi */
        case 20:        /* Quadra 900 - not sure if IIsi or not */
        case 23:        /* Classic II */
        case 26:        /* Quadra 950 - not sure if IIsi or not */
        case 27:        /* LC III, Performa 450 */
        case 37:        /* LC II, Performa 400/405/430 */
        case 44:        /* IIvi */
        case 45:        /* Performa 600 */
        case 48:        /* IIvx */
        case 49:        /* Color Classic - not sure if IIsi or not */
        case 62:        /* Performa 460/465/467 */
        case 83:        /* Color Classic II (number right?) - not sure if IIsi or not */
                adbHardware = ADB_HW_IISI;
                printf_intr("adb: using IIsi series hardware support\n");
                break;
        case 21:        /* PowerBook 170 */
        case 25:        /* PowerBook 140 */
        case 54:        /* PowerBook 145 */
        case 34:        /* PowerBook 160 */
        case 84:        /* PowerBook 165 */
        case 50:        /* PowerBook 165c */
        case 33:        /* PowerBook 180 */
        case 71:        /* PowerBook 180c */
        case 115:       /* PowerBook 150 */
                adbHardware=ADB_HW_PB;
                pm_setup_adb();
                printf_intr("adb: using PowerBook 100-series hardware support\n");
                break;
        case 29:        /* PowerBook Duo 210 */
        case 32:        /* PowerBook Duo 230 */
        case 38:        /* PowerBook Duo 250 */
        case 72:        /* PowerBook 500 series */
        case 77:        /* PowerBook Duo 270 */
        case 102:       /* PowerBook Duo 280 */
        case 103:       /* PowerBook Duo 280c */
                adbHardware = ADB_HW_PB;
                pm_setup_adb();
		printf_intr("adb: using PowerBook Duo-series and PowerBook 500-series hardware support\n");
                break;
        case 60:        /* Centris 660AV */
        case 78:        /* Quadra 840AV */
        case 89:        /* LC 475, Performa 475/476 */
        case 92:        /* LC 575, Performa 575/577/578 */
        case 94:        /* Quadra 605 */
        case 98:        /* LC 630, Performa 630, Quadra 630 */
                adbHardware = ADB_HW_CUDA;
                printf_intr("adb: using Cuda series hardware support\n");
                break;
        default:
                adbHardware = ADB_HW_UNKNOWN;
                printf_intr("adb: hardware type unknown for this machine\n");
                printf_intr("adb: ADB support is disabled\n");
                break;
        }
}

int
count_adbs(void)
{
        int     i;
        int     found;

        found = 0;

        for (i = 1; i < 16; i++)
                if (0 != ADBDevTable[i].devType)
                        found++;

        return found;
}

int
get_ind_adb_info(ADBDataBlock * info, int index)
{
        if ((index < 1) || (index > 15))        /* check range 1-15 */
                return (-1);

        /* printf_intr("index 0x%x devType is: 0x%x\n", index,
            ADBDevTable[index].devType); */
        if (0 == ADBDevTable[index].devType)    /* make sure it's a valid entry */
                return (-1);

        info->devType = ADBDevTable[index].devType;
        info->origADBAddr = ADBDevTable[index].origAddr;
        info->dbServiceRtPtr = (Ptr) ADBDevTable[index].ServiceRtPtr;
        info->dbDataAreaAddr = (Ptr) ADBDevTable[index].DataAreaAddr;

        return (ADBDevTable[index].currentAddr);
}

int
get_adb_info(ADBDataBlock * info, int adbAddr)
{
        int     i;

        if ((adbAddr < 1) || (adbAddr > 15))    /* check range 1-15 */
                return (-1);

        for (i = 1; i < 15; i++)
                if (ADBDevTable[i].currentAddr == adbAddr) {
                        info->devType = ADBDevTable[i].devType;
                        info->origADBAddr = ADBDevTable[i].origAddr;
                        info->dbServiceRtPtr = (Ptr)ADBDevTable[i].ServiceRtPtr;
                        info->dbDataAreaAddr = ADBDevTable[i].DataAreaAddr;
                        return 0;       /* found */
                }

        return (-1);            /* not found */
}

int
set_adb_info(ADBSetInfoBlock * info, int adbAddr)
{
        int     i;

        if ((adbAddr < 1) || (adbAddr > 15))    /* check range 1-15 */
                return (-1);

        for (i = 1; i < 15; i++)
                if (ADBDevTable[i].currentAddr == adbAddr) {
                        ADBDevTable[i].ServiceRtPtr =
                            (void *)(info->siServiceRtPtr);
                        ADBDevTable[i].DataAreaAddr = info->siDataAreaAddr;
                        return 0;       /* found */
                }

        return (-1);            /* not found */

}

#ifndef MRG_ADB
long
mrg_adbintr(void)
{
        adb_intr();
	return 1;	/* mimic mrg_adbintr in macrom.h just in case */
}

long
mrg_pmintr(void)	/* we don't do this yet */
{
	pm_intr();
	return 1;	/* mimic mrg_pmintr in macrom.h just in case */
}
#endif /* !MRG_ADB */

/* caller should really use machine-independant version: getPramTime */
/* this version does pseudo-adb access only */
int
adb_read_date_time(unsigned long *time)
{
        u_char output[MAX_ADB_MSG_LENGTH];
        int result;
        volatile int flag = 0;

        switch (adbHardware) {
        case ADB_HW_II:
                return -1;

        case ADB_HW_IISI:
                output[0] = 0x02;       /* 2 byte message */
                output[1] = 0x01;       /* to pram/rtc device */
                output[2] = 0x03;       /* read date/time */
                result = send_adb_IIsi((u_char *) output,
                    (u_char *) output, (void *) adb_op_comprout,
                    (void *) &flag, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                while (0 == flag) ;     /* wait for result */

                *time = (long) (*(long *) (output + 1));
                return 0;

        case ADB_HW_PB:
                return -1;

	case ADB_HW_CUDA:
                output[0] = 0x02;       /* 2 byte message */
                output[1] = 0x01;       /* to pram/rtc device */
                output[2] = 0x03;       /* read date/time */
                result = send_adb_cuda((u_char *) output,
                    (u_char *) output, (void *) adb_op_comprout,
                    (void *) &flag, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                while (0 == flag) ;     /* wait for result */

                *time = (long) (*(long *) (output + 1));
                return 0;

        case ADB_HW_UNKNOWN:
        default:
                return -1;
        }
}

/* caller should really use machine-independant version: setPramTime */
/* this version does pseudo-adb access only */
int
adb_set_date_time(unsigned long time)
{
        u_char output[MAX_ADB_MSG_LENGTH];
        int result;
        volatile int flag = 0;

        switch (adbHardware) {
        case ADB_HW_II:
		return -1;

        case ADB_HW_IISI:
                output[0] = 0x06;       /* 6 byte message */
                output[1] = 0x01;       /* to pram/rtc device */
                output[2] = 0x09;       /* set date/time */
                output[3] = (u_char) (time >> 24);
                output[4] = (u_char) (time >> 16);
                output[5] = (u_char) (time >> 8);
                output[6] = (u_char) (time);
                result = send_adb_IIsi((u_char *) output,
                    (u_char *) 0, (void *) adb_op_comprout,
                    (void *) &flag, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                while (0 == flag) ;     /* wait for send to finish */

                return 0;

        case ADB_HW_PB:
                return -1;

	case ADB_HW_CUDA:
                output[0] = 0x06;       /* 6 byte message */
                output[1] = 0x01;       /* to pram/rtc device */
                output[2] = 0x09;       /* set date/time */
                output[3] = (u_char) (time >> 24);
                output[4] = (u_char) (time >> 16);
                output[5] = (u_char) (time >> 8);
                output[6] = (u_char) (time);
                result = send_adb_cuda((u_char *) output,
                    (u_char *) 0, (void *) adb_op_comprout,
                    (void *) &flag, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                while (0 == flag) ;     /* wait for send to finish */

                return 0;

        case ADB_HW_UNKNOWN:
	default:
                return -1;
        }
}


int
adb_poweroff(void)
{
        u_char output[MAX_ADB_MSG_LENGTH];
        int     result;

        switch (adbHardware) {
        case ADB_HW_IISI:
                output[0] = 0x02;       /* 2 byte message */
                output[1] = 0x01;       /* to pram/rtc/soft-power device */
                output[2] = 0x0a;       /* set date/time */
                result = send_adb_IIsi((u_char *) output,
                    (u_char *) 0, (void *) 0, (void *) 0, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                for (;;) ;		/* wait for power off */

                return 0;

        case ADB_HW_PB:
                return -1;

	/* TO DO: some cuda models claim to do soft power - check out */
        case ADB_HW_II:			/* II models don't do soft power */
	case ADB_HW_CUDA:		/* cuda doesn't do soft power */
        case ADB_HW_UNKNOWN:
	default:
                return -1;
        }
}                               /* adb_poweroff */

int
adb_prog_switch_enable(void)
{
        u_char output[MAX_ADB_MSG_LENGTH];
        int result;
        volatile int flag = 0;

        switch (adbHardware) {
        case ADB_HW_IISI:
                output[0] = 0x03;       /* 3 byte message */
                output[1] = 0x01;       /* to pram/rtc/soft-power device */
                output[2] = 0x1c;       /* prog. switch control */
                output[3] = 0x01;       /* enable */
                result = send_adb_IIsi((u_char *) output,
                    (u_char *) 0, (void *) adb_op_comprout,
                    (void *) &flag, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                while (0 == flag) ;     /* wait for send to finish */

                return 0;

        case ADB_HW_PB:
                return -1;

        case ADB_HW_II:		/* II models don't do prog. switch */
        case ADB_HW_CUDA:	/* cuda doesn't do prog. switch */
        case ADB_HW_UNKNOWN:
	default:
                return -1;
        }
}                               /* adb_prog_switch_enable */

int
adb_prog_switch_disable(void)
{
        u_char output[MAX_ADB_MSG_LENGTH];
        int result;
        volatile int flag = 0;

        switch (adbHardware) {
        case ADB_HW_IISI:
                output[0] = 0x03;       /* 3 byte message */
                output[1] = 0x01;       /* to pram/rtc/soft-power device */
                output[2] = 0x1c;       /* prog. switch control */
                output[3] = 0x01;       /* disable */
                result = send_adb_IIsi((u_char *) output,
                    (u_char *) 0, (void *) adb_op_comprout,
                    (void *) &flag, (int) 0);
                if (result != 0)        /* exit if not sent */
                        return -1;

                while (0 == flag) ;     /* wait for send to finish */

                return 0;

        case ADB_HW_PB:
                return -1;

        case ADB_HW_II:		/* II models don't do prog. switch */
        case ADB_HW_CUDA:	/* cuda doesn't do prog. switch */
        case ADB_HW_UNKNOWN:
	default:
                return -1;
        }
}                               /* adb_prog_switch_disable */

#ifndef MRG_ADB
int
CountADBs(void)
{
        return (count_adbs());
}

void
ADBReInit(void)
{
        adb_reinit();
}

int
GetIndADB(ADBDataBlock * info, int index)
{
        return (get_ind_adb_info(info, index));
}

int
GetADBInfo(ADBDataBlock * info, int adbAddr)
{
        return (get_adb_info(info, adbAddr));
}

int
SetADBInfo(ADBSetInfoBlock * info, int adbAddr)
{
        return (set_adb_info(info, adbAddr));
}

int
ADBOp(Ptr buffer, Ptr compRout, Ptr data, short commandNum)
{
        return (adb_op(buffer, compRout, data, commandNum));
}
#endif /* !MRG_ADB */