![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pmu.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvPMU|
Return to pmu.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvPMU |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: #import "pmu.h" ! 26: #import "pmupriv.h" ! 27: #import "pmumisc.h" ! 28: #import "pmutables.h" ! 29: #import <kern/clock.h> ! 30: #import <kernserv/prototypes.h> ! 31: #import <kernserv/clock_timer.h> ! 32: #import <kernserv/ns_timer.h> ! 33: #import <bsd/sys/time.h> ! 34: #import <sys/callout.h> ! 35: #import <machdep/ppc/proc_reg.h> ! 36: #import <driverkit/generalFuncs.h> ! 37: #import <driverkit/kernelDriver.h> ! 38: #import <driverkit/interruptMsg.h> ! 39: ! 40: // extern to let us fix up the boot time. ! 41: extern void set_boot_time(void); ! 42: ! 43: void gotInterruptCause(id, UInt32, UInt32, UInt8 *); ! 44: void timer_expired(port_t mach_port); ! 45: ! 46: extern void kprintf(const char *, ...); ! 47: extern void bcopy(void *, void *, int); ! 48: extern msg_send_from_kernel(msg_header_t *, int, int); ! 49: ! 50: extern id ApplePMUId; ! 51: ! 52: @implementation ApplePMU ! 53: ! 54: // ********************************************************************************** ! 55: // probe ! 56: // ! 57: // ! 58: // ! 59: // ********************************************************************************** ! 60: + (Boolean) probe : deviceDescription ! 61: { ! 62: id dev; ! 63: kprintf("PMU probe\n"); ! 64: if ( (dev = [ self alloc ]) == nil ) { ! 65: return NO; ! 66: } ! 67: ! 68: if ([dev initFromDeviceDescription:deviceDescription] == nil) { ! 69: return NO; ! 70: } ! 71: ! 72: ApplePMUId = dev; ! 73: ! 74: set_boot_time(); ! 75: ! 76: return YES; ! 77: } ! 78: ! 79: ! 80: ! 81: ! 82: // ********************************************************************************** ! 83: // initFromDeviceDescription ! 84: // ! 85: // ! 86: // ! 87: // ********************************************************************************** ! 88: - initFromDeviceDescription:(IODeviceDescription *)deviceDescription ! 89: { ! 90: VIAAddress physicalAddress; ! 91: IORange *ioRange; ! 92: PMUmachMessage theRequest; ! 93: unsigned int *oldIRQs, newIRQs[2], tmpIRQ; ! 94: ! 95: ! 96: if ( [super initFromDeviceDescription:deviceDescription] == nil ) { ! 97: [self free]; ! 98: return nil; ! 99: } ! 100: ! 101: [self setDeviceKind:"PM Subsystem"]; ! 102: [self setLocation:NULL]; ! 103: [self setName:"PMU"]; ! 104: ! 105: ioRange = [deviceDescription memoryRangeList]; ! 106: physicalAddress = (VIAAddress)ioRange->start; ! 107: ! 108: VIA1_shift = physicalAddress + 0x1400; // initialize VIA addresses ! 109: VIA1_auxillaryControl = physicalAddress + 0x1600; ! 110: VIA1_interruptFlag = physicalAddress + 0x1A00; ! 111: VIA1_interruptEnable = physicalAddress + 0x1C00; ! 112: // VIA2_dataB = physicalAddress + 0x2000; // 5300 ! 113: // PMreq = 1 << M2Req; ! 114: // PMack = 1 << M2Ack; ! 115: VIA2_dataB = physicalAddress + 0x0000; // Hooper uses VIA 1 instead ! 116: PMreq = 1 << HooperReq; // and different bits in it as well ! 117: PMack = 1 << HooperAck; ! 118: // initialize other variables ! 119: ADBclient = NULL; ! 120: RTCclient = NULL; ! 121: debugging = FALSE; ! 122: queueHead = NULL; ! 123: queueTail = NULL; ! 124: PGE_ISR_state = kPMUidle; ! 125: pollList = 0; ! 126: autopollOn = FALSE; ! 127: adb_reading = FALSE; ! 128: PMU_int_pending = FALSE; ! 129: ! 130: adb_read_timeout = 100000000; ! 131: ! 132: [self AcknowledgePMUInterrupt]; // turn off any pending PGE interrupt ! 133: [self EnablePMUInterrupt]; // enable PGE interrupts ! 134: ! 135: // This is a still sleazy hack... ! 136: oldIRQs = [deviceDescription interruptList]; ! 137: ! 138: // This is another sleazy hack. The second irq is two lower in the via table. ! 139: tmpIRQ = ((*oldIRQs ^ 0x18) + 2) ^ 0x18; ! 140: ! 141: newIRQs[0] = *oldIRQs; ! 142: newIRQs[1] = tmpIRQ; ! 143: ! 144: [deviceDescription setInterruptList:newIRQs num:2]; ! 145: ! 146: [self enableAllInterrupts]; ! 147: ! 148: if ([self startIOThread] != IO_R_SUCCESS) { ! 149: [self free]; ! 150: return nil; ! 151: } ! 152: ! 153: port = IOConvertPort([self interruptPort],IO_KernelIOTask,IO_Kernel); ! 154: ! 155: theRequest.msgBody.pmCommand = kPMUSetModem1SecInt; // tell PGE why it may interrupt ! 156: theRequest.msgBody.pmFlag = FALSE; ! 157: theRequest.msgBody.pmSLength1 = 1; ! 158: theRequest.msgBody.pmSBuffer1[0] = kPMUMD2Int | kPMUbrightnessInt | kPMUADBint; ! 159: theRequest.msgBody.pmSLength2 = 0; ! 160: theRequest.msgBody.pmCallback = NULL; ! 161: ! 162: theRequest.msgHeader.msg_simple = TRUE; ! 163: theRequest.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 164: theRequest.msgHeader.msg_remote_port = port; ! 165: theRequest.msgHeader.msg_local_port = PORT_NULL; ! 166: theRequest.msgHeader.msg_size = sizeof(PMUmachMessage); ! 167: msg_send_from_kernel(&theRequest.msgHeader, MSG_OPTION_NONE, 0); ! 168: ! 169: theRequest.msgBody.pmCommand = kPMUreadINT; // read any pending interrupt from PGE ! 170: theRequest.msgBody.pmFlag = FALSE; ! 171: theRequest.msgBody.pmSLength1 = 0; // just to clear it ! 172: theRequest.msgBody.pmSLength2 = 0; ! 173: theRequest.msgBody.pmRBuffer = &interruptState[0]; ! 174: theRequest.msgBody.pmCallback = NULL; ! 175: ! 176: theRequest.msgHeader.msg_simple = TRUE; ! 177: theRequest.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 178: theRequest.msgHeader.msg_remote_port = port; ! 179: theRequest.msgHeader.msg_local_port = PORT_NULL; ! 180: theRequest.msgHeader.msg_size = sizeof(PMUmachMessage); ! 181: msg_send_from_kernel(&theRequest.msgHeader, MSG_OPTION_NONE, 0); ! 182: ! 183: [self registerDevice]; ! 184: ! 185: return self; ! 186: } ! 187: ! 188: ! 189: // ********************************************************************************** ! 190: // free ! 191: // ! 192: // ! 193: // ! 194: // ********************************************************************************** ! 195: - free ! 196: { ! 197: return [ super free ]; ! 198: } ! 199: ! 200: ! 201: ! 202: ! 203: ! 204: // ********************************************************************************** ! 205: // poll_device ! 206: // ! 207: // System interrupts are disabled, but we are still operating the PMU for mini- ! 208: // monitor keyboard input. We are called here in a loop to service the PMU. ! 209: // ! 210: // ********************************************************************************** ! 211: - (void)poll_device ! 212: { ! 213: if ( *VIA1_interruptFlag & 0x04 ) { // is shift register done? ( ifSR ) ! 214: [self interruptOccurred]; // yes, handle it ! 215: return; ! 216: } ! 217: if ( *VIA1_interruptFlag & 0x10 ) { // is PMU requesting service? ( ifCB1 ) ! 218: *VIA1_interruptFlag = 0x10; // yes, clear interrupt ( ifCB1 ) ! 219: PGE_ISR_state = kPMUidle; // and handle it ! 220: [self interruptOccurredAt:1]; ! 221: } ! 222: } ! 223: ! 224: ! 225: // ********************************************************************************** ! 226: // receiveMsg ! 227: // ! 228: // ! 229: // ! 230: // ********************************************************************************** ! 231: - (void)receiveMsg ! 232: { ! 233: PMUmachMessage * toQueue; ! 234: IOReturn result; ! 235: if ( (PGE_ISR_state == kPMUidle) && !adb_reading ) { ! 236: localMachMessage.msgHeader.msg_size = sizeof(PMUmachMessage); ! 237: localMachMessage.msgHeader.msg_local_port = [self interruptPort]; ! 238: result = msg_receive(&localMachMessage.msgHeader, (msg_option_t)RCV_TIMEOUT, 0); ! 239: if ( result == RCV_SUCCESS ) { ! 240: [self StartPMUTransmission:&localMachMessage.msgBody]; ! 241: } ! 242: } ! 243: else { ! 244: toQueue = (PMUmachMessage*)kalloc(sizeof(PMUmachMessage)); ! 245: toQueue->msgHeader.msg_size = sizeof(PMUmachMessage); ! 246: toQueue->msgHeader.msg_local_port = [self interruptPort]; ! 247: result = msg_receive(&toQueue->msgHeader, (msg_option_t)RCV_TIMEOUT, 0); ! 248: if ( result == RCV_SUCCESS ) { ! 249: toQueue->msgBody.prev = queueTail; ! 250: toQueue->msgBody.next = NULL; ! 251: if ( queueTail != NULL ) { ! 252: queueTail->msgBody.next = toQueue; ! 253: } ! 254: else { ! 255: queueHead = toQueue; ! 256: } ! 257: queueTail = toQueue; ! 258: } ! 259: } ! 260: } ! 261: ! 262: ! 263: // ********************************************************************************** ! 264: // timeoutOccurred ! 265: // ! 266: // Our adb-read timer has expired after sending an adb-read command to the PMU. ! 267: // This means there is no such addressed device on the ADB bus. ! 268: // We call back to the ADB driver with a zero-characters-received response and ! 269: // dequeue our command queue and carry on. ! 270: // ********************************************************************************** ! 271: - (void)timeoutOccurred ! 272: { ! 273: adb_reading = FALSE; ! 274: if ( clientRequest->pmCallback != NULL ) { // Make the client callback ! 275: clientRequest->pmCallback(clientRequest->pmId, clientRequest->pmRefNum, 0, NULL); ! 276: } // with zero received-length ! 277: [self CheckRequestQueue]; ! 278: } ! 279: ! 280: ! 281: // **************************************************************************** ! 282: // CheckRequestQueue ! 283: // Called at interrupt time when current request is complete. We may start ! 284: // another request here if one is in queue, or we may re-enable PMU interrupts ! 285: // (they were turned off in PMUStartIO) and return. ! 286: // **************************************************************************** ! 287: - (void)CheckRequestQueue ! 288: { ! 289: PMUmachMessage * nextRequest; ! 290: ! 291: if ( queueHead == NULL ) { // is queue empty? ! 292: [self EnablePMUInterrupt]; // yes, enable interrupt and return ! 293: } ! 294: else { ! 295: nextRequest = queueHead; // no, dequeue first command ! 296: queueHead = nextRequest->msgBody.next; ! 297: if ( queueHead == NULL ) { ! 298: queueTail = NULL; ! 299: } ! 300: bcopy (&nextRequest->msgBody, &localMachMessage.msgBody, sizeof(PMURequest)); // copy it ! 301: kfree(nextRequest, sizeof(PMUmachMessage)); // free its memory ! 302: [self StartPMUTransmission:&localMachMessage.msgBody]; // and send it to the PMU ! 303: } ! 304: } ! 305: ! 306: ! 307: // ********************************************************************************** ! 308: // registerForADBAutopoll ! 309: // ! 310: // The ADB driver is calling to tell us that it is prepared to receive ! 311: // "unsolicited" ADB autopoll data. The parameter tells who to call ! 312: // when we get some. ! 313: // ! 314: // ********************************************************************************** ! 315: - (void)registerForADBAutopoll :(pmADBinput_func)InputHandler ! 316: :(id)caller ! 317: { ! 318: ADBclient = InputHandler; ! 319: ADBid = caller; ! 320: } ! 321: ! 322: ! 323: // ********************************************************************************** ! 324: // ADBWrite ! 325: // ! 326: // ********************************************************************************** ! 327: - (PMUStatus)ADBWrite :(UInt32)DevAddr ! 328: :(UInt32)DevReg ! 329: :(UInt32)ByteCount ! 330: :(UInt8*)Buffer ! 331: :(UInt32)RefNum ! 332: :(id)Id ! 333: :(pmCallback_func)Callback ! 334: { ! 335: PMUmachMessage request; ! 336: msg_return_t return_code; ! 337: ! 338: if ( (ByteCount == 0) || ! 339: (Buffer == NULL) || ! 340: (ByteCount > (MISC_LENGTH-3) ) ) { ! 341: return kPMUParameterError; ! 342: } ! 343: ! 344: request.msgBody.pmCommand = kPMUpMgrADB; ! 345: request.msgBody.pmFlag = TRUE; // this op solicits input from PGE ! 346: request.msgBody.pmSLength1 = 3; ! 347: request.msgBody.pmSBuffer2 = Buffer; ! 348: request.msgBody.pmSLength2 = ByteCount; ! 349: request.msgBody.pmRBuffer = NULL; ! 350: request.msgBody.pmCallback = Callback; ! 351: request.msgBody.pmId = Id; ! 352: request.msgBody.pmRefNum = RefNum; ! 353: request.msgBody.pmSBuffer1[0] = kPMUWriteADB | (DevAddr << kPMUADBAddressField) | (DevReg); ! 354: if ( autopollOn ) { ! 355: request.msgBody.pmSBuffer1[1] = 2; ! 356: } ! 357: else { ! 358: request.msgBody.pmSBuffer1[1] = 0; ! 359: } ! 360: request.msgBody.pmSBuffer1[2] = ByteCount; ! 361: ! 362: request.msgHeader.msg_simple = TRUE; ! 363: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 364: request.msgHeader.msg_remote_port = port; ! 365: request.msgHeader.msg_local_port = PORT_NULL; ! 366: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 367: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 368: ! 369: if ( return_code == SEND_SUCCESS ) { ! 370: return kPMUNoError; ! 371: } ! 372: else { ! 373: return kPMUIOError; ! 374: } ! 375: } ! 376: ! 377: ! 378: // ********************************************************************************** ! 379: // ADBRead ! 380: // ! 381: // ********************************************************************************** ! 382: - (PMUStatus)ADBRead :(UInt32)DevAddr ! 383: :(UInt32)DevReg ! 384: :(UInt32)RefNum ! 385: :(id)Id ! 386: :(pmCallback_func)Callback ! 387: { ! 388: PMUmachMessage request; ! 389: msg_return_t return_code; ! 390: ! 391: request.msgBody.pmCommand = kPMUpMgrADB; ! 392: request.msgBody.pmFlag = TRUE; // this op solicits input from PGE ! 393: request.msgBody.pmSLength1 = 3; ! 394: request.msgBody.pmSBuffer2 = NULL; ! 395: request.msgBody.pmSLength2 = 0; ! 396: request.msgBody.pmRBuffer = NULL; ! 397: request.msgBody.pmCallback = Callback; ! 398: request.msgBody.pmId = Id; ! 399: request.msgBody.pmRefNum = RefNum; ! 400: request.msgBody.pmSBuffer1[0] = kPMUReadADB | (DevAddr << kPMUADBAddressField) | (DevReg); ! 401: if ( autopollOn ) { ! 402: request.msgBody.pmSBuffer1[1] = 2; ! 403: } ! 404: else { ! 405: request.msgBody.pmSBuffer1[1] = 0; ! 406: } ! 407: request.msgBody.pmSBuffer1[2] = 0; ! 408: ! 409: request.msgHeader.msg_simple = TRUE; ! 410: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 411: request.msgHeader.msg_remote_port = port; ! 412: request.msgHeader.msg_local_port = PORT_NULL; ! 413: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 414: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 415: ! 416: if ( return_code == SEND_SUCCESS ) { ! 417: return kPMUNoError; ! 418: } ! 419: else { ! 420: return kPMUIOError; ! 421: } ! 422: } ! 423: ! 424: ! 425: // ********************************************************************************** ! 426: // ADBReset ! 427: // ! 428: // ********************************************************************************** ! 429: - (PMUStatus)ADBReset :(UInt32)RefNum ! 430: :(id)Id ! 431: :(pmCallback_func)Callback ! 432: { ! 433: PMUmachMessage request; ! 434: msg_return_t return_code; ! 435: ! 436: request.msgBody.pmCommand = kPMUpMgrADB; ! 437: request.msgBody.pmFlag = TRUE; // this op solicits input from PGE ! 438: request.msgBody.pmSLength1 = 3; ! 439: request.msgBody.pmSBuffer2 = NULL; ! 440: request.msgBody.pmSLength2 = 0; ! 441: request.msgBody.pmRBuffer = NULL; ! 442: request.msgBody.pmCallback = Callback; ! 443: request.msgBody.pmId = Id; ! 444: request.msgBody.pmRefNum = RefNum; ! 445: request.msgBody.pmSBuffer1[0] = kPMUResetADBBus; ! 446: request.msgBody.pmSBuffer1[1] = 0; ! 447: request.msgBody.pmSBuffer1[2] = 0; ! 448: ! 449: request.msgHeader.msg_simple = TRUE; ! 450: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 451: request.msgHeader.msg_remote_port = port; ! 452: request.msgHeader.msg_local_port = PORT_NULL; ! 453: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 454: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 455: ! 456: if ( return_code == SEND_SUCCESS ) { ! 457: return kPMUNoError; ! 458: } ! 459: else { ! 460: return kPMUIOError; ! 461: } ! 462: } ! 463: ! 464: ! 465: // ********************************************************************************** ! 466: // ADBFlush ! 467: // ! 468: // ********************************************************************************** ! 469: - (PMUStatus)ADBFlush :(UInt32)DevAddr ! 470: :(UInt32)RefNum ! 471: :(id)Id ! 472: :(pmCallback_func)Callback ! 473: { ! 474: PMUmachMessage request; ! 475: msg_return_t return_code; ! 476: ! 477: request.msgBody.pmCommand = kPMUpMgrADB; ! 478: request.msgBody.pmFlag = TRUE; ! 479: request.msgBody.pmSLength1 = 3; ! 480: request.msgBody.pmSBuffer2 = NULL; ! 481: request.msgBody.pmSLength2 = 0; ! 482: request.msgBody.pmRBuffer = NULL; ! 483: request.msgBody.pmId = Id; ! 484: request.msgBody.pmRefNum = RefNum; ! 485: request.msgBody.pmCallback = Callback; ! 486: request.msgBody.pmSBuffer1[0] = kPMUFlushADB | (DevAddr << kPMUADBAddressField); ! 487: if ( autopollOn ) { ! 488: request.msgBody.pmSBuffer1[1] = 2; ! 489: } ! 490: else { ! 491: request.msgBody.pmSBuffer1[1] = 0; ! 492: } ! 493: request.msgBody.pmSBuffer1[2] = 0; ! 494: ! 495: request.msgHeader.msg_simple = TRUE; ! 496: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 497: request.msgHeader.msg_remote_port = port; ! 498: request.msgHeader.msg_local_port = PORT_NULL; ! 499: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 500: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 501: ! 502: if ( return_code == SEND_SUCCESS ) { ! 503: return kPMUNoError; ! 504: } ! 505: else { ! 506: return kPMUIOError; ! 507: } ! 508: } ! 509: ! 510: ! 511: // ********************************************************************************** ! 512: // ADBSetPollList ! 513: // ! 514: // ********************************************************************************** ! 515: - (PMUStatus)ADBSetPollList :(UInt32)PollBitField ! 516: :(UInt32)RefNum ! 517: :(id)Id ! 518: :(pmCallback_func)Callback ! 519: { ! 520: PMUmachMessage request; ! 521: msg_return_t return_code; ! 522: ! 523: pollList = PollBitField; // remember the new poll list ! 524: ! 525: if ( autopollOn ) { // if PMU is currently autopolling, ! 526: request.msgBody.pmCommand = kPMUpMgrADB; // give it the new list ! 527: request.msgBody.pmFlag = FALSE; ! 528: request.msgBody.pmSLength1 = 4; ! 529: request.msgBody.pmSBuffer2 = NULL; ! 530: request.msgBody.pmSLength2 = 0; ! 531: request.msgBody.pmRBuffer = NULL; ! 532: request.msgBody.pmRefNum = RefNum; ! 533: request.msgBody.pmId = Id; ! 534: request.msgBody.pmCallback = Callback; ! 535: request.msgBody.pmSBuffer1[0] = 0; ! 536: request.msgBody.pmSBuffer1[1] = 0x86; ! 537: request.msgBody.pmSBuffer1[2] = (UInt8)(PollBitField >> 8); ! 538: request.msgBody.pmSBuffer1[3] = (UInt8)(PollBitField & 0xff); ! 539: ! 540: request.msgHeader.msg_simple = TRUE; ! 541: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 542: request.msgHeader.msg_remote_port = port; ! 543: request.msgHeader.msg_local_port = PORT_NULL; ! 544: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 545: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 546: ! 547: if ( return_code == SEND_SUCCESS ) { ! 548: return kPMUNoError; ! 549: } ! 550: else { ! 551: return kPMUIOError; ! 552: } ! 553: } ! 554: else { // we'll do it later ! 555: if ( Callback != NULL ) { // but make the client callback now ! 556: Callback(Id, RefNum, 0, NULL); ! 557: } ! 558: } ! 559: return kPMUNoError; ! 560: } ! 561: ! 562: ! 563: // ********************************************************************************** ! 564: // ADBSetFileServerMode() ! 565: // ! 566: // ********************************************************************************** ! 567: - (PMUStatus)ADBSetFileServerMode :(UInt32)RefNum ! 568: :(id)Id ! 569: :(pmCallback_func)Callback ! 570: ! 571: { ! 572: return kPMUNotSupported; ! 573: } ! 574: ! 575: ! 576: // ********************************************************************************** ! 577: // ADBPollEnable ! 578: // ! 579: // ********************************************************************************** ! 580: - (PMUStatus)ADBPollEnable :(UInt32)RefNum ! 581: :(id)Id ! 582: :(pmCallback_func)Callback ! 583: ! 584: { ! 585: PMUmachMessage request; ! 586: msg_return_t return_code; ! 587: ! 588: ! 589: request.msgBody.pmCommand = kPMUpMgrADB; // give it the list we have ! 590: request.msgBody.pmFlag = FALSE; ! 591: request.msgBody.pmSLength1 = 4; ! 592: request.msgBody.pmSBuffer2 = NULL; ! 593: request.msgBody.pmSLength2 = 0; ! 594: request.msgBody.pmRBuffer = NULL; ! 595: request.msgBody.pmRefNum = RefNum; ! 596: request.msgBody.pmId = Id; ! 597: request.msgBody.pmCallback = Callback; ! 598: request.msgBody.pmSBuffer1[0] = 0; ! 599: request.msgBody.pmSBuffer1[1] = 0x86; ! 600: request.msgBody.pmSBuffer1[2] = (UInt8)(pollList >> 8); ! 601: request.msgBody.pmSBuffer1[3] = (UInt8)(pollList & 0xff); ! 602: ! 603: request.msgHeader.msg_simple = TRUE; ! 604: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 605: request.msgHeader.msg_remote_port = port; ! 606: request.msgHeader.msg_local_port = PORT_NULL; ! 607: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 608: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 609: ! 610: if ( return_code == SEND_SUCCESS ) { ! 611: autopollOn = TRUE; ! 612: return kPMUNoError; ! 613: } ! 614: else { ! 615: return kPMUIOError; ! 616: } ! 617: } ! 618: ! 619: ! 620: // ********************************************************************************** ! 621: // ADBPollDisable ! 622: // ! 623: // ********************************************************************************** ! 624: - (PMUStatus)ADBPollDisable :(UInt32)RefNum ! 625: :(id)Id ! 626: :(pmCallback_func)Callback ! 627: { ! 628: PMUmachMessage request; ! 629: msg_return_t return_code; ! 630: ! 631: request.msgBody.pmCommand = kPMUpMgrADBoff; ! 632: request.msgBody.pmFlag = FALSE; ! 633: request.msgBody.pmFlag = TRUE; ! 634: request.msgBody.pmSLength1 = 0; ! 635: request.msgBody.pmSBuffer2 = NULL; ! 636: request.msgBody.pmSLength2 = 0; ! 637: request.msgBody.pmRBuffer = NULL; ! 638: request.msgBody.pmRefNum = RefNum; ! 639: request.msgBody.pmId = Id; ! 640: request.msgBody.pmCallback = Callback; ! 641: ! 642: request.msgHeader.msg_simple = TRUE; ! 643: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 644: request.msgHeader.msg_remote_port = port; ! 645: request.msgHeader.msg_local_port = PORT_NULL; ! 646: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 647: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 648: ! 649: if ( return_code == SEND_SUCCESS ) { ! 650: autopollOn = FALSE; ! 651: return kPMUNoError; ! 652: } ! 653: else { ! 654: return kPMUIOError; ! 655: } ! 656: } ! 657: ! 658: ! 659: // ********************************************************************************** ! 660: // ADBSetPollRate ! 661: // ! 662: // ********************************************************************************** ! 663: - (PMUStatus)ADBSetPollRate :(UInt32)NewRate ! 664: :(UInt32)RefNum ! 665: :(id)Id ! 666: :(pmCallback_func)Callback ! 667: { ! 668: return kPMUNotSupported; ! 669: } ! 670: ! 671: ! 672: // ********************************************************************************** ! 673: // ADBGetPollRate ! 674: // ! 675: // ********************************************************************************** ! 676: - (PMUStatus)ADBGetPollRate :(UInt32 *)CurrentRate ! 677: :(UInt32)RefNum ! 678: :(id)Id ! 679: :(pmCallback_func)Callback ! 680: { ! 681: return kPMUNotSupported; ! 682: } ! 683: ! 684: ! 685: // ********************************************************************************** ! 686: // ADBSetAlternateKeyboard ! 687: // ! 688: // ********************************************************************************** ! 689: - (PMUStatus)ADBSetAlternateKeyboard :(UInt32)DevAddr ! 690: :(UInt32)RefNum ! 691: :(id)Id ! 692: :(pmCallback_func)Callback ! 693: { ! 694: return kPMUNotSupported; ! 695: } ! 696: ! 697: ! 698: // ********************************************************************************** ! 699: // ADBinput ! 700: // ! 701: // The PGE has interrupted with ADB data. We package this up and send ! 702: // it to our ADB client, if there is one, either as the result to its previous ! 703: // read command, or as autopoll data. ! 704: // ! 705: // ********************************************************************************** ! 706: - (void)ADBinput:(UInt32)theLength:(UInt8 *)theInput ! 707: { ! 708: if ( theInput[0] & kPMUautopoll ) { // autopoll data? ! 709: if ( ADBclient != NULL ) { ! 710: ADBclient(ADBid, 0, (theInput[1]>>4)&0x0F, theLength-2, theInput+2); ! 711: // yes, call adb input handler ! 712: } ! 713: return; ! 714: } ! 715: if ( adb_reading ) { // no, expecting adb input? ! 716: if ( clientRequest->pmSBuffer1[0] == theInput[1] ) { // yes, is it our input? ! 717: ns_untimeout((func)timer_expired,(void *)port); // yes, turn off our timer ! 718: if ( clientRequest->pmCallback != NULL ) { // Make the client callback ! 719: clientRequest->pmCallback(clientRequest->pmId, clientRequest->pmRefNum, theLength-2, theInput+2); ! 720: } ! 721: adb_reading = FALSE; ! 722: return; ! 723: } ! 724: } ! 725: kprintf("unexpected adb input: %02d %02x %02x %02x %02x\n", theLength, interruptState[0], interruptState[1], interruptState[2], interruptState[3]); ! 726: } ! 727: ! 728: ! 729: // ********************************************************************************** ! 730: // registerForClockTicks ! 731: // ! 732: // The RTC driver is calling to tell us that it is prepared to receive clock ! 733: // ticks every second. The parameter block tells who to call when we get one. ! 734: // ! 735: // ********************************************************************************** ! 736: - (void)registerForClockTicks :(pmCallback_func)TickHandler ! 737: :(id)caller ! 738: { ! 739: RTCclient = TickHandler; ! 740: RTCid = caller; ! 741: } ! 742: ! 743: ! 744: // ********************************************************************************** ! 745: // setRealTimeClock ! 746: // ! 747: // The RTC driver is calling to set the real time clock. We translate this into ! 748: // a PMU command and enqueue it to our command queue. ! 749: // ! 750: // ********************************************************************************** ! 751: - (PMUStatus)setRealTimeClock :(UInt8 *)newTime ! 752: :(UInt32)RefNum ! 753: :(id)Id ! 754: :(pmCallback_func)Callback ! 755: { ! 756: PMUmachMessage request; ! 757: msg_return_t return_code; ! 758: ! 759: if ( newTime == NULL ) { ! 760: return kPMUParameterError; ! 761: } ! 762: ! 763: request.msgBody.pmCommand = kPMUtimeWrite; ! 764: request.msgBody.pmFlag = FALSE; ! 765: request.msgBody.pmSLength1 = 0; ! 766: request.msgBody.pmSBuffer2 = newTime; ! 767: request.msgBody.pmSLength2 = 4; ! 768: request.msgBody.pmRBuffer = NULL; ! 769: request.msgBody.pmRefNum = RefNum; ! 770: request.msgBody.pmId = Id; ! 771: request.msgBody.pmCallback = Callback; ! 772: ! 773: request.msgHeader.msg_simple = TRUE; ! 774: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 775: request.msgHeader.msg_remote_port = port; ! 776: request.msgHeader.msg_local_port = PORT_NULL; ! 777: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 778: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 779: ! 780: if ( return_code == SEND_SUCCESS ) { ! 781: return kPMUNoError; ! 782: } ! 783: else { ! 784: return kPMUIOError; ! 785: } ! 786: } ! 787: ! 788: ! 789: // ********************************************************************************** ! 790: // getRealTimeClock ! 791: // ! 792: // The RTC driver is calling to read the real time clock. We translate this into ! 793: // a PMU command and enqueue it to our command queue. ! 794: // ! 795: // ********************************************************************************** ! 796: - (PMUStatus)getRealTimeClock :(UInt8 *)currentTime ! 797: :(UInt32)RefNum ! 798: :(id)Id ! 799: :(pmCallback_func)Callback ! 800: { ! 801: PMUmachMessage request; ! 802: msg_return_t return_code; ! 803: ! 804: if ( currentTime == NULL ) { ! 805: return kPMUParameterError; ! 806: } ! 807: ! 808: request.msgBody.pmCommand = kPMUtimeRead; ! 809: request.msgBody.pmFlag = FALSE; ! 810: request.msgBody.pmSLength1 = 0; ! 811: request.msgBody.pmSBuffer2 = NULL; ! 812: request.msgBody.pmSLength2 = 0; ! 813: request.msgBody.pmRBuffer = currentTime; ! 814: request.msgBody.pmRefNum = RefNum; ! 815: request.msgBody.pmId = Id; ! 816: request.msgBody.pmCallback = Callback; ! 817: ! 818: request.msgHeader.msg_simple = TRUE; ! 819: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 820: request.msgHeader.msg_remote_port = port; ! 821: request.msgHeader.msg_local_port = PORT_NULL; ! 822: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 823: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 824: ! 825: if ( return_code == SEND_SUCCESS ) { ! 826: return kPMUNoError; ! 827: } ! 828: else { ! 829: return kPMUIOError; ! 830: } ! 831: } ! 832: ! 833: ! 834: // ********************************************************************************** ! 835: // readNVRAM ! 836: // ! 837: // The NVRAM driver is calling to read part of the NVRAM. We translate this into ! 838: // single-byte PMU commands and enqueue them to our command queue. ! 839: // ! 840: // ********************************************************************************** ! 841: - (PMUStatus) readNVRAM :(UInt32)Offset ! 842: :(UInt32)Length ! 843: :(UInt8 *)Buffer ! 844: :(UInt32)RefNum ! 845: :(id)Id ! 846: :(pmCallback_func)Callback ! 847: { ! 848: PMUmachMessage request; ! 849: msg_return_t return_code; ! 850: int i; ! 851: UInt8 * client_buffer = Buffer; ! 852: UInt32 our_offset = Offset; ! 853: ! 854: if ( (Buffer == NULL) || ! 855: (Length == 0) || ! 856: (Length > 8192) || ! 857: (Offset > 8192) || ! 858: ((Length + Offset) > 8192) ) { ! 859: return kPMUParameterError; ! 860: } ! 861: ! 862: for ( i = 0; i < (Length - 1); i++ ) { // read all but the last byte ! 863: request.msgBody.pmCommand = kPMUNVRAMRead; ! 864: request.msgBody.pmFlag = FALSE; ! 865: request.msgBody.pmSLength1 = 2; ! 866: request.msgBody.pmSBuffer2 = NULL; ! 867: request.msgBody.pmSLength2 = 0; ! 868: request.msgBody.pmRBuffer = client_buffer++; ! 869: request.msgBody.pmCallback = NULL; ! 870: request.msgBody.pmSBuffer1[0] = our_offset >> 8; ! 871: request.msgBody.pmSBuffer1[1] = our_offset++; ! 872: ! 873: request.msgHeader.msg_simple = TRUE; ! 874: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 875: request.msgHeader.msg_remote_port = port; ! 876: request.msgHeader.msg_local_port = PORT_NULL; ! 877: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 878: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 879: ! 880: if ( return_code != SEND_SUCCESS ) { ! 881: return kPMUIOError; ! 882: } ! 883: } ! 884: ! 885: request.msgBody.pmCommand = kPMUNVRAMRead; // now read last byte ! 886: request.msgBody.pmFlag = FALSE; ! 887: request.msgBody.pmSLength1 = 2; ! 888: request.msgBody.pmSBuffer2 = NULL; ! 889: request.msgBody.pmSLength2 = 0; ! 890: request.msgBody.pmRBuffer = client_buffer; ! 891: request.msgBody.pmRefNum = RefNum; ! 892: request.msgBody.pmId = Id; ! 893: request.msgBody.pmCallback = Callback; ! 894: request.msgBody.pmSBuffer1[0] = our_offset >> 8; ! 895: request.msgBody.pmSBuffer1[1] = our_offset; ! 896: ! 897: request.msgHeader.msg_simple = TRUE; ! 898: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 899: request.msgHeader.msg_remote_port = port; ! 900: request.msgHeader.msg_local_port = PORT_NULL; ! 901: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 902: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 903: ! 904: if ( return_code == SEND_SUCCESS ) { ! 905: return kPMUNoError; ! 906: } ! 907: else { ! 908: return kPMUIOError; ! 909: } ! 910: } ! 911: ! 912: ! 913: // ********************************************************************************** ! 914: // writeNVRAM ! 915: // ! 916: // The NVRAM driver is calling to write part of the NVRAM. We translate this into ! 917: // single-byte PMU commands and enqueue them to our command queue. ! 918: // ! 919: // ********************************************************************************** ! 920: - (PMUStatus) writeNVRAM:(UInt32)Offset ! 921: :(UInt32)Length ! 922: :(UInt8 *)Buffer ! 923: :(UInt32)RefNum ! 924: :(id)Id ! 925: :(pmCallback_func)Callback ! 926: { ! 927: PMUmachMessage request; ! 928: msg_return_t return_code; ! 929: int i; ! 930: UInt32 our_offset = Offset; ! 931: UInt8 * client_buffer = Buffer; ! 932: ! 933: if ( (Buffer == NULL) || ! 934: (Length == 0) || ! 935: (Length > 8192) || ! 936: (Offset > 8192) || ! 937: ((Length + Offset) > 8192) ) { ! 938: return kPMUParameterError; ! 939: } ! 940: ! 941: for ( i = 0; i < (Length - 1); i++ ) { // write all but the last byte ! 942: request.msgBody.pmCommand = kPMUNVRAMWrite; ! 943: request.msgBody.pmFlag = FALSE; ! 944: request.msgBody.pmSLength1 = 3; ! 945: request.msgBody.pmSBuffer2 = NULL; ! 946: request.msgBody.pmSLength2 = 0; ! 947: request.msgBody.pmRBuffer = NULL; ! 948: request.msgBody.pmCallback = NULL; ! 949: request.msgBody.pmSBuffer1[0] = our_offset >> 8; ! 950: request.msgBody.pmSBuffer1[1] = our_offset++; ! 951: request.msgBody.pmSBuffer1[2] = *client_buffer++; ! 952: ! 953: request.msgHeader.msg_simple = TRUE; ! 954: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 955: request.msgHeader.msg_remote_port = port; ! 956: request.msgHeader.msg_local_port = PORT_NULL; ! 957: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 958: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 959: ! 960: if ( return_code != SEND_SUCCESS ) { ! 961: return kPMUIOError; ! 962: } ! 963: } ! 964: ! 965: request.msgBody.pmCommand = kPMUNVRAMWrite; // write the last byte ! 966: request.msgBody.pmFlag = FALSE; ! 967: request.msgBody.pmSLength1 = 3; ! 968: request.msgBody.pmSBuffer2 = NULL; ! 969: request.msgBody.pmSLength2 = 0; ! 970: request.msgBody.pmRBuffer = NULL; ! 971: request.msgBody.pmRefNum = RefNum; ! 972: request.msgBody.pmId = Id; ! 973: request.msgBody.pmCallback = Callback; ! 974: request.msgBody.pmSBuffer1[0] = our_offset >> 8; ! 975: request.msgBody.pmSBuffer1[1] = our_offset; ! 976: request.msgBody.pmSBuffer1[2] = *client_buffer; ! 977: ! 978: request.msgHeader.msg_simple = TRUE; ! 979: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 980: request.msgHeader.msg_remote_port = port; ! 981: request.msgHeader.msg_local_port = PORT_NULL; ! 982: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 983: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 984: ! 985: if ( return_code == SEND_SUCCESS ) { ! 986: return kPMUNoError; ! 987: } ! 988: else { ! 989: return kPMUIOError; ! 990: } ! 991: } ! 992: ! 993: ! 994: // ********************************************************************************** ! 995: // registerForPowerInterrupts ! 996: // ! 997: // Some driver is calling to say it is prepared to receive "unsolicited" power-system ! 998: // interrups (e.g. battery low). The parameter block says who to call when we get one. ! 999: // ! 1000: // ********************************************************************************** ! 1001: - (void)registerForPowerInterrupts :(pmCallback_func)buttonHandler ! 1002: :(id)caller ! 1003: { ! 1004: PWRclient = buttonHandler; ! 1005: PWRid = caller; ! 1006: } ! 1007: ! 1008: ! 1009: // ********************************************************************************** ! 1010: // sendMiscCommand ! 1011: // ! 1012: // Some driver is calling to send some miscellaneous command. We copy this into a ! 1013: // PMU command and enqueue it to our command queue. ! 1014: // ! 1015: // ********************************************************************************** ! 1016: - (PMUStatus)sendMiscCommand :(UInt32)Command ! 1017: :(UInt32)SLength ! 1018: :(UInt8 *)SBuffer ! 1019: :(UInt8 *)RBuffer ! 1020: :(UInt32)RefNum ! 1021: :(id)Id ! 1022: :(pmCallback_func)Callback ! 1023: { ! 1024: PMUmachMessage request; ! 1025: msg_return_t return_code; ! 1026: SInt32 rsp_length; ! 1027: SInt32 send_length; ! 1028: ! 1029: rsp_length = rspLengthTable[Command]; // get cmd and response lengths from table ! 1030: send_length = cmdLengthTable[Command]; ! 1031: ! 1032: if ( ((SLength != 0) && (SBuffer == NULL)) || // validate pointers ! 1033: ((rsp_length != 0) && (RBuffer == NULL)) ) { ! 1034: return kPMUParameterError; ! 1035: } ! 1036: if ( (Command != kPMUdownloadFlash) && ! 1037: ((send_length != -1) && (send_length != SLength)) ) { ! 1038: return kPMUParameterError; ! 1039: } ! 1040: ! 1041: if ( send_length > MISC_LENGTH ) { ! 1042: return kPMUParameterError; ! 1043: } ! 1044: ! 1045: request.msgBody.pmCommand = Command; ! 1046: request.msgBody.pmFlag = FALSE; ! 1047: request.msgBody.pmSLength1 = 0; ! 1048: request.msgBody.pmSBuffer2 = SBuffer; ! 1049: request.msgBody.pmSLength2 = SLength; ! 1050: request.msgBody.pmRBuffer = RBuffer; ! 1051: request.msgBody.pmRefNum = RefNum; ! 1052: request.msgBody.pmId = Id; ! 1053: request.msgBody.pmCallback = Callback; ! 1054: ! 1055: request.msgHeader.msg_simple = TRUE; ! 1056: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 1057: request.msgHeader.msg_remote_port = port; ! 1058: request.msgHeader.msg_local_port = PORT_NULL; ! 1059: request.msgHeader.msg_size = sizeof(PMUmachMessage); ! 1060: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 1061: ! 1062: if ( return_code == SEND_SUCCESS ) { ! 1063: return kPMUNoError; ! 1064: } ! 1065: else { ! 1066: return kPMUIOError; ! 1067: } ! 1068: } ! 1069: ! 1070: ! 1071: // ********************************************************************************** ! 1072: // StartPMUTransmission ! 1073: // ! 1074: // Transmission of the command byte is started. The transaction will be ! 1075: // completed by the Shift Register Interrupt Service Routine. ! 1076: // ********************************************************************************** ! 1077: - (void)StartPMUTransmission:(PMURequest *)plugInMessage ! 1078: { ! 1079: if ( !debugging ) { ! 1080: clientRequest = plugInMessage; ! 1081: firstChar = plugInMessage->pmCommand; // get command byte ! 1082: charCountS1 = plugInMessage->pmSLength1; // get caller's length counters ! 1083: charCountS2 = plugInMessage->pmSLength2; ! 1084: dataPointer1 = plugInMessage->pmSBuffer1; // and transmit data pointers ! 1085: dataPointer2 = plugInMessage->pmSBuffer2; ! 1086: dataPointer = plugInMessage->pmRBuffer; // set up read pointer for data bytes ! 1087: charCountR = rspLengthTable[firstChar]; // get response length from table ! 1088: charCountR2 = charCountR; ! 1089: ! 1090: // figure out what happens after command byte transmission ! 1091: if ( cmdLengthTable[firstChar] < 0 ) { // will we be sending a length byte next? ! 1092: PGE_ISR_state = kPMUxmtLen; // yes ! 1093: } ! 1094: else { // no, will we be sending data next? ! 1095: if ( cmdLengthTable[firstChar] > 0 ) { ! 1096: PGE_ISR_state = kPMUxmtData; // yes ! 1097: } ! 1098: else { // no, will we be receiving a length byte next? ! 1099: if ( charCountR < 0 ) { ! 1100: PGE_ISR_state = kPMUreadLen_cmd; // yes ! 1101: } ! 1102: else { // no, will we be receiving data next? ! 1103: if ( charCountR > 0 ) { ! 1104: PGE_ISR_state = kPMUreadData; // yes ! 1105: } ! 1106: else { ! 1107: PGE_ISR_state = kPMUdone; // no, this is a single-byte transaction ! 1108: } ! 1109: } ! 1110: } ! 1111: } ! 1112: // ready to start the command byte ! 1113: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1114: *VIA1_shift = firstChar; // give it the byte (this clears any pending SR interrupt) ! 1115: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1116: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1117: return; ! 1118: ! 1119: } ! 1120: else { ! 1121: UInt32 i; ! 1122: ! 1123: *VIA1_interruptEnable = 0x04; // disable SR interrupt ! 1124: ! 1125: firstChar = plugInMessage->pmCommand; // get command byte ! 1126: charCountS1 = plugInMessage->pmSLength1; // get caller's length counters ! 1127: charCountS2 = plugInMessage->pmSLength2; ! 1128: dataPointer1 = plugInMessage->pmSBuffer1; // and transmit data pointers ! 1129: dataPointer2 = plugInMessage->pmSBuffer2; ! 1130: ! 1131: charCountR = rspLengthTable[firstChar]; // get response length from table ! 1132: charCountR2 = charCountR; ! 1133: ! 1134: [self SendPMUByte:firstChar]; // send command byte ! 1135: ! 1136: if ( cmdLengthTable[firstChar] < 0 ) { // should we send a length byte? ! 1137: [self SendPMUByte:(UInt8)(charCountS1 + charCountS2)]; // yes, do it ! 1138: } ! 1139: ! 1140: for ( i = 0; i < charCountS1; i++ ) { // send data bytes ! 1141: [self SendPMUByte:*dataPointer1++]; ! 1142: } ! 1143: ! 1144: for ( i = 0; i < charCountS2; i++ ) { // send more data bytes ! 1145: [self SendPMUByte:*dataPointer2++]; ! 1146: } ! 1147: /* charCountR == 0: no reply at all ! 1148: 1: only a reply byte will be sent by the PGE ! 1149: <0: a length byte and a reply will be sent ! 1150: >1: a reply will be sent, but no length byte ! 1151: (length is charCount - 1) ! 1152: */ ! 1153: if ( charCountR ) { // receive the reply byte ! 1154: if ( charCountR == 1 ) { ! 1155: [self ReadPMUByte:plugInMessage->pmRBuffer]; ! 1156: } ! 1157: else { ! 1158: if ( charCountR < 0 ) { // receive the length byte ! 1159: [self ReadPMUByte:&receivedByte]; ! 1160: charCountR = receivedByte; ! 1161: } ! 1162: else { ! 1163: charCountR--; ! 1164: } ! 1165: dataPointer = plugInMessage->pmRBuffer; ! 1166: for ( i = 0; i < charCountR; i++ ) { ! 1167: [self ReadPMUByte:dataPointer++]; // receive the rest of the reply ! 1168: } ! 1169: } ! 1170: } ! 1171: ! 1172: if ( plugInMessage->pmCallback != NULL ) { // Make the client callback ! 1173: plugInMessage->pmCallback(plugInMessage->pmId, plugInMessage->pmRefNum, charCountR, plugInMessage->pmRBuffer); ! 1174: } ! 1175: return; ! 1176: } ! 1177: } ! 1178: ! 1179: ! 1180: ! 1181: // **************************************************************************** ! 1182: // interruptOccurred ! 1183: // The shift register has finished shifting in a byte from PG&E or finished ! 1184: // shifting out a byte to PG&E. Here we continue the transaction by starting ! 1185: // the i/o of the next byte, or we finish the transaction by calling the ! 1186: // client's callback function. ! 1187: // Both the VIA interrupt flag register and the interrupt enable registers ! 1188: // have been cleared by the ohare ISR. ! 1189: // **************************************************************************** ! 1190: ! 1191: - (void)interruptOccurred ! 1192: { ! 1193: *VIA2_dataB |= PMreq; // deassert /REQ line ! 1194: // what state are we in? ! 1195: switch ( PGE_ISR_state ) { ! 1196: // We are processing a PMU interrupt. We are reading the response ! 1197: // to the kPMUreadINT command, and a byte has arrived. ! 1198: case kPMUrcvData_int: ! 1199: *dataPointer++ = *VIA1_shift; // read the data byte ! 1200: charCountR2--; ! 1201: if ( charCountR2 > 0 ) { // is there more to read? ! 1202: while ( !(*VIA2_dataB & PMack) ) { ! 1203: } ! 1204: *VIA2_dataB &= ~PMreq; // yes, assert /REQ ! 1205: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1206: return; // next interrupt will be next data byte ! 1207: } ! 1208: if ( interruptState[0] & kPMUADBint ) { // no, what kind of interrupt was it? ! 1209: [self ADBinput: (UInt32)charCountR: &interruptState[0]]; // ADB ! 1210: } ! 1211: else { ! 1212: if ( interruptState[0] & kPMUbattInt ) { ! 1213: kprintf("battery PGE interrupt\n"); ! 1214: } ! 1215: else { ! 1216: if ( interruptState[0] & kPMUoneSecInt ) { ! 1217: // kprintf("one-second PGE interrupt\n"); ! 1218: if ( RTCclient != NULL ) { // one-second interrupt ! 1219: RTCclient(RTCid,0,0,0); ! 1220: } ! 1221: } ! 1222: else { ! 1223: if ( interruptState[0] & kPMUenvironmentInt ) { ! 1224: kprintf("environment interrupt\n"); ! 1225: } ! 1226: else { ! 1227: if ( interruptState[0] & kPMUbrightnessInt ) { ! 1228: kprintf("brightness button PGE interrupt\n"); ! 1229: } ! 1230: else { ! 1231: kprintf("machine-dependent PGE interrupt\n"); ! 1232: } ! 1233: } ! 1234: } ! 1235: } ! 1236: } ! 1237: PGE_ISR_state = kPMUidle; // set the state ! 1238: if ( !PMU_int_pending ) { // is PMU requesting service again? ! 1239: // if ( !(*VIA1_interruptFlag & 0x10) ) { // is PMU requesting service again? ( ifCB1 ) ! 1240: // if ( queueHead == (PMUmachMessage*)0 ) { // no, queue empty? ! 1241: // *VIA1_interruptEnable = 0x90; // yes, enable PMU interrupts ( ifCB1 ) ! 1242: // return; // and we are completely idle ! 1243: // } ! 1244: [self CheckRequestQueue]; // no, start next queued transaction ! 1245: } ! 1246: else { ! 1247: // *VIA1_interruptFlag = 0x10; // PMU wants service, acknowledge VIA interrupt ( ifCB1 ) ! 1248: PMU_int_pending = FALSE; ! 1249: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1250: *VIA1_shift = kPMUreadINT; // give it the command byte ! 1251: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1252: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1253: PGE_ISR_state = kPMUreadLen_int; // set the state ! 1254: dataPointer = &interruptState[0]; // set up read pointer for data bytes ! 1255: return; // next interrupt is command byte transmission complete ! 1256: } ! 1257: return; ! 1258: ! 1259: // We are processing a PMU interrupt. ! 1260: // We have finished transmitting the kPMUreadINT command byte, and ! 1261: // according to our table, we will be getting a response and a ! 1262: // length byte for it. Finish the transmit handshake and set up ! 1263: case kPMUreadLen_int: // a receive for the length byte. ! 1264: receivedByte = *VIA1_shift; // read shift reg to turn off SR int ! 1265: PGE_ISR_state = kPMUrcvLen_int; ! 1266: *VIA1_auxillaryControl &= 0xEF; // set shift register to input ! 1267: while ( !(*VIA2_dataB & PMack) ) { ! 1268: } ! 1269: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1270: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1271: return; // next interrupt will be the length byte ! 1272: ! 1273: // We are processing a PMU interrupt. ! 1274: case kPMUrcvLen_int: // The length byte has arrived. Read it and start data read ! 1275: charCountR = *VIA1_shift; // read it ! 1276: ! 1277: charCountR2 = charCountR; ! 1278: PGE_ISR_state = kPMUrcvData_int; ! 1279: while ( !(*VIA2_dataB & PMack) ) { ! 1280: } ! 1281: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1282: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1283: return; // next interrupt will be the first data byte ! 1284: ! 1285: // We are doing a command transaction. The command byte transmission ! 1286: case kPMUxmtLen: // has completed. Start length byte transmission ! 1287: PGE_ISR_state = kPMUxmtData; ! 1288: while ( !(*VIA2_dataB & PMack) ) { ! 1289: } ! 1290: *VIA1_shift = (UInt8)(charCountS1 + charCountS2); // give it the length byte ! 1291: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1292: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1293: return; // next interrupt start sending data ! 1294: ! 1295: // We are doing a command transaction. A byte transmission has completed. ! 1296: case kPMUxmtData: // Continue data byte transmission ! 1297: while ( !(*VIA2_dataB & PMack) ) { ! 1298: } ! 1299: if ( charCountS1 ) { ! 1300: *VIA1_shift = *dataPointer1++; // give it the next data byte from buffer 1 ! 1301: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1302: if ( --charCountS1 + charCountS2 ) { ! 1303: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1304: return; // next interrupt do another byte ! 1305: } ! 1306: } ! 1307: else { ! 1308: if ( charCountS2 ) { ! 1309: *VIA1_shift = *dataPointer2++; // buffer 1 empty, give it the next byte from buffer 2 ! 1310: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1311: if ( --charCountS2 ) { ! 1312: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1313: return; // next interrupt do another byte ! 1314: } ! 1315: } ! 1316: } ! 1317: // sending last byte, what's next? ! 1318: if ( charCountR < 0 ) { ! 1319: PGE_ISR_state = kPMUreadLen_cmd; // we will receive a length byte ! 1320: } ! 1321: else { ! 1322: if ( charCountR > 0 ) { ! 1323: PGE_ISR_state = kPMUreadData; // we will receive constant-length data ! 1324: } ! 1325: else { ! 1326: PGE_ISR_state = kPMUdone; // nothing, we're done ! 1327: } ! 1328: } ! 1329: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1330: return; ! 1331: ! 1332: // We have finished the transmission part of a command transaction, and ! 1333: // according to our table, we will be getting a response and a ! 1334: // length byte for it. Finish the transmit handshake and set up ! 1335: case kPMUreadLen_cmd: // a receive for the length byte. ! 1336: receivedByte = *VIA1_shift; // read shift reg to turn off SR int ! 1337: PGE_ISR_state = kPMUrcvLen_cmd; ! 1338: *VIA1_auxillaryControl &= 0xEF; // set shift register to input ! 1339: while ( !(*VIA2_dataB & PMack) ) { ! 1340: } ! 1341: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1342: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1343: return; // next interrupt will be the length byte ! 1344: ! 1345: case kPMUrcvLen_cmd: // the length byte has arrived, read it and start data read ! 1346: charCountR = *VIA1_shift; // read it ! 1347: charCountR2 = charCountR; ! 1348: PGE_ISR_state = kPMUrcvData_cmd; ! 1349: if ( !(*VIA2_dataB & PMack) ) ! 1350: if ( ![self WaitForAckHi] ) { ! 1351: return; // make sure ACK is high ! 1352: } ! 1353: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1354: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1355: return; // next interrupt will be the first data byte ! 1356: ! 1357: ! 1358: // We have finished the transmission part of a command transaction, and ! 1359: // according to our table, we will be getting a response but not a ! 1360: // length byte for it. Finish the transmit handshake and set up ! 1361: case kPMUreadData: // a receive for the first data byte. ! 1362: if ( charCountR > 1 ) { ! 1363: charCountR2--; // make constant (byte count + 1) into byte count ! 1364: charCountR--; ! 1365: } ! 1366: // receivedByte = *VIA1_shift; // read shift reg to turn off SR int ! 1367: PGE_ISR_state = kPMUrcvData_cmd; ! 1368: *VIA1_auxillaryControl &= 0xEF; // set shift register to input ! 1369: if ( !(*VIA2_dataB & PMack) ) ! 1370: if ( ![self WaitForAckHi] ) { ! 1371: return; // make sure ACK is high ! 1372: } ! 1373: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1374: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1375: return; // next interrupt will be the first data character ! 1376: ! 1377: // We are reading the response in a command transaction, and ! 1378: case kPMUrcvData_cmd: // a data byte has arrived ! 1379: *dataPointer++ = *VIA1_shift; // read the data byte ! 1380: charCountR2--; ! 1381: if ( charCountR2 > 0 ) { // is there more to read? ! 1382: if ( !(*VIA2_dataB & PMack) ) ! 1383: if ( ![self WaitForAckHi] ) { ! 1384: return; // yes, make sure ACK is high ! 1385: } ! 1386: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1387: return; // next interrupt will be next data byte ! 1388: } ! 1389: if ( clientRequest->pmCallback != NULL ) { // no, make the client callback ! 1390: clientRequest->pmCallback(clientRequest->pmId, clientRequest->pmRefNum, charCountR, clientRequest->pmRBuffer); ! 1391: } ! 1392: PGE_ISR_state = kPMUidle; // set the state ! 1393: if ( !PMU_int_pending ) { // is PMU now requesting service? ! 1394: // if ( !(*VIA1_interruptFlag & 0x10) ) { // is PMU now requesting service? (ifCB1) ! 1395: // if ( queueHead == (PMUmachMessage*)0 ) { // no, queue empty? ! 1396: // *VIA1_interruptEnable = 0x90; // yes, enable PMU interrupts ( ifCB1 ) ! 1397: // return; // and we are completely idle ! 1398: // } ! 1399: [self CheckRequestQueue]; // no, start next queued transaction ! 1400: } ! 1401: else { ! 1402: // *VIA1_interruptFlag = 0x10; // PMU wants service, acknowledge VIA interrupt ( ifCB1 ) ! 1403: PMU_int_pending = FALSE; ! 1404: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1405: *VIA1_shift = kPMUreadINT; // give it the command byte ! 1406: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1407: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1408: PGE_ISR_state = kPMUreadLen_int; // set the state ! 1409: dataPointer = &interruptState[0]; // set up read pointer for data bytes ! 1410: return; // next interrupt is command byte transmission complete ! 1411: } ! 1412: return; ! 1413: ! 1414: case kPMUdone: // this was the last xmt SR interrupt of a command transaction ! 1415: // receivedByte = *VIA1_shift; // read shift reg to turn off SR int ! 1416: ! 1417: if ( clientRequest->pmFlag ) { // does this command cause input? ! 1418: PGE_ISR_state = kPMUidle; // yes, set the state ! 1419: adb_reading = TRUE; // don't do callback now ! 1420: // who_to_call = clientRequest->pmCallback; // do it after the read completes ! 1421: // theirId = clientRequest->pmId; ! 1422: // theirRefNum = clientRequest->pmRefNum; ! 1423: ns_timeout((func)timer_expired,(void *)port,adb_read_timeout,CALLOUT_PRI_SOFTINT0); // start timer ! 1424: if ( !PMU_int_pending ) { // is PMU now requesting service? ! 1425: // if ( !(*VIA1_interruptFlag & 0x10) ) { // is PMU now requesting service? (ifCB1) ! 1426: // *VIA1_interruptEnable = 0x90; // yes, enable PMU interrupts ( ifCB1 ) ! 1427: return; // and we are completely idle ! 1428: } ! 1429: else { ! 1430: // *VIA1_interruptFlag = 0x10; // PMU wants service, acknowledge VIA interrupt ( ifCB1 ) ! 1431: PMU_int_pending = FALSE; ! 1432: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1433: *VIA1_shift = kPMUreadINT; // give it the command byte ! 1434: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1435: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1436: PGE_ISR_state = kPMUreadLen_int; // set the state ! 1437: dataPointer = &interruptState[0]; // set up read pointer for data bytes ! 1438: return; // next interrupt is command byte transmission complete ! 1439: } ! 1440: } ! 1441: // not an adb read ! 1442: if ( clientRequest->pmCallback != NULL ) { // Make the client callback ! 1443: clientRequest->pmCallback(clientRequest->pmId, clientRequest->pmRefNum, 0, NULL); ! 1444: } ! 1445: if ( !PMU_int_pending ) { // is PMU now requesting service? ! 1446: // if ( !(*VIA1_interruptFlag & 0x10) ) { // is PMU now requesting service? (ifCB1) ! 1447: // if ( queueHead == (PMUmachMessage*)0 ) { // no, queue empty? ! 1448: PGE_ISR_state = kPMUidle; ! 1449: // *VIA1_interruptEnable = 0x90; // yes, enable PMU interrupts ( ifCB1 ) ! 1450: // return; // and we are completely idle ! 1451: // } ! 1452: [self CheckRequestQueue]; // no, start next queued transaction ! 1453: } ! 1454: else { ! 1455: *VIA1_interruptFlag = 0x10; // PMU wants service, acknowledge VIA interrupt ( ifCB1 ) ! 1456: PMU_int_pending = FALSE; ! 1457: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1458: *VIA1_shift = kPMUreadINT; // give it the command byte ! 1459: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1460: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1461: PGE_ISR_state = kPMUreadLen_int; // set the state ! 1462: dataPointer = &interruptState[0]; // set up read pointer for data bytes ! 1463: return; // next interrupt is command byte transmission complete ! 1464: } ! 1465: return; ! 1466: } ! 1467: return; ! 1468: } ! 1469: ! 1470: // **************************************************************************** ! 1471: // interruptOccurredAt ! 1472: // PGE has interrupted. Send the ReadInt command to find out why. ! 1473: // When the command byte is sent, the Shift Register will interrupt. ! 1474: // If we are mid-transaction when we find out about the interrupt, ! 1475: // set a flag and find out why later. ! 1476: // ! 1477: // **************************************************************************** ! 1478: ! 1479: - (void)interruptOccurredAt:(int)localInterrupt ! 1480: { ! 1481: if ( PGE_ISR_state != kPMUidle ) { ! 1482: PMU_int_pending = TRUE; ! 1483: return; ! 1484: } ! 1485: if ( !debugging ) { ! 1486: // make sure ACK is high ! 1487: // *VIA1_interruptFlag = 0x10; // acknowledge VIA interrupt ( ifCB1 ) ! 1488: // *VIA1_interruptEnable = 0x10; // and disable it entirely ( ifCB1 ) ! 1489: while ( !(*VIA2_dataB & PMack) ) { ! 1490: } ! 1491: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1492: *VIA1_shift = kPMUreadINT; // give it the command byte ! 1493: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1494: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1495: PGE_ISR_state = kPMUreadLen_int; // set the state ! 1496: dataPointer = &interruptState[0]; // set up read pointer for data bytes ! 1497: return; // return till character transmission completes ! 1498: } ! 1499: else { ! 1500: PMURequest getInterruptState; // debug mode PMU interrupt handler ! 1501: ! 1502: // [self AcknowledgePMUInterrupt]; // turn off VIA interrupt ! 1503: *VIA1_interruptEnable = 0x04; // disable SR interrupt ! 1504: ! 1505: getInterruptState.pmCommand = kPMUreadINT; // find out cause of interrupt from PGE ! 1506: getInterruptState.pmFlag = FALSE; ! 1507: getInterruptState.pmSLength1 = 0; ! 1508: getInterruptState.pmSLength2 = 0; ! 1509: getInterruptState.pmRBuffer = &interruptState[0]; ! 1510: getInterruptState.pmCallback = gotInterruptCause; ! 1511: getInterruptState.pmId = self; ! 1512: ! 1513: [self StartPMUTransmission:&getInterruptState]; ! 1514: } ! 1515: } ! 1516: ! 1517: ! 1518: // **************************************************************************** ! 1519: // gotInterruptCause ! 1520: // ! 1521: // Called by the debug-mode PMU interrupt handler as the Callback function ! 1522: // after sending the kPMUreadInt command and receiving its response ! 1523: // **************************************************************************** ! 1524: void gotInterruptCause(id PMUdriver, UInt32 unused, UInt32 length, UInt8 * data) ! 1525: { ! 1526: UInt8 interruptSource; ! 1527: ! 1528: interruptSource = *data; ! 1529: ! 1530: if ( interruptSource & kPMUADBint ) { ! 1531: [PMUdriver ADBinput: length: data]; ! 1532: } ! 1533: else { ! 1534: if ( interruptSource & kPMUbattInt ) { ! 1535: IOLog("battery PGE interrupt"); ! 1536: } ! 1537: else { ! 1538: if ( interruptSource & kPMUoneSecInt ) { ! 1539: IOLog("one-second PGE interrupt"); ! 1540: } ! 1541: else { ! 1542: if ( interruptSource & kPMUenvironmentInt ) { ! 1543: IOLog("environment interrupt"); ! 1544: } ! 1545: else { ! 1546: if ( interruptSource & kPMUbrightnessInt ) { ! 1547: IOLog("brightness button PGE interrupt"); ! 1548: } ! 1549: else { ! 1550: IOLog("machine-dependent PGE interrupt"); ! 1551: } ! 1552: } ! 1553: } ! 1554: } ! 1555: } ! 1556: } ! 1557: ! 1558: ! 1559: // **************************************************************************** ! 1560: // SendPMUByte ! 1561: // **************************************************************************** ! 1562: - (void)SendPMUByte:(UInt8)theByte ! 1563: { ! 1564: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1565: eieio(); ! 1566: *VIA1_shift = theByte; // give it the byte ! 1567: eieio(); ! 1568: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1569: eieio(); ! 1570: if ( [self WaitForAckLo] ) { // ack now low ! 1571: *VIA2_dataB |= PMreq; // deassert /REQ line ! 1572: eieio(); ! 1573: if ( ! [self WaitForAckHi] ) { ! 1574: return; ! 1575: } ! 1576: } ! 1577: else { ! 1578: *VIA2_dataB |= PMreq; // deassert /REQ line ! 1579: eieio(); ! 1580: return; ! 1581: } ! 1582: return; ! 1583: } ! 1584: ! 1585: ! 1586: // **************************************************************************** ! 1587: // ReadPMUByte ! 1588: // **************************************************************************** ! 1589: - (void)ReadPMUByte:(UInt8 *)theByte ! 1590: { ! 1591: *VIA1_auxillaryControl |= 0x0C; // set shift register to input ! 1592: *VIA1_auxillaryControl &= ~0x10; ! 1593: *theByte = *VIA1_shift; // read a byte to reset shift reg ! 1594: eieio(); ! 1595: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1596: eieio(); ! 1597: if ( [self WaitForAckLo] ) { // ack now low ! 1598: *VIA2_dataB |= PMreq; // deassert /REQ line ! 1599: eieio(); ! 1600: if ( [self WaitForAckHi] ) { // wait for /ACK high ! 1601: *theByte = *VIA1_shift; // got it, read the byte ! 1602: eieio(); ! 1603: } ! 1604: else { ! 1605: return; ! 1606: } ! 1607: } ! 1608: else { ! 1609: *VIA2_dataB |= PMreq; // deassert /REQ line ! 1610: eieio(); ! 1611: return; ! 1612: } ! 1613: return; ! 1614: } ! 1615: ! 1616: ! 1617: // **************************************************************************** ! 1618: // WaitForAckLo ! 1619: // **************************************************************************** ! 1620: - (Boolean)WaitForAckLo ! 1621: { ! 1622: struct timeval startTime; ! 1623: struct timeval currentTime; ! 1624: ns_time_t x; ! 1625: ! 1626: // wait up to 32 milliseconds for Ack signal from PG&E to go low ! 1627: ! 1628: IOGetTimestamp(&x); ! 1629: ns_time_to_timeval(x, &startTime); // get current time ! 1630: ! 1631: while ( TRUE ) { ! 1632: if ( !(*VIA2_dataB & PMack) ) { ! 1633: return ( TRUE ); // ack is low, return ! 1634: } ! 1635: IOGetTimestamp(&x); ! 1636: ns_time_to_timeval(x, ¤tTime); ! 1637: if ( startTime.tv_usec > currentTime.tv_usec ) { ! 1638: currentTime.tv_usec += 1000000; // clock has wrapped, adjust it ! 1639: } ! 1640: if ( currentTime.tv_usec > (startTime.tv_usec + 32000) ) { // has 32 ms elapsed? ! 1641: return ( FALSE ); // yes, return ! 1642: } ! 1643: } ! 1644: } ! 1645: ! 1646: ! 1647: // **************************************************************************** ! 1648: // WaitForAckHi ! 1649: // **************************************************************************** ! 1650: - (Boolean)WaitForAckHi ! 1651: { ! 1652: struct timeval startTime; ! 1653: struct timeval currentTime; ! 1654: ns_time_t x; ! 1655: ! 1656: // wait up to 32 milliseconds for Ack signal from PG&E to go high ! 1657: ! 1658: IOGetTimestamp(&x); ! 1659: ns_time_to_timeval(x, &startTime); // get current time ! 1660: ! 1661: while ( TRUE ) { ! 1662: if ( *VIA2_dataB & PMack ) { ! 1663: return ( TRUE ); // ack is high, return ! 1664: } ! 1665: IOGetTimestamp(&x); ! 1666: ns_time_to_timeval(x, ¤tTime); ! 1667: if ( startTime.tv_usec > currentTime.tv_usec ) { ! 1668: currentTime.tv_usec += 1000000; // clock has wrapped, adjust it ! 1669: } ! 1670: if ( currentTime.tv_usec > (startTime.tv_usec + 32000) ) { // has 32 ms elapsed? ! 1671: return ( FALSE ); // yes, return ! 1672: } ! 1673: } ! 1674: } ! 1675: ! 1676: ! 1677: // **************************************************************************** ! 1678: // GetPMUInterruptState ! 1679: // **************************************************************************** ! 1680: - (UInt8)GetPMUInterruptState ! 1681: { // return current state of CB1 int enable ! 1682: return (*VIA1_interruptEnable & (1<<ifCB1)); ! 1683: } ! 1684: ! 1685: ! 1686: // **************************************************************************** ! 1687: // RestorePMUInterrupt ! 1688: // **************************************************************************** ! 1689: - (void)RestorePMUInterrupt:(UInt8)savedValue ! 1690: { ! 1691: if ( savedValue ) { // restore VIA interrupt state ! 1692: *VIA1_interruptEnable = savedValue | 0x80; ! 1693: } ! 1694: eieio(); ! 1695: } ! 1696: ! 1697: ! 1698: // **************************************************************************** ! 1699: // DisablePMUInterrupt ! 1700: // **************************************************************************** ! 1701: - (void)DisablePMUInterrupt ! 1702: { ! 1703: *VIA1_interruptEnable = 1<<ifCB1; ! 1704: eieio(); ! 1705: } ! 1706: ! 1707: ! 1708: // **************************************************************************** ! 1709: // EnablePMUInterrupt ! 1710: // **************************************************************************** ! 1711: - (void)EnablePMUInterrupt ! 1712: { ! 1713: *VIA1_interruptEnable = (1<<ifCB1) | 0x80; ! 1714: eieio(); ! 1715: } ! 1716: ! 1717: ! 1718: // **************************************************************************** ! 1719: // AcknowledgePMUInterrupt ! 1720: // **************************************************************************** ! 1721: - (void)AcknowledgePMUInterrupt ! 1722: { ! 1723: *VIA1_interruptFlag = 1<<ifCB1; ! 1724: eieio(); ! 1725: } ! 1726: ! 1727: ! 1728: // **************************************************************************** ! 1729: // GetSRInterruptState ! 1730: // **************************************************************************** ! 1731: - (UInt8)GetSRInterruptState ! 1732: { // return current state of SR int enable ! 1733: return (*VIA1_interruptEnable & (1<<ifSR)); ! 1734: } ! 1735: ! 1736: ! 1737: // **************************************************************************** ! 1738: // RestoreSRInterrupt ! 1739: // **************************************************************************** ! 1740: - (void)RestoreSRInterrupt:(UInt8)savedValue ! 1741: { ! 1742: if ( savedValue ) { // restore SR interrupt state ! 1743: *VIA1_interruptEnable = savedValue | 0x80; ! 1744: eieio(); ! 1745: } ! 1746: } ! 1747: ! 1748: ! 1749: // **************************************************************************** ! 1750: // DisableSRInterrupt ! 1751: // **************************************************************************** ! 1752: - (void)DisableSRInterrupt ! 1753: { ! 1754: *VIA1_interruptEnable = 1<<ifSR; ! 1755: } ! 1756: ! 1757: ! 1758: // **************************************************************************** ! 1759: // EnableSRInterrupt ! 1760: // **************************************************************************** ! 1761: - (void)EnableSRInterrupt ! 1762: { ! 1763: *VIA1_interruptEnable = (1<<ifSR) | 0x80; ! 1764: } ! 1765: ! 1766: ! 1767: ! 1768: // **************************************************************************** ! 1769: // timer_expired ! 1770: // ! 1771: // Our adb-read timer has expired, so we have to notify our i/o thread by ! 1772: // enqueuing a Timeout message to its interrupt port. ! 1773: // **************************************************************************** ! 1774: void timer_expired(port_t mach_port) ! 1775: { ! 1776: PMUmachMessage request; ! 1777: ! 1778: request.msgHeader.msg_simple = TRUE; ! 1779: request.msgHeader.msg_type = MSG_TYPE_NORMAL; ! 1780: request.msgHeader.msg_id = IO_TIMEOUT_MSG; ! 1781: request.msgHeader.msg_remote_port = mach_port; ! 1782: request.msgHeader.msg_local_port = PORT_NULL; ! 1783: request.msgHeader.msg_size = sizeof(msg_header_t); ! 1784: msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0); ! 1785: ! 1786: } ! 1787: ! 1788: ! 1789: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.