diff options
Diffstat (limited to 'sys/arch/mac68k/dev')
| -rw-r--r-- | sys/arch/mac68k/dev/adb_direct.c | 3461 |
1 files changed, 1837 insertions, 1624 deletions
diff --git a/sys/arch/mac68k/dev/adb_direct.c b/sys/arch/mac68k/dev/adb_direct.c index d837512e889..e7cac16159a 100644 --- a/sys/arch/mac68k/dev/adb_direct.c +++ b/sys/arch/mac68k/dev/adb_direct.c @@ -1,5 +1,7 @@ -/* $OpenBSD: adb_direct.c,v 1.6 1997/04/18 22:08:07 gene Exp $ */ -/* adb_direct.c 1.91 1/20/97 jpw */ +/* $OpenBSD: adb_direct.c,v 1.7 1997/04/22 20:11:34 gene Exp $ */ +/* $NetBSD: adb_direct.c,v 1.5 1997/04/21 18:04:28 scottr Exp $ */ + +/* From: adb_direct.c 2.02 4/18/97 jpw */ /* * Copyright (C) 1996, 1997 John P. Wittkoski @@ -35,22 +37,28 @@ * to clean it up as much as I would like. * But it works, so I'm happy. :-) jpw */ -#include <sys/types.h> -#include <sys/cdefs.h> +#if defined(__NetBSD__) || defined(__OpenBSD__) + #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 <machine/macinfo.h> -#include <machine/viareg.h> #include <arch/mac68k/mac68k/macrom.h> -#include <arch/mac68k/dev/adbvar.h> - -#include "pm_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 HWDIRECT_TEST*/ +/*#define DEBUG*/ /* some misc. leftovers */ #define vPB 0x0000 @@ -94,9 +102,9 @@ #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, \ +#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 @@ -113,17 +121,18 @@ #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) ) +#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 +#define ADB_DELAY 150 /* * Maximum ADB message length; includes space for data, result, and @@ -134,7 +143,7 @@ /* * A structure for storing information about each ADB device. */ -struct ADBDevEntry { +struct ADBDevEntry { void (*ServiceRtPtr) __P((void)); void *DataAreaAddr; char devType; @@ -146,10 +155,10 @@ struct ADBDevEntry { * 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 */ + 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 */ }; /* @@ -160,52 +169,56 @@ 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 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 */ +int adbWaitingCmd = 0; /* ADB command we are waiting for */ +u_char *adbBuffer = (long) 0; /* pointer to user data area */ +void *adbCompRout = (long) 0; /* pointer to the completion routine */ +void *adbCompData = (long) 0; /* pointer to the completion routine data */ +long adbFakeInts = 0; /* keeps track of fake ADB interrupts for + * timeouts (II) */ +int adbStarting = 1; /* doing ADBReInit so do polling differently */ +int adbSendTalk = 0; /* the intr routine is sending the talk, not + * the user (II) */ +int adbPolling = 0; /* we are polling for service request */ +int adbPollCmd = 0; /* the last poll command we sent */ + +u_char adbInputBuffer[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 dev we heard from (II ONLY) */ +int adbLastDevIndex = 0; /* last ADB dev loc in dev table (II ONLY) */ +int adbLastCommand = 0; /* the last ADB command we sent (II) */ + +struct ADBDevEntry ADBDevTable[16]; /* our ADB device table */ +int ADBNumDevices; /* num. of ADB devices found with ADBReInit */ extern struct mac68k_machine_S mac68k_machine; -extern int zshard __P((int)); +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((unsigned char *)); +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((unsigned char *, unsigned char *, void *, void *, int)); -int send_adb_IIsi __P((unsigned char *, unsigned char *, void *, void *, int)); -int send_adb_cuda __P((unsigned char *, unsigned char *, void *, void *, int)); -void db_handle_unsol __P((unsigned char *)); +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)); @@ -214,655 +227,733 @@ 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((unsigned char *)); +void adb_handle_unsol __P((u_char *)); int adb_op_sync __P((Ptr, Ptr, Ptr, short)); -void adb_read_II __P((unsigned char *)); -void adb_cleanup __P((unsigned char *)); -void adb_cleanup_IIsi __P((unsigned char *)); +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((unsigned char *)); -int adb_cmd_extra __P((unsigned char *)); +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((unsigned char *, void *, void *)); +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 +void print_single(thestring) - u_char *thestring; + u_char *thestring; { - int x; - - if ((int)(thestring[0]) == 0) { - printf("nothing returned\n"); - return; - } - if (thestring == 0) { - printf("no data - null pointer\n"); - return; - } - if (thestring[0] > 20) { - printf("ADB: ACK > 20 no way!\n"); - thestring[0] = 20; - } - printf("(length=0x%x):", thestring[0]); - for (x = 0; x < thestring[0]; x++) - printf(" 0x%02x", thestring[x + 1]); - printf("\n"); + int x; + + if ((int) (thestring[0]) == 0) { + printf_intr("nothing returned\n"); + return; + } + if (thestring == 0) { + printf_intr("no data - null pointer\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 +/* + * called when when an adb interrupt happens * * Cuda version of adb_intr - * TO DO: can probably reduce the number of zshard calls in here + * TO DO: do we want to add some zshard calls in here? */ -void +void adb_intr_cuda(void) { - int i, ending, len; - unsigned int s; + int i, ending, len; + unsigned int s; - s = splhigh(); /* can't be too careful - might be called */ - /* from a routine, NOT an interrupt */ + s = splhigh(); /* can't be too careful - might be called */ + /* from a routine, NOT an interrupt */ - ADB_VIA_CLR_INTR(); /* clear interrupt */ + ADB_VIA_CLR_INTR(); /* clear interrupt */ - ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */ + 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("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("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 */ + switch (adbActionState) { + case ADB_ACTION_IDLE: + /* This is an unexpected packet, so grab the first (dummy) + * byte, set up the proper vars, and tell the chip we are + * starting to receive the packet by setting the TIP bit. */ + adbInputBuffer[1] = ADB_SR(); + ADB_SET_STATE_TIP(); + ADB_SET_SR_INPUT(); + delay(ADB_DELAY); /* required delay */ +#ifdef DEBUG + printf_intr("idle 0x%02x ", adbInputBuffer[1]); +#endif + adbInputBuffer[0] = 1; + adbActionState = ADB_ACTION_IN; + break; + + case ADB_ACTION_IN: + adbInputBuffer[++adbInputBuffer[0]] = ADB_SR(); + /* intr off means this is the last byte (end of frame) */ + if (ADB_INTR_IS_OFF) + ending = 1; + else + ending = 0; + + /* if the second byte is 0xff, it's a "dummy" packet */ + if (adbInputBuffer[2] == 0xff) + ending = 1; + + if (1 == ending) { /* end of message? */ +#ifdef DEBUG + printf_intr("in end 0x%02x ", + adbInputBuffer[adbInputBuffer[0]]); + print_single(adbInputBuffer); +#endif + + /* Are we waiting AND does this packet match what we + * are waiting for AND is it coming from either the + * ADB or RTC/PRAM sub-device? This section _should_ + * recognize all ADB and RTC/PRAM type commands, but + * there may be more... NOTE: commands are always at + * [4], even for RTC/PRAM commands. */ + if ((adbWaiting == 1) && + (adbInputBuffer[4] == adbWaitingCmd) && + ((adbInputBuffer[2] == 0x00) || + (adbInputBuffer[2] == 0x01))) { + + 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("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("in 0x%02x ", adbInputBuffer[adbInputBuffer[0]]); - } - - break; - - case ADB_ACTION_OUT: - i = ADB_SR(); /* reset SR-intr in IFR */ - printf("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 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("write done "); - } else { - ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* send next byte */ - ADB_TOGGLE_STATE_ACK_CUDA(); /* signal byte ready to shift */ - printf("toggle "); - } - break; - - case ADB_ACTION_NOTREADY: - printf("adb: not yet initialized\n"); - break; - - default: - printf("intr: unknown ADB state\n"); - } - - ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */ - - splx(s); /* restore */ - - return; -} /* end adb_intr_IIsi */ + 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; + } + /* call completion routine and clean up */ + adb_comp_exec(); + adbWaitingCmd = 0; + adbWaiting = 0; + adbBuffer = (long) 0; + adbCompRout = (long) 0; + adbCompData = (long) 0; + } else { + /* + * This was an unsolicited packet, so + * pass the data off to the handler for + * this device if we are NOT doing this + * during a ADBReInit. + * 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) + if (adbInputBuffer[2] == 0x00) + adb_handle_unsol(adbInputBuffer); + } + /* reset vars and signal the end of this frame */ + adbActionState = ADB_ACTION_IDLE; + adbInputBuffer[0] = 0; + ADB_SET_STATE_IDLE_CUDA(); + + /* + * If there is something waiting to be sent out, + * the set everything up and send the first byte. + */ + if (adbWriteDelay == 1) { + delay(ADB_DELAY); /* required */ + adbSentChars = 0; + adbActionState = ADB_ACTION_OUT; + +/* TO DO: don't we need to set up adbWaiting vars here??? */ + + /* + * If the interrupt is on, we were too slow + * and the chip has already started to send + * something to us, so back out of the write + * and start a read cycle. + */ + if (ADB_INTR_IS_ON) { + ADB_SET_STATE_IDLE_CUDA(); + ADB_SET_SR_INPUT(); + adbSentChars = 0; + adbActionState = ADB_ACTION_IDLE; + adbInputBuffer[0] = 0; + break; + } + /* + * If we got here, it's ok to start sending + * so load the first byte and tell the chip + * we want to send. + */ + ADB_SET_SR_OUTPUT(); + ADB_SR() = adbOutputBuffer[adbSentChars + 1]; + ADB_SET_STATE_TIP(); + } + } else { + ADB_TOGGLE_STATE_ACK_CUDA(); +#ifdef DEBUG + printf_intr("in 0x%02x ", + adbInputBuffer[adbInputBuffer[0]]); +#endif + } + break; -int -send_adb_cuda(u_char *in, u_char *buffer, void *compRout, void *data, int -command) + case ADB_ACTION_OUT: + i = ADB_SR(); /* reset SR-intr in IFR */ +#ifdef DEBUG + printf_intr("intr out 0x%02x ", i); +#endif + ADB_SET_SR_OUTPUT(); /* set shift register for OUT */ + + adbSentChars++; + if (ADB_INTR_IS_ON) { /* ADB intr low during write */ +#ifdef DEBUG + printf_intr("intr was on "); +#endif + ADB_SET_STATE_IDLE_CUDA(); + ADB_SET_SR_INPUT(); /* make sure SR is set to IN */ + adbSentChars = 0; /* must start all over */ + adbActionState = ADB_ACTION_IDLE; /* new state */ + adbInputBuffer[0] = 0; + adbWriteDelay = 1; /* must retry when done with + * read */ + delay(ADB_DELAY); + 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_STATE_IDLE_CUDA(); +#ifdef DEBUG + printf_intr("write done "); +#endif + } else { + ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* send next byte */ + ADB_TOGGLE_STATE_ACK_CUDA(); /* signal byte ready to + * shift */ +#ifdef DEBUG + printf_intr("toggle "); +#endif + } + 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("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 */ + int i, s, len; + +#ifdef DEBUG + printf_intr("SEND\n"); +#endif + + 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! */ + } + +#ifdef DEBUG + printf_intr("QUEUE\n"); +#endif + if ((long) in == (long) 0) { /* need to convert? */ + /* don't need to use adb_cmd_extra here because this section + * will be called */ + /* ONLY when it is an ADB command (no RTC or PRAM) */ + if ((command & 0x0c) == 0x08) /* copy addl data ONLY if + * doing a listen! */ + len = buffer[0]; /* length of additional data */ + else + len = 0;/* no additional data */ + + adbOutputBuffer[0] = 2 + len; /* dev. type + command + addl. + * data */ + adbOutputBuffer[1] = 0x00; /* mark as an ADB command */ + adbOutputBuffer[2] = (u_char) command; /* load command */ + + 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? */ +#ifdef DEBUG + printf_intr("out start NOW"); +#endif + delay(ADB_DELAY); + adbActionState = ADB_ACTION_OUT; /* set next state */ + ADB_SET_SR_OUTPUT(); /* set shift register for OUT */ + ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* load byte for output */ ADB_SET_STATE_ACKOFF_CUDA(); - ADB_SET_STATE_TIP(); /* tell ADB that we want to send */ - } - adbWriteDelay = 1; /* something in the write "queue" */ + ADB_SET_STATE_TIP(); /* tell ADB that we want to send */ + } + adbWriteDelay = 1; /* something in the write "queue" */ - splx(s); + 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" */ + 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 */ + return 0; +} /* send_adb_cuda */ /* 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; + 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 */ + s = splhigh(); /* can't be too careful - might be called */ + /* from a routine, NOT an interrupt */ - ADB_VIA_CLR_INTR(); /* clear interrupt */ + ADB_VIA_CLR_INTR(); /* clear interrupt */ - ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */ + ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */ /*if (ADB_INTR_IS_ON)*/ -/* printf("INTR ON ");*/ -if (ADB_INTR_IS_ON) - intr_on=1; /* save for later */ - - switch (adbActionState) { - case ADB_ACTION_IDLE: - if ( !intr_on ) { - /*printf("FAKE DROPPED \n");*/ - /*printf(" XX ");*/ - i=ADB_SR(); - break; - } - adbNextEnd=0; - /*printf("idle ");*/ - adbInputBuffer[0] = 1; - adbInputBuffer[1] = ADB_SR(); /* get first byte */ - /*printf("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("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("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("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("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("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("starting POLL ");*/ - do_srq=1; - adbPolling=1; - } else if ( (adbInputBuffer[1] & 0x0f) != 0x0c) { - /*printf("xC HACK ");*/ - adbPolling=1; - send=1; - adbOutputBuffer[0]=1; - adbOutputBuffer[1]=(adbInputBuffer[1] & 0xf0) | 0x0c; - } else { - /*printf("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("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. +/* 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 (!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 */ + 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; + break; case ADB_BUS_ODD: - ADB_SET_STATE_EVEN(); /* set state to even */ - adbBusState = ADB_BUS_EVEN; - break; - default: - printf("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("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("non-talk out 0x%0x ", i);*/ - ADB_SET_SR_OUTPUT(); - if (adbOutputBuffer[0] == adbSentChars) { /* check for done */ - /*printf("done \n");*/ + 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("strange state!!! (0x%x)\n", adbBusState); - break; - } - break; - - default: - printf("adb: unknown ADB state (during intr)\n"); - } - - ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */ + 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; - splx(s); /* restore */ + 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; + return; } -/* - * send_adb version for II series machines +/* + * send_adb version for II series machines */ int -send_adb_II(u_char *in, u_char *buffer, void *compRout, void *data, int command) +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; + 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; } @@ -873,255 +964,272 @@ send_adb_II(u_char *in, u_char *buffer, void *compRout, void *data, int command) int adb_guess_next_device(void) { - int last, i, dummy; + 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) + /* 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 */ + 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 */ + if (adbLastDevice < 1 || adbLastDevice > 15) /* let's be parinoid */ adbLastDevice = 2; - last = 1; /* default index location */ - + 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 */ + 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 = 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; + 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) + if (ADBDevTable[dummy].devType != 0) break; } - adbLastDevice=ADBDevTable[dummy].currentAddr; + 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 +void adb_intr(void) { - switch (adbHardware) { - case ADB_HW_II: - adb_intr_II(); - break; + switch (adbHardware) { + case ADB_HW_II: + adb_intr_II(); + break; - case ADB_HW_IISI: - adb_intr_IIsi(); - break; + case ADB_HW_IISI: + adb_intr_IIsi(); + break; - case ADB_HW_PB: - break; + case ADB_HW_PB: + break; case ADB_HW_CUDA: adb_intr_cuda(); break; - - case ADB_HW_UNKNOWN: - break; - } + + case ADB_HW_UNKNOWN: + break; + } } -/* - * called when when an adb interrupt happens +/* + * called when when an adb interrupt happens * * IIsi version of adb_intr * */ -void +void adb_intr_IIsi(void) { - int i, ending, len; - unsigned int s; + int i, ending, len; + unsigned int s; - s = splhigh(); /* can't be too careful - might be called */ - /* from a routine, NOT an interrupt */ + s = splhigh(); /* can't be too careful - might be called */ + /* from a routine, NOT an interrupt */ - ADB_VIA_CLR_INTR(); /* clear interrupt */ + ADB_VIA_CLR_INTR(); /* clear interrupt */ - ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */ + 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 */ + switch (adbActionState) { + case ADB_ACTION_IDLE: + delay(ADB_DELAY); /* short delay is required before the + * first byte */ + + ADB_SET_SR_INPUT(); /* make sure SR is set to IN */ + ADB_SET_STATE_ACTIVE(); /* signal start of data frame */ + adbInputBuffer[1] = ADB_SR(); /* get byte */ + adbInputBuffer[0] = 1; + adbActionState = ADB_ACTION_IN; /* set next state */ + + ADB_SET_STATE_ACKON(); /* start ACK to ADB chip */ + delay(ADB_DELAY); /* delay */ + ADB_SET_STATE_ACKOFF(); /* end ACK to ADB chip */ + 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_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("adb: not yet initialized\n"); - break; - - default: - printf("intr: unknown ADB state\n"); - } - - ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */ - - splx(s); /* restore */ - - return; -} /* end adb_intr_IIsi */ + 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_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_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_DELAY); /* delay */ + zshard(0); /* grab any serial interrupts */ + goto switch_start; /* process next state right + * now */ + break; + } + delay(ADB_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 */ /***************************************************************************** @@ -1132,177 +1240,221 @@ switch_start: * 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 + * 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 +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; + int i, s, len; - s = splhigh(); /* don't interrupt while we are messing with the ADB */ + if (adbActionState == ADB_ACTION_NOTREADY) + return 1; - if ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */ - (ADB_INTR_IS_OFF)) { /* and no incoming interrupt? */ + s = splhigh(); /* don't interrupt while we are messing with + * the ADB */ - } 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 ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */ + (ADB_INTR_IS_OFF)) {/* and no incoming interrupt? */ - 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 */ + } 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! */ + } - ADB_SET_STATE_ACKON(); /* tell ADB byte ready to shift */ - } - adbWriteDelay = 1; /* something in the write "queue" */ + 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); + 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" */ + 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 */ + 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) +void +adb_comp_exec(void) { - if ( (long)0 != adbCompRout ) /* don't call if empty return location */ - #if defined(__NetBSD__) || defined(__OpenBSD__) - 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 + 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) + :"d0", "a0", "a1", "a2"); +#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. + * This routine handles what needs to be done after an unsolicited + * message is read from the ADB device. 'in' points to the raw + * data received from the device, including device number + * (on IIsi) and result code. + * + * Note that the service (completion) routine for an unsolicited + * message is whatever is set in the ADB device table. This is + * different than for a device responding to a specific request, + * where the completion routine is defined by the caller. */ -void -adb_handle_unsol(u_char *in) +void +adb_handle_unsol(u_char * in) { - int i, cmd; - u_char data[MAX_ADB_MSG_LENGTH]; + int i, cmd = 0; + u_char data[MAX_ADB_MSG_LENGTH]; + u_char *buffer = 0; + ADBDataBlock block; + + /* 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; + + buffer = (data + 1); + break; - /* 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_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; + + buffer = (data + 4); + break; - case ADB_HW_UNKNOWN: - return; - } + case ADB_HW_PB: + return; /* how does PM handle "unsolicited" messages? */ - return; + case ADB_HW_UNKNOWN: + 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))(); + if (-1 == get_adb_info(&block, ((cmd & 0xf0) >> 4))) + return; + + /* call default completion routine if it's valid */ + /* TO DO: This section of code is somewhat redundant with + * adb_comp_exec (above). Some day we may want to generalize it and + * make it a single function. */ + if ((long) 0 != (long) block.dbServiceRtPtr) { +#ifdef __NetBSD__ + asm(" + movml #0xffff, sp@- | save all registers + movl %0, a2 | block.dbDataAreaAddr + movl %1, a1 | block.dbServiceRtPtr + movl %2, a0 | buffer + movl %3, d0 | cmd + jbsr a1@ | go call the routine + movml sp@+, #0xffff | restore all registers" + : + : "g"(block.dbDataAreaAddr), + "g"(block.dbServiceRtPtr), "g"(buffer), "g"(cmd) + : "d0", "a0", "a1", "a2"); +#else /* for macos based testing */ + asm + { + movem.l a0/a1/a2/d0, -(a7) + move.l block.dbDataAreaAddr, a2 + move.l block.dbServiceRtPtr, a1 + move.l buffer, a0 + move.w cmd, d0 + jsr(a1) + movem.l(a7) +, d0/a2/a1/a0 + } #endif + } + return; } @@ -1310,63 +1462,72 @@ adb_handle_unsol(u_char *in) * 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 + * 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 + * 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 +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); - break; - - case ADB_HW_IISI: - result = send_adb_IIsi((u_char *) 0, - (u_char *) buffer, (void *) compRout, - (void *) data, (int) 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, + * 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); + 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_UNKNOWN: + 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; - } - if (result == 0) - return 0; - else - return -1; + return -1; + } } @@ -1374,302 +1535,348 @@ adb_op(Ptr buffer, Ptr compRout, Ptr data, short command) * adb_cleanup * This routine simply calls the appropriate version of the adb_cleanup routine. */ -void -adb_cleanup(u_char *in) +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; - } + volatile int i; + + 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: + /* + * XXX - 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: + i = ADB_SR(); /* clear interrupt */ + ADB_VIA_INTR_DISABLE(); /* no interrupts while clearing */ + ADB_SET_STATE_IDLE_CUDA(); /* reset state to idle */ + delay(ADB_DELAY); + ADB_SET_STATE_TIP(); /* signal start of frame */ + delay(ADB_DELAY); + ADB_TOGGLE_STATE_ACK_CUDA(); + delay(ADB_DELAY); + ADB_CLR_STATE_TIP(); + delay(ADB_DELAY); + ADB_SET_STATE_IDLE_CUDA(); /* back to idle state */ + i = ADB_SR(); /* clear interrupt */ + ADB_VIA_INTR_ENABLE(); /* ints ok now */ + break; + + case ADB_HW_UNKNOWN: + 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) +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 */ + int i; + int dummy; + int s; + long my_time; + int endofframe; + + delay(ADB_DELAY); + + i = 1; /* skip over [0] */ + s = splhigh(); /* block ALL interrupts while we are working */ + ADB_SET_SR_INPUT(); /* make sure SR is set to IN */ + ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */ + /* this is required, especially on faster machines */ + delay(ADB_DELAY); + + if (ADB_INTR_IS_ON) { + ADB_SET_STATE_ACTIVE(); /* signal start of data frame */ + + endofframe = 0; + while (0 == endofframe) { + /* poll for ADB interrupt and watch for timeout */ + /* if time out, keep going in hopes of not hanging the + * ADB chip - I think */ + my_time = ADB_DELAY * 5; + while ((ADB_SR_INTR_IS_OFF) && (my_time-- > 0)) + 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_DELAY); /* delay */ + ADB_SET_STATE_ACKOFF(); /* send ACK to ADB chip */ + } + ADB_SET_STATE_INACTIVE(); /* signal end of frame and + * delay */ + + /* probably don't need to delay this long */ + delay(ADB_DELAY); + } + buffer[0] = --i; /* [0] is length of message */ + ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */ + splx(s); /* restore interrupts */ + + return; +} /* adb_cleanup_IIsi */ + /* * adb_reinit sets up the adb stuff * */ -void +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 */ + u_char send_string[MAX_ADB_MSG_LENGTH]; + int s = 0; + volatile 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); /* XXX workaround gcc bug */ - - /* Make sure we are not interrupted while building the table. */ - 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 */ + (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 */ + via_reg(VIA1, vACR) = (via_reg(VIA1, vACR) | 0x0c) & ~0x10; + adbActionState = ADB_ACTION_IDLE; /* used by all types of + * hardware */ + adbBusState = ADB_BUS_IDLE; /* this var. used in II-series + * code only */ + via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts + * are on */ + ADB_SET_STATE_IDLE_CUDA(); /* set ADB bus state to idle */ + 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; + 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("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.) + } + + /* + * 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_DELAY); + adb_cleanup(send_string); + printf_intr("adb: cleanup: "); + print_single(send_string); + delay(ADB_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++) { + 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 ?? */ + 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 = (void *) 0; - /*printf("initial device found (at index %d)\n", ADBNumDevices);*/ - pm_check_adb_devices(i); + /* printf_intr("initial device found (at index %i)\n", + * ADBNumDevices); */ + pm_check_adb_devices(i); /* tell pm driver device + * is here */ } } - + /* find highest unused address */ - for ( saveptr=15; saveptr>0; saveptr-- ) - if ( -1 == get_adb_info(&data, saveptr) ) + for (saveptr = 15; saveptr > 0; saveptr--) + if (-1 == get_adb_info(&data, saveptr)) break; - - if ( saveptr==0 ) /* no free addresses??? */ - saveptr=15; - - /*printf("first free is: 0x%02x\n", saveptr);*/ - /*printf("devices: %d\n", ADBNumDevices);*/ - - nonewtimes=0; /* no loops w/o new devices */ - while ( nonewtimes++ < 11 ) { - for ( i=1; i <= ADBNumDevices; i++ ) { - device=ADBDevTable[i].currentAddr; - /*printf("moving device 0x%02x to 0x%02x (index 0x%02x) ", device, saveptr, i);*/ + + 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); - + 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 ) { + if (send_string[0] != 0) { /* new device found */ /* update data for previously moved device */ - ADBDevTable[i].currentAddr=saveptr; - /*printf("old device at index %d\n",i);*/ + ADBDevTable[i].currentAddr = saveptr; + /* printf_intr("old device at index %i\n",i); */ /* add new device in table */ - /*printf("new device found\n");*/ + /* printf_intr("new device found\n"); */ ADBDevTable[++ADBNumDevices].devType = (u_char) send_string[2]; ADBDevTable[ADBNumDevices].origAddr = device; ADBDevTable[ADBNumDevices].currentAddr = device; + /* These will be set correctly in adbsys.c */ + /* Until then, unsol. data will be ignored. */ ADBDevTable[ADBNumDevices].DataAreaAddr = (long) 0; ADBDevTable[ADBNumDevices].ServiceRtPtr = (void *) 0; /* find next unused address */ - for ( x=saveptr; x>0; x-- ) - if ( -1 == get_adb_info(&data, x) ) { - saveptr=x; + for (x = saveptr; x > 0; x--) + if (-1 == get_adb_info(&data, x)) { + saveptr = x; break; } - /*printf("new free is 0x%02x\n", saveptr);*/ - nonewtimes=0; + /* printf_intr("new free is 0x%02x\n", + * saveptr); */ + nonewtimes = 0; + /* tell pm driver device is here */ + pm_check_adb_devices(device); } else { - /*printf("moving back...\n");*/ + /* 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); + 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 */ +#ifdef DEBUG + for (i = 1; i <= ADBNumDevices; i++) { + x = get_ind_adb_info(&data, i); + if (x != -1) + printf_intr("index 0x%x, addr 0x%x, type 0x%x\n", i, x, data.devType); + + } +#endif - if (0 == ADBNumDevices) /* tell user if no devices found */ - printf("adb: no devices found\n"); + adb_prog_switch_enable(); /* enable the programmer's switch, if + * we have one */ - adbStarting = 0; /* not starting anymore */ - printf("adb: ADBReInit complete\n"); + if (0 == ADBNumDevices) /* tell user if no devices found */ + printf_intr("adb: no devices found\n"); - splx(s); + adbStarting = 0; /* not starting anymore */ + printf_intr("adb: ADBReInit complete\n"); - return; + if (adbHardware != ADB_HW_PB) /* ints must be on for PB? */ + splx(s); + return; } @@ -1679,39 +1886,39 @@ adb_reinit(void) * returns: 0 if a result should be expected * 1 if a result should NOT be expected */ -int -adb_cmd_result(u_char *in) +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: + 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: + if ((in[1] == 0x00) && ((in[2] & 0x0c) == 0x0c)) + return 0; + /* was is an RTC/PRAM read date/time? */ + else + 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; - } + return 1; + } } @@ -1721,35 +1928,35 @@ adb_cmd_result(u_char *in) * returns: 0 if extra data is allowed * 1 if extra data is NOT allowed */ -int -adb_cmd_extra(u_char *in) +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: + 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; - } + return 1; + } } @@ -1757,189 +1964,188 @@ adb_cmd_extra(u_char *in) * 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 +int adb_op_sync(Ptr buffer, Ptr compRout, Ptr data, short command) { - int result; - volatile 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; + int result; + volatile int flag = 0; + + result = adb_op(buffer, (void *) adb_op_comprout, + (void *) &flag, command); /* send command */ + if (result == 0) { /* send ok? */ + while (0 == flag); /* wait for compl. routine */ + 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 + * This function is used by the adb_op_sync routine so it knows when the function is * done. */ -void adb_op_comprout(void) +void +adb_op_comprout(void) { - #if defined(__NetBSD__) || defined(__OpenBSD__) - asm ( "movw #1,a2@ | update flag value" ); - #else /* for macos based testing */ - asm { move.w #1,(a2) } /* update flag value */ - #endif +#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("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("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("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("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("adb: using Cuda series hardware support\n"); - break; - default: - adbHardware = ADB_HW_UNKNOWN; - printf("adb: hardware type unknown for this machine\n"); - printf("adb: ADB support is disabled\n"); - break; - } + 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: /* Quadra 610 */ + 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 - 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 56: /* LC 520 */ + case 60: /* Centris 660AV */ + case 78: /* Quadra 840AV */ + case 80: /* LC 550, Performa 550 */ + 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; + int i; + int found; - found = 0; + found = 0; - for (i = 1; i < 16; i++) - if (0 != ADBDevTable[i].devType) - found++; + for (i = 1; i < 16; i++) + if (0 != ADBDevTable[i].devType) + found++; - return found; + return found; } int get_ind_adb_info(ADBDataBlock * info, int index) { - if ((index < 1) || (index > 15)) /* check range 1-15 */ - return (-1); + if ((index < 1) || (index > 15)) /* check range 1-15 */ + return (-1); - /* printf("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); + /* 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; + 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); + 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 */ - } + 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 */ + return (-1); /* not found */ } int set_adb_info(ADBSetInfoBlock * info, int adbAddr) { - int i; + int i; - if ((adbAddr < 1) || (adbAddr > 15)) /* check range 1-15 */ - return (-1); + 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 */ - } + 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 */ + return (-1); /* not found */ } @@ -1947,7 +2153,7 @@ set_adb_info(ADBSetInfoBlock * info, int adbAddr) long mrg_adbintr(void) { - adb_intr(); + adb_intr(); return 1; /* mimic mrg_adbintr in macrom.h just in case */ } @@ -1964,51 +2170,53 @@ mrg_pmintr(void) /* we don't do this yet */ int adb_read_date_time(unsigned long *time) { - u_char output[MAX_ADB_MSG_LENGTH]; - int result; - volatile int flag = 0; + u_char output[MAX_ADB_MSG_LENGTH]; + int result; + volatile int flag = 0; - switch (adbHardware) { - case ADB_HW_II: - return -1; + 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; + 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, + (int *) &flag, (int) 0); + if (result != 0) /* exit if not sent */ + return -1; - while (0 == flag) ; /* wait for result */ + while (0 == flag) /* wait for result */ + ; - *time = (long) (*(long *) (output + 1)); - return 0; + *time = (long) (*(long *) (output + 1)); + return 0; - case ADB_HW_PB: - return -1; + 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; - } + 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 */ @@ -2016,196 +2224,201 @@ adb_read_date_time(unsigned long *time) int adb_set_date_time(unsigned long time) { - u_char output[MAX_ADB_MSG_LENGTH]; - int result; - volatile int flag = 0; + u_char output[MAX_ADB_MSG_LENGTH]; + int result; + volatile int flag = 0; - switch (adbHardware) { - case ADB_HW_II: + 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_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: + 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; - } + return -1; + } } int adb_poweroff(void) { - u_char output[MAX_ADB_MSG_LENGTH]; - int result; + 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; + 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 */ + for (;;); /* wait for power off */ - return 0; + return 0; - case ADB_HW_PB: - return -1; + 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_II: /* II models don't do soft power */ case ADB_HW_CUDA: /* cuda doesn't do soft power */ - case ADB_HW_UNKNOWN: + case ADB_HW_UNKNOWN: default: - return -1; - } -} /* adb_poweroff */ + return -1; + } +} 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: + 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 TO DO: verify this */ + case ADB_HW_UNKNOWN: default: - return -1; - } -} /* adb_prog_switch_enable */ + return -1; + } +} 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: + 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 */ + return -1; + } +} #ifndef MRG_ADB int CountADBs(void) { - return (count_adbs()); + return (count_adbs()); } void ADBReInit(void) { - adb_reinit(); + adb_reinit(); } int GetIndADB(ADBDataBlock * info, int index) { - return (get_ind_adb_info(info, index)); + return (get_ind_adb_info(info, index)); } int GetADBInfo(ADBDataBlock * info, int adbAddr) { - return (get_adb_info(info, adbAddr)); + return (get_adb_info(info, adbAddr)); } int SetADBInfo(ADBSetInfoBlock * info, int adbAddr) { - return (set_adb_info(info, adbAddr)); + return (set_adb_info(info, adbAddr)); } int ADBOp(Ptr buffer, Ptr compRout, Ptr data, short commandNum) { - return (adb_op(buffer, compRout, data, commandNum)); + return (adb_op(buffer, compRout, data, commandNum)); } #endif + |