![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pmu.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / platform / drvApplePMU|
Return to pmu.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / platform / drvApplePMU |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: #include <IOKit/IOPlatformExpert.h> ! 23: #include <IOKit/IODeviceTreeSupport.h> ! 24: extern "C" { ! 25: #include <machine/machine_routines.h> ! 26: #include <kern/clock.h> ! 27: } ! 28: #include <IOKit/assert.h> ! 29: #include <IOKit/IOSyncer.h> ! 30: ! 31: #include "pmupriv.h" ! 32: #include "pmutables.h" ! 33: #include "IOPMUADBController.h" ! 34: #include "IOPMUNVRAMController.h" ! 35: #include "IOPMURTCController.h" ! 36: //#include "IOPMUPwrController.h" ! 37: ! 38: //extern void kprintf(const char *, ...); ! 39: ! 40: void receiveMsg ( OSObject * unused, void * newRequest, void * unused1, ! 41: void * unused2, void * unused3 ); ! 42: //void shiftRegisterInt ( OSObject * PMUdriver, IOInterruptEventSource * unused, int alsoUnused ); ! 43: void commandDoneInt ( OSObject * PMUdriver, IOInterruptEventSource * unused, int alsoUnused ); ! 44: void unsolicitedInt ( OSObject * PMUdriver, IOInterruptEventSource * unused, int alsoUnused ); ! 45: ! 46: void PMUint ( OSObject * PMUdriver, IOInterruptEventSource * unused, int alsoUnused ); ! 47: void serviceShiftRegister ( ApplePMU * ); ! 48: ! 49: static int PMU_PE_poll_input ( unsigned int, char * ); ! 50: static int PMU_PE_halt_restart ( unsigned int type ); ! 51: static int PMU_PE_write_IIC ( unsigned char, unsigned char, unsigned char ); ! 52: static int PMU_PE_read_write_time_of_day ( unsigned int, long * ); ! 53: ! 54: // Interrupt Vectors ! 55: #define VIA_DEV_VIA0 2 ! 56: #define VIA_DEV_VIA2 4 ! 57: ! 58: #define super IOService ! 59: OSDefineMetaClassAndStructors(ApplePMU,IOService) ! 60: ! 61: static ApplePMU * gOurself; ! 62: ! 63: // ********************************************************************************** ! 64: // init ! 65: // ! 66: // ********************************************************************************** ! 67: bool ApplePMU::init ( OSDictionary * properties = 0 ) ! 68: { ! 69: return super::init(properties); ! 70: } ! 71: ! 72: ! 73: // ********************************************************************************** ! 74: // start ! 75: // ! 76: // ********************************************************************************** ! 77: bool ApplePMU::start ( IOService * nub ) ! 78: { ! 79: IOMemoryMap * viaMap; ! 80: unsigned char * physicalAddress; ! 81: PMUrequest theRequest; ! 82: ! 83: workLoop = NULL; ! 84: commandQueue = NULL; ! 85: //SRintEventSrc = NULL; ! 86: cmdDoneEventSrc = NULL; ! 87: unsolicitedEventSrc = NULL; ! 88: PMUintEventSrc = NULL; ! 89: ourADBinterface = NULL; ! 90: ourRTCinterface = NULL; ! 91: /* ! 92: ourNVRAMinterface = NULL; ! 93: ourPwrinterface = NULL; ! 94: */ ! 95: ADBclient = NULL; ! 96: RTCclient = NULL; ! 97: queueHead = NULL; ! 98: queueTail = NULL; ! 99: PGE_ISR_state = kPMUidle; ! 100: adb_reading = false; ! 101: PMU_int_pending = false; ! 102: ! 103: adb_read_timeout.tv_sec = 0; ! 104: adb_read_timeout.tv_nsec = 100000000; ! 105: ! 106: gOurself = this; ! 107: ! 108: if( 0 == (viaMap = nub->mapDeviceMemoryWithIndex( 0 )) ) { ! 109: IOLog("%s: no via memory\n", getName()); ! 110: return false; ! 111: } ! 112: physicalAddress = (unsigned char *)viaMap->getVirtualAddress(); ! 113: ! 114: //kprintf("VIA base = %08x\n", (UInt32)physicalAddress); ! 115: ! 116: VIA1_shift = physicalAddress + 0x1400; // initialize VIA addresses ! 117: VIA1_auxillaryControl = physicalAddress + 0x1600; ! 118: VIA1_interruptFlag = physicalAddress + 0x1A00; ! 119: VIA1_interruptEnable = physicalAddress + 0x1C00; ! 120: VIA2_dataB = physicalAddress + 0x0000; ! 121: ! 122: PMreq = 1 << HooperReq; ! 123: PMack = 1 << HooperAck; ! 124: ! 125: // max to wait for ack low after SR interrupt, 100us ! 126: clock_interval_to_absolutetime_interval(100, 1000, &SR_to_ack_transition_delay); ! 127: ! 128: workLoop = IOWorkLoop::workLoop(); // make the workloop ! 129: if ( !workLoop ) { ! 130: kprintf("can't create workloop\n"); ! 131: return false; ! 132: } ! 133: // make the command queue ! 134: commandQueue = IOCommandQueue::commandQueue(this, receiveMsg); ! 135: if (!commandQueue || ! 136: (workLoop->addEventSource(commandQueue) != kIOReturnSuccess) ) { // add it to the workloop ! 137: kprintf("can't create or add commandQueue\n"); ! 138: return false; ! 139: } ! 140: #if 0 ! 141: // make the shift register interrupt source ! 142: SRintEventSrc = IOInterruptEventSource:: ! 143: interruptEventSource(this, shiftRegisterInt, nub, VIA_DEV_VIA0); ! 144: if ( !SRintEventSrc || ! 145: (workLoop->addEventSource(SRintEventSrc) != kIOReturnSuccess) ) { // add it to the workloop ! 146: kprintf("can't create or add SRintEventSrc\n"); ! 147: return false; ! 148: } ! 149: #endif ! 150: ! 151: nub->registerInterrupt(VIA_DEV_VIA0,this,(IOInterruptAction) serviceShiftRegister); ! 152: nub->enableInterrupt(VIA_DEV_VIA0); ! 153: ! 154: // make the command-done interrupt source ! 155: cmdDoneEventSrc = IOInterruptEventSource::interruptEventSource(this, commandDoneInt); ! 156: if ( !cmdDoneEventSrc || // add it to the workloop ! 157: (workLoop->addEventSource(cmdDoneEventSrc) != kIOReturnSuccess) ) { ! 158: kprintf("can't create or add cmdDoneEventSrc\n"); ! 159: return false; ! 160: } ! 161: ! 162: // make the unsolicited interrupt source ! 163: unsolicitedEventSrc = IOInterruptEventSource::interruptEventSource(this, unsolicitedInt); ! 164: if ( !unsolicitedEventSrc || // add it to the workloop ! 165: (workLoop->addEventSource(unsolicitedEventSrc) != kIOReturnSuccess) ) { ! 166: kprintf("can't create or add unsolicitedEventSrc\n"); ! 167: return false; ! 168: } ! 169: // make the PMU interrupt source ! 170: PMUintEventSrc = IOInterruptEventSource:: ! 171: interruptEventSource(this, PMUint, nub, VIA_DEV_VIA2); ! 172: if ( !PMUintEventSrc || ! 173: (workLoop->addEventSource(PMUintEventSrc) != kIOReturnSuccess) ) { // add it to the workloop ! 174: kprintf("can't create or add PMUintEventSrc\n"); ! 175: return false; ! 176: } ! 177: ! 178: AcknowledgePMUInterrupt(); // turn off any pending PGE interrupt ! 179: workLoop->enableAllInterrupts(); // enable interrupt delivery ! 180: EnablePMUInterrupt(); // enable PGE interrupts ! 181: EnableSRInterrupt(); ! 182: ! 183: theRequest.sync = IOSyncer::create(); ! 184: theRequest.pmCommand = kPMUSetModem1SecInt; // tell PGE why it may interrupt ! 185: theRequest.pmFlag = false; ! 186: theRequest.pmSLength1 = 1; ! 187: //theRequest.pmSBuffer1[0] = kPMUMD2Int | kPMUbrightnessInt | kPMUADBint; ! 188: theRequest.pmSBuffer1[0] = kPMUMD2Int | kPMUbrightnessInt | kPMUADBint | kPMUoneSecInt; ! 189: theRequest.pmSLength2 = 0; ! 190: commandQueue->enqueueCommand(true, &theRequest); ! 191: theRequest.sync->wait(); // wait till done ! 192: ! 193: theRequest.sync = IOSyncer::create(); ! 194: theRequest.pmCommand = kPMUreadINT; // read any pending interrupt from PGE ! 195: theRequest.pmFlag = false; ! 196: theRequest.pmSLength1 = 0; // just to clear it ! 197: theRequest.pmSLength2 = 0; ! 198: theRequest.pmRBuffer = &interruptState[0]; ! 199: commandQueue->enqueueCommand(true, &theRequest); ! 200: theRequest.sync->wait(); // wait till done ! 201: ! 202: // initialize our interfaces ! 203: ! 204: // Do not create the IOPMUADBController if the no-adb property is set. ! 205: if (!nub->getProperty("no-adb")) { ! 206: ourADBinterface = new IOPMUADBController; ! 207: if ( !ourADBinterface ) { ! 208: return false; ! 209: } ! 210: if ( !ourADBinterface->init(0,this) ) { ! 211: return false; ! 212: } ! 213: if ( !ourADBinterface->attach( this) ) { ! 214: return false; ! 215: } ! 216: } ! 217: ! 218: // Do not create the IOPMUNVRAMController if the no-nvram property is set. ! 219: if (!nub->getProperty("no-nvram")) { ! 220: ourNVRAMinterface = new IOPMUNVRAMController; ! 221: if ( !ourNVRAMinterface ) { ! 222: return false; ! 223: } ! 224: if ( !ourNVRAMinterface->init(0,this) ) { ! 225: return false; ! 226: } ! 227: if ( !ourNVRAMinterface->attach( this) ) { ! 228: return false; ! 229: } ! 230: } ! 231: ! 232: ! 233: ourRTCinterface = new IOPMURTCController; ! 234: if ( !ourRTCinterface ) { ! 235: return false; ! 236: } ! 237: if ( !ourRTCinterface->init(0,this) ) { ! 238: return false; ! 239: } ! 240: ! 241: /* ! 242: ourPwrinterface = new IOPMUPwrController; ! 243: if ( !ourPwrinterface ) { ! 244: return false; ! 245: } ! 246: if ( !ourPwrinterface->init(ourRegEntry,this) ) { ! 247: return false; ! 248: } ! 249: */ ! 250: ! 251: if (ourADBinterface) ourADBinterface->start( this ); ! 252: if (ourNVRAMinterface) ourNVRAMinterface->start( this ); ! 253: if (ourRTCinterface) ourRTCinterface->start( this ); ! 254: if (ourRTCinterface) { ! 255: PE_read_write_time_of_day = PMU_PE_read_write_time_of_day; ! 256: } ! 257: ! 258: PE_poll_input =PMU_PE_poll_input; ! 259: PE_halt_restart =PMU_PE_halt_restart; ! 260: PE_write_IIC = PMU_PE_write_IIC; ! 261: ! 262: /* are these even implemented? */ ! 263: publishResource( "IOiic0", this ); ! 264: publishResource( "IORTC", this ); ! 265: ! 266: OSSerializer * infoSerializer = OSSerializer::forTarget( ! 267: (void *) this, &serializeBatteryInfo ); ! 268: if( infoSerializer) { ! 269: IORegistryEntry * entry; ! 270: if( (entry = IORegistryEntry::fromPath("mac-io/battery", ! 271: gIODTPlane))) { ! 272: entry->setProperty( kIOBatteryInfoKey, infoSerializer ); ! 273: entry->release(); ! 274: } ! 275: infoSerializer->release(); ! 276: } ! 277: ! 278: publishResource(kPMUname, this); ! 279: ! 280: return true; ! 281: } ! 282: ! 283: ! 284: // ***************************************************************************** ! 285: // getWorkLoop ! 286: // ! 287: // Return the PMU's workloop. ! 288: // ! 289: // ***************************************************************************** ! 290: IOWorkLoop *ApplePMU::getWorkLoop() const ! 291: { ! 292: return workLoop; ! 293: } ! 294: ! 295: // ***************************************************************************** ! 296: // free ! 297: // ! 298: // Release everything we may have allocated. ! 299: // ! 300: // ***************************************************************************** ! 301: void ApplePMU::free ( void ) ! 302: { ! 303: if ( workLoop ) { ! 304: workLoop->release(); ! 305: } ! 306: if ( commandQueue ) { ! 307: commandQueue->release(); ! 308: } ! 309: #if 0 ! 310: if ( SRintEventSrc ) { ! 311: SRintEventSrc->release(); ! 312: } ! 313: #endif ! 314: if ( cmdDoneEventSrc ) { ! 315: cmdDoneEventSrc->release(); ! 316: } ! 317: if ( unsolicitedEventSrc ) { ! 318: unsolicitedEventSrc->release(); ! 319: } ! 320: if ( PMUintEventSrc ) { ! 321: PMUintEventSrc->release(); ! 322: } ! 323: if ( ourADBinterface ) { ! 324: ourADBinterface->release(); ! 325: } ! 326: if ( ourNVRAMinterface ) { ! 327: ourNVRAMinterface->release(); ! 328: } ! 329: ! 330: if ( ourRTCinterface ) { ! 331: ourRTCinterface->release(); ! 332: } ! 333: /* ! 334: if ( ourPwrinterface ) { ! 335: ourPwrinterface->release(); ! 336: } ! 337: */ ! 338: super::free(); ! 339: } ! 340: ! 341: ! 342: // ********************************************************************************** ! 343: // PMU_PE_halt_restart ! 344: // ! 345: // ********************************************************************************** ! 346: static int PMU_PE_halt_restart ( unsigned int type ) ! 347: { ! 348: PMUrequest theRequest; ! 349: UInt8 reply_byte; ! 350: ! 351: switch( type ) { ! 352: ! 353: case kPERestartCPU: ! 354: theRequest.sync = IOSyncer::create(); ! 355: theRequest.pmCommand = kPMUresetCPU; ! 356: theRequest.pmFlag = false; ! 357: theRequest.pmSLength1 = 0; ! 358: theRequest.pmSLength2 = 0; ! 359: theRequest.pmRBuffer = &reply_byte; ! 360: gOurself->enqueueCommand(&theRequest); ! 361: theRequest.sync->wait(); // wait till done ! 362: break; ! 363: ! 364: case kPEHaltCPU: ! 365: theRequest.sync = IOSyncer::create(); ! 366: theRequest.pmCommand = kPMUPmgrPWRoff; ! 367: theRequest.pmFlag = false; ! 368: theRequest.pmSLength1 = 4; ! 369: theRequest.pmSBuffer1[0] = 'M'; ! 370: theRequest.pmSBuffer1[1] = 'A'; ! 371: theRequest.pmSBuffer1[2] = 'T'; ! 372: theRequest.pmSBuffer1[3] = 'T'; ! 373: theRequest.pmSLength2 = 0; ! 374: theRequest.pmRBuffer = &reply_byte; ! 375: gOurself->enqueueCommand(&theRequest); ! 376: theRequest.sync->wait(); // wait till done ! 377: break; ! 378: ! 379: default: ! 380: return 1; ! 381: } ! 382: ! 383: // workaround 2377033; avoid memory accesses after this point ! 384: ml_set_interrupts_enabled(false); ! 385: while(true) {} ! 386: ! 387: return 1; ! 388: } ! 389: ! 390: ! 391: // ********************************************************************************** ! 392: // PMU_PE_read_write_time_of_day ! 393: // ! 394: // ********************************************************************************** ! 395: static int PMU_PE_read_write_time_of_day ( unsigned int options, long * secs ) ! 396: { ! 397: UInt8 currentTime[8]; ! 398: IOByteCount length,i; ! 399: long longTime = 0; ! 400: ! 401: if( (options == kPEReadTOD) && (gOurself->ourRTCinterface != NULL) ) ! 402: { ! 403: gOurself->ourRTCinterface->getRealTimeClock(currentTime,&length); ! 404: ! 405: for ( i = 0; i < length; i++ ) ! 406: { ! 407: longTime |= currentTime[i] << ((length-i-1)*8); ! 408: } ! 409: *secs = longTime; ! 410: } ! 411: ! 412: if( (options == kPEWriteTOD) && (gOurself->ourRTCinterface != NULL) ) ! 413: { ! 414: gOurself->ourRTCinterface->setRealTimeClock((UInt8 *)secs); ! 415: } ! 416: ! 417: return 0; ! 418: } ! 419: ! 420: ! 421: // ********************************************************************************** ! 422: // PMU_PE_write_IIC ! 423: // ! 424: // ********************************************************************************** ! 425: static int PMU_PE_write_IIC ( unsigned char, unsigned char, unsigned char ) ! 426: { ! 427: kprintf ("PMU_PE_write_IIC - "); ! 428: ! 429: return 1; ! 430: } ! 431: ! 432: ! 433: // ********************************************************************************** ! 434: // PMU_PE_poll_input ! 435: // ! 436: // System interrupts are disabled, but we are still operating the PMU for mini- ! 437: // monitor keyboard input. We are called here in a loop to service the PMU. ! 438: // ! 439: // ********************************************************************************** ! 440: static int PMU_PE_poll_input ( unsigned int, char * ) ! 441: { ! 442: return 1; // XXX -- svail: what is the correct value??? ! 443: } ! 444: ! 445: #if 0 ! 446: // ********************************************************************************** ! 447: // poll_device ! 448: // ! 449: // System interrupts are disabled, but we are still operating the PMU for mini- ! 450: // monitor keyboard input. We are called here in a loop to service the PMU. ! 451: // ! 452: // ********************************************************************************** ! 453: void ApplePMU::poll_device( void ) ! 454: { ! 455: if ( *VIA1_interruptFlag & 0x04 ) { // is shift register done? ( ifSR ) ! 456: serviceShiftRegister(); // yes, handle it ! 457: return; ! 458: } ! 459: if ( *VIA1_interruptFlag & 0x10 ) { // is PMU requesting service? ( ifCB1 ) ! 460: *VIA1_interruptFlag = 0x10; // yes, clear interrupt ( ifCB1 ) ! 461: PGE_ISR_state = kPMUidle; // and handle it ! 462: servicePMU(); ! 463: } ! 464: } ! 465: #endif ! 466: ! 467: // ********************************************************************************** ! 468: // receiveMsg ! 469: // ! 470: // ! 471: // ! 472: // ********************************************************************************** ! 473: void receiveMsg ( OSObject * theDriver, void * newRequest, void *, void *, void * ) ! 474: { ! 475: ApplePMU * PMUdriver = (ApplePMU *) theDriver; ! 476: ! 477: if ( (PMUdriver->PGE_ISR_state == kPMUidle) && !PMUdriver->adb_reading ) { ! 478: PMUdriver->StartPMUTransmission((PMUrequest *)newRequest); ! 479: } ! 480: else { ! 481: ((PMUrequest *) newRequest)->prev = PMUdriver->queueTail; ! 482: ((PMUrequest *) newRequest)->next = NULL; ! 483: if ( PMUdriver->queueTail != NULL ) { ! 484: PMUdriver->queueTail->next = (PMUrequest *) newRequest; ! 485: } ! 486: else { ! 487: PMUdriver->queueHead = (PMUrequest *)newRequest; ! 488: } ! 489: PMUdriver->queueTail = (PMUrequest *)newRequest; ! 490: } ! 491: } ! 492: ! 493: ! 494: // ********************************************************************************** ! 495: // timeoutOccurred ! 496: // ! 497: // Our adb-read timer has expired after sending an adb-read command to the PMU. ! 498: // This means there is no such addressed device on the ADB bus. ! 499: // We call back to the ADB driver with a zero-characters-received response and ! 500: // dequeue our command queue and carry on. ! 501: // ********************************************************************************** ! 502: void ApplePMU::timeoutOccurred ( void ) ! 503: { ! 504: adb_reading = false; ! 505: clientRequest->pmRLength = 0; // nothing was read ! 506: clientRequest->sync->signal(); // unblock the caller ! 507: clientRequest = 0; ! 508: CheckRequestQueue(); ! 509: } ! 510: ! 511: ! 512: // **************************************************************************** ! 513: // CheckRequestQueue ! 514: // Called at interrupt time when current request is complete. We start ! 515: // another request here if one is in queue. ! 516: // **************************************************************************** ! 517: void ApplePMU::CheckRequestQueue ( void ) ! 518: { ! 519: PMUrequest * nextRequest; ! 520: ! 521: if ( queueHead != NULL ) { // is queue empty? ! 522: nextRequest = queueHead; // no, dequeue first command ! 523: queueHead = nextRequest->next; ! 524: if ( queueHead == NULL ) { ! 525: queueTail = NULL; ! 526: } ! 527: StartPMUTransmission(nextRequest); // and send it to the PMU ! 528: } ! 529: } ! 530: ! 531: ! 532: // ********************************************************************************** ! 533: // enqueueCommand ! 534: // ! 535: // ********************************************************************************** ! 536: void ApplePMU::enqueueCommand ( PMUrequest * request ) ! 537: { ! 538: commandQueue->enqueueCommand(true,request); ! 539: } ! 540: ! 541: ! 542: // ********************************************************************************** ! 543: // ADBinput ! 544: // ! 545: // The PGE has interrupted with ADB data. We package this up and send ! 546: // it to our ADB client, if there is one, either as the result to its previous ! 547: // read command, or as autopoll data. ! 548: // ! 549: // ********************************************************************************** ! 550: void ApplePMU::ADBinput(UInt32 theLength, UInt8 * theInput) ! 551: { ! 552: if ( theInput[0] & kPMUautopoll ) { // autopoll data? ! 553: if ( ADBclient != NULL ) { ! 554: // kprintf("autopoll: %d %02x %02x %02x %02x\n", theLength, theInput[0], theInput[1], theInput[2], theInput[3]); ! 555: ! 556: (* ADBclient)(ADBid, theInput[1], theLength-2, theInput+2 );// yes, call adb input handler ! 557: } ! 558: return; ! 559: } ! 560: if ( adb_reading ) { // no, expecting adb input? ! 561: if ( clientRequest->pmSBuffer1[0] == theInput[1] ) { // yes, is it our input? ! 562: // q8q // yes, turn off our timer ! 563: clientRequest->pmRLength = theLength-2; // this much was read ! 564: clientRequest->pmRBuffer = theInput+2; // to here ! 565: clientRequest->sync->signal(); // unblock the caller ! 566: clientRequest = 0; ! 567: adb_reading = false; ! 568: return; ! 569: } ! 570: } ! 571: kprintf("unexpected adb input: %02d %02x %02x %02x %02x %02x\n", theLength, theInput[0], theInput[1], theInput[2], theInput[3], clientRequest->pmSBuffer1[0]); ! 572: } ! 573: ! 574: ! 575: // ********************************************************************************** ! 576: // registerForADBInterrupts ! 577: // ! 578: // Some driver is calling to say it is prepared to receive "unsolicited" adb ! 579: // interrupts (e.g. autopoll keyboard and trackpad data). The parameters identify ! 580: // who to call when we get one. ! 581: // ********************************************************************************** ! 582: void ApplePMU::registerForADBInterrupts ( ADB_callback_func client, IOService * caller ) ! 583: { ! 584: ADBclient = client; ! 585: ADBid = caller; ! 586: } ! 587: ! 588: ! 589: // ********************************************************************************** ! 590: // registerForPowerInterrupts ! 591: // ! 592: // Some driver is calling to say it is prepared to receive "unsolicited" power-system ! 593: // interrupts (e.g. battery low). The parameters identify who to call when we get one. ! 594: // ********************************************************************************** ! 595: void ApplePMU::registerForPowerInterrupts ( pmCallback_func buttonHandler, IOService * caller ) ! 596: { ! 597: PWRclient = buttonHandler; ! 598: PWRid = caller; ! 599: } ! 600: ! 601: ! 602: // ********************************************************************************** ! 603: // registerForClockInterrupts ! 604: // ! 605: // Some driver is calling to say it is prepared to receive "unsolicited" real-time clock ! 606: // interrupts (e.g. one-second tick). The parameters identify who to call when we get one. ! 607: // ********************************************************************************** ! 608: void ApplePMU::registerForClockInterrupts ( pmCallback_func tickHandler, IOService * caller ) ! 609: { ! 610: RTCclient = tickHandler; ! 611: RTCid = caller; ! 612: } ! 613: ! 614: ! 615: // ********************************************************************************** ! 616: // buttonInput ! 617: // ! 618: // The PGE has interrupted with Brightness/Contrast data. We package this up and send ! 619: // it to our Display client, if there is one. ! 620: // ! 621: // ********************************************************************************** ! 622: void ApplePMU::buttonInput ( UInt32 theLength, UInt8 * theInput ) ! 623: { ! 624: if ( PWRclient != NULL ) { ! 625: (* PWRclient)(PWRid, theLength-1, theInput+1); ! 626: } ! 627: } ! 628: ! 629: // ********************************************************************************** ! 630: ! 631: bool ApplePMU::serializeBatteryInfo( void * target, void * ref, OSSerialize * s ) ! 632: { ! 633: UInt32 flags, current, capacity; ! 634: OSArray * array; ! 635: OSDictionary * dict; ! 636: OSNumber * num; ! 637: UInt32 battery; ! 638: UInt8 data[16]; ! 639: IOByteCount readLen; ! 640: IOReturn err; ! 641: bool ok = true; ! 642: ! 643: array = OSArray::withCapacity(2); ! 644: if( !array) ! 645: return( false ); ! 646: ! 647: for( battery = 1; battery <= 2; battery++) { ! 648: data[0] = battery; ! 649: err = ((ApplePMU *) target)->sendMiscCommand( kPMUGetSOB, ! 650: 1, data, &readLen, data ); ! 651: if( kIOReturnSuccess == err) { ! 652: switch( data[0] ) { ! 653: case 3: ! 654: case 4: ! 655: current = data[2]; ! 656: capacity = data[3]; ! 657: break; ! 658: case 5: ! 659: current = (data[2] << 8) | data[3]; ! 660: capacity = (data[4] << 8) | data[5]; ! 661: break; ! 662: default: ! 663: continue; ! 664: } ! 665: flags = data[1]; ! 666: dict = OSDictionary::withCapacity(2); ! 667: if( !dict) ! 668: continue; ! 669: num = OSNumber::withNumber(flags, 32); ! 670: if( num) { ! 671: dict->setObject(kIOBatteryFlagsKey, num); ! 672: num->release(); ! 673: } ! 674: num = OSNumber::withNumber(current, 32); ! 675: if( num) { ! 676: dict->setObject(kIOBatteryCurrentChargeKey, num); ! 677: num->release(); ! 678: } ! 679: num = OSNumber::withNumber(capacity, 32); ! 680: if( num) { ! 681: dict->setObject(kIOBatteryCapacityKey, num); ! 682: num->release(); ! 683: } ! 684: array->setObject( dict ); ! 685: dict->release(); ! 686: } ! 687: } ! 688: ! 689: ok = array->serialize(s); ! 690: array->release(); ! 691: ! 692: return( ok ); ! 693: } ! 694: ! 695: ! 696: // ********************************************************************************** ! 697: // sendMiscCommand ! 698: // ! 699: // Some driver is calling to send some miscellaneous command. We copy this into a ! 700: // PMU command and enqueue it to our command queue. ! 701: // ! 702: // The read-length parameter is ignored on entry. On exit it is set to the number ! 703: // of bytes read in response to transmission of the command. ! 704: // ********************************************************************************** ! 705: IOReturn ApplePMU::sendMiscCommand ( UInt32 Command, IOByteCount SLength, ! 706: UInt8 * SBuffer, IOByteCount * RLength, UInt8 * RBuffer ) ! 707: { ! 708: PMUrequest request; ! 709: SInt32 rsp_length; ! 710: SInt32 send_length; ! 711: ! 712: rsp_length = rspLengthTable[Command]; // get cmd and response lengths from table ! 713: send_length = cmdLengthTable[Command]; ! 714: ! 715: if ( ((SLength != 0) && (SBuffer == NULL)) || // validate pointers ! 716: ((rsp_length != 0) && (RBuffer == NULL)) || ! 717: (RLength == NULL) ) { ! 718: return kPMUParameterError; ! 719: } ! 720: if ( (Command != kPMUdownloadFlash) && ! 721: ((send_length != -1) && ((IOByteCount )send_length != SLength)) ) { ! 722: return kPMUParameterError; ! 723: } ! 724: ! 725: if ( send_length > MISC_LENGTH ) { ! 726: return kPMUParameterError; ! 727: } ! 728: ! 729: request.sync = IOSyncer::create(); ! 730: request.pmCommand = Command; ! 731: request.pmFlag = false; // this is usually correct, but the API needs to be enhanced ! 732: request.pmSLength1 = 0; ! 733: request.pmSBuffer2 = SBuffer; ! 734: request.pmSLength2 = SLength; ! 735: request.pmRBuffer = RBuffer; ! 736: ! 737: commandQueue->enqueueCommand(true, &request); ! 738: request.sync->wait(); // wait till done ! 739: ! 740: *RLength = request.pmRLength; // set user's receive byte count ! 741: ! 742: return kPMUNoError; ! 743: } ! 744: ! 745: ! 746: // ********************************************************************************** ! 747: // StartPMUTransmission ! 748: // ! 749: // Transmission of the command byte is started. The transaction will be ! 750: // completed by the Shift Register Interrupt Service Routine. ! 751: // ********************************************************************************** ! 752: void ApplePMU::StartPMUTransmission ( PMUrequest * plugInMessage ) ! 753: { ! 754: clientRequest = plugInMessage; ! 755: firstChar = plugInMessage->pmCommand; // get command byte ! 756: charCountS1 = plugInMessage->pmSLength1; // get caller's length counters ! 757: charCountS2 = plugInMessage->pmSLength2; ! 758: dataPointer1 = plugInMessage->pmSBuffer1; // and transmit data pointers ! 759: dataPointer2 = plugInMessage->pmSBuffer2; ! 760: dataPointer = plugInMessage->pmRBuffer; // set up read pointer for data bytes ! 761: charCountR = rspLengthTable[firstChar]; // get response length from table ! 762: charCountR2 = charCountR; ! 763: // figure out what happens after command byte transmission ! 764: if ( cmdLengthTable[firstChar] < 0 ) { // will we be sending a length byte next? ! 765: PGE_ISR_state = kPMUxmtLen; // yes ! 766: } ! 767: else { // no, will we be sending data next? ! 768: if ( cmdLengthTable[firstChar] > 0 ) { ! 769: PGE_ISR_state = kPMUxmtData; // yes ! 770: } ! 771: else { // no, will we be receiving a length byte next? ! 772: if ( charCountR < 0 ) { ! 773: PGE_ISR_state = kPMUreadLen_cmd; // yes ! 774: } ! 775: else { // no, will we be receiving data next? ! 776: if ( charCountR > 0 ) { ! 777: PGE_ISR_state = kPMUreadData; // yes ! 778: } ! 779: else { ! 780: PGE_ISR_state = kPMUdone; // no, this is a single-byte transaction ! 781: } ! 782: } ! 783: } ! 784: } ! 785: // ready to start the command byte ! 786: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 787: *VIA1_shift = firstChar; // give it the byte (this clears any pending SR interrupt) ! 788: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 789: *VIA2_dataB &= ~PMreq; // assert /REQ ! 790: return; ! 791: } ! 792: ! 793: #if 0 ! 794: // **************************************************************************** ! 795: // shiftRegisterInt ! 796: // ! 797: // **************************************************************************** ! 798: ! 799: void shiftRegisterInt ( OSObject * PMUdriver, IOInterruptEventSource *, int ) ! 800: { ! 801: ((ApplePMU *)PMUdriver)->serviceShiftRegister(); ! 802: } ! 803: #endif ! 804: ! 805: ! 806: // **************************************************************************** ! 807: // commandDoneInt ! 808: // ! 809: // **************************************************************************** ! 810: ! 811: void commandDoneInt ( OSObject * PMUdriver, IOInterruptEventSource *, int ) ! 812: { ! 813: ApplePMU * pmu = (ApplePMU *)PMUdriver; ! 814: pmu->PGE_ISR_state = kPMUidle; // set the state ! 815: if ( pmu->clientRequest->pmFlag ) { // does this command cause input? ! 816: if ( ! pmu->adb_reading ) { // yes, is this the input completion? ! 817: pmu->adb_reading = true; // no, don't unblock caller now ! 818: //q8q // start timer ! 819: if ( pmu->PMU_int_pending ) { // is PMU now requesting service? ! 820: pmu->PMU_int_pending = false; ! 821: *(pmu->VIA1_auxillaryControl) |= 0x1C; // set shift register to output ! 822: *(pmu->VIA1_shift) = kPMUreadINT; // give it this command byte ! 823: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 824: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 825: pmu->PGE_ISR_state = kPMUreadLen_int; // next int is cmd byte xmt done ! 826: pmu->dataPointer = &(pmu->interruptState[0]); // set up read ptr for data bytes ! 827: } ! 828: return; ! 829: } ! 830: } ! 831: ! 832: pmu->clientRequest->sync->signal(); // unblock the caller ! 833: pmu->clientRequest = 0; ! 834: if ( !(pmu->PMU_int_pending) ) { // is PMU now requesting service? ! 835: pmu->CheckRequestQueue(); // no, start next queued transaction ! 836: } ! 837: else { ! 838: pmu->PMU_int_pending = false; ! 839: *(pmu->VIA1_auxillaryControl) |= 0x1C; // set shift register to output ! 840: *(pmu->VIA1_shift) = kPMUreadINT; // give it this command byte ! 841: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 842: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 843: pmu->PGE_ISR_state = kPMUreadLen_int; // next int is cmd byte xmt done ! 844: pmu->dataPointer = &(pmu->interruptState[0]); // set up read ptr for data bytes ! 845: } ! 846: } ! 847: ! 848: ! 849: // **************************************************************************** ! 850: // unsolicitedInt ! 851: // ! 852: // **************************************************************************** ! 853: ! 854: void unsolicitedInt ( OSObject * PMUdriver, IOInterruptEventSource *, int ) ! 855: { ! 856: ApplePMU * pmu = (ApplePMU *)PMUdriver; ! 857: if ( pmu->interruptState[0] & kPMUADBint ) { // what kind of int was it? ! 858: pmu->ADBinput((UInt32)(pmu->charCountR), &(pmu->interruptState[0])); // ADB ! 859: } ! 860: else { ! 861: if ( pmu->interruptState[0] & kPMUbattInt ) { ! 862: // kprintf("battery PGE interrupt\n"); ! 863: } ! 864: else { ! 865: if ( pmu->interruptState[0] & kPMUoneSecInt ) { ! 866: // kprintf("one-second PGE interrupt\n"); ! 867: if ( pmu->RTCclient != NULL ) { // one-second interrupt ! 868: // (* RTCclient)(RTCid,0,0,0); ! 869: } ! 870: } ! 871: else { ! 872: if ( pmu->interruptState[0] & kPMUenvironmentInt ) { ! 873: // kprintf("environment interrupt\n"); ! 874: } ! 875: else { ! 876: if ( pmu->interruptState[0] & kPMUbrightnessInt ) { ! 877: // kprintf("brightness button PGE interrupt\n"); ! 878: pmu->buttonInput((UInt32)(pmu->charCountR),&(pmu->interruptState[0])); ! 879: } ! 880: else { ! 881: // kprintf("machine-dependent PGE interrupt\n"); ! 882: } ! 883: } ! 884: } ! 885: } ! 886: } ! 887: pmu->PGE_ISR_state = kPMUidle; // set the state ! 888: ! 889: if ( !(pmu->PMU_int_pending) ) { // is PMU requesting service again? ! 890: if (0 == pmu->clientRequest) ! 891: pmu->CheckRequestQueue(); // no, start next queued command ! 892: } ! 893: else { ! 894: pmu->PMU_int_pending = false; ! 895: *(pmu->VIA1_auxillaryControl) |= 0x1C; // set shift register to output ! 896: *(pmu->VIA1_shift) = kPMUreadINT; // give it this command byte ! 897: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 898: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 899: pmu->PGE_ISR_state = kPMUreadLen_int; // next int is cmd byte xmt done ! 900: pmu->dataPointer = &(pmu->interruptState[0]); // set up read ptr for data bytes ! 901: } ! 902: } ! 903: ! 904: bool ApplePMU::WaitForAckLo ( void ) ! 905: { ! 906: AbsoluteTime deadline, now; ! 907: bool ok = true; ! 908: ! 909: clock_absolutetime_interval_to_deadline( ! 910: SR_to_ack_transition_delay, &deadline); ! 911: ! 912: while( ok && ((*VIA2_dataB) & PMack) ) { ! 913: clock_get_uptime( &now ); ! 914: ok = (CMP_ABSOLUTETIME( &now, &deadline ) < 0); ! 915: } ! 916: eieio(); ! 917: ! 918: return( ok ); ! 919: } ! 920: ! 921: // **************************************************************************** ! 922: // serviceShiftRegister ! 923: // The shift register has finished shifting in a byte from PG&E or finished ! 924: // shifting out a byte to PG&E. Here we continue the transaction by starting ! 925: // the i/o of the next byte, or we finish the transaction by indicating an ! 926: // interrupt on either the command-done interrupt source or the autopoll ! 927: // interrupt source on the workloop. ! 928: // Both the VIA interrupt flag register and the interrupt enable registers ! 929: // have been cleared by the ohare ISR. ! 930: // **************************************************************************** ! 931: ! 932: void serviceShiftRegister ( ApplePMU * pmu ) ! 933: { ! 934: ! 935: if( (*(pmu->VIA2_dataB) & pmu->PMack) ) ! 936: pmu->WaitForAckLo(); ! 937: ! 938: *(pmu->VIA2_dataB) |= pmu->PMreq; // deassert /REQ line ! 939: // what state are we in? ! 940: switch ( pmu->PGE_ISR_state ) { ! 941: // We are processing a PMU interrupt. We are reading the response ! 942: // to the kPMUreadINT command, and a byte has arrived. ! 943: case kPMUrcvData_int: ! 944: *(pmu->dataPointer)++ = *(pmu->VIA1_shift); // read the data byte ! 945: (pmu->charCountR2)--; ! 946: if ( pmu->charCountR2 > 0 ) { // is there more to read? ! 947: while ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 948: } ! 949: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // yes, assert /REQ ! 950: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 951: return; // next int is next data byte ! 952: } ! 953: pmu->unsolicitedEventSrc->interruptOccurred(0,0,0); // no, inform workloop ! 954: return; ! 955: ! 956: // We are processing a PMU interrupt. ! 957: // We have finished transmitting the kPMUreadINT command byte, ! 958: // and according to our table, we will be getting a response and ! 959: // a length byte for it. Finish the transmit handshake and set ! 960: case kPMUreadLen_int: // up a receive for the length byte. ! 961: pmu->receivedByte = *(pmu->VIA1_shift); // read shift reg to turn off SR int ! 962: pmu->PGE_ISR_state = kPMUrcvLen_int; ! 963: *(pmu->VIA1_auxillaryControl) &= 0xEF; // set shift register to input ! 964: while ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 965: } ! 966: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 967: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 968: return; // next interrupt will be the length byte ! 969: ! 970: // We are processing a PMU interrupt. ! 971: case kPMUrcvLen_int: // The length byte has arrived. Read it and start data read ! 972: pmu->charCountR = *(pmu->VIA1_shift); // read it ! 973: ! 974: pmu->charCountR2 = pmu->charCountR; ! 975: pmu->PGE_ISR_state = kPMUrcvData_int; ! 976: while ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 977: } ! 978: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 979: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 980: return; // next int will be the first data byte ! 981: ! 982: // We are doing a command transaction. The command byte ! 983: case kPMUxmtLen: // transmission has completed. Start length byte transmission ! 984: pmu->PGE_ISR_state = kPMUxmtData; ! 985: while ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 986: } ! 987: *(pmu->VIA1_shift) = (UInt8)(pmu->charCountS1 + pmu->charCountS2); // give it the length byte ! 988: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 989: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 990: return; // next int start sending data ! 991: ! 992: // We are doing a command transaction. A byte transmission has ! 993: case kPMUxmtData: // completed . Continue data byte transmission ! 994: while ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 995: } ! 996: if ( pmu->charCountS1 ) { ! 997: *(pmu->VIA1_shift) = *(pmu->dataPointer1)++; // give it the next data byte from buffer 1 ! 998: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 999: if ( --(pmu->charCountS1) + pmu->charCountS2 ) { ! 1000: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1001: return; // next interrupt do another byte ! 1002: } ! 1003: } ! 1004: else { ! 1005: if ( pmu->charCountS2 ) { // buffer 1 empty, ! 1006: *(pmu->VIA1_shift) = *(pmu->dataPointer2)++; // give it the next byte from buffer 2 ! 1007: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 1008: if ( --(pmu->charCountS2) ) { ! 1009: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1010: return; // next interrupt do another byte ! 1011: } ! 1012: } ! 1013: } ! 1014: // sending last byte, what's next? ! 1015: if ( pmu->charCountR < 0 ) { ! 1016: pmu->PGE_ISR_state = kPMUreadLen_cmd; // we will receive a length byte ! 1017: } ! 1018: else { ! 1019: if ( pmu->charCountR > 0 ) { ! 1020: pmu->PGE_ISR_state = kPMUreadData; // we will receive constant-length data ! 1021: } ! 1022: else { ! 1023: pmu->PGE_ISR_state = kPMUdone; // nothing, we're done ! 1024: } ! 1025: } ! 1026: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1027: return; ! 1028: ! 1029: // We have finished the transmission part of a command transaction, and ! 1030: // according to our table, we will be getting a response and a ! 1031: // length byte for it. Finish the transmit handshake and set up ! 1032: case kPMUreadLen_cmd: // a receive for the length byte. ! 1033: pmu->receivedByte = *(pmu->VIA1_shift); // read shift reg to turn off SR int ! 1034: pmu->PGE_ISR_state = kPMUrcvLen_cmd; ! 1035: *(pmu->VIA1_auxillaryControl) &= 0xEF; // set shift register to input ! 1036: while ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 1037: } ! 1038: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 1039: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1040: return; // next interrupt will be the length byte ! 1041: ! 1042: case kPMUrcvLen_cmd: // the length byte has arrived, read it and start data read ! 1043: pmu->charCountR = *(pmu->VIA1_shift); // read it ! 1044: pmu->charCountR2 = pmu->charCountR; ! 1045: pmu->PGE_ISR_state = kPMUrcvData_cmd; ! 1046: if ( pmu->charCountR2 > 0 ) { // is there anything to read? ! 1047: if ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 1048: if ( !(pmu->WaitForAckHi()) ) { ! 1049: return; // yes, make sure ACK is high ! 1050: } ! 1051: } ! 1052: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 1053: return; // next interrupt will be first data byte ! 1054: } ! 1055: pmu->clientRequest->pmRLength = pmu->charCountR; // no, this much was read ! 1056: pmu->cmdDoneEventSrc->interruptOccurred(0,0,0); // inform workloop ! 1057: return; ! 1058: // We have finished the transmission part of a command transaction, and ! 1059: // according to our table, we will be getting a response but not a ! 1060: // length byte for it. Finish the transmit handshake and set up ! 1061: case kPMUreadData: // a receive for the first data byte. ! 1062: if ( pmu->charCountR > 1 ) { ! 1063: pmu->charCountR2--; // make constant (byte count + 1) into byte count ! 1064: pmu->charCountR--; ! 1065: } ! 1066: // receivedByte = *VIA1_shift; // read shift reg to turn off SR int ! 1067: pmu->PGE_ISR_state = kPMUrcvData_cmd; ! 1068: *(pmu->VIA1_auxillaryControl) &= 0xEF; // set shift register to input ! 1069: if ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 1070: if ( !(pmu->WaitForAckHi()) ) { ! 1071: return; // make sure ACK is high ! 1072: } ! 1073: } ! 1074: *(pmu->VIA2_dataB) &= ~(pmu->PMreq);// assert /REQ ! 1075: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1076: return; // next interrupt will be the first data character ! 1077: ! 1078: // We are reading the response in a command transaction, and ! 1079: case kPMUrcvData_cmd: // a data byte has arrived ! 1080: *(pmu->dataPointer)++ = *(pmu->VIA1_shift); // read the data byte ! 1081: pmu->charCountR2--; ! 1082: if ( pmu->charCountR2 > 0 ) { // is there more to read? ! 1083: if ( !(*(pmu->VIA2_dataB) & pmu->PMack) ) { ! 1084: if ( !(pmu->WaitForAckHi()) ) { ! 1085: return; // yes, make sure ACK is high ! 1086: } ! 1087: } ! 1088: *(pmu->VIA2_dataB) &= ~(pmu->PMreq); // assert /REQ ! 1089: return; // next interrupt will be next data byte ! 1090: } ! 1091: pmu->clientRequest->pmRLength = pmu->charCountR; // no, this much was read ! 1092: pmu->cmdDoneEventSrc->interruptOccurred(0,0,0); // inform workloop ! 1093: return; ! 1094: ! 1095: case kPMUdone: // this was the last xmt SR interrupt of a command transaction ! 1096: // receivedByte = *VIA1_shift; // read shift reg to turn off SR int ! 1097: pmu->clientRequest->pmRLength = 0; // nothing was read ! 1098: pmu->cmdDoneEventSrc->interruptOccurred(0,0,0); // inform workloop ! 1099: return; ! 1100: } ! 1101: return; ! 1102: } ! 1103: ! 1104: ! 1105: // **************************************************************************** ! 1106: // PMUint ! 1107: // ! 1108: // **************************************************************************** ! 1109: ! 1110: void PMUint ( OSObject * PMUdriver, IOInterruptEventSource *, int ) ! 1111: { ! 1112: ((ApplePMU *)PMUdriver)->servicePMU(); ! 1113: } ! 1114: ! 1115: ! 1116: // **************************************************************************** ! 1117: // servicePMU ! 1118: // PGE has interrupted. Send the ReadInt command to find out why. ! 1119: // When the command byte is sent, the Shift Register will interrupt. ! 1120: // If we are mid-transaction when we find out about the interrupt, ! 1121: // set a flag and find out why later. ! 1122: // ! 1123: // **************************************************************************** ! 1124: ! 1125: void ApplePMU::servicePMU ( void ) ! 1126: { ! 1127: if ( PGE_ISR_state != kPMUidle ) { ! 1128: PMU_int_pending = true; ! 1129: return; ! 1130: } ! 1131: ! 1132: // *VIA1_interruptFlag = 0x10; // acknowledge VIA interrupt ( ifCB1 ) ! 1133: // *VIA1_interruptEnable = 0x10; // and disable it entirely ( ifCB1 ) ! 1134: while ( !(*VIA2_dataB & PMack) ) { // make sure ACK is high ! 1135: } ! 1136: *VIA1_auxillaryControl |= 0x1C; // set shift register to output ! 1137: *VIA1_shift = kPMUreadINT; // give it this command byte ! 1138: *VIA2_dataB &= ~PMreq; // assert /REQ ! 1139: // *VIA1_interruptEnable = 0x84; // enable SR interrupt ! 1140: PGE_ISR_state = kPMUreadLen_int; // set the state ! 1141: dataPointer = &interruptState[0]; // set up read pointer for data bytes ! 1142: return; // return till character transmission completes ! 1143: } ! 1144: ! 1145: ! 1146: // **************************************************************************** ! 1147: // WaitForAckHi ! 1148: // **************************************************************************** ! 1149: bool ApplePMU::WaitForAckHi ( void ) ! 1150: { ! 1151: // q8q struct timeval startTime; ! 1152: // q8q struct timeval currentTime; ! 1153: // q8q ns_time_t x; ! 1154: ! 1155: // wait up to 32 milliseconds for Ack signal from PG&E to go high ! 1156: ! 1157: // q8q IOGetTimestamp(&x); ! 1158: // q8q ns_time_to_timeval(x, &startTime); // get current time ! 1159: ! 1160: while ( true ) { ! 1161: if ( *VIA2_dataB & PMack ) { ! 1162: return ( true ); // ack is high, return ! 1163: } ! 1164: // q8q IOGetTimestamp(&x); ! 1165: // q8q ns_time_to_timeval(x, ¤tTime); ! 1166: // q8q if ( startTime.tv_usec > currentTime.tv_usec ) { ! 1167: // q8q currentTime.tv_usec += 1000000; // clock has wrapped, adjust it ! 1168: // q8q } ! 1169: // q8q if ( currentTime.tv_usec > (startTime.tv_usec + 32000) ) { // has 32 ms elapsed? ! 1170: // q8q return ( false ); // yes, return ! 1171: // q8q } ! 1172: } ! 1173: } ! 1174: ! 1175: ! 1176: // **************************************************************************** ! 1177: // DisablePMUInterrupt ! 1178: // **************************************************************************** ! 1179: void ApplePMU::DisablePMUInterrupt ( void ) ! 1180: { ! 1181: *VIA1_interruptEnable = 1<<ifCB1; ! 1182: eieio(); ! 1183: } ! 1184: ! 1185: ! 1186: // **************************************************************************** ! 1187: // EnablePMUInterrupt ! 1188: // **************************************************************************** ! 1189: void ApplePMU::EnablePMUInterrupt ( void ) ! 1190: { ! 1191: *VIA1_interruptEnable = (1<<ifCB1) | 0x80; ! 1192: eieio(); ! 1193: } ! 1194: ! 1195: ! 1196: // **************************************************************************** ! 1197: // AcknowledgePMUInterrupt ! 1198: // **************************************************************************** ! 1199: void ApplePMU::AcknowledgePMUInterrupt ( void ) ! 1200: { ! 1201: *VIA1_interruptFlag = 1<<ifCB1; ! 1202: eieio(); ! 1203: } ! 1204: ! 1205: ! 1206: // **************************************************************************** ! 1207: // DisableSRInterrupt ! 1208: // **************************************************************************** ! 1209: void ApplePMU::DisableSRInterrupt ( void ) ! 1210: { ! 1211: *VIA1_interruptEnable = 1<<ifSR; ! 1212: } ! 1213: ! 1214: ! 1215: // **************************************************************************** ! 1216: // EnableSRInterrupt ! 1217: // **************************************************************************** ! 1218: void ApplePMU::EnableSRInterrupt ( void ) ! 1219: { ! 1220: *VIA1_interruptEnable = (1<<ifSR) | 0x80; ! 1221: } ! 1222: ! 1223: ! 1224: ! 1225: // **************************************************************************** ! 1226: // timer_expired ! 1227: // ! 1228: // Our adb-read timer has expired, so we have to notify our i/o thread by ! 1229: // enqueuing a Timeout message to its interrupt port. ! 1230: // **************************************************************************** ! 1231: // q8q void timer_expired(port_t mach_port) ! 1232: // q8q { ! 1233: ! 1234: // q8q }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.