Annotation of sys/arch/macppc/dev/adb.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: adb.c,v 1.27 2007/04/23 16:27:20 deraadt Exp $ */
! 2: /* $NetBSD: adb.c,v 1.6 1999/08/16 06:28:09 tsubai Exp $ */
! 3: /* $NetBSD: adb_direct.c,v 1.14 2000/06/08 22:10:45 tsubai Exp $ */
! 4:
! 5: /*
! 6: * Copyright (C) 1996, 1997 John P. Wittkoski
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. All advertising materials mentioning features or use of this software
! 18: * must display the following acknowledgement:
! 19: * This product includes software developed by John P. Wittkoski.
! 20: * 4. The name of the author may not be used to endorse or promote products
! 21: * derived from this software without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
! 32: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 33: */
! 34:
! 35: /*-
! 36: * Copyright (C) 1994 Bradley A. Grantham
! 37: * All rights reserved.
! 38: *
! 39: * Redistribution and use in source and binary forms, with or without
! 40: * modification, are permitted provided that the following conditions
! 41: * are met:
! 42: * 1. Redistributions of source code must retain the above copyright
! 43: * notice, this list of conditions and the following disclaimer.
! 44: * 2. Redistributions in binary form must reproduce the above copyright
! 45: * notice, this list of conditions and the following disclaimer in the
! 46: * documentation and/or other materials provided with the distribution.
! 47: * 3. All advertising materials mentioning features or use of this software
! 48: * must display the following acknowledgement:
! 49: * This product includes software developed by Bradley A. Grantham.
! 50: * 4. The name of the author may not be used to endorse or promote products
! 51: * derived from this software without specific prior written permission.
! 52: *
! 53: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 54: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 55: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 56: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 57: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 58: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 59: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 60: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 61: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
! 62: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 63: */
! 64:
! 65: /*
! 66: * This code is rather messy, but I don't have time right now
! 67: * to clean it up as much as I would like.
! 68: * But it works, so I'm happy. :-) jpw
! 69: */
! 70:
! 71: /*
! 72: * TO DO:
! 73: * - We could reduce the time spent in the adb_intr_* routines
! 74: * by having them save the incoming and outgoing data directly
! 75: * in the adbInbound and adbOutbound queues, as it would reduce
! 76: * the number of times we need to copy the data around. It
! 77: * would also make the code more readable and easier to follow.
! 78: * - (Related to above) Use the header part of adbCommand to
! 79: * reduce the number of copies we have to do of the data.
! 80: * - (Related to above) Actually implement the adbOutbound queue.
! 81: * This is fairly easy once you switch all the intr routines
! 82: * over to using adbCommand structs directly.
! 83: * - There is a bug in the state machine of adb_intr_cuda
! 84: * code that causes hangs, especially on 030 machines, probably
! 85: * because of some timing issues. Because I have been unable to
! 86: * determine the exact cause of this bug, I used the timeout function
! 87: * to check for and recover from this condition. If anyone finds
! 88: * the actual cause of this bug, the calls to timeout and the
! 89: * adb_cuda_tickle routine can be removed.
! 90: */
! 91:
! 92: #include <sys/param.h>
! 93: #include <sys/device.h>
! 94: #include <sys/fcntl.h>
! 95: #include <sys/poll.h>
! 96: #include <sys/selinfo.h>
! 97: #include <sys/proc.h>
! 98: #include <sys/signalvar.h>
! 99: #include <sys/timeout.h>
! 100: #include <sys/systm.h>
! 101:
! 102: #include <machine/autoconf.h>
! 103: #include <machine/cpu.h>
! 104: #include <dev/ofw/openfirm.h>
! 105:
! 106: #include <dev/adb/adb.h>
! 107: #include <macppc/dev/adbvar.h>
! 108: #include <macppc/dev/pm_direct.h>
! 109: #include <macppc/dev/viareg.h>
! 110:
! 111: #include "apm.h"
! 112:
! 113: #define printf_intr printf
! 114:
! 115: #ifdef DEBUG
! 116: #ifndef ADB_DEBUG
! 117: #define ADB_DEBUG
! 118: #endif
! 119: #endif
! 120:
! 121: int adb_polling; /* Are we polling? (Debugger mode) */
! 122: #ifdef ADB_DEBUG
! 123: int adb_debug; /* Output debugging messages */
! 124: #endif /* ADB_DEBUG */
! 125:
! 126: /* some misc. leftovers */
! 127: #define vPB 0x0000
! 128: #define vPB3 0x08
! 129: #define vPB4 0x10
! 130: #define vPB5 0x20
! 131: #define vSR_INT 0x04
! 132: #define vSR_OUT 0x10
! 133:
! 134: /* the type of ADB action that we are currently performing */
! 135: #define ADB_ACTION_NOTREADY 0x1 /* has not been initialized yet */
! 136: #define ADB_ACTION_IDLE 0x2 /* the bus is currently idle */
! 137: #define ADB_ACTION_OUT 0x3 /* sending out a command */
! 138: #define ADB_ACTION_IN 0x4 /* receiving data */
! 139:
! 140: /*
! 141: * Shortcuts for setting or testing the VIA bit states.
! 142: * Not all shortcuts are used for every type of ADB hardware.
! 143: */
! 144: #define ADB_SET_STATE_IDLE_CUDA() via_reg_or(VIA1, vBufB, (vPB4 | vPB5))
! 145: #define ADB_SET_STATE_TIP() via_reg_and(VIA1, vBufB, ~vPB5)
! 146: #define ADB_CLR_STATE_TIP() via_reg_or(VIA1, vBufB, vPB5)
! 147: #define ADB_TOGGLE_STATE_ACK_CUDA() via_reg_xor(VIA1, vBufB, vPB4)
! 148: #define ADB_SET_STATE_ACKOFF_CUDA() via_reg_or(VIA1, vBufB, vPB4)
! 149: #define ADB_SET_SR_INPUT() via_reg_and(VIA1, vACR, ~vSR_OUT)
! 150: #define ADB_SET_SR_OUTPUT() via_reg_or(VIA1, vACR, vSR_OUT)
! 151: #define ADB_SR() read_via_reg(VIA1, vSR)
! 152: #define ADB_VIA_INTR_ENABLE() write_via_reg(VIA1, vIER, 0x84)
! 153: #define ADB_VIA_INTR_DISABLE() write_via_reg(VIA1, vIER, 0x04)
! 154: #define ADB_VIA_CLR_INTR() write_via_reg(VIA1, vIFR, 0x04)
! 155: #define ADB_INTR_IS_OFF (vPB3 == (read_via_reg(VIA1, vBufB) & vPB3))
! 156: #define ADB_INTR_IS_ON (0 == (read_via_reg(VIA1, vBufB) & vPB3))
! 157: #define ADB_SR_INTR_IS_ON (vSR_INT == (read_via_reg(VIA1, \
! 158: vIFR) & vSR_INT))
! 159:
! 160: /*
! 161: * This is the delay that is required (in uS) between certain
! 162: * ADB transactions. The actual timing delay for for each uS is
! 163: * calculated at boot time to account for differences in machine speed.
! 164: */
! 165: #define ADB_DELAY 150
! 166:
! 167: /*
! 168: * Maximum ADB message length; includes space for data, result, and
! 169: * device code - plus a little for safety.
! 170: */
! 171: #define ADB_MAX_MSG_LENGTH 16
! 172: #define ADB_MAX_HDR_LENGTH 8
! 173:
! 174: #define ADB_QUEUE 32
! 175: #define ADB_TICKLE_TICKS 4
! 176:
! 177: /*
! 178: * A structure for storing information about each ADB device.
! 179: */
! 180: struct ADBDevEntry {
! 181: void (*ServiceRtPtr)(void);
! 182: void *DataAreaAddr;
! 183: int devType;
! 184: int origAddr;
! 185: int currentAddr;
! 186: };
! 187:
! 188: /*
! 189: * Used to hold ADB commands that are waiting to be sent out.
! 190: */
! 191: struct adbCmdHoldEntry {
! 192: u_char outBuf[ADB_MAX_MSG_LENGTH]; /* our message */
! 193: u_char *saveBuf; /* buffer to know where to save result */
! 194: u_char *compRout; /* completion routine pointer */
! 195: u_char *data; /* completion routine data pointer */
! 196: };
! 197:
! 198: /*
! 199: * Eventually used for two separate queues, the queue between
! 200: * the upper and lower halves, and the outgoing packet queue.
! 201: * TO DO: adbCommand can replace all of adbCmdHoldEntry eventually
! 202: */
! 203: struct adbCommand {
! 204: u_char header[ADB_MAX_HDR_LENGTH]; /* not used yet */
! 205: u_char data[ADB_MAX_MSG_LENGTH]; /* packet data only */
! 206: u_char *saveBuf; /* where to save result */
! 207: u_char *compRout; /* completion routine pointer */
! 208: u_char *compData; /* completion routine data pointer */
! 209: u_int cmd; /* the original command for this data */
! 210: u_int unsol; /* 1 if packet was unsolicited */
! 211: u_int ack_only; /* 1 for no special processing */
! 212: };
! 213:
! 214: /*
! 215: * A few variables that we need and their initial values.
! 216: */
! 217: int adbHardware = ADB_HW_UNKNOWN;
! 218: int adbActionState = ADB_ACTION_NOTREADY;
! 219: int adbWaiting; /* waiting for return data from the device */
! 220: int adbWriteDelay; /* working on (or waiting to do) a write */
! 221: int adbSoftPower; /* machine supports soft power */
! 222:
! 223: int adbWaitingCmd; /* ADB command we are waiting for */
! 224: u_char *adbBuffer; /* pointer to user data area */
! 225: void *adbCompRout; /* pointer to the completion routine */
! 226: void *adbCompData; /* pointer to the completion routine data */
! 227: int adbStarting = 1; /* doing adb_reinit so do polling differently */
! 228:
! 229: u_char adbInputBuffer[ADB_MAX_MSG_LENGTH]; /* data input buffer */
! 230: u_char adbOutputBuffer[ADB_MAX_MSG_LENGTH]; /* data output buffer */
! 231: struct adbCmdHoldEntry adbOutQueue; /* our 1 entry output queue */
! 232:
! 233: int adbSentChars; /* how many characters we have sent */
! 234:
! 235: struct ADBDevEntry ADBDevTable[16]; /* our ADB device table */
! 236: int ADBNumDevices; /* num. of ADB devices found with adb_reinit */
! 237:
! 238: struct adbCommand adbInbound[ADB_QUEUE]; /* incoming queue */
! 239: int adbInCount; /* how many packets in in queue */
! 240: int adbInHead; /* head of in queue */
! 241: int adbInTail; /* tail of in queue */
! 242: struct adbCommand adbOutbound[ADB_QUEUE]; /* outgoing queue - not used yet */
! 243: int adbOutCount; /* how many packets in out queue */
! 244: int adbOutHead; /* head of out queue */
! 245: int adbOutTail; /* tail of out queue */
! 246:
! 247: int tickle_count; /* how many tickles seen for this packet? */
! 248: int tickle_serial; /* the last packet tickled */
! 249: int adb_cuda_serial; /* the current packet */
! 250: struct timeout adb_cuda_timeout;
! 251: struct timeout adb_softintr_timeout;
! 252: int adbempty; /* nonzero if no adb devices */
! 253:
! 254: volatile u_char *Via1Base;
! 255:
! 256: /*
! 257: * The following are private routines.
! 258: */
! 259: #ifdef ADB_DEBUG
! 260: void print_single(u_char *);
! 261: #endif
! 262: void adb_intr_cuda(void);
! 263: void adb_soft_intr(void);
! 264: int send_adb_cuda(u_char *, u_char *, void *, void *, int);
! 265: void adb_cuda_tickle(void);
! 266: void adb_pass_up(struct adbCommand *);
! 267: void adb_op_comprout(caddr_t, caddr_t, int);
! 268: void adb_reinit(void);
! 269: int count_adbs(void);
! 270: int get_ind_adb_info(ADBDataBlock *, int);
! 271: int get_adb_info(ADBDataBlock *, int);
! 272: void adb_setup_hw_type(void);
! 273: int adb_op(Ptr, Ptr, Ptr, short);
! 274: void adb_hw_setup(void);
! 275: int adb_cmd_result(u_char *);
! 276: void setsoftadb(void);
! 277:
! 278: int adb_intr(void *arg);
! 279: void adb_cuda_autopoll(void);
! 280: void adb_cuda_fileserver_mode(void);
! 281:
! 282: #ifdef ADB_DEBUG
! 283: /*
! 284: * print_single
! 285: * Diagnostic display routine. Displays the hex values of the
! 286: * specified elements of the u_char. The length of the "string"
! 287: * is in [0].
! 288: */
! 289: void
! 290: print_single(str)
! 291: u_char *str;
! 292: {
! 293: int x;
! 294:
! 295: if (str == NULL) {
! 296: printf_intr("no data - null pointer\n");
! 297: return;
! 298: }
! 299: if (*str == '\0') {
! 300: printf_intr("nothing returned\n");
! 301: return;
! 302: }
! 303: if (*str > 20) {
! 304: printf_intr("ADB: ACK > 20 no way!\n");
! 305: *str = 20;
! 306: }
! 307: printf_intr("(length=0x%x):", *str);
! 308: for (x = 1; x <= *str; x++)
! 309: printf_intr(" 0x%02x", str[x]);
! 310: printf_intr("\n");
! 311: }
! 312: #endif
! 313:
! 314: void
! 315: adb_cuda_tickle(void)
! 316: {
! 317: volatile int s;
! 318:
! 319: if (adbActionState == ADB_ACTION_IN) {
! 320: if (tickle_serial == adb_cuda_serial) {
! 321: if (++tickle_count > 0) {
! 322: s = splhigh();
! 323: adbActionState = ADB_ACTION_IDLE;
! 324: adbInputBuffer[0] = 0;
! 325: ADB_SET_STATE_IDLE_CUDA();
! 326: splx(s);
! 327: }
! 328: } else {
! 329: tickle_serial = adb_cuda_serial;
! 330: tickle_count = 0;
! 331: }
! 332: } else {
! 333: tickle_serial = adb_cuda_serial;
! 334: tickle_count = 0;
! 335: }
! 336:
! 337: timeout_add(&adb_cuda_timeout, ADB_TICKLE_TICKS);
! 338: }
! 339:
! 340: /*
! 341: * called when when an adb interrupt happens
! 342: *
! 343: * Cuda version of adb_intr
! 344: * TO DO: do we want to add some calls to intr_dispatch() here to
! 345: * grab serial interrupts?
! 346: */
! 347: void
! 348: adb_intr_cuda(void)
! 349: {
! 350: volatile int i, ending;
! 351: volatile unsigned int s;
! 352: struct adbCommand packet;
! 353:
! 354: s = splhigh(); /* can't be too careful - might be called */
! 355: /* from a routine, NOT an interrupt */
! 356:
! 357: ADB_VIA_CLR_INTR(); /* clear interrupt */
! 358: ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */
! 359:
! 360: switch_start:
! 361: switch (adbActionState) {
! 362: case ADB_ACTION_IDLE:
! 363: /*
! 364: * This is an unexpected packet, so grab the first (dummy)
! 365: * byte, set up the proper vars, and tell the chip we are
! 366: * starting to receive the packet by setting the TIP bit.
! 367: */
! 368: adbInputBuffer[1] = ADB_SR();
! 369: adb_cuda_serial++;
! 370: if (ADB_INTR_IS_OFF) /* must have been a fake start */
! 371: break;
! 372:
! 373: ADB_SET_SR_INPUT();
! 374: ADB_SET_STATE_TIP();
! 375:
! 376: adbInputBuffer[0] = 1;
! 377: adbActionState = ADB_ACTION_IN;
! 378: #ifdef ADB_DEBUG
! 379: if (adb_debug)
! 380: printf_intr("idle 0x%02x ", adbInputBuffer[1]);
! 381: #endif
! 382: break;
! 383:
! 384: case ADB_ACTION_IN:
! 385: adbInputBuffer[++adbInputBuffer[0]] = ADB_SR();
! 386: /* intr off means this is the last byte (end of frame) */
! 387: if (ADB_INTR_IS_OFF)
! 388: ending = 1;
! 389: else
! 390: ending = 0;
! 391:
! 392: if (1 == ending) { /* end of message? */
! 393: #ifdef ADB_DEBUG
! 394: if (adb_debug) {
! 395: printf_intr("in end 0x%02x ",
! 396: adbInputBuffer[adbInputBuffer[0]]);
! 397: print_single(adbInputBuffer);
! 398: }
! 399: #endif
! 400:
! 401: /*
! 402: * Are we waiting AND does this packet match what we
! 403: * are waiting for AND is it coming from either the
! 404: * ADB or RTC/PRAM sub-device? This section _should_
! 405: * recognize all ADB and RTC/PRAM type commands, but
! 406: * there may be more... NOTE: commands are always at
! 407: * [4], even for RTC/PRAM commands.
! 408: */
! 409: /* set up data for adb_pass_up */
! 410: memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
! 411:
! 412: if ((adbWaiting == 1) &&
! 413: (adbInputBuffer[4] == adbWaitingCmd) &&
! 414: ((adbInputBuffer[2] == 0x00) ||
! 415: (adbInputBuffer[2] == 0x01))) {
! 416: packet.saveBuf = adbBuffer;
! 417: packet.compRout = adbCompRout;
! 418: packet.compData = adbCompData;
! 419: packet.unsol = 0;
! 420: packet.ack_only = 0;
! 421: adb_pass_up(&packet);
! 422:
! 423: adbWaitingCmd = 0; /* reset "waiting" vars */
! 424: adbWaiting = 0;
! 425: adbBuffer = NULL;
! 426: adbCompRout = NULL;
! 427: adbCompData = NULL;
! 428: } else {
! 429: packet.unsol = 1;
! 430: packet.ack_only = 0;
! 431: adb_pass_up(&packet);
! 432: }
! 433:
! 434:
! 435: /* reset vars and signal the end of this frame */
! 436: adbActionState = ADB_ACTION_IDLE;
! 437: adbInputBuffer[0] = 0;
! 438: ADB_SET_STATE_IDLE_CUDA();
! 439: /*ADB_SET_SR_INPUT();*/
! 440:
! 441: /*
! 442: * If there is something waiting to be sent out,
! 443: * the set everything up and send the first byte.
! 444: */
! 445: if (adbWriteDelay == 1) {
! 446: delay(ADB_DELAY); /* required */
! 447: adbSentChars = 0;
! 448: adbActionState = ADB_ACTION_OUT;
! 449: /*
! 450: * If the interrupt is on, we were too slow
! 451: * and the chip has already started to send
! 452: * something to us, so back out of the write
! 453: * and start a read cycle.
! 454: */
! 455: if (ADB_INTR_IS_ON) {
! 456: ADB_SET_SR_INPUT();
! 457: ADB_SET_STATE_IDLE_CUDA();
! 458: adbSentChars = 0;
! 459: adbActionState = ADB_ACTION_IDLE;
! 460: adbInputBuffer[0] = 0;
! 461: break;
! 462: }
! 463: /*
! 464: * If we got here, it's ok to start sending
! 465: * so load the first byte and tell the chip
! 466: * we want to send.
! 467: */
! 468: ADB_SET_STATE_TIP();
! 469: ADB_SET_SR_OUTPUT();
! 470: write_via_reg(VIA1, vSR, adbOutputBuffer[adbSentChars + 1]);
! 471: }
! 472: } else {
! 473: ADB_TOGGLE_STATE_ACK_CUDA();
! 474: #ifdef ADB_DEBUG
! 475: if (adb_debug)
! 476: printf_intr("in 0x%02x ",
! 477: adbInputBuffer[adbInputBuffer[0]]);
! 478: #endif
! 479: }
! 480: break;
! 481:
! 482: case ADB_ACTION_OUT:
! 483: i = ADB_SR(); /* reset SR-intr in IFR */
! 484: #ifdef ADB_DEBUG
! 485: if (adb_debug)
! 486: printf_intr("intr out 0x%02x ", i);
! 487: #endif
! 488:
! 489: adbSentChars++;
! 490: if (ADB_INTR_IS_ON) { /* ADB intr low during write */
! 491: #ifdef ADB_DEBUG
! 492: if (adb_debug)
! 493: printf_intr("intr was on ");
! 494: #endif
! 495: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
! 496: ADB_SET_STATE_IDLE_CUDA();
! 497: adbSentChars = 0; /* must start all over */
! 498: adbActionState = ADB_ACTION_IDLE; /* new state */
! 499: adbInputBuffer[0] = 0;
! 500: adbWriteDelay = 1; /* must retry when done with
! 501: * read */
! 502: delay(ADB_DELAY);
! 503: goto switch_start; /* process next state right
! 504: * now */
! 505: break;
! 506: }
! 507: if (adbOutputBuffer[0] == adbSentChars) { /* check for done */
! 508: if (0 == adb_cmd_result(adbOutputBuffer)) { /* do we expect data
! 509: * back? */
! 510: adbWaiting = 1; /* signal waiting for return */
! 511: adbWaitingCmd = adbOutputBuffer[2]; /* save waiting command */
! 512: } else { /* no talk, so done */
! 513: /* set up stuff for adb_pass_up */
! 514: memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
! 515: packet.saveBuf = adbBuffer;
! 516: packet.compRout = adbCompRout;
! 517: packet.compData = adbCompData;
! 518: packet.cmd = adbWaitingCmd;
! 519: packet.unsol = 0;
! 520: packet.ack_only = 1;
! 521: adb_pass_up(&packet);
! 522:
! 523: /* reset "waiting" vars, just in case */
! 524: adbWaitingCmd = 0;
! 525: adbBuffer = NULL;
! 526: adbCompRout = NULL;
! 527: adbCompData = NULL;
! 528: }
! 529:
! 530: adbWriteDelay = 0; /* done writing */
! 531: adbActionState = ADB_ACTION_IDLE; /* signal bus is idle */
! 532: ADB_SET_SR_INPUT();
! 533: ADB_SET_STATE_IDLE_CUDA();
! 534: #ifdef ADB_DEBUG
! 535: if (adb_debug)
! 536: printf_intr("write done ");
! 537: #endif
! 538: } else {
! 539: write_via_reg(VIA1, vSR, adbOutputBuffer[adbSentChars + 1]); /* send next byte */
! 540: ADB_TOGGLE_STATE_ACK_CUDA(); /* signal byte ready to
! 541: * shift */
! 542: #ifdef ADB_DEBUG
! 543: if (adb_debug)
! 544: printf_intr("toggle ");
! 545: #endif
! 546: }
! 547: break;
! 548:
! 549: case ADB_ACTION_NOTREADY:
! 550: #ifdef ADB_DEBUG
! 551: if (adb_debug)
! 552: printf_intr("adb: not yet initialized\n");
! 553: #endif
! 554: break;
! 555:
! 556: default:
! 557: ;
! 558: #ifdef ADB_DEBUG
! 559: if (adb_debug)
! 560: printf_intr("intr: unknown ADB state\n");
! 561: #endif
! 562: }
! 563:
! 564: ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */
! 565:
! 566: splx(s); /* restore */
! 567: }
! 568:
! 569:
! 570: int
! 571: send_adb_cuda(u_char * in, u_char * buffer, void *compRout, void *data, int
! 572: command)
! 573: {
! 574: int s, len;
! 575:
! 576: #ifdef ADB_DEBUG
! 577: if (adb_debug)
! 578: printf_intr("SEND\n");
! 579: #endif
! 580:
! 581: if (adbActionState == ADB_ACTION_NOTREADY)
! 582: return 1;
! 583:
! 584: /* Don't interrupt while we are messing with the ADB */
! 585: s = splhigh();
! 586:
! 587: if ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */
! 588: (ADB_INTR_IS_OFF)) { /* and no incoming interrupt? */
! 589: } else
! 590: if (adbWriteDelay == 0) /* it's busy, but is anything waiting? */
! 591: adbWriteDelay = 1; /* if no, then we'll "queue"
! 592: * it up */
! 593: else {
! 594: splx(s);
! 595: return 1; /* really busy! */
! 596: }
! 597:
! 598: #ifdef ADB_DEBUG
! 599: if (adb_debug)
! 600: printf_intr("QUEUE\n");
! 601: #endif
! 602: if ((long)in == (long)0) { /* need to convert? */
! 603: if ((command & 0x0c) == 0x08) /* copy addl data ONLY if
! 604: * doing a listen! */
! 605: len = buffer[0]; /* length of additional data */
! 606: else
! 607: len = 0;/* no additional data */
! 608:
! 609: adbOutputBuffer[0] = 2 + len; /* dev. type + command + addl.
! 610: * data */
! 611: adbOutputBuffer[1] = 0x00; /* mark as an ADB command */
! 612: adbOutputBuffer[2] = (u_char)command; /* load command */
! 613:
! 614: /* copy additional output data, if any */
! 615: memcpy(adbOutputBuffer + 3, buffer + 1, len);
! 616: } else
! 617: /* if data ready, just copy over */
! 618: memcpy(adbOutputBuffer, in, in[0] + 2);
! 619:
! 620: adbSentChars = 0; /* nothing sent yet */
! 621: adbBuffer = buffer; /* save buffer to know where to save result */
! 622: adbCompRout = compRout; /* save completion routine pointer */
! 623: adbCompData = data; /* save completion routine data pointer */
! 624: adbWaitingCmd = adbOutputBuffer[2]; /* save wait command */
! 625:
! 626: if (adbWriteDelay != 1) { /* start command now? */
! 627: #ifdef ADB_DEBUG
! 628: if (adb_debug)
! 629: printf_intr("out start NOW");
! 630: #endif
! 631: delay(ADB_DELAY);
! 632: adbActionState = ADB_ACTION_OUT; /* set next state */
! 633: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
! 634: write_via_reg(VIA1, vSR, adbOutputBuffer[adbSentChars + 1]); /* load byte for output */
! 635: ADB_SET_STATE_ACKOFF_CUDA();
! 636: ADB_SET_STATE_TIP(); /* tell ADB that we want to send */
! 637: }
! 638: adbWriteDelay = 1; /* something in the write "queue" */
! 639:
! 640: splx(s);
! 641:
! 642: if ((s & (1 << 18)) || adb_polling) /* XXX were VIA1 interrupts blocked ? */
! 643: /* poll until byte done */
! 644: while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
! 645: || (adbWaiting == 1))
! 646: if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
! 647: adb_intr_cuda(); /* process it */
! 648: if (cold)
! 649: delay(ADB_DELAY);
! 650: adb_soft_intr();
! 651: }
! 652:
! 653: return 0;
! 654: }
! 655:
! 656: /*
! 657: * Called when when an adb interrupt happens.
! 658: * This routine simply transfers control over to the appropriate
! 659: * code for the machine we are running on.
! 660: */
! 661: int
! 662: adb_intr(void *arg)
! 663: {
! 664: switch (adbHardware) {
! 665: case ADB_HW_PMU:
! 666: pm_intr();
! 667: break;
! 668:
! 669: case ADB_HW_CUDA:
! 670: adb_intr_cuda();
! 671: break;
! 672: }
! 673: return 1;
! 674: }
! 675:
! 676:
! 677: /*
! 678: * adb_pass_up is called by the interrupt-time routines.
! 679: * It takes the raw packet data that was received from the
! 680: * device and puts it into the queue that the upper half
! 681: * processes. It then signals for a soft ADB interrupt which
! 682: * will eventually call the upper half routine (adb_soft_intr).
! 683: *
! 684: * If in->unsol is 0, then this is either the notification
! 685: * that the packet was sent (on a LISTEN, for example), or the
! 686: * response from the device (on a TALK). The completion routine
! 687: * is called only if the user specified one.
! 688: *
! 689: * If in->unsol is 1, then this packet was unsolicited and
! 690: * so we look up the device in the ADB device table to determine
! 691: * what its default service routine is.
! 692: *
! 693: * If in->ack_only is 1, then we really only need to call
! 694: * the completion routine, so don't do any other stuff.
! 695: *
! 696: * Note that in->data contains the packet header AND data,
! 697: * while adbInbound[]->data contains ONLY data.
! 698: *
! 699: * Note: Called only at interrupt time. Assumes this.
! 700: */
! 701: void
! 702: adb_pass_up(struct adbCommand *in)
! 703: {
! 704: int start = 0, len = 0, cmd = 0;
! 705: ADBDataBlock block;
! 706:
! 707: if (adbInCount >= ADB_QUEUE) {
! 708: #ifdef ADB_DEBUG
! 709: if (adb_debug)
! 710: printf_intr("adb: ring buffer overflow\n");
! 711: #endif
! 712: return;
! 713: }
! 714:
! 715: if (in->ack_only) {
! 716: len = in->data[0];
! 717: cmd = in->cmd;
! 718: start = 0;
! 719: } else {
! 720: switch (adbHardware) {
! 721: case ADB_HW_CUDA:
! 722: /* If it's unsolicited, accept only ADB data for now */
! 723: if (in->unsol)
! 724: if (0 != in->data[2])
! 725: return;
! 726: cmd = in->data[4];
! 727: if (in->data[0] < 5)
! 728: len = 0;
! 729: else
! 730: len = in->data[0]-4;
! 731: start = 4;
! 732: break;
! 733:
! 734: case ADB_HW_PMU:
! 735: cmd = in->data[1];
! 736: if (in->data[0] < 2)
! 737: len = 0;
! 738: else
! 739: len = in->data[0]-1;
! 740: start = 1;
! 741: break;
! 742:
! 743: case ADB_HW_UNKNOWN:
! 744: return;
! 745: }
! 746:
! 747: /* Make sure there is a valid device entry for this device */
! 748: if (in->unsol) {
! 749: /* ignore unsolicited data during adbreinit */
! 750: if (adbStarting)
! 751: return;
! 752: /* get device's comp. routine and data area */
! 753: if (-1 == get_adb_info(&block, ADB_CMDADDR(cmd)))
! 754: return;
! 755: }
! 756: }
! 757:
! 758: /*
! 759: * If this is an unsolicited packet, we need to fill in
! 760: * some info so adb_soft_intr can process this packet
! 761: * properly. If it's not unsolicited, then use what
! 762: * the caller sent us.
! 763: */
! 764: if (in->unsol) {
! 765: adbInbound[adbInTail].compRout = (void *)block.dbServiceRtPtr;
! 766: adbInbound[adbInTail].compData = (void *)block.dbDataAreaAddr;
! 767: adbInbound[adbInTail].saveBuf = (void *)adbInbound[adbInTail].data;
! 768: } else {
! 769: adbInbound[adbInTail].compRout = (void *)in->compRout;
! 770: adbInbound[adbInTail].compData = (void *)in->compData;
! 771: adbInbound[adbInTail].saveBuf = (void *)in->saveBuf;
! 772: }
! 773:
! 774: #ifdef ADB_DEBUG
! 775: if (adb_debug && in->data[1] == 2)
! 776: printf_intr("adb: caught error\n");
! 777: #endif
! 778:
! 779: /* copy the packet data over */
! 780: /*
! 781: * TO DO: If the *_intr routines fed their incoming data
! 782: * directly into an adbCommand struct, which is passed to
! 783: * this routine, then we could eliminate this copy.
! 784: */
! 785: memcpy(adbInbound[adbInTail].data + 1, in->data + start + 1, len);
! 786: adbInbound[adbInTail].data[0] = len;
! 787: adbInbound[adbInTail].cmd = cmd;
! 788:
! 789: adbInCount++;
! 790: if (++adbInTail >= ADB_QUEUE)
! 791: adbInTail = 0;
! 792:
! 793: /*
! 794: * If the debugger is running, call upper half manually.
! 795: * Otherwise, trigger a soft interrupt to handle the rest later.
! 796: */
! 797: if (adb_polling)
! 798: adb_soft_intr();
! 799: else
! 800: setsoftadb();
! 801: }
! 802:
! 803:
! 804: /*
! 805: * Called to process the packets after they have been
! 806: * placed in the incoming queue.
! 807: *
! 808: */
! 809: void
! 810: adb_soft_intr(void)
! 811: {
! 812: int s;
! 813: int cmd = 0;
! 814: u_char *buffer;
! 815: u_char *comprout;
! 816: u_char *compdata;
! 817:
! 818: /*delay(2*ADB_DELAY);*/
! 819:
! 820: while (adbInCount) {
! 821: #ifdef ADB_DEBUG
! 822: if (adb_debug & 0x80)
! 823: printf_intr("%x %x %x ",
! 824: adbInCount, adbInHead, adbInTail);
! 825: #endif
! 826: /* get the data we need from the queue */
! 827: buffer = adbInbound[adbInHead].saveBuf;
! 828: comprout = adbInbound[adbInHead].compRout;
! 829: compdata = adbInbound[adbInHead].compData;
! 830: cmd = adbInbound[adbInHead].cmd;
! 831:
! 832: /* copy over data to data area if it's valid */
! 833: /*
! 834: * Note that for unsol packets we don't want to copy the
! 835: * data anywhere, so buffer was already set to 0.
! 836: * For ack_only buffer was set to 0, so don't copy.
! 837: */
! 838: if (buffer)
! 839: memcpy(buffer, adbInbound[adbInHead].data,
! 840: adbInbound[adbInHead].data[0] + 1);
! 841:
! 842: #ifdef ADB_DEBUG
! 843: if (adb_debug & 0x80) {
! 844: printf_intr("%p %p %p %x ",
! 845: buffer, comprout, compdata, (short)cmd);
! 846: printf_intr("buf: ");
! 847: print_single(adbInbound[adbInHead].data);
! 848: }
! 849: #endif
! 850: /*
! 851: * Remove the packet from the queue before calling
! 852: * the completion routine, so that the completion
! 853: * routine can reentrantly process the queue. For
! 854: * example, this happens when polling is turned on
! 855: * by entering the debuger by keystroke.
! 856: */
! 857: s = splhigh();
! 858: adbInCount--;
! 859: if (++adbInHead >= ADB_QUEUE)
! 860: adbInHead = 0;
! 861: splx(s);
! 862:
! 863: /* call default completion routine if it's valid */
! 864: if (comprout) {
! 865: ((int (*)(u_char *, u_char *, int)) comprout)
! 866: (buffer, compdata, cmd);
! 867: }
! 868:
! 869: }
! 870: }
! 871:
! 872:
! 873: /*
! 874: * This is my version of the ADBOp routine. It mainly just calls the
! 875: * hardware-specific routine.
! 876: *
! 877: * data : pointer to data area to be used by compRout
! 878: * compRout : completion routine
! 879: * buffer : for LISTEN: points to data to send - MAX 8 data bytes,
! 880: * byte 0 = # of bytes
! 881: * : for TALK: points to place to save return data
! 882: * command : the adb command to send
! 883: * result : 0 = success
! 884: * : -1 = could not complete
! 885: */
! 886: int
! 887: adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)
! 888: {
! 889: int result;
! 890:
! 891: switch (adbHardware) {
! 892: case ADB_HW_PMU:
! 893: result = pm_adb_op((u_char *)buffer, (void *)compRout,
! 894: (void *)data, (int)command);
! 895:
! 896: if (result == 0)
! 897: return 0;
! 898: else
! 899: return -1;
! 900: break;
! 901:
! 902: case ADB_HW_CUDA:
! 903: result = send_adb_cuda((u_char *)0, (u_char *)buffer,
! 904: (void *)compRout, (void *)data, (int)command);
! 905: if (result == 0)
! 906: return 0;
! 907: else
! 908: return -1;
! 909: break;
! 910:
! 911: default:
! 912: return -1;
! 913: }
! 914: }
! 915:
! 916:
! 917: /*
! 918: * adb_hw_setup
! 919: * This routine sets up the possible machine specific hardware
! 920: * config (mainly VIA settings) for the various models.
! 921: */
! 922: void
! 923: adb_hw_setup(void)
! 924: {
! 925: volatile int i;
! 926:
! 927: switch (adbHardware) {
! 928:
! 929: case ADB_HW_PMU:
! 930: /*
! 931: * XXX - really PM_VIA_CLR_INTR - should we put it in
! 932: * pm_direct.h?
! 933: */
! 934: write_via_reg(VIA1, vIFR, 0x90); /* clear interrupt */
! 935: break;
! 936:
! 937: case ADB_HW_CUDA:
! 938: via_reg_or(VIA1, vDirB, 0x30); /* register B bits 4 and 5:
! 939: * outputs */
! 940: via_reg_and(VIA1, vDirB, 0xf7); /* register B bit 3: input */
! 941: via_reg_and(VIA1, vACR, ~vSR_OUT); /* make sure SR is set
! 942: * to IN */
! 943: write_via_reg(VIA1, vACR, (read_via_reg(VIA1, vACR) | 0x0c) & ~0x10);
! 944: adbActionState = ADB_ACTION_IDLE; /* used by all types of
! 945: * hardware */
! 946: write_via_reg(VIA1, vIER, 0x84);/* make sure VIA interrupts
! 947: * are on */
! 948: ADB_SET_STATE_IDLE_CUDA(); /* set ADB bus state to idle */
! 949:
! 950: /* sort of a device reset */
! 951: i = ADB_SR(); /* clear interrupt */
! 952: ADB_VIA_INTR_DISABLE(); /* no interrupts while clearing */
! 953: ADB_SET_STATE_IDLE_CUDA(); /* reset state to idle */
! 954: delay(ADB_DELAY);
! 955: ADB_SET_STATE_TIP(); /* signal start of frame */
! 956: delay(ADB_DELAY);
! 957: ADB_TOGGLE_STATE_ACK_CUDA();
! 958: delay(ADB_DELAY);
! 959: ADB_CLR_STATE_TIP();
! 960: delay(ADB_DELAY);
! 961: ADB_SET_STATE_IDLE_CUDA(); /* back to idle state */
! 962: i = ADB_SR(); /* clear interrupt */
! 963: ADB_VIA_INTR_ENABLE(); /* ints ok now */
! 964: break;
! 965:
! 966: case ADB_HW_UNKNOWN:
! 967: default:
! 968: write_via_reg(VIA1, vIER, 0x04);/* turn interrupts off - TO
! 969: * DO: turn PB ints off? */
! 970: break;
! 971: }
! 972: }
! 973:
! 974: /*
! 975: * adb_reinit sets up the adb stuff
! 976: *
! 977: */
! 978: void
! 979: adb_reinit(void)
! 980: {
! 981: u_char send_string[ADB_MAX_MSG_LENGTH];
! 982: ADBDataBlock data; /* temp. holder for getting device info */
! 983: volatile int i, x;
! 984: int s;
! 985: int command;
! 986: int result;
! 987: int saveptr; /* point to next free relocation address */
! 988: int device;
! 989: int nonewtimes; /* times thru loop w/o any new devices */
! 990:
! 991: /* Make sure we are not interrupted while building the table. */
! 992: if (adbHardware != ADB_HW_PMU) /* ints must be on for PB? */
! 993: s = splhigh();
! 994:
! 995: ADBNumDevices = 0; /* no devices yet */
! 996:
! 997: /* Let intr routines know we are running reinit */
! 998: adbStarting = 1;
! 999:
! 1000: /*
! 1001: * Initialize the ADB table. For now, we'll always use the same table
! 1002: * that is defined at the beginning of this file - no mallocs.
! 1003: */
! 1004: for (i = 0; i < 16; i++)
! 1005: ADBDevTable[i].devType = 0;
! 1006:
! 1007: adb_setup_hw_type(); /* setup hardware type */
! 1008:
! 1009: adb_hw_setup(); /* init the VIA bits and hard reset ADB */
! 1010:
! 1011: delay(1000);
! 1012:
! 1013: /* send an ADB reset first */
! 1014: adb_op_sync((Ptr)0, (short)0x00);
! 1015: delay(200000);
! 1016:
! 1017: /*
! 1018: * Probe for ADB devices. Probe devices 1-15 quickly to determine
! 1019: * which device addresses are in use and which are free. For each
! 1020: * address that is in use, move the device at that address to a higher
! 1021: * free address. Continue doing this at that address until no device
! 1022: * responds at that address. Then move the last device that was moved
! 1023: * back to the original address. Do this for the remaining addresses
! 1024: * that we determined were in use.
! 1025: *
! 1026: * When finished, do this entire process over again with the updated
! 1027: * list of in use addresses. Do this until no new devices have been
! 1028: * found in 20 passes though the in use address list. (This probably
! 1029: * seems long and complicated, but it's the best way to detect multiple
! 1030: * devices at the same address - sometimes it takes a couple of tries
! 1031: * before the collision is detected.)
! 1032: */
! 1033:
! 1034: /* initial scan through the devices */
! 1035: for (i = 1; i < 16; i++) {
! 1036: send_string[0] = 0;
! 1037: command = ADBTALK(i, 3);
! 1038: result = adb_op_sync((Ptr)send_string, (short)command);
! 1039:
! 1040: if (send_string[0] != 0) {
! 1041: /* check for valid device handler */
! 1042: switch (send_string[2]) {
! 1043: case 0:
! 1044: case 0xfd:
! 1045: case 0xfe:
! 1046: case 0xff:
! 1047: continue; /* invalid, skip */
! 1048: }
! 1049:
! 1050: /* found a device */
! 1051: ++ADBNumDevices;
! 1052: KASSERT(ADBNumDevices < 16);
! 1053: ADBDevTable[ADBNumDevices].devType =
! 1054: (int)send_string[2];
! 1055: ADBDevTable[ADBNumDevices].origAddr = i;
! 1056: ADBDevTable[ADBNumDevices].currentAddr = i;
! 1057: ADBDevTable[ADBNumDevices].DataAreaAddr = NULL;
! 1058: ADBDevTable[ADBNumDevices].ServiceRtPtr = NULL;
! 1059: }
! 1060: }
! 1061:
! 1062: /* find highest unused address */
! 1063: for (saveptr = 15; saveptr > 0; saveptr--)
! 1064: if (-1 == get_adb_info(&data, saveptr))
! 1065: break;
! 1066:
! 1067: #ifdef ADB_DEBUG
! 1068: if (adb_debug & 0x80) {
! 1069: printf_intr("first free is: 0x%02x\n", saveptr);
! 1070: printf_intr("devices: %i\n", ADBNumDevices);
! 1071: }
! 1072: #endif
! 1073:
! 1074: nonewtimes = 0; /* no loops w/o new devices */
! 1075: while (saveptr > 0 && nonewtimes++ < 11) {
! 1076: for (i = 1; i <= ADBNumDevices; i++) {
! 1077: device = ADBDevTable[i].currentAddr;
! 1078: #ifdef ADB_DEBUG
! 1079: if (adb_debug & 0x80)
! 1080: printf_intr("moving device 0x%02x to 0x%02x "
! 1081: "(index 0x%02x) ", device, saveptr, i);
! 1082: #endif
! 1083:
! 1084: /* send TALK R3 to address */
! 1085: command = ADBTALK(device, 3);
! 1086: adb_op_sync((Ptr)send_string, (short)command);
! 1087:
! 1088: /* move device to higher address */
! 1089: command = ADBLISTEN(device, 3);
! 1090: send_string[0] = 2;
! 1091: send_string[1] = (u_char)(saveptr | 0x60);
! 1092: send_string[2] = 0xfe;
! 1093: adb_op_sync((Ptr)send_string, (short)command);
! 1094: delay(500);
! 1095:
! 1096: /* send TALK R3 - anything at new address? */
! 1097: command = ADBTALK(saveptr, 3);
! 1098: adb_op_sync((Ptr)send_string, (short)command);
! 1099: delay(500);
! 1100:
! 1101: if (send_string[0] == 0) {
! 1102: #ifdef ADB_DEBUG
! 1103: if (adb_debug & 0x80)
! 1104: printf_intr("failed, continuing\n");
! 1105: #endif
! 1106: continue;
! 1107: }
! 1108:
! 1109: /* send TALK R3 - anything at old address? */
! 1110: command = ADBTALK(device, 3);
! 1111: result = adb_op_sync((Ptr)send_string, (short)command);
! 1112: if (send_string[0] != 0) {
! 1113: /* check for valid device handler */
! 1114: switch (send_string[2]) {
! 1115: case 0:
! 1116: case 0xfd:
! 1117: case 0xfe:
! 1118: case 0xff:
! 1119: continue; /* invalid, skip */
! 1120: }
! 1121:
! 1122: /* new device found */
! 1123: /* update data for previously moved device */
! 1124: ADBDevTable[i].currentAddr = saveptr;
! 1125: #ifdef ADB_DEBUG
! 1126: if (adb_debug & 0x80)
! 1127: printf_intr("old device at index %i\n",i);
! 1128: #endif
! 1129: /* add new device in table */
! 1130: #ifdef ADB_DEBUG
! 1131: if (adb_debug & 0x80)
! 1132: printf_intr("new device found\n");
! 1133: #endif
! 1134: if (saveptr > ADBNumDevices) {
! 1135: ++ADBNumDevices;
! 1136: KASSERT(ADBNumDevices < 16);
! 1137: }
! 1138: ADBDevTable[ADBNumDevices].devType =
! 1139: (int)send_string[2];
! 1140: ADBDevTable[ADBNumDevices].origAddr = device;
! 1141: ADBDevTable[ADBNumDevices].currentAddr = device;
! 1142: /* These will be set correctly in adbsys.c */
! 1143: /* Until then, unsol. data will be ignored. */
! 1144: ADBDevTable[ADBNumDevices].DataAreaAddr = NULL;
! 1145: ADBDevTable[ADBNumDevices].ServiceRtPtr = NULL;
! 1146: /* find next unused address */
! 1147: for (x = saveptr; x > 0; x--) {
! 1148: if (-1 == get_adb_info(&data, x)) {
! 1149: saveptr = x;
! 1150: break;
! 1151: }
! 1152: }
! 1153: if (x == 0)
! 1154: saveptr = 0;
! 1155: #ifdef ADB_DEBUG
! 1156: if (adb_debug & 0x80)
! 1157: printf_intr("new free is 0x%02x\n",
! 1158: saveptr);
! 1159: #endif
! 1160: nonewtimes = 0;
! 1161: } else {
! 1162: #ifdef ADB_DEBUG
! 1163: if (adb_debug & 0x80)
! 1164: printf_intr("moving back...\n");
! 1165: #endif
! 1166: /* move old device back */
! 1167: command = ADBLISTEN(saveptr, 3);
! 1168: send_string[0] = 2;
! 1169: send_string[1] = (u_char)(device | 0x60);
! 1170: send_string[2] = 0xfe;
! 1171: adb_op_sync((Ptr)send_string, (short)command);
! 1172: delay(1000);
! 1173: }
! 1174: }
! 1175: }
! 1176:
! 1177: #ifdef ADB_DEBUG
! 1178: if (adb_debug) {
! 1179: for (i = 1; i <= ADBNumDevices; i++) {
! 1180: x = get_ind_adb_info(&data, i);
! 1181: if (x != -1)
! 1182: printf_intr("index 0x%x, addr 0x%x, type 0x%x\n",
! 1183: i, x, data.devType);
! 1184: }
! 1185: }
! 1186: #endif
! 1187:
! 1188: #ifdef ADB_DEBUG
! 1189: if (adb_debug) {
! 1190: if (0 == ADBNumDevices) /* tell user if no devices found */
! 1191: printf_intr("adb: no devices found\n");
! 1192: }
! 1193: #endif
! 1194:
! 1195: adbStarting = 0; /* not starting anymore */
! 1196: #ifdef ADB_DEBUG
! 1197: if (adb_debug)
! 1198: printf_intr("adb: adb_reinit complete\n");
! 1199: #endif
! 1200:
! 1201: if (adbHardware == ADB_HW_CUDA) {
! 1202: timeout_set(&adb_cuda_timeout, (void *)adb_cuda_tickle, NULL);
! 1203: timeout_add(&adb_cuda_timeout, ADB_TICKLE_TICKS);
! 1204: }
! 1205:
! 1206: if (adbHardware != ADB_HW_PMU) /* ints must be on for PB? */
! 1207: splx(s);
! 1208: }
! 1209:
! 1210:
! 1211: /*
! 1212: * adb_cmd_result
! 1213: *
! 1214: * This routine lets the caller know whether the specified adb command string
! 1215: * should expect a returned result, such as a TALK command.
! 1216: *
! 1217: * returns: 0 if a result should be expected
! 1218: * 1 if a result should NOT be expected
! 1219: */
! 1220: int
! 1221: adb_cmd_result(u_char *in)
! 1222: {
! 1223: switch (adbHardware) {
! 1224: case ADB_HW_CUDA:
! 1225: /* was it an ADB talk command? */
! 1226: if ((in[1] == 0x00) && ((in[2] & 0x0c) == 0x0c))
! 1227: return 0;
! 1228: /* was it an RTC/PRAM read date/time? */
! 1229: if ((in[1] == 0x01) && (in[2] == 0x03))
! 1230: return 0;
! 1231: return 1;
! 1232:
! 1233: case ADB_HW_PMU:
! 1234: return 1;
! 1235:
! 1236: default:
! 1237: return 1;
! 1238: }
! 1239: }
! 1240:
! 1241:
! 1242: /*
! 1243: * adb_op_sync
! 1244: *
! 1245: * This routine does exactly what the adb_op routine does, except that after
! 1246: * the adb_op is called, it waits until the return value is present before
! 1247: * returning.
! 1248: */
! 1249: int
! 1250: adb_op_sync(Ptr buffer, short command)
! 1251: {
! 1252: int tmout;
! 1253: int result;
! 1254: volatile int flag = 0;
! 1255:
! 1256: result = adb_op(buffer, (void *)adb_op_comprout,
! 1257: (void *)&flag, command); /* send command */
! 1258: if (result == 0) { /* send ok? */
! 1259: /*
! 1260: * Total time to wait is calculated as follows:
! 1261: * - Tlt (stop to start time): 260 usec
! 1262: * - start bit: 100 usec
! 1263: * - up to 8 data bytes: 64 * 100 usec = 6400 usec
! 1264: * - stop bit (with SRQ): 140 usec
! 1265: * Total: 6900 usec
! 1266: *
! 1267: * This is the total time allowed by the specification. Any
! 1268: * device that doesn't conform to this will fail to operate
! 1269: * properly on some Apple systems. In spite of this we
! 1270: * double the time to wait; some Cuda-based apparently
! 1271: * queues some commands and allows the main CPU to continue
! 1272: * processing (radical concept, eh?). To be safe, allow
! 1273: * time for two complete ADB transactions to occur.
! 1274: */
! 1275: for (tmout = 13800; !flag && tmout >= 10; tmout -= 10)
! 1276: delay(10);
! 1277: if (!flag && tmout > 0)
! 1278: delay(tmout);
! 1279:
! 1280: if (!flag)
! 1281: result = -2;
! 1282: }
! 1283:
! 1284: return result;
! 1285: }
! 1286:
! 1287:
! 1288: /*
! 1289: * adb_op_comprout
! 1290: *
! 1291: * This function is used by the adb_op_sync routine so it knows when the
! 1292: * function is done.
! 1293: */
! 1294: void
! 1295: adb_op_comprout(caddr_t buffer, caddr_t compdata, int cmd)
! 1296: {
! 1297: *(int *)compdata = 0x01; /* update flag value */
! 1298: }
! 1299:
! 1300: void
! 1301: adb_setup_hw_type(void)
! 1302: {
! 1303: switch (adbHardware) {
! 1304: case ADB_HW_CUDA:
! 1305: adbSoftPower = 1;
! 1306: return;
! 1307:
! 1308: case ADB_HW_PMU:
! 1309: adbSoftPower = 1;
! 1310: pm_setup_adb();
! 1311: return;
! 1312:
! 1313: default:
! 1314: panic("unknown adb hardware");
! 1315: }
! 1316: }
! 1317:
! 1318: int
! 1319: count_adbs(void)
! 1320: {
! 1321: int i;
! 1322: int found;
! 1323:
! 1324: found = 0;
! 1325:
! 1326: for (i = 1; i < 16; i++)
! 1327: if (0 != ADBDevTable[i].devType)
! 1328: found++;
! 1329:
! 1330: return found;
! 1331: }
! 1332:
! 1333: int
! 1334: get_ind_adb_info(ADBDataBlock * info, int index)
! 1335: {
! 1336: if ((index < 1) || (index > 15)) /* check range 1-15 */
! 1337: return (-1);
! 1338:
! 1339: #ifdef ADB_DEBUG
! 1340: if (adb_debug & 0x80)
! 1341: printf_intr("index 0x%x devType is: 0x%x\n", index,
! 1342: ADBDevTable[index].devType);
! 1343: #endif
! 1344: if (0 == ADBDevTable[index].devType) /* make sure it's a valid entry */
! 1345: return (-1);
! 1346:
! 1347: info->devType = ADBDevTable[index].devType;
! 1348: info->origADBAddr = ADBDevTable[index].origAddr;
! 1349: info->dbServiceRtPtr = (Ptr)ADBDevTable[index].ServiceRtPtr;
! 1350: info->dbDataAreaAddr = (Ptr)ADBDevTable[index].DataAreaAddr;
! 1351:
! 1352: return (ADBDevTable[index].currentAddr);
! 1353: }
! 1354:
! 1355: int
! 1356: get_adb_info(ADBDataBlock * info, int adbAddr)
! 1357: {
! 1358: int i;
! 1359:
! 1360: if ((adbAddr < 1) || (adbAddr > 15)) /* check range 1-15 */
! 1361: return (-1);
! 1362:
! 1363: for (i = 1; i < 15; i++)
! 1364: if (ADBDevTable[i].currentAddr == adbAddr) {
! 1365: info->devType = ADBDevTable[i].devType;
! 1366: info->origADBAddr = ADBDevTable[i].origAddr;
! 1367: info->dbServiceRtPtr = (Ptr)ADBDevTable[i].ServiceRtPtr;
! 1368: info->dbDataAreaAddr = ADBDevTable[i].DataAreaAddr;
! 1369: return 0; /* found */
! 1370: }
! 1371:
! 1372: return (-1); /* not found */
! 1373: }
! 1374:
! 1375: int
! 1376: set_adb_info(ADBSetInfoBlock * info, int adbAddr)
! 1377: {
! 1378: int i;
! 1379:
! 1380: if ((adbAddr < 1) || (adbAddr > 15)) /* check range 1-15 */
! 1381: return (-1);
! 1382:
! 1383: for (i = 1; i < 15; i++)
! 1384: if (ADBDevTable[i].currentAddr == adbAddr) {
! 1385: ADBDevTable[i].ServiceRtPtr =
! 1386: (void *)(info->siServiceRtPtr);
! 1387: ADBDevTable[i].DataAreaAddr = info->siDataAreaAddr;
! 1388: return 0; /* found */
! 1389: }
! 1390:
! 1391: return (-1); /* not found */
! 1392:
! 1393: }
! 1394:
! 1395: /* caller should really use machine-independent version: getPramTime */
! 1396: /* this version does pseudo-adb access only */
! 1397: int
! 1398: adb_read_date_time(time_t *time)
! 1399: {
! 1400: u_char output[ADB_MAX_MSG_LENGTH];
! 1401: int result;
! 1402: int retcode;
! 1403: volatile int flag = 0;
! 1404:
! 1405: switch (adbHardware) {
! 1406: case ADB_HW_PMU:
! 1407: pm_read_date_time(time);
! 1408: retcode = 0;
! 1409: break;
! 1410:
! 1411: case ADB_HW_CUDA:
! 1412: output[0] = 0x02; /* 2 byte message */
! 1413: output[1] = 0x01; /* to pram/rtc device */
! 1414: output[2] = 0x03; /* read date/time */
! 1415: result = send_adb_cuda((u_char *)output, (u_char *)output,
! 1416: (void *)adb_op_comprout, (void *)&flag, (int)0);
! 1417: if (result != 0) { /* exit if not sent */
! 1418: retcode = -1;
! 1419: break;
! 1420: }
! 1421:
! 1422: while (0 == flag) /* wait for result */
! 1423: ;
! 1424:
! 1425: delay(20); /* completion occurs too soon? */
! 1426: memcpy(time, output + 1, 4);
! 1427: retcode = 0;
! 1428: break;
! 1429:
! 1430: case ADB_HW_UNKNOWN:
! 1431: default:
! 1432: retcode = -1;
! 1433: break;
! 1434: }
! 1435: if (retcode == 0) {
! 1436: #define DIFF19041970 2082844800
! 1437: *time -= DIFF19041970;
! 1438:
! 1439: } else {
! 1440: *time = 0;
! 1441: }
! 1442: return retcode;
! 1443: }
! 1444:
! 1445: /* caller should really use machine-independent version: setPramTime */
! 1446: /* this version does pseudo-adb access only */
! 1447: int
! 1448: adb_set_date_time(time_t time)
! 1449: {
! 1450: u_char output[ADB_MAX_MSG_LENGTH];
! 1451: int result;
! 1452: volatile int flag = 0;
! 1453:
! 1454: time += DIFF19041970;
! 1455: switch (adbHardware) {
! 1456:
! 1457: case ADB_HW_CUDA:
! 1458: output[0] = 0x06; /* 6 byte message */
! 1459: output[1] = 0x01; /* to pram/rtc device */
! 1460: output[2] = 0x09; /* set date/time */
! 1461: output[3] = (u_char)(time >> 24);
! 1462: output[4] = (u_char)(time >> 16);
! 1463: output[5] = (u_char)(time >> 8);
! 1464: output[6] = (u_char)(time);
! 1465: result = send_adb_cuda((u_char *)output, (u_char *)0,
! 1466: (void *)adb_op_comprout, (void *)&flag, (int)0);
! 1467: if (result != 0) /* exit if not sent */
! 1468: return -1;
! 1469:
! 1470: while (0 == flag) /* wait for send to finish */
! 1471: ;
! 1472:
! 1473: return 0;
! 1474:
! 1475: case ADB_HW_PMU:
! 1476: pm_set_date_time(time);
! 1477: return 0;
! 1478:
! 1479: default:
! 1480: return -1;
! 1481: }
! 1482: }
! 1483:
! 1484:
! 1485: int
! 1486: adb_poweroff(void)
! 1487: {
! 1488: u_char output[ADB_MAX_MSG_LENGTH];
! 1489: int result;
! 1490:
! 1491: if (!adbSoftPower)
! 1492: return -1;
! 1493:
! 1494: adb_polling = 1;
! 1495:
! 1496: switch (adbHardware) {
! 1497: case ADB_HW_PMU:
! 1498: /* Clear the wake on AC loss event */
! 1499: pmu_fileserver_mode(0);
! 1500: pm_adb_poweroff();
! 1501:
! 1502: for (;;); /* wait for power off */
! 1503:
! 1504: return 0;
! 1505:
! 1506: case ADB_HW_CUDA:
! 1507: output[0] = 0x02; /* 2 byte message */
! 1508: output[1] = 0x01; /* to pram/rtc/soft-power device */
! 1509: output[2] = 0x0a; /* set poweroff */
! 1510: result = send_adb_cuda((u_char *)output, (u_char *)0,
! 1511: (void *)0, (void *)0, (int)0);
! 1512: if (result != 0) /* exit if not sent */
! 1513: return -1;
! 1514:
! 1515: for (;;); /* wait for power off */
! 1516:
! 1517: return 0;
! 1518:
! 1519: default:
! 1520: return -1;
! 1521: }
! 1522: }
! 1523:
! 1524: void
! 1525: setsoftadb()
! 1526: {
! 1527: if (!timeout_initialized(&adb_softintr_timeout))
! 1528: timeout_set(&adb_softintr_timeout, (void *)adb_soft_intr, NULL);
! 1529: timeout_add(&adb_softintr_timeout, 1);
! 1530: }
! 1531:
! 1532: void
! 1533: adb_cuda_autopoll()
! 1534: {
! 1535: volatile int flag = 0;
! 1536: int result;
! 1537: u_char output[16];
! 1538:
! 1539: output[0] = 0x03; /* 3-byte message */
! 1540: output[1] = 0x01; /* to pram/rtc/soft-power device */
! 1541: output[2] = 0x01; /* cuda autopoll */
! 1542: output[3] = 0x01;
! 1543: result = send_adb_cuda(output, output, adb_op_comprout,
! 1544: (void *)&flag, 0);
! 1545: if (result != 0) /* exit if not sent */
! 1546: return;
! 1547:
! 1548: while (flag == 0); /* wait for result */
! 1549: }
! 1550:
! 1551: void
! 1552: adb_cuda_fileserver_mode()
! 1553: {
! 1554: volatile int flag = 0;
! 1555: int result;
! 1556: u_char output[16];
! 1557:
! 1558: output[0] = 0x03; /* 3-byte message */
! 1559: output[1] = 0x01; /* to pram/rtc device/soft-power device */
! 1560: output[2] = 0x13; /* cuda file server mode */
! 1561: output[3] = 0x01; /* True - Turn on after AC loss */
! 1562:
! 1563: result = send_adb_cuda(output, output, adb_op_comprout,
! 1564: (void *)&flag, 0);
! 1565: if (result != 0)
! 1566: return;
! 1567:
! 1568: while (flag == 0);
! 1569: }
! 1570:
! 1571: void
! 1572: adb_restart()
! 1573: {
! 1574: int result;
! 1575: u_char output[16];
! 1576:
! 1577: adb_polling = 1;
! 1578:
! 1579: switch (adbHardware) {
! 1580: case ADB_HW_CUDA:
! 1581: output[0] = 0x02; /* 2 byte message */
! 1582: output[1] = 0x01; /* to pram/rtc/soft-power device */
! 1583: output[2] = 0x11; /* restart */
! 1584: result = send_adb_cuda((u_char *)output, (u_char *)0,
! 1585: (void *)0, (void *)0, (int)0);
! 1586: if (result != 0) /* exit if not sent */
! 1587: return;
! 1588: while (1); /* not return */
! 1589:
! 1590: case ADB_HW_PMU:
! 1591: pm_adb_restart();
! 1592: while (1); /* not return */
! 1593: }
! 1594: }
! 1595:
! 1596: /*
! 1597: * Driver definition.
! 1598: */
! 1599:
! 1600: int adbmatch(struct device *, void *, void *);
! 1601: void adbattach(struct device *, struct device *, void *);
! 1602:
! 1603: struct cfattach adb_ca = {
! 1604: sizeof(struct adb_softc), adbmatch, adbattach
! 1605: };
! 1606:
! 1607: int
! 1608: adbmatch(struct device *parent, void *cf, void *aux)
! 1609: {
! 1610: struct confargs *ca = aux;
! 1611:
! 1612: if (ca->ca_nreg < 8)
! 1613: return 0;
! 1614:
! 1615: if (ca->ca_nintr < 4)
! 1616: return 0;
! 1617:
! 1618: if (strcmp(ca->ca_name, "via-cuda") == 0)
! 1619: return 1;
! 1620:
! 1621: if (strcmp(ca->ca_name, "via-pmu") == 0)
! 1622: return 1;
! 1623:
! 1624: return 0;
! 1625: }
! 1626:
! 1627: void
! 1628: adbattach(struct device *parent, struct device *self, void *aux)
! 1629: {
! 1630: struct adb_softc *sc = (struct adb_softc *)self;
! 1631: struct confargs *ca = aux;
! 1632: struct confargs nca;
! 1633: char name[32];
! 1634: int node;
! 1635:
! 1636: ADBDataBlock adbdata;
! 1637: struct adb_attach_args aa_args;
! 1638: int totaladbs;
! 1639: int adbindex, adbaddr;
! 1640:
! 1641: ca->ca_reg[0] += ca->ca_baseaddr;
! 1642:
! 1643: sc->sc_regbase = mapiodev(ca->ca_reg[0], ca->ca_reg[1]);
! 1644: Via1Base = sc->sc_regbase;
! 1645:
! 1646: if (strcmp(ca->ca_name, "via-cuda") == 0)
! 1647: adbHardware = ADB_HW_CUDA;
! 1648: else if (strcmp(ca->ca_name, "via-pmu") == 0) {
! 1649: adbHardware = ADB_HW_PMU;
! 1650:
! 1651: /*
! 1652: * Bus reset can take a long time if no adb devices are
! 1653: * connected, e.g. on a Mac Mini; so check for an adb
! 1654: * child in the OF tree to speed up pm_adb_op().
! 1655: */
! 1656: adbempty = 1;
! 1657: for (node = OF_child(ca->ca_node); node; node = OF_peer(node)) {
! 1658: if (OF_getprop(node, "name", name, sizeof name) <= 0)
! 1659: continue;
! 1660: if (strcmp(name, "adb") == 0) {
! 1661: adbempty = 0;
! 1662: break;
! 1663: }
! 1664: }
! 1665: }
! 1666:
! 1667: adb_polling = 1;
! 1668: adb_reinit();
! 1669:
! 1670: mac_intr_establish(parent, ca->ca_intr[0], IST_LEVEL, IPL_HIGH,
! 1671: adb_intr, sc, sc->sc_dev.dv_xname);
! 1672:
! 1673: /* init powerpc globals which control RTC functionality */
! 1674: time_read = adb_read_date_time;
! 1675: time_write = adb_set_date_time;
! 1676:
! 1677: #ifdef ADB_DEBUG
! 1678: if (adb_debug)
! 1679: printf("adb: done with adb_reinit\n");
! 1680: #endif
! 1681: totaladbs = count_adbs();
! 1682:
! 1683: printf(" irq %d: %s, %d target%s\n", ca->ca_intr[0], ca->ca_name,
! 1684: totaladbs, (totaladbs == 1) ? "" : "s");
! 1685:
! 1686: /* for each ADB device */
! 1687: for (adbindex = 1; adbindex <= totaladbs; adbindex++) {
! 1688: /* Get the ADB information */
! 1689: adbaddr = get_ind_adb_info(&adbdata, adbindex);
! 1690:
! 1691: aa_args.origaddr = adbdata.origADBAddr;
! 1692: aa_args.adbaddr = adbaddr;
! 1693: aa_args.handler_id = adbdata.devType;
! 1694:
! 1695: (void)config_found(self, &aa_args, adbprint);
! 1696: }
! 1697:
! 1698: #if NAPM > 0
! 1699: /* Magic for signalling the apm driver to match. */
! 1700: aa_args.origaddr = ADBADDR_APM;
! 1701: aa_args.adbaddr = ADBADDR_APM;
! 1702: aa_args.handler_id = ADBADDR_APM;
! 1703:
! 1704: (void)config_found(self, &aa_args, NULL);
! 1705: #endif
! 1706:
! 1707: /* Attach I2C controller. */
! 1708: for (node = OF_child(ca->ca_node); node; node = OF_peer(node)) {
! 1709: if (OF_getprop(node, "name", name, sizeof name) <= 0)
! 1710: continue;
! 1711: if (strcmp(name, "pmu-i2c") == 0) {
! 1712: nca.ca_name = "piic";
! 1713: nca.ca_node = node;
! 1714: config_found(self, &nca, NULL);
! 1715: }
! 1716: }
! 1717:
! 1718: if (adbHardware == ADB_HW_CUDA)
! 1719: adb_cuda_fileserver_mode();
! 1720: if (adbHardware == ADB_HW_PMU)
! 1721: pmu_fileserver_mode(1);
! 1722:
! 1723: if (adbHardware == ADB_HW_CUDA)
! 1724: adb_cuda_autopoll();
! 1725: adb_polling = 0;
! 1726: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to adb.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / dev