X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/3e170ce000f1506b7b5d2c5c7faec85ceabb573d..94ff46dc2849db4d43eaaf144872decc522aafb4:/iokit/Kernel/IOServicePM.cpp diff --git a/iokit/Kernel/IOServicePM.cpp b/iokit/Kernel/IOServicePM.cpp index 30612ce42..5cdc56a78 100644 --- a/iokit/Kernel/IOServicePM.cpp +++ b/iokit/Kernel/IOServicePM.cpp @@ -1,8 +1,8 @@ /* - * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved. + * Copyright (c) 1998-2016 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ - * + * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in @@ -11,10 +11,10 @@ * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. - * + * * Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this file. - * + * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, @@ -22,7 +22,7 @@ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. - * + * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ @@ -37,6 +37,7 @@ #include #include #include +#include #include #include @@ -62,15 +63,16 @@ static void idle_timer_expired(thread_call_param_t, thread_call_param_t); static void tellKernelClientApplier(OSObject * object, void * arg); static void tellAppClientApplier(OSObject * object, void * arg); -static uint64_t computeTimeDeltaNS( const AbsoluteTime * start ) +static uint64_t +computeTimeDeltaNS( const AbsoluteTime * start ) { - AbsoluteTime now; - uint64_t nsec; + AbsoluteTime now; + uint64_t nsec; - clock_get_uptime(&now); - SUB_ABSOLUTETIME(&now, start); - absolutetime_to_nanoseconds(now, &nsec); - return nsec; + clock_get_uptime(&now); + SUB_ABSOLUTETIME(&now, start); + absolutetime_to_nanoseconds(now, &nsec); + return nsec; } #if PM_VARS_SUPPORT @@ -85,57 +87,46 @@ static bool gIOPMInitialized = false; static uint32_t gIOPMBusyRequestCount = 0; static uint32_t gIOPMWorkInvokeCount = 0; static uint32_t gIOPMTickleGeneration = 0; -static IOWorkLoop * gIOPMWorkLoop = 0; -static IOPMRequestQueue * gIOPMRequestQueue = 0; -static IOPMRequestQueue * gIOPMReplyQueue = 0; -static IOPMWorkQueue * gIOPMWorkQueue = 0; -static IOPMCompletionQueue * gIOPMCompletionQueue = 0; -static IOPMRequest * gIOPMRequest = 0; -static IOService * gIOPMRootNode = 0; -static IOPlatformExpert * gPlatform = 0; - -static char gIOSpinDumpKextName[128]; -static char gIOSpinDumpDelayType[16]; -static uint32_t gIOSpinDumpDelayDuration = 0; - -static SYSCTL_STRING(_debug, OID_AUTO, swd_kext_name, - CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED, - &gIOSpinDumpKextName, sizeof(gIOSpinDumpKextName), ""); -static SYSCTL_STRING(_debug, OID_AUTO, swd_delay_type, - CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED, - &gIOSpinDumpDelayType, sizeof(gIOSpinDumpDelayType), ""); -static SYSCTL_INT(_debug, OID_AUTO, swd_delay_duration, - CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED, - &gIOSpinDumpDelayDuration, 0, ""); - -const OSSymbol * gIOPMPowerClientDevice = 0; -const OSSymbol * gIOPMPowerClientDriver = 0; -const OSSymbol * gIOPMPowerClientChildProxy = 0; -const OSSymbol * gIOPMPowerClientChildren = 0; -const OSSymbol * gIOPMPowerClientRootDomain = 0; - -static const OSSymbol * gIOPMPowerClientAdvisoryTickle = 0; +static IOWorkLoop * gIOPMWorkLoop = NULL; +static IOPMRequestQueue * gIOPMRequestQueue = NULL; +static IOPMRequestQueue * gIOPMReplyQueue = NULL; +static IOPMWorkQueue * gIOPMWorkQueue = NULL; +static IOPMCompletionQueue * gIOPMCompletionQueue = NULL; +static IOPMRequest * gIOPMRequest = NULL; +static IOService * gIOPMRootNode = NULL; +static IOPlatformExpert * gPlatform = NULL; + + +const OSSymbol * gIOPMPowerClientDevice = NULL; +const OSSymbol * gIOPMPowerClientDriver = NULL; +const OSSymbol * gIOPMPowerClientChildProxy = NULL; +const OSSymbol * gIOPMPowerClientChildren = NULL; +const OSSymbol * gIOPMPowerClientRootDomain = NULL; + +static const OSSymbol * gIOPMPowerClientAdvisoryTickle = NULL; static bool gIOPMAdvisoryTickleEnabled = true; static thread_t gIOPMWatchDogThread = NULL; uint32_t gCanSleepTimeout = 0; -static uint32_t getPMRequestType( void ) +static uint32_t +getPMRequestType( void ) { - uint32_t type = kIOPMRequestTypeInvalid; - if (gIOPMRequest) - type = gIOPMRequest->getType(); - return type; + uint32_t type = kIOPMRequestTypeInvalid; + if (gIOPMRequest) { + type = gIOPMRequest->getType(); + } + return type; } -static IOPMRequestTag getPMRequestTag( void ) +static IOPMRequestTag +getPMRequestTag( void ) { - IOPMRequestTag tag = 0; - if (gIOPMRequest && - (gIOPMRequest->getType() == kIOPMRequestTypeRequestPowerStateOverride)) - { - tag = gIOPMRequest->fRequestTag; - } - return tag; + IOPMRequestTag tag = 0; + if (gIOPMRequest && + (gIOPMRequest->getType() == kIOPMRequestTypeRequestPowerStateOverride)) { + tag = gIOPMRequest->fRequestTag; + } + return tag; } SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gCanSleepTimeout, 0, "Power Management Timeout"); @@ -145,16 +136,16 @@ SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gCanSleepT //****************************************************************************** #define PM_ERROR(x...) do { kprintf(x);IOLog(x); \ - } while (false) + } while (false) #define PM_LOG(x...) do { kprintf(x); } while (false) #define PM_LOG1(x...) do { \ - if (kIOLogDebugPower & gIOKitDebug) \ - kprintf(x); } while (false) + if (kIOLogDebugPower & gIOKitDebug) \ + kprintf(x); } while (false) #define PM_LOG2(x...) do { \ - if (kIOLogDebugPower & gIOKitDebug) \ - kprintf(x); } while (false) + if (kIOLogDebugPower & gIOKitDebug) \ + kprintf(x); } while (false) #if 0 #define PM_LOG3(x...) do { kprintf(x); } while (false) @@ -163,10 +154,10 @@ SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gCanSleepT #endif #define RD_LOG(x...) do { \ - if ((kIOLogPMRootDomain & gIOKitDebug) && \ - (getPMRootDomain() == this)) { \ - kprintf("PMRD: " x); \ - }} while (false) + if ((kIOLogPMRootDomain & gIOKitDebug) && \ + (getPMRootDomain() == this)) { \ + kprintf("PMRD: " x); \ + }} while (false) #define PM_ASSERT_IN_GATE(x) \ do { \ assert(gIOPMWorkLoop->inGate()); \ @@ -181,18 +172,42 @@ do { \ #define ns_per_us 1000 #define k30Seconds (30*us_per_s) #define k5Seconds ( 5*us_per_s) +#if CONFIG_EMBEDDED +#define kCanSleepMaxTimeReq k5Seconds +#else #define kCanSleepMaxTimeReq k30Seconds +#endif #define kMaxTimeRequested k30Seconds #define kMinAckTimeoutTicks (10*1000000) #define kIOPMTardyAckSPSKey "IOPMTardyAckSetPowerState" #define kIOPMTardyAckPSCKey "IOPMTardyAckPowerStateChange" #define kPwrMgtKey "IOPowerManagement" -#define OUR_PMLog(t, a, b) do { \ - if (gIOKitDebug & kIOLogPower) \ - pwrMgt->pmPrint(t, a, b); \ - if (gIOKitTrace & kIOTracePowerMgmt) \ - pwrMgt->pmTrace(t, a, b); \ +#define OUR_PMLog(t, a, b) do { \ + if (pwrMgt) { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, DBG_FUNC_NONE, a, b); \ + } \ + } while(0) + +#define OUR_PMLogFuncStart(t, a, b) do { \ + if (pwrMgt) { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, DBG_FUNC_START, a, b); \ + } \ + } while(0) + +#define OUR_PMLogFuncEnd(t, a, b) do { \ + if (pwrMgt) { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(-t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, DBG_FUNC_END, a, b); \ + } \ } while(0) #define NS_TO_MS(nsec) ((int)((nsec) / 1000000ULL)) @@ -221,44 +236,47 @@ do { \ // use message tracer to log messages longer than (ns): #define LOG_APP_RESPONSE_MSG_TRACER (3 * 1000ULL * 1000ULL * 1000ULL) +// log kext responses longer than (ns): +#define LOG_KEXT_RESPONSE_TIMES (100ULL * 1000ULL * 1000ULL) + enum { - kReserveDomainPower = 1 + kReserveDomainPower = 1 }; #define MS_PUSH(n) \ do { assert(kIOPM_BadMachineState == fSavedMachineState); \ - assert(kIOPM_BadMachineState != n); \ - fSavedMachineState = n; } while (false) + assert(kIOPM_BadMachineState != n); \ + fSavedMachineState = n; } while (false) #define MS_POP() \ do { assert(kIOPM_BadMachineState != fSavedMachineState); \ - fMachineState = fSavedMachineState; \ - fSavedMachineState = kIOPM_BadMachineState; } while (false) + fMachineState = fSavedMachineState; \ + fSavedMachineState = kIOPM_BadMachineState; } while (false) #define PM_ACTION_0(a) \ do { if (fPMActions.a) { \ - (fPMActions.a)(fPMActions.target, this, &fPMActions); } \ - } while (false) + (fPMActions.a)(fPMActions.target, this, &fPMActions); } \ + } while (false) #define PM_ACTION_2(a, x, y) \ do { if (fPMActions.a) { \ - (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y, \ - getPMRequestTag()); } \ - } while (false) + (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y, \ + getPMRequestTag()); } \ + } while (false) #define PM_ACTION_3(a, x, y, z) \ do { if (fPMActions.a) { \ - (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y, z); } \ - } while (false) + (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y, z); } \ + } while (false) static OSNumber * copyClientIDForNotification( - OSObject *object, - IOPMInterestContext *context); + OSObject *object, + IOPMInterestContext *context); static void logClientIDForNotification( - OSObject *object, - IOPMInterestContext *context, - const char *logString); + OSObject *object, + IOPMInterestContext *context, + const char *logString); //********************************************************************************* // PM machine states @@ -267,39 +285,39 @@ static void logClientIDForNotification( //********************************************************************************* enum { - kIOPM_Finished = 0, - - kIOPM_OurChangeTellClientsPowerDown = 1, - kIOPM_OurChangeTellUserPMPolicyPowerDown = 2, - kIOPM_OurChangeTellPriorityClientsPowerDown = 3, - kIOPM_OurChangeNotifyInterestedDriversWillChange = 4, - kIOPM_OurChangeSetPowerState = 5, - kIOPM_OurChangeWaitForPowerSettle = 6, - kIOPM_OurChangeNotifyInterestedDriversDidChange = 7, - kIOPM_OurChangeTellCapabilityDidChange = 8, - kIOPM_OurChangeFinish = 9, - - kIOPM_ParentChangeTellPriorityClientsPowerDown = 10, - kIOPM_ParentChangeNotifyInterestedDriversWillChange = 11, - kIOPM_ParentChangeSetPowerState = 12, - kIOPM_ParentChangeWaitForPowerSettle = 13, - kIOPM_ParentChangeNotifyInterestedDriversDidChange = 14, - kIOPM_ParentChangeTellCapabilityDidChange = 15, - kIOPM_ParentChangeAcknowledgePowerChange = 16, - - kIOPM_NotifyChildrenStart = 17, - kIOPM_NotifyChildrenOrdered = 18, - kIOPM_NotifyChildrenDelayed = 19, - kIOPM_SyncTellClientsPowerDown = 20, - kIOPM_SyncTellPriorityClientsPowerDown = 21, - kIOPM_SyncNotifyWillChange = 22, - kIOPM_SyncNotifyDidChange = 23, - kIOPM_SyncTellCapabilityDidChange = 24, - kIOPM_SyncFinish = 25, - kIOPM_TellCapabilityChangeDone = 26, - kIOPM_DriverThreadCallDone = 27, - - kIOPM_BadMachineState = 0xFFFFFFFF + kIOPM_Finished = 0, + + kIOPM_OurChangeTellClientsPowerDown = 1, + kIOPM_OurChangeTellUserPMPolicyPowerDown = 2, + kIOPM_OurChangeTellPriorityClientsPowerDown = 3, + kIOPM_OurChangeNotifyInterestedDriversWillChange = 4, + kIOPM_OurChangeSetPowerState = 5, + kIOPM_OurChangeWaitForPowerSettle = 6, + kIOPM_OurChangeNotifyInterestedDriversDidChange = 7, + kIOPM_OurChangeTellCapabilityDidChange = 8, + kIOPM_OurChangeFinish = 9, + + kIOPM_ParentChangeTellPriorityClientsPowerDown = 10, + kIOPM_ParentChangeNotifyInterestedDriversWillChange = 11, + kIOPM_ParentChangeSetPowerState = 12, + kIOPM_ParentChangeWaitForPowerSettle = 13, + kIOPM_ParentChangeNotifyInterestedDriversDidChange = 14, + kIOPM_ParentChangeTellCapabilityDidChange = 15, + kIOPM_ParentChangeAcknowledgePowerChange = 16, + + kIOPM_NotifyChildrenStart = 17, + kIOPM_NotifyChildrenOrdered = 18, + kIOPM_NotifyChildrenDelayed = 19, + kIOPM_SyncTellClientsPowerDown = 20, + kIOPM_SyncTellPriorityClientsPowerDown = 21, + kIOPM_SyncNotifyWillChange = 22, + kIOPM_SyncNotifyDidChange = 23, + kIOPM_SyncTellCapabilityDidChange = 24, + kIOPM_SyncFinish = 25, + kIOPM_TellCapabilityChangeDone = 26, + kIOPM_DriverThreadCallDone = 27, + + kIOPM_BadMachineState = 0xFFFFFFFF }; //********************************************************************************* @@ -308,187 +326,172 @@ enum { // Initialize power management. //********************************************************************************* -void IOService::PMinit( void ) -{ - if ( !initialized ) - { - if ( !gIOPMInitialized ) - { - gPlatform = getPlatform(); - gIOPMWorkLoop = IOWorkLoop::workLoop(); - if (gIOPMWorkLoop) - { - gIOPMRequestQueue = IOPMRequestQueue::create( - this, OSMemberFunctionCast(IOPMRequestQueue::Action, - this, &IOService::actionPMRequestQueue)); - - gIOPMReplyQueue = IOPMRequestQueue::create( - this, OSMemberFunctionCast(IOPMRequestQueue::Action, - this, &IOService::actionPMReplyQueue)); - - gIOPMWorkQueue = IOPMWorkQueue::create(this, - OSMemberFunctionCast(IOPMWorkQueue::Action, this, - &IOService::actionPMWorkQueueInvoke), - OSMemberFunctionCast(IOPMWorkQueue::Action, this, - &IOService::actionPMWorkQueueRetire)); - - gIOPMCompletionQueue = IOPMCompletionQueue::create( - this, OSMemberFunctionCast(IOPMCompletionQueue::Action, - this, &IOService::actionPMCompletionQueue)); - - if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) != - kIOReturnSuccess) - { - gIOPMRequestQueue->release(); - gIOPMRequestQueue = 0; - } - - if (gIOPMWorkLoop->addEventSource(gIOPMReplyQueue) != - kIOReturnSuccess) - { - gIOPMReplyQueue->release(); - gIOPMReplyQueue = 0; - } - - if (gIOPMWorkLoop->addEventSource(gIOPMWorkQueue) != - kIOReturnSuccess) - { - gIOPMWorkQueue->release(); - gIOPMWorkQueue = 0; - } - - // Must be added after the work queue, which pushes request - // to the completion queue without signaling the work loop. - if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) != - kIOReturnSuccess) - { - gIOPMCompletionQueue->release(); - gIOPMCompletionQueue = 0; - } - - gIOPMPowerClientDevice = - OSSymbol::withCStringNoCopy( "DevicePowerState" ); - - gIOPMPowerClientDriver = - OSSymbol::withCStringNoCopy( "DriverPowerState" ); - - gIOPMPowerClientChildProxy = - OSSymbol::withCStringNoCopy( "ChildProxyPowerState" ); - - gIOPMPowerClientChildren = - OSSymbol::withCStringNoCopy( "ChildrenPowerState" ); - - gIOPMPowerClientAdvisoryTickle = - OSSymbol::withCStringNoCopy( "AdvisoryTicklePowerState" ); - - gIOPMPowerClientRootDomain = - OSSymbol::withCStringNoCopy( "RootDomainPower" ); - - gIOSpinDumpKextName[0] = '\0'; - gIOSpinDumpDelayType[0] = '\0'; - } - - if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue) - gIOPMInitialized = true; - } - if (!gIOPMInitialized) - return; - - pwrMgt = new IOServicePM; - pwrMgt->init(); - setProperty(kPwrMgtKey, pwrMgt); - - queue_init(&pwrMgt->WorkChain); - queue_init(&pwrMgt->RequestHead); - queue_init(&pwrMgt->PMDriverCallQueue); - - fOwner = this; - fPMLock = IOLockAlloc(); - fInterestedDrivers = new IOPMinformeeList; - fInterestedDrivers->initialize(); - fDesiredPowerState = kPowerStateZero; - fDeviceDesire = kPowerStateZero; - fInitialPowerChange = true; - fInitialSetPowerState = true; - fPreviousRequestPowerFlags = 0; - fDeviceOverrideEnabled = false; - fMachineState = kIOPM_Finished; - fSavedMachineState = kIOPM_BadMachineState; - fIdleTimerMinPowerState = kPowerStateZero; - fActivityLock = IOLockAlloc(); - fStrictTreeOrder = false; - fActivityTicklePowerState = kInvalidTicklePowerState; - fAdvisoryTicklePowerState = kInvalidTicklePowerState; - fControllingDriver = NULL; - fPowerStates = NULL; - fNumberOfPowerStates = 0; - fCurrentPowerState = kPowerStateZero; - fParentsCurrentPowerFlags = 0; - fMaxPowerState = kPowerStateZero; - fName = getName(); - fParentsKnowState = false; - fSerialNumber = 0; - fResponseArray = NULL; - fNotifyClientArray = NULL; - fCurrentPowerConsumption = kIOPMUnknown; - fOverrideMaxPowerState = kIOPMPowerStateMax; - - if (!gIOPMRootNode && (getParentEntry(gIOPowerPlane) == getRegistryRoot())) - { - gIOPMRootNode = this; - fParentsKnowState = true; - } - else if (getProperty(kIOPMResetPowerStateOnWakeKey) == kOSBooleanTrue) - { - fResetPowerStateOnWake = true; - } - - if (IS_ROOT_DOMAIN) - { - fWatchdogTimer = thread_call_allocate( - &IOService::watchdog_timer_expired, (thread_call_param_t)this); - } - - fAckTimer = thread_call_allocate( - &IOService::ack_timer_expired, (thread_call_param_t)this); - fSettleTimer = thread_call_allocate( - &settle_timer_expired, (thread_call_param_t)this); - fIdleTimer = thread_call_allocate( - &idle_timer_expired, (thread_call_param_t)this); - fDriverCallEntry = thread_call_allocate( - (thread_call_func_t) &IOService::pmDriverCallout, this); - assert(fDriverCallEntry); - if (kIOKextSpinDump & gIOKitDebug) - { - fSpinDumpTimer = thread_call_allocate( - &IOService::spindump_timer_expired, (thread_call_param_t)this); - } - - // Check for powerChangeDone override. - if (OSMemberFunctionCast(void (*)(void), - getResourceService(), &IOService::powerChangeDone) != - OSMemberFunctionCast(void (*)(void), - this, &IOService::powerChangeDone)) - { - fPCDFunctionOverride = true; - } +void +IOService::PMinit( void ) +{ + if (!initialized) { + if (!gIOPMInitialized) { + gPlatform = getPlatform(); + gIOPMWorkLoop = IOWorkLoop::workLoop(); + if (gIOPMWorkLoop) { + gIOPMRequestQueue = IOPMRequestQueue::create( + this, OSMemberFunctionCast(IOPMRequestQueue::Action, + this, &IOService::actionPMRequestQueue)); + + gIOPMReplyQueue = IOPMRequestQueue::create( + this, OSMemberFunctionCast(IOPMRequestQueue::Action, + this, &IOService::actionPMReplyQueue)); + + gIOPMWorkQueue = IOPMWorkQueue::create(this, + OSMemberFunctionCast(IOPMWorkQueue::Action, this, + &IOService::actionPMWorkQueueInvoke), + OSMemberFunctionCast(IOPMWorkQueue::Action, this, + &IOService::actionPMWorkQueueRetire)); + + gIOPMCompletionQueue = IOPMCompletionQueue::create( + this, OSMemberFunctionCast(IOPMCompletionQueue::Action, + this, &IOService::actionPMCompletionQueue)); + + if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) != + kIOReturnSuccess) { + gIOPMRequestQueue->release(); + gIOPMRequestQueue = NULL; + } + + if (gIOPMWorkLoop->addEventSource(gIOPMReplyQueue) != + kIOReturnSuccess) { + gIOPMReplyQueue->release(); + gIOPMReplyQueue = NULL; + } + + if (gIOPMWorkLoop->addEventSource(gIOPMWorkQueue) != + kIOReturnSuccess) { + gIOPMWorkQueue->release(); + gIOPMWorkQueue = NULL; + } + + // Must be added after the work queue, which pushes request + // to the completion queue without signaling the work loop. + if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) != + kIOReturnSuccess) { + gIOPMCompletionQueue->release(); + gIOPMCompletionQueue = NULL; + } + + gIOPMPowerClientDevice = + OSSymbol::withCStringNoCopy( "DevicePowerState" ); + + gIOPMPowerClientDriver = + OSSymbol::withCStringNoCopy( "DriverPowerState" ); + + gIOPMPowerClientChildProxy = + OSSymbol::withCStringNoCopy( "ChildProxyPowerState" ); + + gIOPMPowerClientChildren = + OSSymbol::withCStringNoCopy( "ChildrenPowerState" ); + + gIOPMPowerClientAdvisoryTickle = + OSSymbol::withCStringNoCopy( "AdvisoryTicklePowerState" ); + + gIOPMPowerClientRootDomain = + OSSymbol::withCStringNoCopy( "RootDomainPower" ); + } + + if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue) { + gIOPMInitialized = true; + } + } + if (!gIOPMInitialized) { + return; + } + + pwrMgt = new IOServicePM; + pwrMgt->init(); + setProperty(kPwrMgtKey, pwrMgt); + + queue_init(&pwrMgt->WorkChain); + queue_init(&pwrMgt->RequestHead); + queue_init(&pwrMgt->PMDriverCallQueue); + + fOwner = this; + fPMLock = IOLockAlloc(); + fInterestedDrivers = new IOPMinformeeList; + fInterestedDrivers->initialize(); + fDesiredPowerState = kPowerStateZero; + fDeviceDesire = kPowerStateZero; + fInitialPowerChange = true; + fInitialSetPowerState = true; + fPreviousRequestPowerFlags = 0; + fDeviceOverrideEnabled = false; + fMachineState = kIOPM_Finished; + fSavedMachineState = kIOPM_BadMachineState; + fIdleTimerMinPowerState = kPowerStateZero; + fActivityLock = IOLockAlloc(); + fStrictTreeOrder = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + fAdvisoryTicklePowerState = kInvalidTicklePowerState; + fControllingDriver = NULL; + fPowerStates = NULL; + fNumberOfPowerStates = 0; + fCurrentPowerState = kPowerStateZero; + fParentsCurrentPowerFlags = 0; + fMaxPowerState = kPowerStateZero; + fName = getName(); + fParentsKnowState = false; + fSerialNumber = 0; + fResponseArray = NULL; + fNotifyClientArray = NULL; + fCurrentPowerConsumption = kIOPMUnknown; + fOverrideMaxPowerState = kIOPMPowerStateMax; + + if (!gIOPMRootNode && (getParentEntry(gIOPowerPlane) == getRegistryRoot())) { + gIOPMRootNode = this; + fParentsKnowState = true; + } else if (getProperty(kIOPMResetPowerStateOnWakeKey) == kOSBooleanTrue) { + fResetPowerStateOnWake = true; + } + + if (IS_ROOT_DOMAIN) { + fWatchdogTimer = thread_call_allocate( + &IOService::watchdog_timer_expired, (thread_call_param_t)this); + fWatchdogLock = IOLockAlloc(); + + fBlockedArray = OSArray::withCapacity(4); + } + + fAckTimer = thread_call_allocate( + &IOService::ack_timer_expired, (thread_call_param_t)this); + fSettleTimer = thread_call_allocate( + &settle_timer_expired, (thread_call_param_t)this); + fIdleTimer = thread_call_allocate( + &idle_timer_expired, (thread_call_param_t)this); + fDriverCallEntry = thread_call_allocate( + (thread_call_func_t) &IOService::pmDriverCallout, this); + assert(fDriverCallEntry); + + // Check for powerChangeDone override. + if (OSMemberFunctionCast(void (*)(void), + getResourceService(), &IOService::powerChangeDone) != + OSMemberFunctionCast(void (*)(void), + this, &IOService::powerChangeDone)) { + fPCDFunctionOverride = true; + } #if PM_VARS_SUPPORT - IOPMprot * prot = new IOPMprot; - if (prot) - { - prot->init(); - prot->ourName = fName; - prot->thePlatform = gPlatform; - fPMVars = prot; - pm_vars = prot; - } + IOPMprot * prot = new IOPMprot; + if (prot) { + prot->init(); + prot->ourName = fName; + prot->thePlatform = gPlatform; + fPMVars = prot; + pm_vars = prot; + } #else - pm_vars = (void *) (uintptr_t) true; + pm_vars = (void *) (uintptr_t) true; #endif - initialized = true; - } + initialized = true; + } } //********************************************************************************* @@ -497,101 +500,106 @@ void IOService::PMinit( void ) // Free the data created by PMinit. Only called from IOService::free(). //********************************************************************************* -void IOService::PMfree( void ) -{ - initialized = false; - pm_vars = 0; - - if ( pwrMgt ) - { - assert(fMachineState == kIOPM_Finished); - assert(fInsertInterestSet == NULL); - assert(fRemoveInterestSet == NULL); - assert(fNotifyChildArray == NULL); - assert(queue_empty(&pwrMgt->RequestHead)); - assert(queue_empty(&fPMDriverCallQueue)); - - if (fWatchdogTimer) { - thread_call_cancel(fWatchdogTimer); - thread_call_free(fWatchdogTimer); - fWatchdogTimer = NULL; - } - - if ( fSettleTimer ) { - thread_call_cancel(fSettleTimer); - thread_call_free(fSettleTimer); - fSettleTimer = NULL; - } - if ( fAckTimer ) { - thread_call_cancel(fAckTimer); - thread_call_free(fAckTimer); - fAckTimer = NULL; - } - if ( fIdleTimer ) { - thread_call_cancel(fIdleTimer); - thread_call_free(fIdleTimer); - fIdleTimer = NULL; - } - if ( fDriverCallEntry ) { - thread_call_free(fDriverCallEntry); - fDriverCallEntry = NULL; - } - if ( fSpinDumpTimer ) { - thread_call_cancel(fSpinDumpTimer); - thread_call_free(fSpinDumpTimer); - fSpinDumpTimer = NULL; - } - if ( fPMLock ) { - IOLockFree(fPMLock); - fPMLock = NULL; - } - if ( fActivityLock ) { - IOLockFree(fActivityLock); - fActivityLock = NULL; - } - if ( fInterestedDrivers ) { - fInterestedDrivers->release(); - fInterestedDrivers = NULL; - } - if (fDriverCallParamSlots && fDriverCallParamPtr) { - IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots); - fDriverCallParamPtr = 0; - fDriverCallParamSlots = 0; - } - if ( fResponseArray ) { - fResponseArray->release(); - fResponseArray = NULL; - } - if ( fNotifyClientArray ) { - fNotifyClientArray->release(); - fNotifyClientArray = NULL; - } - if (fPowerStates && fNumberOfPowerStates) { - IODelete(fPowerStates, IOPMPSEntry, fNumberOfPowerStates); - fNumberOfPowerStates = 0; - fPowerStates = NULL; - } - if (fPowerClients) { - fPowerClients->release(); - fPowerClients = 0; - } +void +IOService::PMfree( void ) +{ + initialized = false; + pm_vars = NULL; + + if (pwrMgt) { + assert(fMachineState == kIOPM_Finished); + assert(fInsertInterestSet == NULL); + assert(fRemoveInterestSet == NULL); + assert(fNotifyChildArray == NULL); + assert(queue_empty(&pwrMgt->RequestHead)); + assert(queue_empty(&fPMDriverCallQueue)); + + if (fWatchdogTimer) { + thread_call_cancel(fWatchdogTimer); + thread_call_free(fWatchdogTimer); + fWatchdogTimer = NULL; + } + + if (fWatchdogLock) { + IOLockFree(fWatchdogLock); + fWatchdogLock = NULL; + } + + if (fBlockedArray) { + fBlockedArray->release(); + fBlockedArray = NULL; + } + + if (fSettleTimer) { + thread_call_cancel(fSettleTimer); + thread_call_free(fSettleTimer); + fSettleTimer = NULL; + } + if (fAckTimer) { + thread_call_cancel(fAckTimer); + thread_call_free(fAckTimer); + fAckTimer = NULL; + } + if (fIdleTimer) { + thread_call_cancel(fIdleTimer); + thread_call_free(fIdleTimer); + fIdleTimer = NULL; + } + if (fDriverCallEntry) { + thread_call_free(fDriverCallEntry); + fDriverCallEntry = NULL; + } + if (fPMLock) { + IOLockFree(fPMLock); + fPMLock = NULL; + } + if (fActivityLock) { + IOLockFree(fActivityLock); + fActivityLock = NULL; + } + if (fInterestedDrivers) { + fInterestedDrivers->release(); + fInterestedDrivers = NULL; + } + if (fDriverCallParamSlots && fDriverCallParamPtr) { + IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots); + fDriverCallParamPtr = NULL; + fDriverCallParamSlots = 0; + } + if (fResponseArray) { + fResponseArray->release(); + fResponseArray = NULL; + } + if (fNotifyClientArray) { + fNotifyClientArray->release(); + fNotifyClientArray = NULL; + } + if (fPowerStates && fNumberOfPowerStates) { + IODelete(fPowerStates, IOPMPSEntry, fNumberOfPowerStates); + fNumberOfPowerStates = 0; + fPowerStates = NULL; + } + if (fPowerClients) { + fPowerClients->release(); + fPowerClients = NULL; + } #if PM_VARS_SUPPORT - if (fPMVars) - { - fPMVars->release(); - fPMVars = 0; - } + if (fPMVars) { + fPMVars->release(); + fPMVars = NULL; + } #endif - pwrMgt->release(); - pwrMgt = 0; - } + pwrMgt->release(); + pwrMgt = NULL; + } } -void IOService::PMDebug( uint32_t event, uintptr_t param1, uintptr_t param2 ) +void +IOService::PMDebug( uint32_t event, uintptr_t param1, uintptr_t param2 ) { - OUR_PMLog(event, param1, param2); + OUR_PMLog(event, param1, param2); } //********************************************************************************* @@ -607,13 +615,14 @@ void IOService::PMDebug( uint32_t event, uintptr_t param1, uintptr_t param2 ) // meaning it may not be initialized for power management. //********************************************************************************* -void IOService::joinPMtree( IOService * driver ) +void +IOService::joinPMtree( IOService * driver ) { - IOPlatformExpert * platform; + IOPlatformExpert * platform; - platform = getPlatform(); - assert(platform != 0); - platform->PMRegisterDevice(this, driver); + platform = getPlatform(); + assert(platform != NULL); + platform->PMRegisterDevice(this, driver); } #ifndef __LP64__ @@ -623,9 +632,10 @@ void IOService::joinPMtree( IOService * driver ) // Power Managment is informing us that we are the root power domain. //********************************************************************************* -IOReturn IOService::youAreRoot( void ) +IOReturn +IOService::youAreRoot( void ) { - return IOPMNoErr; + return IOPMNoErr; } #endif /* !__LP64__ */ @@ -636,37 +646,37 @@ IOReturn IOService::youAreRoot( void ) // from power plane. //********************************************************************************* -void IOService::PMstop( void ) +void +IOService::PMstop( void ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return; + if (!initialized) { + return; + } - PM_LOCK(); + PM_LOCK(); - if (fLockedFlags.PMStop) - { - PM_LOG2("%s: PMstop() already stopped\n", fName); - PM_UNLOCK(); - return; - } + if (fLockedFlags.PMStop) { + PM_LOG2("%s: PMstop() already stopped\n", fName); + PM_UNLOCK(); + return; + } - // Inhibit future driver calls. - fLockedFlags.PMStop = true; + // Inhibit future driver calls. + fLockedFlags.PMStop = true; - // Wait for all prior driver calls to finish. - waitForPMDriverCall(); + // Wait for all prior driver calls to finish. + waitForPMDriverCall(); - PM_UNLOCK(); + PM_UNLOCK(); - // The rest of the work is performed async. - request = acquirePMRequest( this, kIOPMRequestTypePMStop ); - if (request) - { - PM_LOG2("%s: %p PMstop\n", getName(), OBFUSCATE(this)); - submitPMRequest( request ); - } + // The rest of the work is performed async. + request = acquirePMRequest( this, kIOPMRequestTypePMStop ); + if (request) { + PM_LOG2("%s: %p PMstop\n", getName(), OBFUSCATE(this)); + submitPMRequest( request ); + } } //********************************************************************************* @@ -675,100 +685,92 @@ void IOService::PMstop( void ) // Disconnect the node from all parents and children in the power plane. //********************************************************************************* -void IOService::handlePMstop( IOPMRequest * request ) -{ - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - IOService * theChild; - IOService * theParent; - - PM_ASSERT_IN_GATE(); - PM_LOG2("%s: %p %s start\n", getName(), OBFUSCATE(this), __FUNCTION__); - - // remove driver from prevent system sleep lists - getPMRootDomain()->updatePreventIdleSleepList(this, false); - getPMRootDomain()->updatePreventSystemSleepList(this, false); - - // remove the property - removeProperty(kPwrMgtKey); - - // detach parents - iter = getParentIterator(gIOPowerPlane); - if ( iter ) - { - while ( (next = iter->getNextObject()) ) - { - if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) - { - theParent = (IOService *)connection->copyParentEntry(gIOPowerPlane); - if ( theParent ) - { - theParent->removePowerChild(connection); - theParent->release(); - } - } - } - iter->release(); - } - - // detach IOConnections - detachAbove( gIOPowerPlane ); - - // no more power state changes - fParentsKnowState = false; - - // detach children - iter = getChildIterator(gIOPowerPlane); - if ( iter ) - { - while ( (next = iter->getNextObject()) ) - { - if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) - { - theChild = ((IOService *)(connection->copyChildEntry(gIOPowerPlane))); - if ( theChild ) - { - // detach nub from child - connection->detachFromChild(theChild, gIOPowerPlane); - theChild->release(); - } - // detach us from nub - detachFromChild(connection, gIOPowerPlane); - } - } - iter->release(); - } - - // Remove all interested drivers from the list, including the power - // controlling driver. - // - // Usually, the controlling driver and the policy-maker functionality - // are implemented by the same object, and without the deregistration, - // the object will be holding an extra retain on itself, and cannot - // be freed. - - if ( fInterestedDrivers ) - { - IOPMinformeeList * list = fInterestedDrivers; - IOPMinformee * item; - - PM_LOCK(); - while ((item = list->firstInList())) - { - list->removeFromList(item->whatObject); - } - PM_UNLOCK(); - } - - // Clear idle period to prevent idleTimerExpired() from servicing - // idle timer expirations. - - fIdleTimerPeriod = 0; - if (fIdleTimer && thread_call_cancel(fIdleTimer)) - release(); - - PM_LOG2("%s: %p %s done\n", getName(), OBFUSCATE(this), __FUNCTION__); +void +IOService::handlePMstop( IOPMRequest * request ) +{ + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOService * theChild; + IOService * theParent; + + PM_ASSERT_IN_GATE(); + PM_LOG2("%s: %p %s start\n", getName(), OBFUSCATE(this), __FUNCTION__); + + // remove driver from prevent system sleep lists + getPMRootDomain()->updatePreventIdleSleepList(this, false); + getPMRootDomain()->updatePreventSystemSleepList(this, false); + + // remove the property + removeProperty(kPwrMgtKey); + + // detach parents + iter = getParentIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((connection = OSDynamicCast(IOPowerConnection, next))) { + theParent = (IOService *)connection->copyParentEntry(gIOPowerPlane); + if (theParent) { + theParent->removePowerChild(connection); + theParent->release(); + } + } + } + iter->release(); + } + + // detach IOConnections + detachAbove( gIOPowerPlane ); + + // no more power state changes + fParentsKnowState = false; + + // detach children + iter = getChildIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((connection = OSDynamicCast(IOPowerConnection, next))) { + theChild = ((IOService *)(connection->copyChildEntry(gIOPowerPlane))); + if (theChild) { + // detach nub from child + connection->detachFromChild(theChild, gIOPowerPlane); + theChild->release(); + } + // detach us from nub + detachFromChild(connection, gIOPowerPlane); + } + } + iter->release(); + } + + // Remove all interested drivers from the list, including the power + // controlling driver. + // + // Usually, the controlling driver and the policy-maker functionality + // are implemented by the same object, and without the deregistration, + // the object will be holding an extra retain on itself, and cannot + // be freed. + + if (fInterestedDrivers) { + IOPMinformeeList * list = fInterestedDrivers; + IOPMinformee * item; + + PM_LOCK(); + while ((item = list->firstInList())) { + list->removeFromList(item->whatObject); + } + PM_UNLOCK(); + } + + // Clear idle period to prevent idleTimerExpired() from servicing + // idle timer expirations. + + fIdleTimerPeriod = 0; + if (fIdleTimer && thread_call_cancel(fIdleTimer)) { + release(); + } + + PM_LOG2("%s: %p %s done\n", getName(), OBFUSCATE(this), __FUNCTION__); } //********************************************************************************* @@ -777,106 +779,114 @@ void IOService::handlePMstop( IOPMRequest * request ) // Power Management is informing us who our children are. //********************************************************************************* -IOReturn IOService::addPowerChild( IOService * child ) -{ - IOPowerConnection * connection = 0; - IOPMRequest * requests[3] = {0, 0, 0}; - OSIterator * iter; - bool ok = true; - - if (!child) - return kIOReturnBadArgument; - - if (!initialized || !child->initialized) - return IOPMNotYetInitialized; - - OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 ); - - do { - // Is this child already one of our children? - - iter = child->getParentIterator( gIOPowerPlane ); - if ( iter ) - { - IORegistryEntry * entry; - OSObject * next; - - while ((next = iter->getNextObject())) - { - if ((entry = OSDynamicCast(IORegistryEntry, next)) && - isChild(entry, gIOPowerPlane)) - { - ok = false; - break; - } - } - iter->release(); - } - if (!ok) - { - PM_LOG("%s: %s (%p) is already a child\n", - getName(), child->getName(), OBFUSCATE(child)); - break; - } +IOReturn +IOService::addPowerChild( IOService * child ) +{ + IOPowerConnection * connection = NULL; + IOPMRequest * requests[3] = {NULL, NULL, NULL}; + OSIterator * iter; + bool ok = true; + + if (!child) { + return kIOReturnBadArgument; + } + + if (!initialized || !child->initialized) { + return IOPMNotYetInitialized; + } + + OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 ); + + do { + // Is this child already one of our children? + + iter = child->getParentIterator( gIOPowerPlane ); + if (iter) { + IORegistryEntry * entry; + OSObject * next; + + while ((next = iter->getNextObject())) { + if ((entry = OSDynamicCast(IORegistryEntry, next)) && + isChild(entry, gIOPowerPlane)) { + ok = false; + break; + } + } + iter->release(); + } + if (!ok) { + PM_LOG2("%s: %s (%p) is already a child\n", + getName(), child->getName(), OBFUSCATE(child)); + break; + } - // Add the child to the power plane immediately, but the - // joining connection is marked as not ready. - // We want the child to appear in the power plane before - // returning to the caller, but don't want the caller to - // block on the PM work loop. + // Add the child to the power plane immediately, but the + // joining connection is marked as not ready. + // We want the child to appear in the power plane before + // returning to the caller, but don't want the caller to + // block on the PM work loop. - connection = new IOPowerConnection; - if (!connection) - break; + connection = new IOPowerConnection; + if (!connection) { + break; + } - // Create a chain of PM requests to perform the bottom-half - // work from the PM work loop. + // Create a chain of PM requests to perform the bottom-half + // work from the PM work loop. - requests[0] = acquirePMRequest( - /* target */ this, - /* type */ kIOPMRequestTypeAddPowerChild1 ); + requests[0] = acquirePMRequest( + /* target */ this, + /* type */ kIOPMRequestTypeAddPowerChild1 ); - requests[1] = acquirePMRequest( - /* target */ child, - /* type */ kIOPMRequestTypeAddPowerChild2 ); + requests[1] = acquirePMRequest( + /* target */ child, + /* type */ kIOPMRequestTypeAddPowerChild2 ); - requests[2] = acquirePMRequest( - /* target */ this, - /* type */ kIOPMRequestTypeAddPowerChild3 ); + requests[2] = acquirePMRequest( + /* target */ this, + /* type */ kIOPMRequestTypeAddPowerChild3 ); - if (!requests[0] || !requests[1] || !requests[2]) - break; + if (!requests[0] || !requests[1] || !requests[2]) { + break; + } - requests[0]->attachNextRequest( requests[1] ); - requests[1]->attachNextRequest( requests[2] ); + requests[0]->attachNextRequest( requests[1] ); + requests[1]->attachNextRequest( requests[2] ); - connection->init(); - connection->start(this); - connection->setAwaitingAck(false); - connection->setReadyFlag(false); + connection->init(); + connection->start(this); + connection->setAwaitingAck(false); + connection->setReadyFlag(false); - attachToChild( connection, gIOPowerPlane ); - connection->attachToChild( child, gIOPowerPlane ); + attachToChild( connection, gIOPowerPlane ); + connection->attachToChild( child, gIOPowerPlane ); - // connection needs to be released - requests[0]->fArg0 = connection; - requests[1]->fArg0 = connection; - requests[2]->fArg0 = connection; + // connection needs to be released + requests[0]->fArg0 = connection; + requests[1]->fArg0 = connection; + requests[2]->fArg0 = connection; - submitPMRequests( requests, 3 ); - return kIOReturnSuccess; - } - while (false); + submitPMRequests( requests, 3 ); + return kIOReturnSuccess; + }while (false); - if (connection) connection->release(); - if (requests[0]) releasePMRequest(requests[0]); - if (requests[1]) releasePMRequest(requests[1]); - if (requests[2]) releasePMRequest(requests[2]); + if (connection) { + connection->release(); + } + if (requests[0]) { + releasePMRequest(requests[0]); + } + if (requests[1]) { + releasePMRequest(requests[1]); + } + if (requests[2]) { + releasePMRequest(requests[2]); + } - // Silent failure, to prevent platform drivers from adding the child - // to the root domain. + // Silent failure, to prevent platform drivers from adding the child + // to the root domain. - return kIOReturnSuccess; + return kIOReturnSuccess; } //********************************************************************************* @@ -885,25 +895,24 @@ IOReturn IOService::addPowerChild( IOService * child ) // Step 1/3 of adding a power child. Called on the power parent. //********************************************************************************* -void IOService::addPowerChild1( IOPMRequest * request ) +void +IOService::addPowerChild1( IOPMRequest * request ) { - IOPMPowerStateIndex tempDesire = kPowerStateZero; + IOPMPowerStateIndex tempDesire = kPowerStateZero; - // Make us temporary usable before adding the child. + // Make us temporary usable before adding the child. - PM_ASSERT_IN_GATE(); - OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 ); + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 ); - if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState) - { - tempDesire = fHighestPowerState; - } + if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState) { + tempDesire = fHighestPowerState; + } - if ((tempDesire != kPowerStateZero) && - (IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire)))) - { - adjustPowerState(tempDesire); - } + if ((tempDesire != kPowerStateZero) && + (IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire)))) { + adjustPowerState(tempDesire); + } } //********************************************************************************* @@ -913,53 +922,53 @@ void IOService::addPowerChild1( IOPMRequest * request ) // Execution blocked behind addPowerChild1. //********************************************************************************* -void IOService::addPowerChild2( IOPMRequest * request ) +void +IOService::addPowerChild2( IOPMRequest * request ) { - IOPowerConnection * connection = (IOPowerConnection *) request->fArg0; - IOService * parent; - IOPMPowerFlags powerFlags; - bool knowsState; - unsigned long powerState; - unsigned long tempDesire; + IOPowerConnection * connection = (IOPowerConnection *) request->fArg0; + IOService * parent; + IOPMPowerFlags powerFlags; + bool knowsState; + unsigned long powerState; + unsigned long tempDesire; - PM_ASSERT_IN_GATE(); - parent = (IOService *) connection->getParentEntry(gIOPowerPlane); + PM_ASSERT_IN_GATE(); + parent = (IOService *) connection->getParentEntry(gIOPowerPlane); - if (!parent || !inPlane(gIOPowerPlane)) - { - PM_LOG("%s: addPowerChild2 not in power plane\n", getName()); - return; - } + if (!parent || !inPlane(gIOPowerPlane)) { + PM_LOG("%s: addPowerChild2 not in power plane\n", getName()); + return; + } - // Parent will be waiting for us to complete this stage. - // It is safe to directly access parent's vars. + // Parent will be waiting for us to complete this stage. + // It is safe to directly access parent's vars. - knowsState = (parent->fPowerStates) && (parent->fParentsKnowState); - powerState = parent->fCurrentPowerState; + knowsState = (parent->fPowerStates) && (parent->fParentsKnowState); + powerState = parent->fCurrentPowerState; - if (knowsState) - powerFlags = parent->fPowerStates[powerState].outputPowerFlags; - else - powerFlags = 0; + if (knowsState) { + powerFlags = parent->fPowerStates[powerState].outputPowerFlags; + } else { + powerFlags = 0; + } - // Set our power parent. + // Set our power parent. - OUR_PMLog(kPMLogSetParent, knowsState, powerFlags); + OUR_PMLog(kPMLogSetParent, knowsState, powerFlags); - setParentInfo( powerFlags, connection, knowsState ); + setParentInfo( powerFlags, connection, knowsState ); - connection->setReadyFlag(true); + connection->setReadyFlag(true); - if ( fControllingDriver && fParentsKnowState ) - { - fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags); - // initially change into the state we are already in - tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags); - fPreviousRequestPowerFlags = (IOPMPowerFlags)(-1); - adjustPowerState(tempDesire); - } + if (fControllingDriver && fParentsKnowState) { + fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags); + // initially change into the state we are already in + tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags); + fPreviousRequestPowerFlags = (IOPMPowerFlags)(-1); + adjustPowerState(tempDesire); + } - getPMRootDomain()->tagPowerPlaneService(this, &fPMActions); + getPMRootDomain()->tagPowerPlaneService(this, &fPMActions); } //********************************************************************************* @@ -969,32 +978,30 @@ void IOService::addPowerChild2( IOPMRequest * request ) // Execution blocked behind addPowerChild2. //********************************************************************************* -void IOService::addPowerChild3( IOPMRequest * request ) +void +IOService::addPowerChild3( IOPMRequest * request ) { - IOPowerConnection * connection = (IOPowerConnection *) request->fArg0; - IOService * child; - IOPMrootDomain * rootDomain = getPMRootDomain(); + IOPowerConnection * connection = (IOPowerConnection *) request->fArg0; + IOService * child; + IOPMrootDomain * rootDomain = getPMRootDomain(); - PM_ASSERT_IN_GATE(); - child = (IOService *) connection->getChildEntry(gIOPowerPlane); + PM_ASSERT_IN_GATE(); + child = (IOService *) connection->getChildEntry(gIOPowerPlane); - if (child && inPlane(gIOPowerPlane)) - { - if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder")) - { - PM_LOG1("%s: strict PM order enforced\n", getName()); - fStrictTreeOrder = true; - } + if (child && inPlane(gIOPowerPlane)) { + if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder")) { + PM_LOG1("%s: strict PM order enforced\n", getName()); + fStrictTreeOrder = true; + } - if (rootDomain) - rootDomain->joinAggressiveness( child ); - } - else - { - PM_LOG("%s: addPowerChild3 not in power plane\n", getName()); - } + if (rootDomain) { + rootDomain->joinAggressiveness( child ); + } + } else { + PM_LOG("%s: addPowerChild3 not in power plane\n", getName()); + } - connection->release(); + connection->release(); } #ifndef __LP64__ @@ -1007,10 +1014,11 @@ void IOService::addPowerChild3( IOPMRequest * request ) // to assume that state. //********************************************************************************* -IOReturn IOService::setPowerParent( - IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags ) +IOReturn +IOService::setPowerParent( + IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags ) { - return kIOReturnUnsupported; + return kIOReturnUnsupported; } #endif /* !__LP64__ */ @@ -1020,283 +1028,299 @@ IOReturn IOService::setPowerParent( // Called on a parent whose child is being removed by PMstop(). //********************************************************************************* -IOReturn IOService::removePowerChild( IOPowerConnection * theNub ) -{ - IORegistryEntry * theChild; +IOReturn +IOService::removePowerChild( IOPowerConnection * theNub ) +{ + IORegistryEntry * theChild; + + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogRemoveChild, 0, 0 ); + + theNub->retain(); + + // detach nub from child + theChild = theNub->copyChildEntry(gIOPowerPlane); + if (theChild) { + theNub->detachFromChild(theChild, gIOPowerPlane); + theChild->release(); + } + // detach from the nub + detachFromChild(theNub, gIOPowerPlane); + + // Are we awaiting an ack from this child? + if (theNub->getAwaitingAck()) { + // yes, pretend we got one + theNub->setAwaitingAck(false); + if (fHeadNotePendingAcks != 0) { + // that's one fewer ack to worry about + fHeadNotePendingAcks--; + + // is that the last? + if (fHeadNotePendingAcks == 0) { + stop_ack_timer(); + getPMRootDomain()->reset_watchdog_timer(this, 0); + + // This parent may have a request in the work queue that is + // blocked on fHeadNotePendingAcks=0. And removePowerChild() + // is called while executing the child's PMstop request so they + // can occur simultaneously. IOPMWorkQueue::checkForWork() must + // restart and check all request queues again. + + gIOPMWorkQueue->incrementProducerCount(); + } + } + } - PM_ASSERT_IN_GATE(); - OUR_PMLog( kPMLogRemoveChild, 0, 0 ); + theNub->release(); - theNub->retain(); + // A child has gone away, re-scan children desires and clamp bits. + // The fPendingAdjustPowerRequest helps to reduce redundant parent work. + + if (!fAdjustPowerScheduled) { + IOPMRequest * request; + request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); + if (request) { + submitPMRequest( request ); + fAdjustPowerScheduled = true; + } + } - // detach nub from child - theChild = theNub->copyChildEntry(gIOPowerPlane); - if ( theChild ) - { - theNub->detachFromChild(theChild, gIOPowerPlane); - theChild->release(); - } - // detach from the nub - detachFromChild(theNub, gIOPowerPlane); + return IOPMNoErr; +} - // Are we awaiting an ack from this child? - if ( theNub->getAwaitingAck() ) - { - // yes, pretend we got one - theNub->setAwaitingAck(false); - if (fHeadNotePendingAcks != 0 ) - { - // that's one fewer ack to worry about - fHeadNotePendingAcks--; +//********************************************************************************* +// [public] registerPowerDriver +// +// A driver has called us volunteering to control power to our device. +//********************************************************************************* - // is that the last? - if ( fHeadNotePendingAcks == 0 ) - { - stop_ack_timer(); +IOReturn +IOService::registerPowerDriver( + IOService * powerDriver, + IOPMPowerState * powerStates, + unsigned long numberOfStates ) +{ + IOPMRequest * request; + IOPMPSEntry * powerStatesCopy = NULL; + IOPMPowerStateIndex stateOrder; + IOReturn error = kIOReturnSuccess; + + if (!initialized) { + return IOPMNotYetInitialized; + } + + if (!powerStates || (numberOfStates < 2)) { + OUR_PMLog(kPMLogControllingDriverErr5, numberOfStates, 0); + return kIOReturnBadArgument; + } + + if (!powerDriver || !powerDriver->initialized) { + OUR_PMLog(kPMLogControllingDriverErr4, 0, 0); + return kIOReturnBadArgument; + } + + if (powerStates[0].version > kIOPMPowerStateVersion2) { + OUR_PMLog(kPMLogControllingDriverErr1, powerStates[0].version, 0); + return kIOReturnBadArgument; + } + + do { + // Make a copy of the supplied power state array. + powerStatesCopy = IONew(IOPMPSEntry, numberOfStates); + if (!powerStatesCopy) { + error = kIOReturnNoMemory; + break; + } - // This parent may have a request in the work queue that is - // blocked on fHeadNotePendingAcks=0. And removePowerChild() - // is called while executing the child's PMstop request so they - // can occur simultaneously. IOPMWorkQueue::checkForWork() must - // restart and check all request queues again. + // Initialize to bogus values + for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) { + powerStatesCopy[i].stateOrderToIndex = kIOPMPowerStateMax; + } - gIOPMWorkQueue->incrementProducerCount(); - } - } - } + for (uint32_t i = 0; i < numberOfStates; i++) { + powerStatesCopy[i].capabilityFlags = powerStates[i].capabilityFlags; + powerStatesCopy[i].outputPowerFlags = powerStates[i].outputPowerCharacter; + powerStatesCopy[i].inputPowerFlags = powerStates[i].inputPowerRequirement; + powerStatesCopy[i].staticPower = powerStates[i].staticPower; + powerStatesCopy[i].settleUpTime = powerStates[i].settleUpTime; + powerStatesCopy[i].settleDownTime = powerStates[i].settleDownTime; + if (powerStates[i].version >= kIOPMPowerStateVersion2) { + stateOrder = powerStates[i].stateOrder; + } else { + stateOrder = i; + } + + if (stateOrder < numberOfStates) { + powerStatesCopy[i].stateOrder = stateOrder; + powerStatesCopy[stateOrder].stateOrderToIndex = i; + } + } - theNub->release(); + for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) { + if (powerStatesCopy[i].stateOrderToIndex == kIOPMPowerStateMax) { + // power state order missing + error = kIOReturnBadArgument; + break; + } + } + if (kIOReturnSuccess != error) { + break; + } - // A child has gone away, re-scan children desires and clamp bits. - // The fPendingAdjustPowerRequest helps to reduce redundant parent work. + request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver ); + if (!request) { + error = kIOReturnNoMemory; + break; + } - if (!fAdjustPowerScheduled) - { - IOPMRequest * request; - request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); - if (request) - { - submitPMRequest( request ); - fAdjustPowerScheduled = true; - } - } + powerDriver->retain(); + request->fArg0 = (void *) powerDriver; + request->fArg1 = (void *) powerStatesCopy; + request->fArg2 = (void *) numberOfStates; - return IOPMNoErr; -} + submitPMRequest( request ); + return kIOReturnSuccess; + }while (false); -//********************************************************************************* -// [public] registerPowerDriver -// -// A driver has called us volunteering to control power to our device. -//********************************************************************************* + if (powerStatesCopy) { + IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates); + } -IOReturn IOService::registerPowerDriver( - IOService * powerDriver, - IOPMPowerState * powerStates, - unsigned long numberOfStates ) -{ - IOPMRequest * request; - IOPMPSEntry * powerStatesCopy = 0; - IOPMPowerStateIndex stateOrder; - IOReturn error = kIOReturnSuccess; - - if (!initialized) - return IOPMNotYetInitialized; - - if (!powerStates || (numberOfStates < 2)) - { - OUR_PMLog(kPMLogControllingDriverErr5, numberOfStates, 0); - return kIOReturnBadArgument; - } - - if (!powerDriver || !powerDriver->initialized) - { - OUR_PMLog(kPMLogControllingDriverErr4, 0, 0); - return kIOReturnBadArgument; - } - - if (powerStates[0].version > kIOPMPowerStateVersion2) - { - OUR_PMLog(kPMLogControllingDriverErr1, powerStates[0].version, 0); - return kIOReturnBadArgument; - } - - do { - // Make a copy of the supplied power state array. - powerStatesCopy = IONew(IOPMPSEntry, numberOfStates); - if (!powerStatesCopy) - { - error = kIOReturnNoMemory; - break; - } - - // Initialize to bogus values - for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) - powerStatesCopy[i].stateOrderToIndex = kIOPMPowerStateMax; - - for (uint32_t i = 0; i < numberOfStates; i++) - { - powerStatesCopy[i].capabilityFlags = powerStates[i].capabilityFlags; - powerStatesCopy[i].outputPowerFlags = powerStates[i].outputPowerCharacter; - powerStatesCopy[i].inputPowerFlags = powerStates[i].inputPowerRequirement; - powerStatesCopy[i].staticPower = powerStates[i].staticPower; - powerStatesCopy[i].settleUpTime = powerStates[i].settleUpTime; - powerStatesCopy[i].settleDownTime = powerStates[i].settleDownTime; - if (powerStates[i].version >= kIOPMPowerStateVersion2) - stateOrder = powerStates[i].stateOrder; - else - stateOrder = i; - - if (stateOrder < numberOfStates) - { - powerStatesCopy[i].stateOrder = stateOrder; - powerStatesCopy[stateOrder].stateOrderToIndex = i; - } - } - - for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) - { - if (powerStatesCopy[i].stateOrderToIndex == kIOPMPowerStateMax) - { - // power state order missing - error = kIOReturnBadArgument; - break; - } - } - if (kIOReturnSuccess != error) - break; - - request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver ); - if (!request) - { - error = kIOReturnNoMemory; - break; - } - - powerDriver->retain(); - request->fArg0 = (void *) powerDriver; - request->fArg1 = (void *) powerStatesCopy; - request->fArg2 = (void *) numberOfStates; - - submitPMRequest( request ); - return kIOReturnSuccess; - } - while (false); - - if (powerStatesCopy) - IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates); - - return error; + return error; } //********************************************************************************* // [private] handleRegisterPowerDriver //********************************************************************************* -void IOService::handleRegisterPowerDriver( IOPMRequest * request ) -{ - IOService * powerDriver = (IOService *) request->fArg0; - IOPMPSEntry * powerStates = (IOPMPSEntry *) request->fArg1; - unsigned long numberOfStates = (unsigned long) request->fArg2; - unsigned long i, stateIndex; - unsigned long lowestPowerState; - IOService * root; - OSIterator * iter; - - PM_ASSERT_IN_GATE(); - assert(powerStates); - assert(powerDriver); - assert(numberOfStates > 1); - - if ( !fNumberOfPowerStates ) - { - OUR_PMLog(kPMLogControllingDriver, - (unsigned long) numberOfStates, - (unsigned long) kIOPMPowerStateVersion1); - - fPowerStates = powerStates; - fNumberOfPowerStates = numberOfStates; - fControllingDriver = powerDriver; - fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags; - - lowestPowerState = fPowerStates[0].stateOrderToIndex; - fHighestPowerState = fPowerStates[numberOfStates - 1].stateOrderToIndex; - - // OR'in all the output power flags - fMergedOutputPowerFlags = 0; - fDeviceUsablePowerState = lowestPowerState; - for ( i = 0; i < numberOfStates; i++ ) - { - fMergedOutputPowerFlags |= fPowerStates[i].outputPowerFlags; - - stateIndex = fPowerStates[i].stateOrderToIndex; - assert(stateIndex < numberOfStates); - if ((fDeviceUsablePowerState == lowestPowerState) && - (fPowerStates[stateIndex].capabilityFlags & IOPMDeviceUsable)) - { - // The minimum power state that the device is usable - fDeviceUsablePowerState = stateIndex; - } - } - - // Register powerDriver as interested, unless already done. - // We don't want to register the default implementation since - // it does nothing. One ramification of not always registering - // is the one fewer retain count held. - - root = getPlatform()->getProvider(); - assert(root); - if (!root || - ((OSMemberFunctionCast(void (*)(void), - root, &IOService::powerStateDidChangeTo)) != - ((OSMemberFunctionCast(void (*)(void), - this, &IOService::powerStateDidChangeTo)))) || - ((OSMemberFunctionCast(void (*)(void), - root, &IOService::powerStateWillChangeTo)) != - ((OSMemberFunctionCast(void (*)(void), - this, &IOService::powerStateWillChangeTo))))) - { - if (fInterestedDrivers->findItem(powerDriver) == NULL) - { - PM_LOCK(); - fInterestedDrivers->appendNewInformee(powerDriver); - PM_UNLOCK(); - } - } - - // Examine all existing power clients and perform limit check. - - if (fPowerClients && - (iter = OSCollectionIterator::withCollection(fPowerClients))) - { - const OSSymbol * client; - while ((client = (const OSSymbol *) iter->getNextObject())) - { - IOPMPowerStateIndex powerState = getPowerStateForClient(client); - if (powerState >= numberOfStates) - { - updatePowerClient(client, fHighestPowerState); - } - } - iter->release(); - } - - if ( inPlane(gIOPowerPlane) && fParentsKnowState ) - { - IOPMPowerStateIndex tempDesire; - fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags); - // initially change into the state we are already in - tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags); - adjustPowerState(tempDesire); - } - } - else - { - OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0); - IODelete(powerStates, IOPMPSEntry, numberOfStates); - } - - powerDriver->release(); +void +IOService::handleRegisterPowerDriver( IOPMRequest * request ) +{ + IOService * powerDriver = (IOService *) request->fArg0; + IOPMPSEntry * powerStates = (IOPMPSEntry *) request->fArg1; + unsigned long numberOfStates = (unsigned long) request->fArg2; + unsigned long i, stateIndex; + unsigned long lowestPowerState; + IOService * root; + OSIterator * iter; + + PM_ASSERT_IN_GATE(); + assert(powerStates); + assert(powerDriver); + assert(numberOfStates > 1); + + if (!fNumberOfPowerStates) { + OUR_PMLog(kPMLogControllingDriver, + (unsigned long) numberOfStates, + (unsigned long) kIOPMPowerStateVersion1); + + fPowerStates = powerStates; + fNumberOfPowerStates = numberOfStates; + fControllingDriver = powerDriver; + fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags; + + lowestPowerState = fPowerStates[0].stateOrderToIndex; + fHighestPowerState = fPowerStates[numberOfStates - 1].stateOrderToIndex; + +#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) + { + uint32_t aotFlags; + IOService * service; + OSObject * object; + OSData * data; + + // Disallow kIOPMAOTPower states unless device tree enabled + + aotFlags = 0; + service = this; + while (service && !service->inPlane(gIODTPlane)) { + service = service->getProvider(); + } + if (service) { + object = service->copyProperty(kIOPMAOTPowerKey, gIODTPlane); + data = OSDynamicCast(OSData, object); + if (data && (data->getLength() >= sizeof(uint32_t))) { + aotFlags = ((uint32_t *)data->getBytesNoCopy())[0]; + } + OSSafeReleaseNULL(object); + } + if (!aotFlags) { + for (i = 0; i < numberOfStates; i++) { + if (kIOPMAOTPower & fPowerStates[i].inputPowerFlags) { + fPowerStates[i].inputPowerFlags = 0xFFFFFFFF; + fPowerStates[i].capabilityFlags = 0; + fPowerStates[i].outputPowerFlags = 0; + } + } + } + } +#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + + // OR'in all the output power flags + fMergedOutputPowerFlags = 0; + fDeviceUsablePowerState = lowestPowerState; + for (i = 0; i < numberOfStates; i++) { + fMergedOutputPowerFlags |= fPowerStates[i].outputPowerFlags; + + stateIndex = fPowerStates[i].stateOrderToIndex; + assert(stateIndex < numberOfStates); + if ((fDeviceUsablePowerState == lowestPowerState) && + (fPowerStates[stateIndex].capabilityFlags & IOPMDeviceUsable)) { + // The minimum power state that the device is usable + fDeviceUsablePowerState = stateIndex; + } + } + + // Register powerDriver as interested, unless already done. + // We don't want to register the default implementation since + // it does nothing. One ramification of not always registering + // is the one fewer retain count held. + + root = getPlatform()->getProvider(); + assert(root); + if (!root || + ((OSMemberFunctionCast(void (*)(void), + root, &IOService::powerStateDidChangeTo)) != + ((OSMemberFunctionCast(void (*)(void), + this, &IOService::powerStateDidChangeTo)))) || + ((OSMemberFunctionCast(void (*)(void), + root, &IOService::powerStateWillChangeTo)) != + ((OSMemberFunctionCast(void (*)(void), + this, &IOService::powerStateWillChangeTo))))) { + if (fInterestedDrivers->findItem(powerDriver) == NULL) { + PM_LOCK(); + fInterestedDrivers->appendNewInformee(powerDriver); + PM_UNLOCK(); + } + } + + // Examine all existing power clients and perform limit check. + + if (fPowerClients && + (iter = OSCollectionIterator::withCollection(fPowerClients))) { + const OSSymbol * client; + while ((client = (const OSSymbol *) iter->getNextObject())) { + IOPMPowerStateIndex powerState = getPowerStateForClient(client); + if (powerState >= numberOfStates) { + updatePowerClient(client, fHighestPowerState); + } + } + iter->release(); + } + + if (inPlane(gIOPowerPlane) && fParentsKnowState) { + IOPMPowerStateIndex tempDesire; + fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags); + // initially change into the state we are already in + tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags); + adjustPowerState(tempDesire); + } + } else { + OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0); + IODelete(powerStates, IOPMPSEntry, numberOfStates); + } + + powerDriver->release(); } //********************************************************************************* @@ -1308,90 +1332,93 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request ) // out what the current power state of the device is. //********************************************************************************* -IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver ) +IOPMPowerFlags +IOService::registerInterestedDriver( IOService * driver ) { - IOPMRequest * request; - bool signal; + IOPMRequest * request; + bool signal; - if (!driver || !initialized || !fInterestedDrivers) - return 0; + if (!driver || !initialized || !fInterestedDrivers) { + return 0; + } - PM_LOCK(); - signal = (!fInsertInterestSet && !fRemoveInterestSet); - if (fInsertInterestSet == NULL) - fInsertInterestSet = OSSet::withCapacity(4); - if (fInsertInterestSet) - { - fInsertInterestSet->setObject(driver); - if (fRemoveInterestSet) - fRemoveInterestSet->removeObject(driver); - } - PM_UNLOCK(); + PM_LOCK(); + signal = (!fInsertInterestSet && !fRemoveInterestSet); + if (fInsertInterestSet == NULL) { + fInsertInterestSet = OSSet::withCapacity(4); + } + if (fInsertInterestSet) { + fInsertInterestSet->setObject(driver); + if (fRemoveInterestSet) { + fRemoveInterestSet->removeObject(driver); + } + } + PM_UNLOCK(); - if (signal) - { - request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged ); - if (request) - submitPMRequest( request ); - } + if (signal) { + request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged ); + if (request) { + submitPMRequest( request ); + } + } - // This return value cannot be trusted, but return a value - // for those clients that care. + // This return value cannot be trusted, but return a value + // for those clients that care. - OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2); - return kIOPMDeviceUsable; + OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2); + return kIOPMDeviceUsable; } //********************************************************************************* // [public] deRegisterInterestedDriver //********************************************************************************* -IOReturn IOService::deRegisterInterestedDriver( IOService * driver ) -{ - IOPMinformee * item; - IOPMRequest * request; - bool signal; - - if (!driver) - return kIOReturnBadArgument; - if (!initialized || !fInterestedDrivers) - return IOPMNotPowerManaged; - - PM_LOCK(); - if (fInsertInterestSet) - { - fInsertInterestSet->removeObject(driver); - } - - item = fInterestedDrivers->findItem(driver); - if (!item) - { - PM_UNLOCK(); - return kIOReturnNotFound; - } - - signal = (!fRemoveInterestSet && !fInsertInterestSet); - if (fRemoveInterestSet == NULL) - fRemoveInterestSet = OSSet::withCapacity(4); - if (fRemoveInterestSet) - { - fRemoveInterestSet->setObject(driver); - if (item->active) - { - item->active = false; - waitForPMDriverCall( driver ); - } - } - PM_UNLOCK(); +IOReturn +IOService::deRegisterInterestedDriver( IOService * driver ) +{ + IOPMinformee * item; + IOPMRequest * request; + bool signal; + + if (!driver) { + return kIOReturnBadArgument; + } + if (!initialized || !fInterestedDrivers) { + return IOPMNotPowerManaged; + } + + PM_LOCK(); + if (fInsertInterestSet) { + fInsertInterestSet->removeObject(driver); + } + + item = fInterestedDrivers->findItem(driver); + if (!item) { + PM_UNLOCK(); + return kIOReturnNotFound; + } + + signal = (!fRemoveInterestSet && !fInsertInterestSet); + if (fRemoveInterestSet == NULL) { + fRemoveInterestSet = OSSet::withCapacity(4); + } + if (fRemoveInterestSet) { + fRemoveInterestSet->setObject(driver); + if (item->active) { + item->active = false; + waitForPMDriverCall( driver ); + } + } + PM_UNLOCK(); - if (signal) - { - request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged ); - if (request) - submitPMRequest( request ); - } + if (signal) { + request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged ); + if (request) { + submitPMRequest( request ); + } + } - return IOPMNoErr; + return IOPMNoErr; } //********************************************************************************* @@ -1400,50 +1427,44 @@ IOReturn IOService::deRegisterInterestedDriver( IOService * driver ) // Handle interest added or removed. //********************************************************************************* -void IOService::handleInterestChanged( IOPMRequest * request ) -{ - IOService * driver; - IOPMinformee * informee; - IOPMinformeeList * list = fInterestedDrivers; - - PM_LOCK(); - - if (fInsertInterestSet) - { - while ((driver = (IOService *) fInsertInterestSet->getAnyObject())) - { - if (list->findItem(driver) == NULL) - { - informee = list->appendNewInformee(driver); - } - fInsertInterestSet->removeObject(driver); - } - fInsertInterestSet->release(); - fInsertInterestSet = 0; - } - - if (fRemoveInterestSet) - { - while ((driver = (IOService *) fRemoveInterestSet->getAnyObject())) - { - informee = list->findItem(driver); - if (informee) - { - // Clean-up async interest acknowledgement - if (fHeadNotePendingAcks && informee->timer) - { - informee->timer = 0; - fHeadNotePendingAcks--; - } - list->removeFromList(driver); - } - fRemoveInterestSet->removeObject(driver); - } - fRemoveInterestSet->release(); - fRemoveInterestSet = 0; - } - - PM_UNLOCK(); +void +IOService::handleInterestChanged( IOPMRequest * request ) +{ + IOService * driver; + IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; + + PM_LOCK(); + + if (fInsertInterestSet) { + while ((driver = (IOService *) fInsertInterestSet->getAnyObject())) { + if (list->findItem(driver) == NULL) { + informee = list->appendNewInformee(driver); + } + fInsertInterestSet->removeObject(driver); + } + fInsertInterestSet->release(); + fInsertInterestSet = NULL; + } + + if (fRemoveInterestSet) { + while ((driver = (IOService *) fRemoveInterestSet->getAnyObject())) { + informee = list->findItem(driver); + if (informee) { + // Clean-up async interest acknowledgement + if (fHeadNotePendingAcks && informee->timer) { + informee->timer = 0; + fHeadNotePendingAcks--; + } + list->removeFromList(driver); + } + fRemoveInterestSet->removeObject(driver); + } + fRemoveInterestSet->release(); + fRemoveInterestSet = NULL; + } + + PM_UNLOCK(); } //********************************************************************************* @@ -1460,128 +1481,125 @@ void IOService::handleInterestChanged( IOPMRequest * request ) // of a "current change note".) //********************************************************************************* -IOReturn IOService::acknowledgePowerChange( IOService * whichObject ) +IOReturn +IOService::acknowledgePowerChange( IOService * whichObject ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return IOPMNotYetInitialized; - if (!whichObject) - return kIOReturnBadArgument; + if (!initialized) { + return IOPMNotYetInitialized; + } + if (!whichObject) { + return kIOReturnBadArgument; + } - request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange ); + if (!request) { + return kIOReturnNoMemory; + } - whichObject->retain(); - request->fArg0 = whichObject; + whichObject->retain(); + request->fArg0 = whichObject; - submitPMRequest( request ); - return IOPMNoErr; + submitPMRequest( request ); + return IOPMNoErr; } //********************************************************************************* // [private] handleAcknowledgePowerChange //********************************************************************************* -bool IOService::handleAcknowledgePowerChange( IOPMRequest * request ) -{ - IOPMinformee * informee; - unsigned long childPower = kIOPMUnknown; - IOService * theChild; - IOService * whichObject; - bool all_acked = false; - - PM_ASSERT_IN_GATE(); - whichObject = (IOService *) request->fArg0; - assert(whichObject); - - // one of our interested drivers? - informee = fInterestedDrivers->findItem( whichObject ); - if ( informee == NULL ) - { - if ( !isChild(whichObject, gIOPowerPlane) ) - { - OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0); - goto no_err; - } else { - OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0); - } - } else { - OUR_PMLog(kPMLogDriverAcknowledge, fHeadNotePendingAcks, 0); - } - - if ( fHeadNotePendingAcks != 0 ) - { - assert(fPowerStates != NULL); - - // yes, make sure we're expecting acks - if ( informee != NULL ) - { - // it's an interested driver - // make sure we're expecting this ack - if ( informee->timer != 0 ) - { -#if LOG_SETPOWER_TIMES - if (informee->timer > 0) - { - uint64_t nsec = computeTimeDeltaNS(&informee->startTime); - if (nsec > LOG_SETPOWER_TIMES) { - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsDriverPSChangeSlow, informee->whatObject->getName(), - fDriverCallReason, NS_TO_MS(nsec), 0, NULL, fHeadNotePowerState); - } - } -#endif - // mark it acked - informee->timer = 0; - // that's one fewer to worry about - fHeadNotePendingAcks--; - } else { - // this driver has already acked - OUR_PMLog(kPMLogAcknowledgeErr2, 0, 0); - } - } else { - // it's a child - // make sure we're expecting this ack - if ( ((IOPowerConnection *)whichObject)->getAwaitingAck() ) - { - // that's one fewer to worry about - fHeadNotePendingAcks--; - ((IOPowerConnection *)whichObject)->setAwaitingAck(false); - theChild = (IOService *)whichObject->copyChildEntry(gIOPowerPlane); - if ( theChild ) - { - childPower = theChild->currentPowerConsumption(); - theChild->release(); - } - if ( childPower == kIOPMUnknown ) - { - fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown; - } else { - if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown) - { - fHeadNotePowerArrayEntry->staticPower += childPower; - } - } - } - } - - if ( fHeadNotePendingAcks == 0 ) { - // yes, stop the timer - stop_ack_timer(); - // and now we can continue - all_acked = true; - } - } else { - OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack - } +bool +IOService::handleAcknowledgePowerChange( IOPMRequest * request ) +{ + IOPMinformee * informee; + unsigned long childPower = kIOPMUnknown; + IOService * theChild; + IOService * whichObject; + bool all_acked = false; + + PM_ASSERT_IN_GATE(); + whichObject = (IOService *) request->fArg0; + assert(whichObject); + + // one of our interested drivers? + informee = fInterestedDrivers->findItem( whichObject ); + if (informee == NULL) { + if (!isChild(whichObject, gIOPowerPlane)) { + OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0); + goto no_err; + } else { + OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0); + } + } else { + OUR_PMLog(kPMLogDriverAcknowledge, fHeadNotePendingAcks, 0); + } + + if (fHeadNotePendingAcks != 0) { + assert(fPowerStates != NULL); + + // yes, make sure we're expecting acks + if (informee != NULL) { + // it's an interested driver + // make sure we're expecting this ack + if (informee->timer != 0) { + if (informee->timer > 0) { + uint64_t nsec = computeTimeDeltaNS(&informee->startTime); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, informee->whatObject->getName(), + fDriverCallReason, NS_TO_MS(nsec), informee->whatObject->getRegistryEntryID(), + NULL, fHeadNotePowerState); + } + } + + // mark it acked + informee->timer = 0; + // that's one fewer to worry about + fHeadNotePendingAcks--; + } else { + // this driver has already acked + OUR_PMLog(kPMLogAcknowledgeErr2, 0, 0); + } + } else { + // it's a child + // make sure we're expecting this ack + if (((IOPowerConnection *)whichObject)->getAwaitingAck()) { + // that's one fewer to worry about + fHeadNotePendingAcks--; + ((IOPowerConnection *)whichObject)->setAwaitingAck(false); + theChild = (IOService *)whichObject->copyChildEntry(gIOPowerPlane); + if (theChild) { + childPower = theChild->currentPowerConsumption(); + theChild->release(); + } + if (childPower == kIOPMUnknown) { + fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown; + } else { + if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown) { + fHeadNotePowerArrayEntry->staticPower += childPower; + } + } + } + } + + if (fHeadNotePendingAcks == 0) { + // yes, stop the timer + stop_ack_timer(); + // and now we can continue + all_acked = true; + getPMRootDomain()->reset_watchdog_timer(this, 0); + } + } else { + OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack + } no_err: - if (whichObject) - whichObject->release(); + if (whichObject) { + whichObject->release(); + } - return all_acked; + return all_acked; } //********************************************************************************* @@ -1592,121 +1610,136 @@ no_err: // We continue to process the power state change. //********************************************************************************* -IOReturn IOService::acknowledgeSetPowerState( void ) +IOReturn +IOService::acknowledgeSetPowerState( void ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return IOPMNotYetInitialized; + if (!initialized) { + return IOPMNotYetInitialized; + } - request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState ); + if (!request) { + return kIOReturnNoMemory; + } - submitPMRequest( request ); - return kIOReturnSuccess; + submitPMRequest( request ); + return kIOReturnSuccess; } //********************************************************************************* // [private] adjustPowerState //********************************************************************************* -void IOService::adjustPowerState( uint32_t clamp ) +void +IOService::adjustPowerState( uint32_t clamp ) { - PM_ASSERT_IN_GATE(); - computeDesiredState(clamp, false); - if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane)) - { - IOPMPowerChangeFlags changeFlags = kIOPMSelfInitiated; + PM_ASSERT_IN_GATE(); + computeDesiredState(clamp, false); + if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane)) { + IOPMPowerChangeFlags changeFlags = kIOPMSelfInitiated; - // Indicate that children desires must be ignored, and do not ask - // apps for permission to drop power. This is used by root domain - // for demand sleep. + // Indicate that children desires must be ignored, and do not ask + // apps for permission to drop power. This is used by root domain + // for demand sleep. - if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) - changeFlags |= (kIOPMIgnoreChildren | kIOPMSkipAskPowerDown); + if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) { + changeFlags |= (kIOPMIgnoreChildren | kIOPMSkipAskPowerDown); + } - startPowerChange( - /* flags */ changeFlags, - /* power state */ fDesiredPowerState, - /* domain flags */ 0, - /* connection */ 0, - /* parent flags */ 0); - } + startPowerChange( + /* flags */ changeFlags, + /* power state */ fDesiredPowerState, + /* domain flags */ 0, + /* connection */ NULL, + /* parent flags */ 0); + } } //********************************************************************************* // [public] synchronizePowerTree //********************************************************************************* -IOReturn IOService::synchronizePowerTree( - IOOptionBits options, - IOService * notifyRoot ) +IOReturn +IOService::synchronizePowerTree( + IOOptionBits options, + IOService * notifyRoot ) { - IOPMRequest * request_c = 0; - IOPMRequest * request_s; + IOPMRequest * request_c = NULL; + IOPMRequest * request_s; - if (this != getPMRootDomain()) - return kIOReturnBadArgument; - if (!initialized) - return kIOPMNotYetInitialized; + if (this != getPMRootDomain()) { + return kIOReturnBadArgument; + } + if (!initialized) { + return kIOPMNotYetInitialized; + } - OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0)); + OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != NULL)); - if (notifyRoot) - { - IOPMRequest * nr; + if (notifyRoot) { + IOPMRequest * nr; - // Cancels don't need to be synchronized. - nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel); - if (nr) submitPMRequest(nr); - nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel); - if (nr) submitPMRequest(nr); - } + // Cancels don't need to be synchronized. + nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel); + if (nr) { + submitPMRequest(nr); + } + nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel); + if (nr) { + submitPMRequest(nr); + } + } - request_s = acquirePMRequest( this, kIOPMRequestTypeSynchronizePowerTree ); - if (!request_s) - goto error_no_memory; + request_s = acquirePMRequest( this, kIOPMRequestTypeSynchronizePowerTree ); + if (!request_s) { + goto error_no_memory; + } - if (options & kIOPMSyncCancelPowerDown) - request_c = acquirePMRequest( this, kIOPMRequestTypeIdleCancel ); - if (request_c) - { - request_c->attachNextRequest( request_s ); - submitPMRequest(request_c); - } + if (options & kIOPMSyncCancelPowerDown) { + request_c = acquirePMRequest( this, kIOPMRequestTypeIdleCancel ); + } + if (request_c) { + request_c->attachNextRequest( request_s ); + submitPMRequest(request_c); + } - request_s->fArg0 = (void *)(uintptr_t) options; - submitPMRequest(request_s); + request_s->fArg0 = (void *)(uintptr_t) options; + submitPMRequest(request_s); - return kIOReturnSuccess; + return kIOReturnSuccess; error_no_memory: - if (request_c) releasePMRequest(request_c); - if (request_s) releasePMRequest(request_s); - return kIOReturnNoMemory; + if (request_c) { + releasePMRequest(request_c); + } + if (request_s) { + releasePMRequest(request_s); + } + return kIOReturnNoMemory; } //********************************************************************************* // [private] handleSynchronizePowerTree //********************************************************************************* -void IOService::handleSynchronizePowerTree( IOPMRequest * request ) +void +IOService::handleSynchronizePowerTree( IOPMRequest * request ) { - PM_ASSERT_IN_GATE(); - if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) && - (fCurrentPowerState == fHighestPowerState)) - { - IOOptionBits options = (uintptr_t) request->fArg0; + PM_ASSERT_IN_GATE(); + if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) && + (fCurrentPowerState == fHighestPowerState)) { + IOOptionBits options = (uintptr_t) request->fArg0; - startPowerChange( - /* flags */ kIOPMSelfInitiated | kIOPMSynchronize | - (options & kIOPMSyncNoChildNotify), - /* power state */ fCurrentPowerState, - /* domain flags */ 0, - /* connection */ 0, - /* parent flags */ 0); - } + startPowerChange( + /* flags */ kIOPMSelfInitiated | kIOPMSynchronize | + (options & kIOPMSyncNoChildNotify), + /* power state */ fCurrentPowerState, + /* domain flags */ 0, + /* connection */ NULL, + /* parent flags */ 0); + } } #ifndef __LP64__ @@ -1720,12 +1753,13 @@ void IOService::handleSynchronizePowerTree( IOPMRequest * request ) // kind of change is occuring in the domain. //********************************************************************************* -IOReturn IOService::powerDomainWillChangeTo( - IOPMPowerFlags newPowerFlags, - IOPowerConnection * whichParent ) +IOReturn +IOService::powerDomainWillChangeTo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent ) { - assert(false); - return kIOReturnUnsupported; + assert(false); + return kIOReturnUnsupported; } #endif /* !__LP64__ */ @@ -1733,110 +1767,105 @@ IOReturn IOService::powerDomainWillChangeTo( // [private] handlePowerDomainWillChangeTo //********************************************************************************* -void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request ) -{ - IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; - IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; - IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; - IOPMPowerChangeFlags myChangeFlags; - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - IOPMPowerStateIndex maxPowerState; - IOPMPowerFlags combinedPowerFlags; - bool savedParentsKnowState; - IOReturn result = IOPMAckImplied; - - PM_ASSERT_IN_GATE(); - OUR_PMLog(kPMLogWillChange, parentPowerFlags, 0); - - if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) - { - PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); - goto exit_no_ack; - } - - savedParentsKnowState = fParentsKnowState; - - // Combine parents' output power flags. - - combinedPowerFlags = 0; - - iter = getParentIterator(gIOPowerPlane); - if ( iter ) - { - while ( (next = iter->getNextObject()) ) - { - if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) - { - if ( connection == whichParent ) - combinedPowerFlags |= parentPowerFlags; - else - combinedPowerFlags |= connection->parentCurrentPowerFlags(); - } - } - iter->release(); - } - - // If our initial change has yet to occur, then defer the power change - // until after the power domain has completed its power transition. - - if ( fControllingDriver && !fInitialPowerChange ) - { - maxPowerState = fControllingDriver->maxCapabilityForDomainState( - combinedPowerFlags); - - if (parentChangeFlags & kIOPMDomainPowerDrop) - { - // fMaxPowerState set a limit on self-initiated power changes. - // Update it before a parent power drop. - fMaxPowerState = maxPowerState; - } - - // Use kIOPMSynchronize below instead of kIOPMRootBroadcastFlags - // to avoid propagating the root change flags if any service must - // change power state due to root's will-change notification. - // Root does not change power state for kIOPMSynchronize. - - myChangeFlags = kIOPMParentInitiated | kIOPMDomainWillChange | - (parentChangeFlags & kIOPMSynchronize); - - result = startPowerChange( - /* flags */ myChangeFlags, - /* power state */ maxPowerState, - /* domain flags */ combinedPowerFlags, - /* connection */ whichParent, - /* parent flags */ parentPowerFlags); - } - - // If parent is dropping power, immediately update the parent's - // capability flags. Any future merging of parent(s) combined - // power flags should account for this power drop. - - if (parentChangeFlags & kIOPMDomainPowerDrop) - { - setParentInfo(parentPowerFlags, whichParent, true); - } - - // Parent is expecting an ACK from us. If we did not embark on a state - // transition, i.e. startPowerChange() returned IOPMAckImplied. We are - // still required to issue an ACK to our parent. - - if (IOPMAckImplied == result) - { - IOService * parent; - parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane); - assert(parent); - if ( parent ) - { - parent->acknowledgePowerChange( whichParent ); - parent->release(); - } - } +void +IOService::handlePowerDomainWillChangeTo( IOPMRequest * request ) +{ + IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; + IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; + IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; + IOPMPowerChangeFlags myChangeFlags; + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOPMPowerStateIndex maxPowerState; + IOPMPowerFlags combinedPowerFlags; + bool savedParentsKnowState; + IOReturn result = IOPMAckImplied; + + PM_ASSERT_IN_GATE(); + OUR_PMLog(kPMLogWillChange, parentPowerFlags, 0); + + if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) { + PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); + goto exit_no_ack; + } + + savedParentsKnowState = fParentsKnowState; + + // Combine parents' output power flags. + + combinedPowerFlags = 0; + + iter = getParentIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((connection = OSDynamicCast(IOPowerConnection, next))) { + if (connection == whichParent) { + combinedPowerFlags |= parentPowerFlags; + } else { + combinedPowerFlags |= connection->parentCurrentPowerFlags(); + } + } + } + iter->release(); + } + + // If our initial change has yet to occur, then defer the power change + // until after the power domain has completed its power transition. + + if (fControllingDriver && !fInitialPowerChange) { + maxPowerState = fControllingDriver->maxCapabilityForDomainState( + combinedPowerFlags); + + if (parentChangeFlags & kIOPMDomainPowerDrop) { + // fMaxPowerState set a limit on self-initiated power changes. + // Update it before a parent power drop. + fMaxPowerState = maxPowerState; + } + + // Use kIOPMSynchronize below instead of kIOPMRootBroadcastFlags + // to avoid propagating the root change flags if any service must + // change power state due to root's will-change notification. + // Root does not change power state for kIOPMSynchronize. + + myChangeFlags = kIOPMParentInitiated | kIOPMDomainWillChange | + (parentChangeFlags & kIOPMSynchronize); + + result = startPowerChange( + /* flags */ myChangeFlags, + /* power state */ maxPowerState, + /* domain flags */ combinedPowerFlags, + /* connection */ whichParent, + /* parent flags */ parentPowerFlags); + } + + // If parent is dropping power, immediately update the parent's + // capability flags. Any future merging of parent(s) combined + // power flags should account for this power drop. + + if (parentChangeFlags & kIOPMDomainPowerDrop) { + setParentInfo(parentPowerFlags, whichParent, true); + } + + // Parent is expecting an ACK from us. If we did not embark on a state + // transition, i.e. startPowerChange() returned IOPMAckImplied. We are + // still required to issue an ACK to our parent. + + if (IOPMAckImplied == result) { + IOService * parent; + parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane); + assert(parent); + if (parent) { + parent->acknowledgePowerChange( whichParent ); + parent->release(); + } + } exit_no_ack: - // Drop the retain from notifyChild(). - if (whichParent) whichParent->release(); + // Drop the retain from notifyChild(). + if (whichParent) { + whichParent->release(); + } } #ifndef __LP64__ @@ -1850,12 +1879,13 @@ exit_no_ack: // kind of change is occuring in the domain. //********************************************************************************* -IOReturn IOService::powerDomainDidChangeTo( - IOPMPowerFlags newPowerFlags, - IOPowerConnection * whichParent ) +IOReturn +IOService::powerDomainDidChangeTo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent ) { - assert(false); - return kIOReturnUnsupported; + assert(false); + return kIOReturnUnsupported; } #endif /* !__LP64__ */ @@ -1863,134 +1893,132 @@ IOReturn IOService::powerDomainDidChangeTo( // [private] handlePowerDomainDidChangeTo //********************************************************************************* -void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request ) -{ - IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; - IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; - IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; - IOPMPowerChangeFlags myChangeFlags; - IOPMPowerStateIndex maxPowerState; - IOPMPowerStateIndex initialDesire = kPowerStateZero; - bool computeDesire = false; - bool desireChanged = false; - bool savedParentsKnowState; - IOReturn result = IOPMAckImplied; - - PM_ASSERT_IN_GATE(); - OUR_PMLog(kPMLogDidChange, parentPowerFlags, 0); - - if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) - { - PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); - goto exit_no_ack; - } - - savedParentsKnowState = fParentsKnowState; - - setParentInfo(parentPowerFlags, whichParent, true); - - if ( fControllingDriver ) - { - maxPowerState = fControllingDriver->maxCapabilityForDomainState( - fParentsCurrentPowerFlags); - - if ((parentChangeFlags & kIOPMDomainPowerDrop) == 0) - { - // fMaxPowerState set a limit on self-initiated power changes. - // Update it after a parent power rise. - fMaxPowerState = maxPowerState; - } - - if (fInitialPowerChange) - { - computeDesire = true; - initialDesire = fControllingDriver->initialPowerStateForDomainState( - fParentsCurrentPowerFlags); - } - else if (parentChangeFlags & kIOPMRootChangeUp) - { - if (fAdvisoryTickleUsed) - { - // On system wake, re-compute the desired power state since - // gIOPMAdvisoryTickleEnabled will change for a full wake, - // which is an input to computeDesiredState(). This is not - // necessary for a dark wake because powerChangeDone() will - // handle the dark to full wake case, but it does no harm. - - desireChanged = true; - } - - if (fResetPowerStateOnWake) - { - // Query the driver for the desired power state on system wake. - // Default implementation returns the lowest power state. - - IOPMPowerStateIndex wakePowerState = - fControllingDriver->initialPowerStateForDomainState( - kIOPMRootDomainState | kIOPMPowerOn ); - - // fDesiredPowerState was adjusted before going to sleep - // with fDeviceDesire at min. - - if (StateOrder(wakePowerState) > StateOrder(fDesiredPowerState)) - { - // Must schedule a power adjustment if we changed the - // device desire. That will update the desired domain - // power on the parent power connection and ping the - // power parent if necessary. - - updatePowerClient(gIOPMPowerClientDevice, wakePowerState); - desireChanged = true; - } - } - } - - if (computeDesire || desireChanged) - computeDesiredState(initialDesire, false); - - // Absorb and propagate parent's broadcast flags - myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange | - (parentChangeFlags & kIOPMRootBroadcastFlags); - - result = startPowerChange( - /* flags */ myChangeFlags, - /* power state */ maxPowerState, - /* domain flags */ fParentsCurrentPowerFlags, - /* connection */ whichParent, - /* parent flags */ 0); - } - - // Parent is expecting an ACK from us. If we did not embark on a state - // transition, i.e. startPowerChange() returned IOPMAckImplied. We are - // still required to issue an ACK to our parent. - - if (IOPMAckImplied == result) - { - IOService * parent; - parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane); - assert(parent); - if ( parent ) - { - parent->acknowledgePowerChange( whichParent ); - parent->release(); - } - } - - // If the parent registers its power driver late, then this is the - // first opportunity to tell our parent about our desire. Or if the - // child's desire changed during a parent change notify. - - if (fControllingDriver && - ((!savedParentsKnowState && fParentsKnowState) || desireChanged)) - { - PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState %d\n", - getName(), fParentsKnowState); - requestDomainPower( fDesiredPowerState ); - } +void +IOService::handlePowerDomainDidChangeTo( IOPMRequest * request ) +{ + IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; + IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; + IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; + IOPMPowerChangeFlags myChangeFlags; + IOPMPowerStateIndex maxPowerState; + IOPMPowerStateIndex initialDesire = kPowerStateZero; + bool computeDesire = false; + bool desireChanged = false; + bool savedParentsKnowState; + IOReturn result = IOPMAckImplied; + + PM_ASSERT_IN_GATE(); + OUR_PMLog(kPMLogDidChange, parentPowerFlags, 0); + + if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) { + PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); + goto exit_no_ack; + } + + savedParentsKnowState = fParentsKnowState; + + setParentInfo(parentPowerFlags, whichParent, true); + + if (fControllingDriver) { + maxPowerState = fControllingDriver->maxCapabilityForDomainState( + fParentsCurrentPowerFlags); + + if ((parentChangeFlags & kIOPMDomainPowerDrop) == 0) { + // fMaxPowerState set a limit on self-initiated power changes. + // Update it after a parent power rise. + fMaxPowerState = maxPowerState; + } + + if (fInitialPowerChange) { + computeDesire = true; + initialDesire = fControllingDriver->initialPowerStateForDomainState( + fParentsCurrentPowerFlags); + } else if (parentChangeFlags & kIOPMRootChangeUp) { + if (fAdvisoryTickleUsed) { + // On system wake, re-compute the desired power state since + // gIOPMAdvisoryTickleEnabled will change for a full wake, + // which is an input to computeDesiredState(). This is not + // necessary for a dark wake because powerChangeDone() will + // handle the dark to full wake case, but it does no harm. + + desireChanged = true; + } + + if (fResetPowerStateOnWake) { + // Query the driver for the desired power state on system wake. + // Default implementation returns the lowest power state. + + IOPMPowerStateIndex wakePowerState = + fControllingDriver->initialPowerStateForDomainState( + kIOPMRootDomainState | kIOPMPowerOn ); + + // fDesiredPowerState was adjusted before going to sleep + // with fDeviceDesire at min. + + if (StateOrder(wakePowerState) > StateOrder(fDesiredPowerState)) { + // Must schedule a power adjustment if we changed the + // device desire. That will update the desired domain + // power on the parent power connection and ping the + // power parent if necessary. + + updatePowerClient(gIOPMPowerClientDevice, wakePowerState); + desireChanged = true; + } + } + } + + if (computeDesire || desireChanged) { + computeDesiredState(initialDesire, false); + } + + // Absorb and propagate parent's broadcast flags + myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange | + (parentChangeFlags & kIOPMRootBroadcastFlags); + +#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) + if (kIOPMAOTPower & fPowerStates[maxPowerState].inputPowerFlags) { + IOLog("aotPS %s0x%qx[%ld]\n", getName(), getRegistryEntryID(), maxPowerState); + } +#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + + result = startPowerChange( + /* flags */ myChangeFlags, + /* power state */ maxPowerState, + /* domain flags */ fParentsCurrentPowerFlags, + /* connection */ whichParent, + /* parent flags */ 0); + } + + // Parent is expecting an ACK from us. If we did not embark on a state + // transition, i.e. startPowerChange() returned IOPMAckImplied. We are + // still required to issue an ACK to our parent. + + if (IOPMAckImplied == result) { + IOService * parent; + parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane); + assert(parent); + if (parent) { + parent->acknowledgePowerChange( whichParent ); + parent->release(); + } + } + + // If the parent registers its power driver late, then this is the + // first opportunity to tell our parent about our desire. Or if the + // child's desire changed during a parent change notify. + + if (fControllingDriver && + ((!savedParentsKnowState && fParentsKnowState) || desireChanged)) { + PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState %d\n", + getName(), fParentsKnowState); + requestDomainPower( fDesiredPowerState ); + } exit_no_ack: - // Drop the retain from notifyChild(). - if (whichParent) whichParent->release(); + // Drop the retain from notifyChild(). + if (whichParent) { + whichParent->release(); + } } //********************************************************************************* @@ -2000,85 +2028,82 @@ exit_no_ack: // data together. //********************************************************************************* -void IOService::setParentInfo( - IOPMPowerFlags newPowerFlags, - IOPowerConnection * whichParent, - bool knowsState ) -{ - OSIterator * iter; - OSObject * next; - IOPowerConnection * conn; - - PM_ASSERT_IN_GATE(); - - // set our connection data - whichParent->setParentCurrentPowerFlags(newPowerFlags); - whichParent->setParentKnowsState(knowsState); - - // recompute our parent info - fParentsCurrentPowerFlags = 0; - fParentsKnowState = true; - - iter = getParentIterator(gIOPowerPlane); - if ( iter ) - { - while ( (next = iter->getNextObject()) ) - { - if ( (conn = OSDynamicCast(IOPowerConnection, next)) ) - { - fParentsKnowState &= conn->parentKnowsState(); - fParentsCurrentPowerFlags |= conn->parentCurrentPowerFlags(); - } - } - iter->release(); - } +void +IOService::setParentInfo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent, + bool knowsState ) +{ + OSIterator * iter; + OSObject * next; + IOPowerConnection * conn; + + PM_ASSERT_IN_GATE(); + + // set our connection data + whichParent->setParentCurrentPowerFlags(newPowerFlags); + whichParent->setParentKnowsState(knowsState); + + // recompute our parent info + fParentsCurrentPowerFlags = 0; + fParentsKnowState = true; + + iter = getParentIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((conn = OSDynamicCast(IOPowerConnection, next))) { + fParentsKnowState &= conn->parentKnowsState(); + fParentsCurrentPowerFlags |= conn->parentCurrentPowerFlags(); + } + } + iter->release(); + } } //****************************************************************************** // [private] trackSystemSleepPreventers //****************************************************************************** -void IOService::trackSystemSleepPreventers( - IOPMPowerStateIndex oldPowerState, - IOPMPowerStateIndex newPowerState, - IOPMPowerChangeFlags changeFlags __unused ) -{ - IOPMPowerFlags oldCapability, newCapability; - - oldCapability = fPowerStates[oldPowerState].capabilityFlags & - (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); - newCapability = fPowerStates[newPowerState].capabilityFlags & - (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); - - if (fHeadNoteChangeFlags & kIOPMInitialPowerChange) - oldCapability = 0; - if (oldCapability == newCapability) - return; - - if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep) - { - bool enablePrevention = ((oldCapability & kIOPMPreventIdleSleep) == 0); - bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList( - this, enablePrevention); +void +IOService::trackSystemSleepPreventers( + IOPMPowerStateIndex oldPowerState, + IOPMPowerStateIndex newPowerState, + IOPMPowerChangeFlags changeFlags __unused ) +{ + IOPMPowerFlags oldCapability, newCapability; + + oldCapability = fPowerStates[oldPowerState].capabilityFlags & + (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); + newCapability = fPowerStates[newPowerState].capabilityFlags & + (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); + + if (fHeadNoteChangeFlags & kIOPMInitialPowerChange) { + oldCapability = 0; + } + if (oldCapability == newCapability) { + return; + } + + if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep) { + bool enablePrevention = ((oldCapability & kIOPMPreventIdleSleep) == 0); + bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList( + this, enablePrevention); #if SUPPORT_IDLE_CANCEL - if (idleCancelAllowed && enablePrevention) - { - IOPMRequest * cancelRequest; - - cancelRequest = acquirePMRequest( getPMRootDomain(), kIOPMRequestTypeIdleCancel ); - if (cancelRequest) - { - submitPMRequest( cancelRequest ); - } - } + if (idleCancelAllowed && enablePrevention) { + IOPMRequest * cancelRequest; + + cancelRequest = acquirePMRequest( getPMRootDomain(), kIOPMRequestTypeIdleCancel ); + if (cancelRequest) { + submitPMRequest( cancelRequest ); + } + } #endif - } + } - if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep) - { - getPMRootDomain()->updatePreventSystemSleepList(this, - ((oldCapability & kIOPMPreventSystemSleep) == 0)); - } + if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep) { + getPMRootDomain()->updatePreventSystemSleepList(this, + ((oldCapability & kIOPMPreventSystemSleep) == 0)); + } } //********************************************************************************* @@ -2087,146 +2112,139 @@ void IOService::trackSystemSleepPreventers( // Called on a power parent when a child's power requirement changes. //********************************************************************************* -IOReturn IOService::requestPowerDomainState( - IOPMPowerFlags childRequestPowerFlags, - IOPowerConnection * childConnection, - unsigned long specification ) -{ - IOPMPowerStateIndex order, powerState; - IOPMPowerFlags outputPowerFlags; - IOService * child; - IOPMRequest * subRequest; - bool adjustPower = false; - - if (!initialized) - return IOPMNotYetInitialized; - - if (gIOPMWorkLoop->onThread() == false) - { - PM_LOG("%s::requestPowerDomainState\n", getName()); - return kIOReturnSuccess; - } - - OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification); - - if (!isChild(childConnection, gIOPowerPlane)) - return kIOReturnNotAttached; - - if (!fControllingDriver || !fNumberOfPowerStates) - return kIOReturnNotReady; - - child = (IOService *) childConnection->getChildEntry(gIOPowerPlane); - assert(child); - - // Remove flags from child request which we can't possibly supply - childRequestPowerFlags &= fMergedOutputPowerFlags; - - // Merge in the power flags contributed by this power parent - // at its current or impending power state. - - outputPowerFlags = fPowerStates[fCurrentPowerState].outputPowerFlags; - if (fMachineState != kIOPM_Finished) - { - if (IS_POWER_DROP && !IS_ROOT_DOMAIN) - { - // Use the lower power state when dropping power. - // Must be careful since a power drop can be cancelled - // from the following states: - // - kIOPM_OurChangeTellClientsPowerDown - // - kIOPM_OurChangeTellPriorityClientsPowerDown - // - // The child must not wait for this parent to raise power - // if the power drop was cancelled. The solution is to cancel - // the power drop if possible, then schedule an adjustment to - // re-evaluate the parent's power state. - // - // Root domain is excluded to avoid idle sleep issues. And allow - // root domain children to pop up when system is going to sleep. - - if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) || - (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)) - { - fDoNotPowerDown = true; // cancel power drop - adjustPower = true; // schedule an adjustment - PM_LOG1("%s: power drop cancelled in state %u by %s\n", - getName(), fMachineState, child->getName()); - } - else - { - // Beyond cancellation point, report the impending state. - outputPowerFlags = - fPowerStates[fHeadNotePowerState].outputPowerFlags; - } - } - else if (IS_POWER_RISE) - { - // When raising power, must report the output power flags from - // child's perspective. A child power request may arrive while - // parent is transitioning upwards. If a request arrives after - // setParentInfo() has already recorded the output power flags - // for the next power state, then using the power supplied by - // fCurrentPowerState is incorrect, and might cause the child - // to wait when it should not. - - outputPowerFlags = childConnection->parentCurrentPowerFlags(); - } - } - child->fHeadNoteDomainTargetFlags |= outputPowerFlags; - - // Map child's requested power flags to one of our power state. - - for (order = 0; order < fNumberOfPowerStates; order++) - { - powerState = fPowerStates[order].stateOrderToIndex; - if ((fPowerStates[powerState].outputPowerFlags & childRequestPowerFlags) - == childRequestPowerFlags) - break; - } - if (order >= fNumberOfPowerStates) - { - powerState = kPowerStateZero; - } - - // Conditions that warrants a power adjustment on this parent. - // Adjust power will also propagate any changes to the child's - // prevent idle/sleep flags towards the root domain. - - if (!childConnection->childHasRequestedPower() || - (powerState != childConnection->getDesiredDomainState())) - adjustPower = true; +IOReturn +IOService::requestPowerDomainState( + IOPMPowerFlags childRequestPowerFlags, + IOPowerConnection * childConnection, + unsigned long specification ) +{ + IOPMPowerStateIndex order, powerState; + IOPMPowerFlags outputPowerFlags; + IOService * child; + IOPMRequest * subRequest; + bool adjustPower = false; + + if (!initialized) { + return IOPMNotYetInitialized; + } + + if (gIOPMWorkLoop->onThread() == false) { + PM_LOG("%s::requestPowerDomainState\n", getName()); + return kIOReturnSuccess; + } + + OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification); + + if (!isChild(childConnection, gIOPowerPlane)) { + return kIOReturnNotAttached; + } + + if (!fControllingDriver || !fNumberOfPowerStates) { + return kIOReturnNotReady; + } + + child = (IOService *) childConnection->getChildEntry(gIOPowerPlane); + assert(child); + + // Remove flags from child request which we can't possibly supply + childRequestPowerFlags &= fMergedOutputPowerFlags; + + // Merge in the power flags contributed by this power parent + // at its current or impending power state. + + outputPowerFlags = fPowerStates[fCurrentPowerState].outputPowerFlags; + if (fMachineState != kIOPM_Finished) { + if (IS_POWER_DROP && !IS_ROOT_DOMAIN) { + // Use the lower power state when dropping power. + // Must be careful since a power drop can be cancelled + // from the following states: + // - kIOPM_OurChangeTellClientsPowerDown + // - kIOPM_OurChangeTellPriorityClientsPowerDown + // + // The child must not wait for this parent to raise power + // if the power drop was cancelled. The solution is to cancel + // the power drop if possible, then schedule an adjustment to + // re-evaluate the parent's power state. + // + // Root domain is excluded to avoid idle sleep issues. And allow + // root domain children to pop up when system is going to sleep. + + if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) || + (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)) { + fDoNotPowerDown = true; // cancel power drop + adjustPower = true;// schedule an adjustment + PM_LOG1("%s: power drop cancelled in state %u by %s\n", + getName(), fMachineState, child->getName()); + } else { + // Beyond cancellation point, report the impending state. + outputPowerFlags = + fPowerStates[fHeadNotePowerState].outputPowerFlags; + } + } else if (IS_POWER_RISE) { + // When raising power, must report the output power flags from + // child's perspective. A child power request may arrive while + // parent is transitioning upwards. If a request arrives after + // setParentInfo() has already recorded the output power flags + // for the next power state, then using the power supplied by + // fCurrentPowerState is incorrect, and might cause the child + // to wait when it should not. + + outputPowerFlags = childConnection->parentCurrentPowerFlags(); + } + } + child->fHeadNoteDomainTargetFlags |= outputPowerFlags; + + // Map child's requested power flags to one of our power state. -#if ENABLE_DEBUG_LOGS - if (adjustPower) - { - PM_LOG("requestPowerDomainState[%s]: %s, init %d, %u->%u\n", - getName(), child->getName(), - !childConnection->childHasRequestedPower(), - (uint32_t) childConnection->getDesiredDomainState(), - (uint32_t) powerState); - } -#endif + for (order = 0; order < fNumberOfPowerStates; order++) { + powerState = fPowerStates[order].stateOrderToIndex; + if ((fPowerStates[powerState].outputPowerFlags & childRequestPowerFlags) + == childRequestPowerFlags) { + break; + } + } + if (order >= fNumberOfPowerStates) { + powerState = kPowerStateZero; + } + + // Conditions that warrants a power adjustment on this parent. + // Adjust power will also propagate any changes to the child's + // prevent idle/sleep flags towards the root domain. - // Record the child's desires on the connection. - childConnection->setChildHasRequestedPower(); - childConnection->setDesiredDomainState( powerState ); + if (!childConnection->childHasRequestedPower() || + (powerState != childConnection->getDesiredDomainState())) { + adjustPower = true; + } - // Schedule a request to re-evaluate all children desires and - // adjust power state. Submit a request if one wasn't pending, - // or if the current request is part of a call tree. +#if ENABLE_DEBUG_LOGS + if (adjustPower) { + PM_LOG("requestPowerDomainState[%s]: %s, init %d, %u->%u\n", + getName(), child->getName(), + !childConnection->childHasRequestedPower(), + (uint32_t) childConnection->getDesiredDomainState(), + (uint32_t) powerState); + } +#endif - if (adjustPower && !fDeviceOverrideEnabled && - (!fAdjustPowerScheduled || gIOPMRequest->getRootRequest())) - { - subRequest = acquirePMRequest( - this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest ); - if (subRequest) - { - submitPMRequest( subRequest ); - fAdjustPowerScheduled = true; - } - } + // Record the child's desires on the connection. + childConnection->setChildHasRequestedPower(); + childConnection->setDesiredDomainState( powerState ); + + // Schedule a request to re-evaluate all children desires and + // adjust power state. Submit a request if one wasn't pending, + // or if the current request is part of a call tree. + + if (adjustPower && !fDeviceOverrideEnabled && + (!fAdjustPowerScheduled || gIOPMRequest->getRootRequest())) { + subRequest = acquirePMRequest( + this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest ); + if (subRequest) { + submitPMRequest( subRequest ); + fAdjustPowerScheduled = true; + } + } - return kIOReturnSuccess; + return kIOReturnSuccess; } //********************************************************************************* @@ -2238,9 +2256,10 @@ IOReturn IOService::requestPowerDomainState( // We enter the highest state until addPowerChild is called. //********************************************************************************* -IOReturn IOService::temporaryPowerClampOn( void ) +IOReturn +IOService::temporaryPowerClampOn( void ) { - return requestPowerState( gIOPMPowerClientChildProxy, kIOPMPowerStateMax ); + return requestPowerState( gIOPMPowerClientChildProxy, kIOPMPowerStateMax ); } //********************************************************************************* @@ -2255,22 +2274,25 @@ IOReturn IOService::temporaryPowerClampOn( void ) // highest power state. //********************************************************************************* -IOReturn IOService::makeUsable( void ) +IOReturn +IOService::makeUsable( void ) { - OUR_PMLog(kPMLogMakeUsable, 0, 0); - return requestPowerState( gIOPMPowerClientDevice, kIOPMPowerStateMax ); + OUR_PMLog(kPMLogMakeUsable, 0, 0); + return requestPowerState( gIOPMPowerClientDevice, kIOPMPowerStateMax ); } //********************************************************************************* // [public] currentCapability //********************************************************************************* -IOPMPowerFlags IOService::currentCapability( void ) +IOPMPowerFlags +IOService::currentCapability( void ) { - if (!initialized) - return IOPMNotPowerManaged; + if (!initialized) { + return IOPMNotPowerManaged; + } - return fCurrentCapabilityFlags; + return fCurrentCapabilityFlags; } //********************************************************************************* @@ -2281,10 +2303,11 @@ IOPMPowerFlags IOService::currentCapability( void ) // power states differ, then a power state change is initiated. //********************************************************************************* -IOReturn IOService::changePowerStateTo( unsigned long ordinal ) +IOReturn +IOService::changePowerStateTo( unsigned long ordinal ) { - OUR_PMLog(kPMLogChangeStateTo, ordinal, 0); - return requestPowerState( gIOPMPowerClientDriver, ordinal ); + OUR_PMLog(kPMLogChangeStateTo, ordinal, 0); + return requestPowerState( gIOPMPowerClientDriver, ordinal ); } //********************************************************************************* @@ -2295,10 +2318,11 @@ IOReturn IOService::changePowerStateTo( unsigned long ordinal ) // power states differ, then a power state change is initiated. //********************************************************************************* -IOReturn IOService::changePowerStateToPriv( unsigned long ordinal ) +IOReturn +IOService::changePowerStateToPriv( unsigned long ordinal ) { - OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0); - return requestPowerState( gIOPMPowerClientDevice, ordinal ); + OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0); + return requestPowerState( gIOPMPowerClientDevice, ordinal ); } //********************************************************************************* @@ -2310,43 +2334,46 @@ IOReturn IOService::changePowerStateToPriv( unsigned long ordinal ) // Override enforced - Children and Driver desires are ignored. //********************************************************************************* -IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal, - IOPMRequestTag tag ) +IOReturn +IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal, + IOPMRequestTag tag ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return kIOPMNotYetInitialized; + if (!initialized) { + return kIOPMNotYetInitialized; + } - OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0); + OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0); - request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride ); + if (!request) { + return kIOReturnNoMemory; + } - gIOPMPowerClientDevice->retain(); - request->fRequestTag = tag; - request->fArg0 = (void *) ordinal; - request->fArg1 = (void *) gIOPMPowerClientDevice; - request->fArg2 = 0; + gIOPMPowerClientDevice->retain(); + request->fRequestTag = tag; + request->fArg0 = (void *) ordinal; + request->fArg1 = (void *) gIOPMPowerClientDevice; + request->fArg2 = NULL; #if NOT_READY - if (action) - request->installCompletionAction( action, target, param ); + if (action) { + request->installCompletionAction( action, target, param ); + } #endif - // Prevent needless downwards power transitions by clamping power - // until the scheduled request is executed. + // Prevent needless downwards power transitions by clamping power + // until the scheduled request is executed. - if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates)) - { - fTempClampPowerState = StateMax(fTempClampPowerState, ordinal); - fTempClampCount++; - fOverrideMaxPowerState = ordinal; - request->fArg2 = (void *) (uintptr_t) true; - } + if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates)) { + fTempClampPowerState = StateMax(fTempClampPowerState, ordinal); + fTempClampCount++; + fOverrideMaxPowerState = ordinal; + request->fArg2 = (void *) (uintptr_t) true; + } - submitPMRequest( request ); - return IOPMNoErr; + submitPMRequest( request ); + return IOPMNoErr; } //********************************************************************************* @@ -2355,10 +2382,11 @@ IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal, // Adjust the root domain's power desire on the target //********************************************************************************* -IOReturn IOService::changePowerStateForRootDomain( IOPMPowerStateIndex ordinal ) +IOReturn +IOService::changePowerStateForRootDomain( IOPMPowerStateIndex ordinal ) { - OUR_PMLog(kPMLogChangeStateForRootDomain, ordinal, 0); - return requestPowerState( gIOPMPowerClientRootDomain, ordinal ); + OUR_PMLog(kPMLogChangeStateForRootDomain, ordinal, 0); + return requestPowerState( gIOPMPowerClientRootDomain, ordinal ); } //********************************************************************************* @@ -2368,369 +2396,394 @@ IOReturn IOService::changePowerStateForRootDomain( IOPMPowerStateIndex ordinal ) // Supplied callback invoked upon completion. //********************************************************************************* -IOReturn IOService::quiescePowerTree( - void * target, IOPMCompletionAction action, void * param ) +IOReturn +IOService::quiescePowerTree( + void * target, IOPMCompletionAction action, void * param ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return kIOPMNotYetInitialized; - if (!target || !action) - return kIOReturnBadArgument; + if (!initialized) { + return kIOPMNotYetInitialized; + } + if (!target || !action) { + return kIOReturnBadArgument; + } - OUR_PMLog(kPMLogQuiescePowerTree, 0, 0); + OUR_PMLog(kPMLogQuiescePowerTree, 0, 0); - // Target the root node instead of root domain. This is to avoid blocking - // the quiesce request behind an existing root domain request in the work - // queue. Root parent and root domain requests in the work queue must not - // block the completion of the quiesce request. + // Target the root node instead of root domain. This is to avoid blocking + // the quiesce request behind an existing root domain request in the work + // queue. Root parent and root domain requests in the work queue must not + // block the completion of the quiesce request. - request = acquirePMRequest(gIOPMRootNode, kIOPMRequestTypeQuiescePowerTree); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest(gIOPMRootNode, kIOPMRequestTypeQuiescePowerTree); + if (!request) { + return kIOReturnNoMemory; + } - request->installCompletionAction(target, action, param); + request->installCompletionAction(target, action, param); - // Submit through the normal request flow. This will make sure any request - // already in the request queue will get pushed over to the work queue for - // execution. Any request submitted after this request may not be serviced. + // Submit through the normal request flow. This will make sure any request + // already in the request queue will get pushed over to the work queue for + // execution. Any request submitted after this request may not be serviced. - submitPMRequest( request ); - return kIOReturnSuccess; + submitPMRequest( request ); + return kIOReturnSuccess; } //********************************************************************************* // [private] requestPowerState //********************************************************************************* -IOReturn IOService::requestPowerState( - const OSSymbol * client, - uint32_t state ) -{ - IOPMRequest * request; - - if (!client) - return kIOReturnBadArgument; - if (!initialized) - return kIOPMNotYetInitialized; - - request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState ); - if (!request) - return kIOReturnNoMemory; - - client->retain(); - request->fArg0 = (void *)(uintptr_t) state; - request->fArg1 = (void *) client; - request->fArg2 = 0; +IOReturn +IOService::requestPowerState( + const OSSymbol * client, + uint32_t state ) +{ + IOPMRequest * request; + + if (!client) { + return kIOReturnBadArgument; + } + if (!initialized) { + return kIOPMNotYetInitialized; + } + + request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState ); + if (!request) { + return kIOReturnNoMemory; + } + + client->retain(); + request->fArg0 = (void *)(uintptr_t) state; + request->fArg1 = (void *) client; + request->fArg2 = NULL; #if NOT_READY - if (action) - request->installCompletionAction( action, target, param ); + if (action) { + request->installCompletionAction( action, target, param ); + } #endif - // Prevent needless downwards power transitions by clamping power - // until the scheduled request is executed. + // Prevent needless downwards power transitions by clamping power + // until the scheduled request is executed. - if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates)) - { - fTempClampPowerState = StateMax(fTempClampPowerState, state); - fTempClampCount++; - request->fArg2 = (void *) (uintptr_t) true; - } + if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates)) { + fTempClampPowerState = StateMax(fTempClampPowerState, state); + fTempClampCount++; + request->fArg2 = (void *) (uintptr_t) true; + } - submitPMRequest( request ); - return IOPMNoErr; + submitPMRequest( request ); + return IOPMNoErr; } //********************************************************************************* // [private] handleRequestPowerState //********************************************************************************* -void IOService::handleRequestPowerState( IOPMRequest * request ) +void +IOService::handleRequestPowerState( IOPMRequest * request ) { - const OSSymbol * client = (const OSSymbol *) request->fArg1; - uint32_t state = (uint32_t)(uintptr_t) request->fArg0; + const OSSymbol * client = (const OSSymbol *) request->fArg1; + uint32_t state = (uint32_t)(uintptr_t) request->fArg0; - PM_ASSERT_IN_GATE(); - if (request->fArg2) - { - assert(fTempClampCount != 0); - if (fTempClampCount) fTempClampCount--; - if (!fTempClampCount) fTempClampPowerState = kPowerStateZero; - } + PM_ASSERT_IN_GATE(); + if (request->fArg2) { + assert(fTempClampCount != 0); + if (fTempClampCount) { + fTempClampCount--; + } + if (!fTempClampCount) { + fTempClampPowerState = kPowerStateZero; + } + } - if (fNumberOfPowerStates && (state >= fNumberOfPowerStates)) - state = fHighestPowerState; + if (fNumberOfPowerStates && (state >= fNumberOfPowerStates)) { + state = fHighestPowerState; + } - // The power suppression due to changePowerStateWithOverrideTo() expires - // upon the next "device" power request - changePowerStateToPriv(). + // The power suppression due to changePowerStateWithOverrideTo() expires + // upon the next "device" power request - changePowerStateToPriv(). - if ((getPMRequestType() != kIOPMRequestTypeRequestPowerStateOverride) && - (client == gIOPMPowerClientDevice)) - fOverrideMaxPowerState = kIOPMPowerStateMax; + if ((getPMRequestType() != kIOPMRequestTypeRequestPowerStateOverride) && + (client == gIOPMPowerClientDevice)) { + fOverrideMaxPowerState = kIOPMPowerStateMax; + } - if ((state == kPowerStateZero) && - (client != gIOPMPowerClientDevice) && - (client != gIOPMPowerClientDriver) && - (client != gIOPMPowerClientChildProxy)) - removePowerClient(client); - else - updatePowerClient(client, state); + if ((state == kPowerStateZero) && + (client != gIOPMPowerClientDevice) && + (client != gIOPMPowerClientDriver) && + (client != gIOPMPowerClientChildProxy)) { + removePowerClient(client); + } else { + updatePowerClient(client, state); + } - adjustPowerState(); - client->release(); + adjustPowerState(); + client->release(); } //********************************************************************************* // [private] Helper functions to update/remove power clients. //********************************************************************************* -void IOService::updatePowerClient( const OSSymbol * client, uint32_t powerState ) -{ - IOPMPowerStateIndex oldPowerState = kPowerStateZero; - - if (!fPowerClients) - fPowerClients = OSDictionary::withCapacity(4); - if (fPowerClients && client) - { - OSNumber * num = (OSNumber *) fPowerClients->getObject(client); - if (num) - { - oldPowerState = num->unsigned32BitValue(); - num->setValue(powerState); - } - else - { - num = OSNumber::withNumber(powerState, 32); - if (num) - { - fPowerClients->setObject(client, num); - num->release(); - } - } +void +IOService::updatePowerClient( const OSSymbol * client, uint32_t powerState ) +{ + IOPMPowerStateIndex oldPowerState = kPowerStateZero; + + if (!fPowerClients) { + fPowerClients = OSDictionary::withCapacity(4); + } + if (fPowerClients && client) { + OSNumber * num = (OSNumber *) fPowerClients->getObject(client); + if (num) { + oldPowerState = num->unsigned32BitValue(); + num->setValue(powerState); + } else { + num = OSNumber::withNumber(powerState, 32); + if (num) { + fPowerClients->setObject(client, num); + num->release(); + } + } - PM_ACTION_3(actionUpdatePowerClient, client, oldPowerState, powerState); - } + PM_ACTION_3(actionUpdatePowerClient, client, oldPowerState, powerState); + } } -void IOService::removePowerClient( const OSSymbol * client ) +void +IOService::removePowerClient( const OSSymbol * client ) { - if (fPowerClients && client) - fPowerClients->removeObject(client); + if (fPowerClients && client) { + fPowerClients->removeObject(client); + } } -uint32_t IOService::getPowerStateForClient( const OSSymbol * client ) +uint32_t +IOService::getPowerStateForClient( const OSSymbol * client ) { - uint32_t powerState = kPowerStateZero; + uint32_t powerState = kPowerStateZero; - if (fPowerClients && client) - { - OSNumber * num = (OSNumber *) fPowerClients->getObject(client); - if (num) powerState = num->unsigned32BitValue(); - } - return powerState; + if (fPowerClients && client) { + OSNumber * num = (OSNumber *) fPowerClients->getObject(client); + if (num) { + powerState = num->unsigned32BitValue(); + } + } + return powerState; } //********************************************************************************* // [protected] powerOverrideOnPriv //********************************************************************************* -IOReturn IOService::powerOverrideOnPriv( void ) +IOReturn +IOService::powerOverrideOnPriv( void ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return IOPMNotYetInitialized; + if (!initialized) { + return IOPMNotYetInitialized; + } - if (gIOPMWorkLoop->inGate()) - { - fDeviceOverrideEnabled = true; - return IOPMNoErr; - } + if (gIOPMWorkLoop->inGate()) { + fDeviceOverrideEnabled = true; + return IOPMNoErr; + } - request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv ); + if (!request) { + return kIOReturnNoMemory; + } - submitPMRequest( request ); - return IOPMNoErr; + submitPMRequest( request ); + return IOPMNoErr; } //********************************************************************************* // [protected] powerOverrideOffPriv //********************************************************************************* -IOReturn IOService::powerOverrideOffPriv( void ) +IOReturn +IOService::powerOverrideOffPriv( void ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return IOPMNotYetInitialized; + if (!initialized) { + return IOPMNotYetInitialized; + } - if (gIOPMWorkLoop->inGate()) - { - fDeviceOverrideEnabled = false; - return IOPMNoErr; - } + if (gIOPMWorkLoop->inGate()) { + fDeviceOverrideEnabled = false; + return IOPMNoErr; + } - request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv ); + if (!request) { + return kIOReturnNoMemory; + } - submitPMRequest( request ); - return IOPMNoErr; + submitPMRequest( request ); + return IOPMNoErr; } //********************************************************************************* // [private] handlePowerOverrideChanged //********************************************************************************* -void IOService::handlePowerOverrideChanged( IOPMRequest * request ) +void +IOService::handlePowerOverrideChanged( IOPMRequest * request ) { - PM_ASSERT_IN_GATE(); - if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv) - { - OUR_PMLog(kPMLogOverrideOn, 0, 0); - fDeviceOverrideEnabled = true; - } - else - { - OUR_PMLog(kPMLogOverrideOff, 0, 0); - fDeviceOverrideEnabled = false; - } + PM_ASSERT_IN_GATE(); + if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv) { + OUR_PMLog(kPMLogOverrideOn, 0, 0); + fDeviceOverrideEnabled = true; + } else { + OUR_PMLog(kPMLogOverrideOff, 0, 0); + fDeviceOverrideEnabled = false; + } - adjustPowerState(); + adjustPowerState(); } //********************************************************************************* // [private] computeDesiredState //********************************************************************************* -void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly ) -{ - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - uint32_t desiredState = kPowerStateZero; - uint32_t newPowerState = kPowerStateZero; - bool hasChildren = false; - - // Desired power state is always 0 without a controlling driver. - - if (!fNumberOfPowerStates) - { - fDesiredPowerState = kPowerStateZero; - return; - } - - // Examine the children's desired power state. - - iter = getChildIterator(gIOPowerPlane); - if (iter) - { - while ((next = iter->getNextObject())) - { - if ((connection = OSDynamicCast(IOPowerConnection, next))) - { - if (connection->getReadyFlag() == false) - { - PM_LOG3("[%s] %s: connection not ready\n", - getName(), __FUNCTION__); - continue; - } - if (connection->childHasRequestedPower()) - hasChildren = true; - desiredState = StateMax(connection->getDesiredDomainState(), desiredState); - } - } - iter->release(); - } - if (hasChildren) - updatePowerClient(gIOPMPowerClientChildren, desiredState); - else - removePowerClient(gIOPMPowerClientChildren); - - // Iterate through all power clients to determine the min power state. - - iter = OSCollectionIterator::withCollection(fPowerClients); - if (iter) - { - const OSSymbol * client; - while ((client = (const OSSymbol *) iter->getNextObject())) - { - // Ignore child and driver when override is in effect. - if ((fDeviceOverrideEnabled || - (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)) && - ((client == gIOPMPowerClientChildren) || - (client == gIOPMPowerClientDriver))) - continue; - - // Ignore child proxy when children are present. - if (hasChildren && (client == gIOPMPowerClientChildProxy)) - continue; - - // Advisory tickles are irrelevant unless system is in full wake - if (client == gIOPMPowerClientAdvisoryTickle && - !gIOPMAdvisoryTickleEnabled) - continue; - - desiredState = getPowerStateForClient(client); - assert(desiredState < fNumberOfPowerStates); - PM_LOG1(" %u %s\n", - desiredState, client->getCStringNoCopy()); - - newPowerState = StateMax(newPowerState, desiredState); - - if (client == gIOPMPowerClientDevice) - fDeviceDesire = desiredState; - } - iter->release(); - } - - // Factor in the temporary power desires. - - newPowerState = StateMax(newPowerState, localClamp); - newPowerState = StateMax(newPowerState, fTempClampPowerState); - - // Limit check against max power override. - - newPowerState = StateMin(newPowerState, fOverrideMaxPowerState); - - // Limit check against number of power states. - - if (newPowerState >= fNumberOfPowerStates) - newPowerState = fHighestPowerState; - - fDesiredPowerState = newPowerState; - - PM_LOG1(" temp %u, clamp %u, current %u, new %u\n", - (uint32_t) localClamp, (uint32_t) fTempClampPowerState, - (uint32_t) fCurrentPowerState, newPowerState); - - if (!computeOnly) - { - // Restart idle timer if possible when device desire has increased. - // Or if an advisory desire exists. - - if (fIdleTimerPeriod && fIdleTimerStopped) - { - restartIdleTimer(); - } - - // Invalidate cached tickle power state when desires change, and not - // due to a tickle request. In case the driver has requested a lower - // power state, but the tickle is caching a higher power state which - // will drop future tickles until the cached value is lowered or in- - // validated. The invalidation must occur before the power transition - // to avoid dropping a necessary tickle. - - if ((getPMRequestType() != kIOPMRequestTypeActivityTickle) && - (fActivityTicklePowerState != kInvalidTicklePowerState)) - { - IOLockLock(fActivityLock); - fActivityTicklePowerState = kInvalidTicklePowerState; - IOLockUnlock(fActivityLock); - } - } +void +IOService::computeDesiredState( unsigned long localClamp, bool computeOnly ) +{ + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + uint32_t desiredState = kPowerStateZero; + uint32_t newPowerState = kPowerStateZero; + bool hasChildren = false; + + // Desired power state is always 0 without a controlling driver. + + if (!fNumberOfPowerStates) { + fDesiredPowerState = kPowerStateZero; + return; + } + + // Examine the children's desired power state. + + iter = getChildIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((connection = OSDynamicCast(IOPowerConnection, next))) { + if (connection->getReadyFlag() == false) { + PM_LOG3("[%s] %s: connection not ready\n", + getName(), __FUNCTION__); + continue; + } + if (connection->childHasRequestedPower()) { + hasChildren = true; + } + desiredState = StateMax(connection->getDesiredDomainState(), desiredState); + } + } + iter->release(); + } + if (hasChildren) { + updatePowerClient(gIOPMPowerClientChildren, desiredState); + } else { + removePowerClient(gIOPMPowerClientChildren); + } + + // Iterate through all power clients to determine the min power state. + + iter = OSCollectionIterator::withCollection(fPowerClients); + if (iter) { + const OSSymbol * client; + while ((client = (const OSSymbol *) iter->getNextObject())) { + // Ignore child and driver when override is in effect. + if ((fDeviceOverrideEnabled || + (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)) && + ((client == gIOPMPowerClientChildren) || + (client == gIOPMPowerClientDriver))) { + continue; + } + + // Ignore child proxy when children are present. + if (hasChildren && (client == gIOPMPowerClientChildProxy)) { + continue; + } + + // Advisory tickles are irrelevant unless system is in full wake + if (client == gIOPMPowerClientAdvisoryTickle && + !gIOPMAdvisoryTickleEnabled) { + continue; + } + + desiredState = getPowerStateForClient(client); + assert(desiredState < fNumberOfPowerStates); + PM_LOG1(" %u %s\n", + desiredState, client->getCStringNoCopy()); + + newPowerState = StateMax(newPowerState, desiredState); + + if (client == gIOPMPowerClientDevice) { + fDeviceDesire = desiredState; + } + } + iter->release(); + } + + // Factor in the temporary power desires. + + newPowerState = StateMax(newPowerState, localClamp); + newPowerState = StateMax(newPowerState, fTempClampPowerState); + + // Limit check against max power override. + + newPowerState = StateMin(newPowerState, fOverrideMaxPowerState); + + // Limit check against number of power states. + + if (newPowerState >= fNumberOfPowerStates) { + newPowerState = fHighestPowerState; + } + +#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) + if (getPMRootDomain()->isAOTMode()) { + if ((kIOPMPreventIdleSleep & fPowerStates[newPowerState].capabilityFlags) + && !(kIOPMPreventIdleSleep & fPowerStates[fDesiredPowerState].capabilityFlags)) { + getPMRootDomain()->claimSystemWakeEvent(this, kIOPMWakeEventAOTExit, getName(), NULL); + } + } +#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + + fDesiredPowerState = newPowerState; + + PM_LOG1(" temp %u, clamp %u, current %u, new %u\n", + (uint32_t) localClamp, (uint32_t) fTempClampPowerState, + (uint32_t) fCurrentPowerState, newPowerState); + + if (!computeOnly) { + // Restart idle timer if possible when device desire has increased. + // Or if an advisory desire exists. + + if (fIdleTimerPeriod && fIdleTimerStopped) { + restartIdleTimer(); + } + + // Invalidate cached tickle power state when desires change, and not + // due to a tickle request. In case the driver has requested a lower + // power state, but the tickle is caching a higher power state which + // will drop future tickles until the cached value is lowered or in- + // validated. The invalidation must occur before the power transition + // to avoid dropping a necessary tickle. + + if ((getPMRequestType() != kIOPMRequestTypeActivityTickle) && + (fActivityTicklePowerState != kInvalidTicklePowerState)) { + IOLockLock(fActivityLock); + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); + } + } } //********************************************************************************* @@ -2738,22 +2791,27 @@ void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly // //********************************************************************************* -unsigned long IOService::currentPowerConsumption( void ) +unsigned long +IOService::currentPowerConsumption( void ) { - if (!initialized) - return kIOPMUnknown; + if (!initialized) { + return kIOPMUnknown; + } - return fCurrentPowerConsumption; + return fCurrentPowerConsumption; } //********************************************************************************* // [deprecated] getPMworkloop //********************************************************************************* -IOWorkLoop * IOService::getPMworkloop( void ) +#ifndef __LP64__ +IOWorkLoop * +IOService::getPMworkloop( void ) { - return gIOPMWorkLoop; + return gIOPMWorkLoop; } +#endif #if NOT_YET @@ -2763,71 +2821,63 @@ IOWorkLoop * IOService::getPMworkloop( void ) static void applyToPowerChildren( - IOService * service, - IOServiceApplierFunction applier, - void * context, - IOOptionBits options ) -{ - PM_ASSERT_IN_GATE(); - - IORegistryEntry * entry; - IORegistryIterator * iter; - IOPowerConnection * connection; - IOService * child; - - iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, options); - if (iter) - { - while ((entry = iter->getNextObject())) - { - // Get child of IOPowerConnection objects - if ((connection = OSDynamicCast(IOPowerConnection, entry))) - { - child = (IOService *) connection->copyChildEntry(gIOPowerPlane); - if (child) - { - (*applier)(child, context); - child->release(); - } - } - } - iter->release(); - } + IOService * service, + IOServiceApplierFunction applier, + void * context, + IOOptionBits options ) +{ + PM_ASSERT_IN_GATE(); + + IORegistryEntry * entry; + IORegistryIterator * iter; + IOPowerConnection * connection; + IOService * child; + + iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, options); + if (iter) { + while ((entry = iter->getNextObject())) { + // Get child of IOPowerConnection objects + if ((connection = OSDynamicCast(IOPowerConnection, entry))) { + child = (IOService *) connection->copyChildEntry(gIOPowerPlane); + if (child) { + (*applier)(child, context); + child->release(); + } + } + } + iter->release(); + } } static void applyToPowerParent( - IOService * service, - IOServiceApplierFunction applier, - void * context, - IOOptionBits options ) -{ - PM_ASSERT_IN_GATE(); - - IORegistryEntry * entry; - IORegistryIterator * iter; - IOPowerConnection * connection; - IOService * parent; - - iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, - options | kIORegistryIterateParents); - if (iter) - { - while ((entry = iter->getNextObject())) - { - // Get child of IOPowerConnection objects - if ((connection = OSDynamicCast(IOPowerConnection, entry))) - { - parent = (IOService *) connection->copyParentEntry(gIOPowerPlane); - if (parent) - { - (*applier)(parent, context); - parent->release(); - } - } - } - iter->release(); - } + IOService * service, + IOServiceApplierFunction applier, + void * context, + IOOptionBits options ) +{ + PM_ASSERT_IN_GATE(); + + IORegistryEntry * entry; + IORegistryIterator * iter; + IOPowerConnection * connection; + IOService * parent; + + iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, + options | kIORegistryIterateParents); + if (iter) { + while ((entry = iter->getNextObject())) { + // Get child of IOPowerConnection objects + if ((connection = OSDynamicCast(IOPowerConnection, entry))) { + parent = (IOService *) connection->copyParentEntry(gIOPowerPlane); + if (parent) { + (*applier)(parent, context); + parent->release(); + } + } + } + iter->release(); + } } #endif /* NOT_YET */ @@ -2835,9 +2885,10 @@ applyToPowerParent( // MARK: - // MARK: Activity Tickle & Idle Timer -void IOService::setAdvisoryTickleEnable( bool enable ) +void +IOService::setAdvisoryTickleEnable( bool enable ) { - gIOPMAdvisoryTickleEnabled = enable; + gIOPMAdvisoryTickleEnabled = enable; } //********************************************************************************* @@ -2850,172 +2901,150 @@ void IOService::setAdvisoryTickleEnable( bool enable ) // should be intercepted by a subclass. //********************************************************************************* -bool IOService::activityTickle( unsigned long type, unsigned long stateNumber ) +bool +IOService::activityTickle( unsigned long type, unsigned long stateNumber ) { - IOPMRequest * request; - bool noPowerChange = true; - uint32_t tickleFlags; + IOPMRequest * request; + bool noPowerChange = true; + uint32_t tickleFlags; - if (!initialized) - return true; // no power change + if (!initialized) { + return true; // no power change + } + if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber)) { + IOLockLock(fActivityLock); - if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber)) - { - IOLockLock(fActivityLock); + // Record device activity for the idle timer handler. - // Record device activity for the idle timer handler. + fDeviceWasActive = true; + fActivityTickleCount++; + clock_get_uptime(&fDeviceActiveTimestamp); - fDeviceWasActive = true; - fActivityTickleCount++; - clock_get_uptime(&fDeviceActiveTimestamp); + PM_ACTION_0(actionActivityTickle); - PM_ACTION_0(actionActivityTickle); + // Record the last tickle power state. + // This helps to filter out redundant tickles as + // this function may be called from the data path. - // Record the last tickle power state. - // This helps to filter out redundant tickles as - // this function may be called from the data path. + if ((fActivityTicklePowerState == kInvalidTicklePowerState) + || StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber)) { + fActivityTicklePowerState = stateNumber; + noPowerChange = false; - if ((fActivityTicklePowerState == kInvalidTicklePowerState) - || StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber)) - { - fActivityTicklePowerState = stateNumber; - noPowerChange = false; - - tickleFlags = kTickleTypeActivity | kTickleTypePowerRise; - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *) stateNumber; - request->fArg1 = (void *)(uintptr_t) tickleFlags; - request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; - submitPMRequest(request); - } - } - - IOLockUnlock(fActivityLock); - } - - else if ((type == kIOPMActivityTickleTypeAdvisory) && - ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero)) - { - IOLockLock(fActivityLock); - - fAdvisoryTickled = true; - - if (fAdvisoryTicklePowerState != stateNumber) - { - fAdvisoryTicklePowerState = stateNumber; - noPowerChange = false; + tickleFlags = kTickleTypeActivity | kTickleTypePowerRise; + request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); + if (request) { + request->fArg0 = (void *) stateNumber; + request->fArg1 = (void *)(uintptr_t) tickleFlags; + request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; + submitPMRequest(request); + } + } - tickleFlags = kTickleTypeAdvisory | kTickleTypePowerRise; - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *) stateNumber; - request->fArg1 = (void *)(uintptr_t) tickleFlags; - request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; - submitPMRequest(request); - } - } + IOLockUnlock(fActivityLock); + } else if ((type == kIOPMActivityTickleTypeAdvisory) && + ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero)) { + IOLockLock(fActivityLock); + + fAdvisoryTickled = true; + + if (fAdvisoryTicklePowerState != stateNumber) { + fAdvisoryTicklePowerState = stateNumber; + noPowerChange = false; + + tickleFlags = kTickleTypeAdvisory | kTickleTypePowerRise; + request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); + if (request) { + request->fArg0 = (void *) stateNumber; + request->fArg1 = (void *)(uintptr_t) tickleFlags; + request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; + submitPMRequest(request); + } + } - IOLockUnlock(fActivityLock); - } + IOLockUnlock(fActivityLock); + } - // Returns false if the activityTickle might cause a transition to a - // higher powered state, true otherwise. + // Returns false if the activityTickle might cause a transition to a + // higher powered state, true otherwise. - return noPowerChange; + return noPowerChange; } //********************************************************************************* // [private] handleActivityTickle //********************************************************************************* -void IOService::handleActivityTickle( IOPMRequest * request ) -{ - uint32_t ticklePowerState = (uint32_t)(uintptr_t) request->fArg0; - uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1; - uint32_t tickleGeneration = (uint32_t)(uintptr_t) request->fArg2; - bool adjustPower = false; - - PM_ASSERT_IN_GATE(); - if (fResetPowerStateOnWake && (tickleGeneration != gIOPMTickleGeneration)) - { - // Drivers that don't want power restored on wake will drop any - // tickles that pre-dates the current system wake. The model is - // that each wake is a fresh start, with power state depressed - // until a new tickle or an explicit power up request from the - // driver. It is possible for the PM work loop to enter the - // system sleep path with tickle requests queued. - - return; - } - - if (tickleFlags & kTickleTypeActivity) - { - IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire); - uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop - - if (tickleFlags & kTickleTypePowerRise) - { - if ((StateOrder(ticklePowerState) > deviceDesireOrder) && - (ticklePowerState < fNumberOfPowerStates)) - { - fIdleTimerMinPowerState = ticklePowerState; - updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); - adjustPower = true; - } - } - else if ((deviceDesireOrder > StateOrder(fIdleTimerMinPowerState)) && - (idleTimerGeneration == fIdleTimerGeneration)) - { - // Power drop due to idle timer expiration. - // Do not allow idle timer to reduce power below tickle power. - // This prevents the idle timer from decreasing the device desire - // to zero and cancelling the effect of a pre-sleep tickle when - // system wakes up to doze state, while the device is unable to - // raise its power state to satisfy the tickle. - - deviceDesireOrder--; - if (deviceDesireOrder < fNumberOfPowerStates) - { - ticklePowerState = fPowerStates[deviceDesireOrder].stateOrderToIndex; - updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); - adjustPower = true; - } - } - } - else // advisory tickle - { - if (tickleFlags & kTickleTypePowerRise) - { - if ((ticklePowerState == fDeviceUsablePowerState) && - (ticklePowerState < fNumberOfPowerStates)) - { - updatePowerClient(gIOPMPowerClientAdvisoryTickle, ticklePowerState); - fHasAdvisoryDesire = true; - fAdvisoryTickleUsed = true; - adjustPower = true; - } - else - { - IOLockLock(fActivityLock); - fAdvisoryTicklePowerState = kInvalidTicklePowerState; - IOLockUnlock(fActivityLock); - } - } - else if (fHasAdvisoryDesire) - { - removePowerClient(gIOPMPowerClientAdvisoryTickle); - fHasAdvisoryDesire = false; - adjustPower = true; - } - } - - if (adjustPower) - { - adjustPowerState(); - } +void +IOService::handleActivityTickle( IOPMRequest * request ) +{ + uint32_t ticklePowerState = (uint32_t)(uintptr_t) request->fArg0; + uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1; + uint32_t tickleGeneration = (uint32_t)(uintptr_t) request->fArg2; + bool adjustPower = false; + + PM_ASSERT_IN_GATE(); + if (fResetPowerStateOnWake && (tickleGeneration != gIOPMTickleGeneration)) { + // Drivers that don't want power restored on wake will drop any + // tickles that pre-dates the current system wake. The model is + // that each wake is a fresh start, with power state depressed + // until a new tickle or an explicit power up request from the + // driver. It is possible for the PM work loop to enter the + // system sleep path with tickle requests queued. + + return; + } + + if (tickleFlags & kTickleTypeActivity) { + IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire); + uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop + + if (tickleFlags & kTickleTypePowerRise) { + if ((StateOrder(ticklePowerState) > deviceDesireOrder) && + (ticklePowerState < fNumberOfPowerStates)) { + fIdleTimerMinPowerState = ticklePowerState; + updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); + adjustPower = true; + } + } else if ((deviceDesireOrder > StateOrder(fIdleTimerMinPowerState)) && + (idleTimerGeneration == fIdleTimerGeneration)) { + // Power drop due to idle timer expiration. + // Do not allow idle timer to reduce power below tickle power. + // This prevents the idle timer from decreasing the device desire + // to zero and cancelling the effect of a pre-sleep tickle when + // system wakes up to doze state, while the device is unable to + // raise its power state to satisfy the tickle. + + deviceDesireOrder--; + if (deviceDesireOrder < fNumberOfPowerStates) { + ticklePowerState = fPowerStates[deviceDesireOrder].stateOrderToIndex; + updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); + adjustPower = true; + } + } + } else { // advisory tickle + if (tickleFlags & kTickleTypePowerRise) { + if ((ticklePowerState == fDeviceUsablePowerState) && + (ticklePowerState < fNumberOfPowerStates)) { + updatePowerClient(gIOPMPowerClientAdvisoryTickle, ticklePowerState); + fHasAdvisoryDesire = true; + fAdvisoryTickleUsed = true; + adjustPower = true; + } else { + IOLockLock(fActivityLock); + fAdvisoryTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); + } + } else if (fHasAdvisoryDesire) { + removePowerClient(gIOPMPowerClientAdvisoryTickle); + fHasAdvisoryDesire = false; + adjustPower = true; + } + } + + if (adjustPower) { + adjustPowerState(); + } } //****************************************************************************** @@ -3025,40 +3054,46 @@ void IOService::handleActivityTickle( IOPMRequest * request ) // Start the idle timer. Period is in seconds. //****************************************************************************** -IOReturn IOService::setIdleTimerPeriod( unsigned long period ) +IOReturn +IOService::setIdleTimerPeriod( unsigned long period ) { - if (!initialized) - return IOPMNotYetInitialized; + if (!initialized) { + return IOPMNotYetInitialized; + } - OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod); + OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod); - IOPMRequest * request = - acquirePMRequest( this, kIOPMRequestTypeSetIdleTimerPeriod ); - if (!request) - return kIOReturnNoMemory; + IOPMRequest * request = + acquirePMRequest( this, kIOPMRequestTypeSetIdleTimerPeriod ); + if (!request) { + return kIOReturnNoMemory; + } - request->fArg0 = (void *) period; - submitPMRequest( request ); + request->fArg0 = (void *) period; + submitPMRequest( request ); - return kIOReturnSuccess; + return kIOReturnSuccess; } -IOReturn IOService::setIgnoreIdleTimer( bool ignore ) +IOReturn +IOService::setIgnoreIdleTimer( bool ignore ) { - if (!initialized) - return IOPMNotYetInitialized; + if (!initialized) { + return IOPMNotYetInitialized; + } - OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0); + OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0); - IOPMRequest * request = - acquirePMRequest( this, kIOPMRequestTypeIgnoreIdleTimer ); - if (!request) - return kIOReturnNoMemory; + IOPMRequest * request = + acquirePMRequest( this, kIOPMRequestTypeIgnoreIdleTimer ); + if (!request) { + return kIOReturnNoMemory; + } - request->fArg0 = (void *) ignore; - submitPMRequest( request ); + request->fArg0 = (void *) ignore; + submitPMRequest( request ); - return kIOReturnSuccess; + return kIOReturnSuccess; } //****************************************************************************** @@ -3068,99 +3103,100 @@ IOReturn IOService::setIgnoreIdleTimer( bool ignore ) // next lowest power state. //****************************************************************************** -SInt32 IOService::nextIdleTimeout( - AbsoluteTime currentTime, - AbsoluteTime lastActivity, - unsigned int powerState) +SInt32 +IOService::nextIdleTimeout( + AbsoluteTime currentTime, + AbsoluteTime lastActivity, + unsigned int powerState) { - AbsoluteTime delta; - UInt64 delta_ns; - SInt32 delta_secs; - SInt32 delay_secs; + AbsoluteTime delta; + UInt64 delta_ns; + SInt32 delta_secs; + SInt32 delay_secs; - // Calculate time difference using funky macro from clock.h. - delta = currentTime; - SUB_ABSOLUTETIME(&delta, &lastActivity); + // Calculate time difference using funky macro from clock.h. + delta = currentTime; + SUB_ABSOLUTETIME(&delta, &lastActivity); - // Figure it in seconds. - absolutetime_to_nanoseconds(delta, &delta_ns); - delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC); + // Figure it in seconds. + absolutetime_to_nanoseconds(delta, &delta_ns); + delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC); - // Be paranoid about delta somehow exceeding timer period. - if (delta_secs < (int) fIdleTimerPeriod) - delay_secs = (int) fIdleTimerPeriod - delta_secs; - else - delay_secs = (int) fIdleTimerPeriod; + // Be paranoid about delta somehow exceeding timer period. + if (delta_secs < (int) fIdleTimerPeriod) { + delay_secs = (int) fIdleTimerPeriod - delta_secs; + } else { + delay_secs = (int) fIdleTimerPeriod; + } - return (SInt32)delay_secs; + return (SInt32)delay_secs; } //********************************************************************************* // [public] start_PM_idle_timer //********************************************************************************* -void IOService::start_PM_idle_timer( void ) +void +IOService::start_PM_idle_timer( void ) { - static const int maxTimeout = 100000; - static const int minTimeout = 1; - AbsoluteTime uptime, deadline; - SInt32 idle_in = 0; - boolean_t pending; + static const int maxTimeout = 100000; + static const int minTimeout = 1; + AbsoluteTime uptime, deadline; + SInt32 idle_in = 0; + boolean_t pending; - if (!initialized || !fIdleTimerPeriod) - return; + if (!initialized || !fIdleTimerPeriod) { + return; + } - IOLockLock(fActivityLock); + IOLockLock(fActivityLock); - clock_get_uptime(&uptime); + clock_get_uptime(&uptime); - // Subclasses may modify idle sleep algorithm - idle_in = nextIdleTimeout(uptime, fDeviceActiveTimestamp, fCurrentPowerState); + // Subclasses may modify idle sleep algorithm + idle_in = nextIdleTimeout(uptime, fDeviceActiveTimestamp, fCurrentPowerState); - // Check for out-of range responses - if (idle_in > maxTimeout) - { - // use standard implementation - idle_in = IOService::nextIdleTimeout(uptime, - fDeviceActiveTimestamp, - fCurrentPowerState); - } else if (idle_in < minTimeout) { - idle_in = fIdleTimerPeriod; - } + // Check for out-of range responses + if (idle_in > maxTimeout) { + // use standard implementation + idle_in = IOService::nextIdleTimeout(uptime, + fDeviceActiveTimestamp, + fCurrentPowerState); + } else if (idle_in < minTimeout) { + idle_in = fIdleTimerPeriod; + } - IOLockUnlock(fActivityLock); + IOLockUnlock(fActivityLock); - fNextIdleTimerPeriod = idle_in; - fIdleTimerStartTime = uptime; + fNextIdleTimerPeriod = idle_in; + fIdleTimerStartTime = uptime; - retain(); - clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline); - ADD_ABSOLUTETIME(&deadline, &uptime); - pending = thread_call_enter_delayed(fIdleTimer, deadline); - if (pending) release(); + retain(); + clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline); + ADD_ABSOLUTETIME(&deadline, &uptime); + pending = thread_call_enter_delayed(fIdleTimer, deadline); + if (pending) { + release(); + } } //********************************************************************************* // [private] restartIdleTimer //********************************************************************************* -void IOService::restartIdleTimer( void ) +void +IOService::restartIdleTimer( void ) { - if (fDeviceDesire != kPowerStateZero) - { - fIdleTimerStopped = false; - fActivityTickleCount = 0; - start_PM_idle_timer(); - } - else if (fHasAdvisoryDesire) - { - fIdleTimerStopped = false; - start_PM_idle_timer(); - } - else - { - fIdleTimerStopped = true; - } + if (fDeviceDesire != kPowerStateZero) { + fIdleTimerStopped = false; + fActivityTickleCount = 0; + start_PM_idle_timer(); + } else if (fHasAdvisoryDesire) { + fIdleTimerStopped = false; + start_PM_idle_timer(); + } else { + fIdleTimerStopped = true; + } } //********************************************************************************* @@ -3169,17 +3205,18 @@ void IOService::restartIdleTimer( void ) static void idle_timer_expired( - thread_call_param_t arg0, thread_call_param_t arg1 ) + thread_call_param_t arg0, thread_call_param_t arg1 ) { - IOService * me = (IOService *) arg0; + IOService * me = (IOService *) arg0; - if (gIOPMWorkLoop) - gIOPMWorkLoop->runAction( - OSMemberFunctionCast(IOWorkLoop::Action, me, - &IOService::idleTimerExpired), - me); + if (gIOPMWorkLoop) { + gIOPMWorkLoop->runAction( + OSMemberFunctionCast(IOWorkLoop::Action, me, + &IOService::idleTimerExpired), + me); + } - me->release(); + me->release(); } //********************************************************************************* @@ -3190,83 +3227,79 @@ idle_timer_expired( // activity, switch to the next lower power state and restart the timer. //********************************************************************************* -void IOService::idleTimerExpired( void ) +void +IOService::idleTimerExpired( void ) { - IOPMRequest * request; - bool restartTimer = true; - uint32_t tickleFlags; + IOPMRequest * request; + bool restartTimer = true; + uint32_t tickleFlags; - if ( !initialized || !fIdleTimerPeriod || fIdleTimerStopped || - fLockedFlags.PMStop ) - return; + if (!initialized || !fIdleTimerPeriod || fIdleTimerStopped || + fLockedFlags.PMStop) { + return; + } - fIdleTimerStartTime = 0; + fIdleTimerStartTime = 0; - IOLockLock(fActivityLock); + IOLockLock(fActivityLock); - // Check for device activity (tickles) over last timer period. + // Check for device activity (tickles) over last timer period. - if (fDeviceWasActive) - { - // Device was active - do not drop power, restart timer. - fDeviceWasActive = false; - } - else if (!fIdleTimerIgnored) - { - // No device activity - drop power state by one level. - // Decrement the cached tickle power state when possible. - // This value may be kInvalidTicklePowerState before activityTickle() - // is called, but the power drop request must be issued regardless. + if (fDeviceWasActive) { + // Device was active - do not drop power, restart timer. + fDeviceWasActive = false; + } else if (!fIdleTimerIgnored) { + // No device activity - drop power state by one level. + // Decrement the cached tickle power state when possible. + // This value may be kInvalidTicklePowerState before activityTickle() + // is called, but the power drop request must be issued regardless. - if ((fActivityTicklePowerState != kInvalidTicklePowerState) && - (fActivityTicklePowerState != kPowerStateZero)) - fActivityTicklePowerState--; - - tickleFlags = kTickleTypeActivity | kTickleTypePowerDrop; - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration; - request->fArg1 = (void *)(uintptr_t) tickleFlags; - request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; - submitPMRequest( request ); - - // Do not restart timer until after the tickle request has been - // processed. - - restartTimer = false; - } - } - - if (fAdvisoryTickled) - { - fAdvisoryTickled = false; - } - else if (fHasAdvisoryDesire) - { - // Want new tickles to turn into pm request after we drop the lock - fAdvisoryTicklePowerState = kInvalidTicklePowerState; + if ((fActivityTicklePowerState != kInvalidTicklePowerState) && + (fActivityTicklePowerState != kPowerStateZero)) { + fActivityTicklePowerState--; + } - tickleFlags = kTickleTypeAdvisory | kTickleTypePowerDrop; - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration; - request->fArg1 = (void *)(uintptr_t) tickleFlags; - request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; - submitPMRequest( request ); + tickleFlags = kTickleTypeActivity | kTickleTypePowerDrop; + request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); + if (request) { + request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration; + request->fArg1 = (void *)(uintptr_t) tickleFlags; + request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; + submitPMRequest( request ); - // Do not restart timer until after the tickle request has been - // processed. + // Do not restart timer until after the tickle request has been + // processed. - restartTimer = false; - } - } + restartTimer = false; + } + } + + if (fAdvisoryTickled) { + fAdvisoryTickled = false; + } else if (fHasAdvisoryDesire) { + // Want new tickles to turn into pm request after we drop the lock + fAdvisoryTicklePowerState = kInvalidTicklePowerState; + + tickleFlags = kTickleTypeAdvisory | kTickleTypePowerDrop; + request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); + if (request) { + request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration; + request->fArg1 = (void *)(uintptr_t) tickleFlags; + request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; + submitPMRequest( request ); + + // Do not restart timer until after the tickle request has been + // processed. + + restartTimer = false; + } + } - IOLockUnlock(fActivityLock); + IOLockUnlock(fActivityLock); - if (restartTimer) - start_PM_idle_timer(); + if (restartTimer) { + start_PM_idle_timer(); + } } #ifndef __LP64__ @@ -3274,7 +3307,8 @@ void IOService::idleTimerExpired( void ) // [deprecated] PM_idle_timer_expiration //********************************************************************************* -void IOService::PM_idle_timer_expiration( void ) +void +IOService::PM_idle_timer_expiration( void ) { } @@ -3282,7 +3316,8 @@ void IOService::PM_idle_timer_expiration( void ) // [deprecated] command_received //********************************************************************************* -void IOService::command_received( void *statePtr , void *, void * , void * ) +void +IOService::command_received( void *statePtr, void *, void *, void * ) { } #endif /* !__LP64__ */ @@ -3294,9 +3329,10 @@ void IOService::command_received( void *statePtr , void *, void * , void * ) // power domains will pass it on to their children, etc. //********************************************************************************* -IOReturn IOService::setAggressiveness( unsigned long type, unsigned long newLevel ) +IOReturn +IOService::setAggressiveness( unsigned long type, unsigned long newLevel ) { - return kIOReturnSuccess; + return kIOReturnSuccess; } //********************************************************************************* @@ -3305,14 +3341,16 @@ IOReturn IOService::setAggressiveness( unsigned long type, unsigned long newLeve // Called by the user client. //********************************************************************************* -IOReturn IOService::getAggressiveness( unsigned long type, unsigned long * currentLevel ) +IOReturn +IOService::getAggressiveness( unsigned long type, unsigned long * currentLevel ) { - IOPMrootDomain * rootDomain = getPMRootDomain(); + IOPMrootDomain * rootDomain = getPMRootDomain(); - if (!rootDomain) - return kIOReturnNotReady; + if (!rootDomain) { + return kIOReturnNotReady; + } - return rootDomain->getAggressiveness( type, currentLevel ); + return rootDomain->getAggressiveness( type, currentLevel ); } //********************************************************************************* @@ -3320,12 +3358,14 @@ IOReturn IOService::getAggressiveness( unsigned long type, unsigned long * curre // //********************************************************************************* -UInt32 IOService::getPowerState( void ) +UInt32 +IOService::getPowerState( void ) { - if (!initialized) - return kPowerStateZero; + if (!initialized) { + return kPowerStateZero; + } - return fCurrentPowerState; + return fCurrentPowerState; } #ifndef __LP64__ @@ -3336,75 +3376,67 @@ UInt32 IOService::getPowerState( void ) // power domains will pass it on to their children, etc. //********************************************************************************* -IOReturn IOService::systemWake( void ) -{ - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - IOService * theChild; - - iter = getChildIterator(gIOPowerPlane); - if ( iter ) - { - while ( (next = iter->getNextObject()) ) - { - if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) - { - if (connection->getReadyFlag() == false) - { - PM_LOG3("[%s] %s: connection not ready\n", - getName(), __FUNCTION__); - continue; - } - - theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane); - if ( theChild ) - { - theChild->systemWake(); - theChild->release(); - } - } - } - iter->release(); - } - - if ( fControllingDriver != NULL ) - { - if ( fControllingDriver->didYouWakeSystem() ) - { - makeUsable(); - } - } - - return IOPMNoErr; +IOReturn +IOService::systemWake( void ) +{ + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOService * theChild; + + iter = getChildIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((connection = OSDynamicCast(IOPowerConnection, next))) { + if (connection->getReadyFlag() == false) { + PM_LOG3("[%s] %s: connection not ready\n", + getName(), __FUNCTION__); + continue; + } + + theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane); + if (theChild) { + theChild->systemWake(); + theChild->release(); + } + } + } + iter->release(); + } + + if (fControllingDriver != NULL) { + if (fControllingDriver->didYouWakeSystem()) { + makeUsable(); + } + } + + return IOPMNoErr; } //********************************************************************************* // [deprecated] temperatureCriticalForZone //********************************************************************************* -IOReturn IOService::temperatureCriticalForZone( IOService * whichZone ) -{ - IOService * theParent; - IOService * theNub; - - OUR_PMLog(kPMLogCriticalTemp, 0, 0); - - if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT ) - { - theNub = (IOService *)copyParentEntry(gIOPowerPlane); - if ( theNub ) - { - theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane); - theNub->release(); - if ( theParent ) - { - theParent->temperatureCriticalForZone(whichZone); - theParent->release(); - } - } - } - return IOPMNoErr; +IOReturn +IOService::temperatureCriticalForZone( IOService * whichZone ) +{ + IOService * theParent; + IOService * theNub; + + OUR_PMLog(kPMLogCriticalTemp, 0, 0); + + if (inPlane(gIOPowerPlane) && !IS_PM_ROOT) { + theNub = (IOService *)copyParentEntry(gIOPowerPlane); + if (theNub) { + theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane); + theNub->release(); + if (theParent) { + theParent->temperatureCriticalForZone(whichZone); + theParent->release(); + } + } + } + return IOPMNoErr; } #endif /* !__LP64__ */ @@ -3417,457 +3449,479 @@ IOReturn IOService::temperatureCriticalForZone( IOService * whichZone ) // All power state changes starts here. //********************************************************************************* -IOReturn IOService::startPowerChange( - IOPMPowerChangeFlags changeFlags, - IOPMPowerStateIndex powerState, - IOPMPowerFlags domainFlags, - IOPowerConnection * parentConnection, - IOPMPowerFlags parentFlags ) -{ - PM_ASSERT_IN_GATE(); - assert( fMachineState == kIOPM_Finished ); - assert( powerState < fNumberOfPowerStates ); - - if (powerState >= fNumberOfPowerStates) - return IOPMAckImplied; - - fIsPreChange = true; - PM_ACTION_2(actionPowerChangeOverride, &powerState, &changeFlags); - - if (changeFlags & kIOPMExpireIdleTimer) - { - // Root domain requested removal of tickle influence - if (StateOrder(fDeviceDesire) > StateOrder(powerState)) - { - // Reset device desire down to the clamped power state - updatePowerClient(gIOPMPowerClientDevice, powerState); - computeDesiredState(kPowerStateZero, true); - - // Invalidate tickle cache so the next tickle will issue a request - IOLockLock(fActivityLock); - fDeviceWasActive = false; - fActivityTicklePowerState = kInvalidTicklePowerState; - IOLockUnlock(fActivityLock); - - fIdleTimerMinPowerState = kPowerStateZero; - } - } - - // Root domain's override handler may cancel the power change by - // setting the kIOPMNotDone flag. - - if (changeFlags & kIOPMNotDone) - return IOPMAckImplied; - - // Forks to either Driver or Parent initiated power change paths. - - fHeadNoteChangeFlags = changeFlags; - fHeadNotePowerState = powerState; - fHeadNotePowerArrayEntry = &fPowerStates[ powerState ]; - fHeadNoteParentConnection = NULL; - - if (changeFlags & kIOPMSelfInitiated) - { - if (changeFlags & kIOPMSynchronize) - OurSyncStart(); - else - OurChangeStart(); - return 0; - } - else - { - assert(changeFlags & kIOPMParentInitiated); - fHeadNoteDomainFlags = domainFlags; - fHeadNoteParentFlags = parentFlags; - fHeadNoteParentConnection = parentConnection; - return ParentChangeStart(); - } +IOReturn +IOService::startPowerChange( + IOPMPowerChangeFlags changeFlags, + IOPMPowerStateIndex powerState, + IOPMPowerFlags domainFlags, + IOPowerConnection * parentConnection, + IOPMPowerFlags parentFlags ) +{ + uint32_t savedPMActionsParam; + + PM_ASSERT_IN_GATE(); + assert( fMachineState == kIOPM_Finished ); + assert( powerState < fNumberOfPowerStates ); + + if (powerState >= fNumberOfPowerStates) { + return IOPMAckImplied; + } + + fIsPreChange = true; + savedPMActionsParam = fPMActions.parameter; + PM_ACTION_2(actionPowerChangeOverride, &powerState, &changeFlags); + + // rdar://problem/55040032 + // Schedule a power adjustment after removing the power clamp + // to inform our power parent(s) about our latest desired domain + // power state. For a self-initiated change, let OurChangeStart() + // automatically request parent power when necessary. + if (!fAdjustPowerScheduled && + ((changeFlags & kIOPMSelfInitiated) == 0) && + ((fPMActions.parameter & kPMActionsFlagLimitPower) == 0) && + ((savedPMActionsParam & kPMActionsFlagLimitPower) != 0)) { + IOPMRequest * request = acquirePMRequest(this, kIOPMRequestTypeAdjustPowerState); + if (request) { + submitPMRequest(request); + fAdjustPowerScheduled = true; + } + } + + if (changeFlags & kIOPMExpireIdleTimer) { + // Root domain requested removal of tickle influence + if (StateOrder(fDeviceDesire) > StateOrder(powerState)) { + // Reset device desire down to the clamped power state + updatePowerClient(gIOPMPowerClientDevice, powerState); + computeDesiredState(kPowerStateZero, true); + + // Invalidate tickle cache so the next tickle will issue a request + IOLockLock(fActivityLock); + fDeviceWasActive = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); + + fIdleTimerMinPowerState = kPowerStateZero; + } + } + + // Root domain's override handler may cancel the power change by + // setting the kIOPMNotDone flag. + + if (changeFlags & kIOPMNotDone) { + return IOPMAckImplied; + } + + // Forks to either Driver or Parent initiated power change paths. + + fHeadNoteChangeFlags = changeFlags; + fHeadNotePowerState = powerState; + fHeadNotePowerArrayEntry = &fPowerStates[powerState]; + fHeadNoteParentConnection = NULL; + + if (changeFlags & kIOPMSelfInitiated) { + if (changeFlags & kIOPMSynchronize) { + OurSyncStart(); + } else { + OurChangeStart(); + } + return 0; + } else { + assert(changeFlags & kIOPMParentInitiated); + fHeadNoteDomainFlags = domainFlags; + fHeadNoteParentFlags = parentFlags; + fHeadNoteParentConnection = parentConnection; + return ParentChangeStart(); + } } //********************************************************************************* // [private] notifyInterestedDrivers //********************************************************************************* -bool IOService::notifyInterestedDrivers( void ) -{ - IOPMinformee * informee; - IOPMinformeeList * list = fInterestedDrivers; - DriverCallParam * param; - IOItemCount count; - - PM_ASSERT_IN_GATE(); - assert( fDriverCallParamCount == 0 ); - assert( fHeadNotePendingAcks == 0 ); - - fHeadNotePendingAcks = 0; - - count = list->numberOfItems(); - if (!count) - goto done; // no interested drivers - - // Allocate an array of interested drivers and their return values - // for the callout thread. Everything else is still "owned" by the - // PM work loop, which can run to process acknowledgePowerChange() - // responses. - - param = (DriverCallParam *) fDriverCallParamPtr; - if (count > fDriverCallParamSlots) - { - if (fDriverCallParamSlots) - { - assert(fDriverCallParamPtr); - IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots); - fDriverCallParamPtr = 0; - fDriverCallParamSlots = 0; - } - - param = IONew(DriverCallParam, count); - if (!param) - goto done; // no memory - - fDriverCallParamPtr = (void *) param; - fDriverCallParamSlots = count; - } - - informee = list->firstInList(); - assert(informee); - for (IOItemCount i = 0; i < count; i++) - { - informee->timer = -1; - param[i].Target = informee; - informee->retain(); - informee = list->nextInList( informee ); - } - - fDriverCallParamCount = count; - fHeadNotePendingAcks = count; - - // Block state machine and wait for callout completion. - assert(!fDriverCallBusy); - fDriverCallBusy = true; - thread_call_enter( fDriverCallEntry ); - return true; +bool +IOService::notifyInterestedDrivers( void ) +{ + IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; + DriverCallParam * param; + IOItemCount count; + IOItemCount skipCnt = 0; + + PM_ASSERT_IN_GATE(); + assert( fDriverCallParamCount == 0 ); + assert( fHeadNotePendingAcks == 0 ); + + fHeadNotePendingAcks = 0; + + count = list->numberOfItems(); + if (!count) { + goto done; // no interested drivers + } + // Allocate an array of interested drivers and their return values + // for the callout thread. Everything else is still "owned" by the + // PM work loop, which can run to process acknowledgePowerChange() + // responses. + + param = (DriverCallParam *) fDriverCallParamPtr; + if (count > fDriverCallParamSlots) { + if (fDriverCallParamSlots) { + assert(fDriverCallParamPtr); + IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots); + fDriverCallParamPtr = NULL; + fDriverCallParamSlots = 0; + } + + param = IONew(DriverCallParam, count); + if (!param) { + goto done; // no memory + } + fDriverCallParamPtr = (void *) param; + fDriverCallParamSlots = count; + } + + informee = list->firstInList(); + assert(informee); + for (IOItemCount i = 0; i < count; i++) { + if (fInitialSetPowerState || (fHeadNoteChangeFlags & kIOPMInitialPowerChange)) { + // Skip notifying self, if 'kIOPMInitialDeviceState' is set and + // this is the initial power state change + if ((this == informee->whatObject) && + (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState)) { + skipCnt++; + continue; + } + } + informee->timer = -1; + param[i].Target = informee; + informee->retain(); + informee = list->nextInList( informee ); + } + + count -= skipCnt; + if (!count) { + goto done; + } + fDriverCallParamCount = count; + fHeadNotePendingAcks = count; + + // Block state machine and wait for callout completion. + assert(!fDriverCallBusy); + fDriverCallBusy = true; + thread_call_enter( fDriverCallEntry ); + return true; done: - // Return false if there are no interested drivers or could not schedule - // callout thread due to error. - return false; + // Return false if there are no interested drivers or could not schedule + // callout thread due to error. + return false; } //********************************************************************************* // [private] notifyInterestedDriversDone //********************************************************************************* -void IOService::notifyInterestedDriversDone( void ) -{ - IOPMinformee * informee; - IOItemCount count; - DriverCallParam * param; - IOReturn result; - - PM_ASSERT_IN_GATE(); - assert( fDriverCallBusy == false ); - assert( fMachineState == kIOPM_DriverThreadCallDone ); - - param = (DriverCallParam *) fDriverCallParamPtr; - count = fDriverCallParamCount; - - if (param && count) - { - for (IOItemCount i = 0; i < count; i++, param++) - { - informee = (IOPMinformee *) param->Target; - result = param->Result; - - if ((result == IOPMAckImplied) || (result < 0)) - { - // Interested driver return IOPMAckImplied. - // If informee timer is zero, it must have de-registered - // interest during the thread callout. That also drops - // the pending ack count. - - if (fHeadNotePendingAcks && informee->timer) - fHeadNotePendingAcks--; - - informee->timer = 0; - } - else if (informee->timer) - { - assert(informee->timer == -1); - - // Driver has not acked, and has returned a positive result. - // Enforce a minimum permissible timeout value. - // Make the min value large enough so timeout is less likely - // to occur if a driver misinterpreted that the return value - // should be in microsecond units. And make it large enough - // to be noticeable if a driver neglects to ack. - - if (result < kMinAckTimeoutTicks) - result = kMinAckTimeoutTicks; - - informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; - } - // else, child has already acked or driver has removed interest, - // and head_note_pendingAcks decremented. - // informee may have been removed from the interested drivers list, - // thus the informee must be retained across the callout. - - informee->release(); - } +void +IOService::notifyInterestedDriversDone( void ) +{ + IOPMinformee * informee; + IOItemCount count; + DriverCallParam * param; + IOReturn result; + int maxTimeout = 0; + + PM_ASSERT_IN_GATE(); + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); + + param = (DriverCallParam *) fDriverCallParamPtr; + count = fDriverCallParamCount; + + if (param && count) { + for (IOItemCount i = 0; i < count; i++, param++) { + informee = (IOPMinformee *) param->Target; + result = param->Result; + + if ((result == IOPMAckImplied) || (result < 0)) { + // Interested driver return IOPMAckImplied. + // If informee timer is zero, it must have de-registered + // interest during the thread callout. That also drops + // the pending ack count. + + if (fHeadNotePendingAcks && informee->timer) { + fHeadNotePendingAcks--; + } + + informee->timer = 0; + } else if (informee->timer) { + assert(informee->timer == -1); + + // Driver has not acked, and has returned a positive result. + // Enforce a minimum permissible timeout value. + // Make the min value large enough so timeout is less likely + // to occur if a driver misinterpreted that the return value + // should be in microsecond units. And make it large enough + // to be noticeable if a driver neglects to ack. + + if (result < kMinAckTimeoutTicks) { + result = kMinAckTimeoutTicks; + } + + informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; + if (result > maxTimeout) { + maxTimeout = result; + } + } + // else, child has already acked or driver has removed interest, + // and head_note_pendingAcks decremented. + // informee may have been removed from the interested drivers list, + // thus the informee must be retained across the callout. + + informee->release(); + } - fDriverCallParamCount = 0; + fDriverCallParamCount = 0; - if ( fHeadNotePendingAcks ) - { - OUR_PMLog(kPMLogStartAckTimer, 0, 0); - start_ack_timer(); - } - } + if (fHeadNotePendingAcks) { + OUR_PMLog(kPMLogStartAckTimer, 0, 0); + start_ack_timer(); + getPMRootDomain()->reset_watchdog_timer(this, maxTimeout / USEC_PER_SEC + 1); + } + } - MS_POP(); // pop the machine state passed to notifyAll() + MS_POP(); // pop the machine state passed to notifyAll() - // If interest acks are outstanding, block the state machine until - // fHeadNotePendingAcks drops to zero before notifying root domain. - // Otherwise notify root domain directly. + // If interest acks are outstanding, block the state machine until + // fHeadNotePendingAcks drops to zero before notifying root domain. + // Otherwise notify root domain directly. - if (!fHeadNotePendingAcks) - { - notifyRootDomain(); - } - else - { - MS_PUSH(fMachineState); - fMachineState = kIOPM_NotifyChildrenStart; - } + if (!fHeadNotePendingAcks) { + notifyRootDomain(); + } else { + MS_PUSH(fMachineState); + fMachineState = kIOPM_NotifyChildrenStart; + } } //********************************************************************************* // [private] notifyRootDomain //********************************************************************************* -void IOService::notifyRootDomain( void ) +void +IOService::notifyRootDomain( void ) { - assert( fDriverCallBusy == false ); + assert( fDriverCallBusy == false ); - // Only for root domain in the will-change phase - if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState)) - { - notifyChildren(); - return; - } + // Only for root domain in the will-change phase + if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState)) { + notifyChildren(); + return; + } - MS_PUSH(fMachineState); // push notifyAll() machine state - fMachineState = kIOPM_DriverThreadCallDone; + MS_PUSH(fMachineState); // push notifyAll() machine state + fMachineState = kIOPM_DriverThreadCallDone; - // Call IOPMrootDomain::willNotifyPowerChildren() on a thread call - // to avoid a deadlock. - fDriverCallReason = kRootDomainInformPreChange; - fDriverCallBusy = true; - thread_call_enter( fDriverCallEntry ); + // Call IOPMrootDomain::willNotifyPowerChildren() on a thread call + // to avoid a deadlock. + fDriverCallReason = kRootDomainInformPreChange; + fDriverCallBusy = true; + thread_call_enter( fDriverCallEntry ); } -void IOService::notifyRootDomainDone( void ) +void +IOService::notifyRootDomainDone( void ) { - assert( fDriverCallBusy == false ); - assert( fMachineState == kIOPM_DriverThreadCallDone ); + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); - MS_POP(); // pop notifyAll() machine state - notifyChildren(); + MS_POP(); // pop notifyAll() machine state + notifyChildren(); } //********************************************************************************* // [private] notifyChildren //********************************************************************************* -void IOService::notifyChildren( void ) -{ - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - OSArray * children = 0; - IOPMrootDomain * rootDomain; - bool delayNotify = false; - - if ((fHeadNotePowerState != fCurrentPowerState) && - (IS_POWER_DROP == fIsPreChange) && - ((rootDomain = getPMRootDomain()) == this)) - { - rootDomain->tracePoint( IS_POWER_DROP ? - kIOPMTracePointSleepPowerPlaneDrivers : - kIOPMTracePointWakePowerPlaneDrivers ); - } - - if (fStrictTreeOrder) - children = OSArray::withCapacity(8); - - // Sum child power consumption in notifyChild() - fHeadNotePowerArrayEntry->staticPower = 0; - - iter = getChildIterator(gIOPowerPlane); - if ( iter ) - { - while ((next = iter->getNextObject())) - { - if ((connection = OSDynamicCast(IOPowerConnection, next))) - { - if (connection->getReadyFlag() == false) - { - PM_LOG3("[%s] %s: connection not ready\n", - getName(), __FUNCTION__); - continue; - } - - // Mechanism to postpone the did-change notification to - // certain power children to order those children last. - // Cannot be used together with strict tree ordering. - - if (!fIsPreChange && - connection->delayChildNotification && - getPMRootDomain()->shouldDelayChildNotification(this)) - { - if (!children) - { - children = OSArray::withCapacity(8); - if (children) - delayNotify = true; - } - if (delayNotify) - { - children->setObject( connection ); - continue; - } - } - - if (!delayNotify && children) - children->setObject( connection ); - else - notifyChild( connection ); - } - } - iter->release(); - } - - if (children && (children->getCount() == 0)) - { - children->release(); - children = 0; - } - if (children) - { - assert(fNotifyChildArray == 0); - fNotifyChildArray = children; - MS_PUSH(fMachineState); - - if (delayNotify) - { - // Block until all non-delayed children have acked their - // notification. Then notify the remaining delayed child - // in the array. This is used to hold off graphics child - // notification while the rest of the system powers up. - // If a hid tickle arrives during this time, the delayed - // children are immediately notified and root domain will - // not clamp power for dark wake. - - fMachineState = kIOPM_NotifyChildrenDelayed; - PM_LOG2("%s: %d children in delayed array\n", - getName(), children->getCount()); - } - else - { - // Child array created to support strict notification order. - // Notify children in the array one at a time. - - fMachineState = kIOPM_NotifyChildrenOrdered; - } - } +void +IOService::notifyChildren( void ) +{ + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + OSArray * children = NULL; + IOPMrootDomain * rootDomain; + bool delayNotify = false; + + if ((fHeadNotePowerState != fCurrentPowerState) && + (IS_POWER_DROP == fIsPreChange) && + ((rootDomain = getPMRootDomain()) == this)) { + rootDomain->tracePoint( IS_POWER_DROP ? + kIOPMTracePointSleepPowerPlaneDrivers : + kIOPMTracePointWakePowerPlaneDrivers ); + } + + if (fStrictTreeOrder) { + children = OSArray::withCapacity(8); + } + + // Sum child power consumption in notifyChild() + fHeadNotePowerArrayEntry->staticPower = 0; + + iter = getChildIterator(gIOPowerPlane); + if (iter) { + while ((next = iter->getNextObject())) { + if ((connection = OSDynamicCast(IOPowerConnection, next))) { + if (connection->getReadyFlag() == false) { + PM_LOG3("[%s] %s: connection not ready\n", + getName(), __FUNCTION__); + continue; + } + + // Mechanism to postpone the did-change notification to + // certain power children to order those children last. + // Cannot be used together with strict tree ordering. + + if (!fIsPreChange && + connection->delayChildNotification && + getPMRootDomain()->shouldDelayChildNotification(this)) { + if (!children) { + children = OSArray::withCapacity(8); + if (children) { + delayNotify = true; + } + } + if (delayNotify) { + children->setObject( connection ); + continue; + } + } + + if (!delayNotify && children) { + children->setObject( connection ); + } else { + notifyChild( connection ); + } + } + } + iter->release(); + } + + if (children && (children->getCount() == 0)) { + children->release(); + children = NULL; + } + if (children) { + assert(fNotifyChildArray == NULL); + fNotifyChildArray = children; + MS_PUSH(fMachineState); + + if (delayNotify) { + // Block until all non-delayed children have acked their + // notification. Then notify the remaining delayed child + // in the array. This is used to hold off graphics child + // notification while the rest of the system powers up. + // If a hid tickle arrives during this time, the delayed + // children are immediately notified and root domain will + // not clamp power for dark wake. + + fMachineState = kIOPM_NotifyChildrenDelayed; + PM_LOG2("%s: %d children in delayed array\n", + getName(), children->getCount()); + } else { + // Child array created to support strict notification order. + // Notify children in the array one at a time. + + fMachineState = kIOPM_NotifyChildrenOrdered; + } + } } //********************************************************************************* // [private] notifyChildrenOrdered //********************************************************************************* -void IOService::notifyChildrenOrdered( void ) +void +IOService::notifyChildrenOrdered( void ) { - PM_ASSERT_IN_GATE(); - assert(fNotifyChildArray); - assert(fMachineState == kIOPM_NotifyChildrenOrdered); + PM_ASSERT_IN_GATE(); + assert(fNotifyChildArray); + assert(fMachineState == kIOPM_NotifyChildrenOrdered); - // Notify one child, wait for it to ack, then repeat for next child. - // This is a workaround for some drivers with multiple instances at - // the same branch in the power tree, but the driver is slow to power - // up unless the tree ordering is observed. Problem observed only on - // system wake, not on system sleep. - // - // We have the ability to power off in reverse child index order. - // That works nicely on some machines, but not on all HW configs. + // Notify one child, wait for it to ack, then repeat for next child. + // This is a workaround for some drivers with multiple instances at + // the same branch in the power tree, but the driver is slow to power + // up unless the tree ordering is observed. Problem observed only on + // system wake, not on system sleep. + // + // We have the ability to power off in reverse child index order. + // That works nicely on some machines, but not on all HW configs. - if (fNotifyChildArray->getCount()) - { - IOPowerConnection * connection; - connection = (IOPowerConnection *) fNotifyChildArray->getObject(0); - notifyChild( connection ); - fNotifyChildArray->removeObject(0); - } - else - { - fNotifyChildArray->release(); - fNotifyChildArray = 0; + if (fNotifyChildArray->getCount()) { + IOPowerConnection * connection; + connection = (IOPowerConnection *) fNotifyChildArray->getObject(0); + notifyChild( connection ); + fNotifyChildArray->removeObject(0); + } else { + fNotifyChildArray->release(); + fNotifyChildArray = NULL; - MS_POP(); // pushed by notifyChildren() - } + MS_POP(); // pushed by notifyChildren() + } } //********************************************************************************* // [private] notifyChildrenDelayed //********************************************************************************* -void IOService::notifyChildrenDelayed( void ) +void +IOService::notifyChildrenDelayed( void ) { - IOPowerConnection * connection; + IOPowerConnection * connection; - PM_ASSERT_IN_GATE(); - assert(fNotifyChildArray); - assert(fMachineState == kIOPM_NotifyChildrenDelayed); + PM_ASSERT_IN_GATE(); + assert(fNotifyChildArray); + assert(fMachineState == kIOPM_NotifyChildrenDelayed); - // Wait after all non-delayed children and interested drivers have ack'ed, - // then notify all delayed children. If notify delay is canceled, child - // acks may be outstanding with PM blocked on fHeadNotePendingAcks != 0. - // But the handling for either case is identical. + // Wait after all non-delayed children and interested drivers have ack'ed, + // then notify all delayed children. If notify delay is canceled, child + // acks may be outstanding with PM blocked on fHeadNotePendingAcks != 0. + // But the handling for either case is identical. - for (int i = 0; ; i++) - { - connection = (IOPowerConnection *) fNotifyChildArray->getObject(i); - if (!connection) - break; + for (int i = 0;; i++) { + connection = (IOPowerConnection *) fNotifyChildArray->getObject(i); + if (!connection) { + break; + } - notifyChild( connection ); - } + notifyChild( connection ); + } - PM_LOG2("%s: notified delayed children\n", getName()); - fNotifyChildArray->release(); - fNotifyChildArray = 0; + PM_LOG2("%s: notified delayed children\n", getName()); + fNotifyChildArray->release(); + fNotifyChildArray = NULL; - MS_POP(); // pushed by notifyChildren() + MS_POP(); // pushed by notifyChildren() } //********************************************************************************* // [private] notifyAll //********************************************************************************* -IOReturn IOService::notifyAll( uint32_t nextMS ) +IOReturn +IOService::notifyAll( uint32_t nextMS ) { - // Save the machine state to be restored by notifyInterestedDriversDone() + // Save the machine state to be restored by notifyInterestedDriversDone() - PM_ASSERT_IN_GATE(); - MS_PUSH(nextMS); - fMachineState = kIOPM_DriverThreadCallDone; - fDriverCallReason = fIsPreChange ? - kDriverCallInformPreChange : kDriverCallInformPostChange; + PM_ASSERT_IN_GATE(); + MS_PUSH(nextMS); + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = fIsPreChange ? + kDriverCallInformPreChange : kDriverCallInformPostChange; - if (!notifyInterestedDrivers()) - notifyInterestedDriversDone(); + if (!notifyInterestedDrivers()) { + notifyInterestedDriversDone(); + } - return IOPMWillAckLater; + return IOPMWillAckLater; } //********************************************************************************* @@ -3876,48 +3930,49 @@ IOReturn IOService::notifyAll( uint32_t nextMS ) // Thread call context //********************************************************************************* -IOReturn IOService::actionDriverCalloutDone( - OSObject * target, - void * arg0, void * arg1, - void * arg2, void * arg3 ) +IOReturn +IOService::actionDriverCalloutDone( + OSObject * target, + void * arg0, void * arg1, + void * arg2, void * arg3 ) { - IOServicePM * pwrMgt = (IOServicePM *) arg0; + IOServicePM * pwrMgt = (IOServicePM *) arg0; - assert( fDriverCallBusy ); - fDriverCallBusy = false; + assert( fDriverCallBusy ); + fDriverCallBusy = false; - assert(gIOPMWorkQueue); - gIOPMWorkQueue->signalWorkAvailable(); + assert(gIOPMWorkQueue); + gIOPMWorkQueue->signalWorkAvailable(); - return kIOReturnSuccess; + return kIOReturnSuccess; } -void IOService::pmDriverCallout( IOService * from ) +void +IOService::pmDriverCallout( IOService * from ) { - assert(from); - switch (from->fDriverCallReason) - { - case kDriverCallSetPowerState: - from->driverSetPowerState(); - break; + assert(from); + switch (from->fDriverCallReason) { + case kDriverCallSetPowerState: + from->driverSetPowerState(); + break; - case kDriverCallInformPreChange: - case kDriverCallInformPostChange: - from->driverInformPowerChange(); - break; + case kDriverCallInformPreChange: + case kDriverCallInformPostChange: + from->driverInformPowerChange(); + break; - case kRootDomainInformPreChange: - getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState); - break; + case kRootDomainInformPreChange: + getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState); + break; - default: - panic("IOService::pmDriverCallout bad machine state %x", - from->fDriverCallReason); - } + default: + panic("IOService::pmDriverCallout bad machine state %x", + from->fDriverCallReason); + } - gIOPMWorkLoop->runAction(actionDriverCalloutDone, - /* target */ from, - /* arg0 */ (void *) from->pwrMgt ); + gIOPMWorkLoop->runAction(actionDriverCalloutDone, + /* target */ from, + /* arg0 */ (void *) from->pwrMgt ); } //********************************************************************************* @@ -3926,66 +3981,63 @@ void IOService::pmDriverCallout( IOService * from ) // Thread call context //********************************************************************************* -void IOService::driverSetPowerState( void ) -{ - IOPMPowerStateIndex powerState; - DriverCallParam * param; - IOPMDriverCallEntry callEntry; - AbsoluteTime end; - IOReturn result; - uint32_t oldPowerState = getPowerState(); - - assert( fDriverCallBusy ); - assert( fDriverCallParamPtr ); - assert( fDriverCallParamCount == 1 ); - - param = (DriverCallParam *) fDriverCallParamPtr; - powerState = fHeadNotePowerState; - - if (assertPMDriverCall(&callEntry)) - { - OUR_PMLog( kPMLogProgramHardware, (uintptr_t) this, powerState); - start_spindump_timer("SetState"); - clock_get_uptime(&fDriverCallStartTime); - result = fControllingDriver->setPowerState( powerState, this ); - clock_get_uptime(&end); - stop_spindump_timer(); - OUR_PMLog((UInt32) -kPMLogProgramHardware, (uintptr_t) this, (UInt32) result); - - deassertPMDriverCall(&callEntry); - - // Record the most recent max power state residency timings. - // Use with DeviceActiveTimestamp to diagnose tickle issues. - if (powerState == fHighestPowerState) - fMaxPowerStateEntryTime = end; - else if (oldPowerState == fHighestPowerState) - fMaxPowerStateExitTime = end; - - if (result < 0) - { - PM_LOG("%s::setPowerState(%p, %lu -> %lu) returned 0x%x\n", - fName, OBFUSCATE(this), fCurrentPowerState, powerState, result); - } - -#if LOG_SETPOWER_TIMES - if ((result == IOPMAckImplied) || (result < 0)) - { - uint64_t nsec; - - SUB_ABSOLUTETIME(&end, &fDriverCallStartTime); - absolutetime_to_nanoseconds(end, &nsec); - if (nsec > LOG_SETPOWER_TIMES) { - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsDriverPSChangeSlow, - fName, kDriverCallSetPowerState, NS_TO_MS(nsec), 0, NULL, powerState); - } - } -#endif - } - else - result = kIOPMAckImplied; +void +IOService::driverSetPowerState( void ) +{ + IOPMPowerStateIndex powerState; + DriverCallParam * param; + IOPMDriverCallEntry callEntry; + AbsoluteTime end; + IOReturn result; + uint32_t oldPowerState = getPowerState(); + + assert( fDriverCallBusy ); + assert( fDriverCallParamPtr ); + assert( fDriverCallParamCount == 1 ); + + param = (DriverCallParam *) fDriverCallParamPtr; + powerState = fHeadNotePowerState; + + if (assertPMDriverCall(&callEntry, kIOPMDriverCallMethodSetPowerState)) { + OUR_PMLogFuncStart(kPMLogProgramHardware, (uintptr_t) this, powerState); + clock_get_uptime(&fDriverCallStartTime); + result = fControllingDriver->setPowerState( powerState, this ); + clock_get_uptime(&end); + OUR_PMLogFuncEnd(kPMLogProgramHardware, (uintptr_t) this, (UInt32) result); + + deassertPMDriverCall(&callEntry); + + // Record the most recent max power state residency timings. + // Use with DeviceActiveTimestamp to diagnose tickle issues. + if (powerState == fHighestPowerState) { + fMaxPowerStateEntryTime = end; + } else if (oldPowerState == fHighestPowerState) { + fMaxPowerStateExitTime = end; + } + + if (result < 0) { + PM_LOG("%s::setPowerState(%p, %lu -> %lu) returned 0x%x\n", + fName, OBFUSCATE(this), fCurrentPowerState, powerState, result); + } + + + if ((result == IOPMAckImplied) || (result < 0)) { + uint64_t nsec; + + SUB_ABSOLUTETIME(&end, &fDriverCallStartTime); + absolutetime_to_nanoseconds(end, &nsec); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, + fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(), + NULL, powerState); + } + } + } else { + result = kIOPMAckImplied; + } - param->Result = result; + param->Result = result; } //********************************************************************************* @@ -3994,79 +4046,72 @@ void IOService::driverSetPowerState( void ) // Thread call context //********************************************************************************* -void IOService::driverInformPowerChange( void ) -{ - IOPMinformee * informee; - IOService * driver; - DriverCallParam * param; - IOPMDriverCallEntry callEntry; - IOPMPowerFlags powerFlags; - IOPMPowerStateIndex powerState; - AbsoluteTime end; - IOReturn result; - IOItemCount count; - - assert( fDriverCallBusy ); - assert( fDriverCallParamPtr ); - assert( fDriverCallParamCount ); - - param = (DriverCallParam *) fDriverCallParamPtr; - count = fDriverCallParamCount; - - powerFlags = fHeadNotePowerArrayEntry->capabilityFlags; - powerState = fHeadNotePowerState; - - for (IOItemCount i = 0; i < count; i++) - { - informee = (IOPMinformee *) param->Target; - driver = informee->whatObject; - - if (assertPMDriverCall(&callEntry, 0, informee)) - { - if (fDriverCallReason == kDriverCallInformPreChange) - { - OUR_PMLog(kPMLogInformDriverPreChange, (uintptr_t) this, powerState); - start_spindump_timer("WillChange"); - clock_get_uptime(&informee->startTime); - result = driver->powerStateWillChangeTo(powerFlags, powerState, this); - clock_get_uptime(&end); - stop_spindump_timer(); - OUR_PMLog((UInt32)-kPMLogInformDriverPreChange, (uintptr_t) this, result); - } - else - { - OUR_PMLog(kPMLogInformDriverPostChange, (uintptr_t) this, powerState); - start_spindump_timer("DidChange"); - clock_get_uptime(&informee->startTime); - result = driver->powerStateDidChangeTo(powerFlags, powerState, this); - clock_get_uptime(&end); - stop_spindump_timer(); - OUR_PMLog((UInt32)-kPMLogInformDriverPostChange, (uintptr_t) this, result); - } - - deassertPMDriverCall(&callEntry); - -#if LOG_SETPOWER_TIMES - if ((result == IOPMAckImplied) || (result < 0)) - { - uint64_t nsec; - - SUB_ABSOLUTETIME(&end, &informee->startTime); - absolutetime_to_nanoseconds(end, &nsec); - if (nsec > LOG_SETPOWER_TIMES) { - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsDriverPSChangeSlow, driver->getName(), - fDriverCallReason, NS_TO_MS(nsec), 0, NULL, powerState); - } - } -#endif - } - else - result = kIOPMAckImplied; +void +IOService::driverInformPowerChange( void ) +{ + IOPMinformee * informee; + IOService * driver; + DriverCallParam * param; + IOPMDriverCallEntry callEntry; + IOPMPowerFlags powerFlags; + IOPMPowerStateIndex powerState; + AbsoluteTime end; + IOReturn result; + IOItemCount count; + IOOptionBits callMethod = (fDriverCallReason == kDriverCallInformPreChange) ? + kIOPMDriverCallMethodWillChange : kIOPMDriverCallMethodDidChange; + + assert( fDriverCallBusy ); + assert( fDriverCallParamPtr ); + assert( fDriverCallParamCount ); + + param = (DriverCallParam *) fDriverCallParamPtr; + count = fDriverCallParamCount; + + powerFlags = fHeadNotePowerArrayEntry->capabilityFlags; + powerState = fHeadNotePowerState; + + for (IOItemCount i = 0; i < count; i++) { + informee = (IOPMinformee *) param->Target; + driver = informee->whatObject; + + if (assertPMDriverCall(&callEntry, callMethod, informee)) { + if (fDriverCallReason == kDriverCallInformPreChange) { + OUR_PMLogFuncStart(kPMLogInformDriverPreChange, (uintptr_t) this, powerState); + clock_get_uptime(&informee->startTime); + result = driver->powerStateWillChangeTo(powerFlags, powerState, this); + clock_get_uptime(&end); + OUR_PMLogFuncEnd(kPMLogInformDriverPreChange, (uintptr_t) this, result); + } else { + OUR_PMLogFuncStart(kPMLogInformDriverPostChange, (uintptr_t) this, powerState); + clock_get_uptime(&informee->startTime); + result = driver->powerStateDidChangeTo(powerFlags, powerState, this); + clock_get_uptime(&end); + OUR_PMLogFuncEnd(kPMLogInformDriverPostChange, (uintptr_t) this, result); + } + + deassertPMDriverCall(&callEntry); + + + if ((result == IOPMAckImplied) || (result < 0)) { + uint64_t nsec; + + SUB_ABSOLUTETIME(&end, &informee->startTime); + absolutetime_to_nanoseconds(end, &nsec); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, driver->getName(), + fDriverCallReason, NS_TO_MS(nsec), driver->getRegistryEntryID(), + NULL, powerState); + } + } + } else { + result = kIOPMAckImplied; + } - param->Result = result; - param++; - } + param->Result = result; + param++; + } } //********************************************************************************* @@ -4076,166 +4121,160 @@ void IOService::driverInformPowerChange( void ) // If the object acknowledges the current change, we return TRUE. //********************************************************************************* -bool IOService::notifyChild( IOPowerConnection * theNub ) -{ - IOReturn ret = IOPMAckImplied; - unsigned long childPower; - IOService * theChild; - IOPMRequest * childRequest; - IOPMPowerChangeFlags requestArg2; - int requestType; - - PM_ASSERT_IN_GATE(); - theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane)); - if (!theChild) - { - return true; - } - - // Unless the child handles the notification immediately and returns - // kIOPMAckImplied, we'll be awaiting their acknowledgement later. - fHeadNotePendingAcks++; - theNub->setAwaitingAck(true); - - requestArg2 = fHeadNoteChangeFlags; - if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) - requestArg2 |= kIOPMDomainPowerDrop; - - requestType = fIsPreChange ? - kIOPMRequestTypePowerDomainWillChange : - kIOPMRequestTypePowerDomainDidChange; - - childRequest = acquirePMRequest( theChild, requestType ); - if (childRequest) - { - theNub->retain(); - childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags; - childRequest->fArg1 = (void *) theNub; - childRequest->fArg2 = (void *)(uintptr_t) requestArg2; - theChild->submitPMRequest( childRequest ); - ret = IOPMWillAckLater; - } - else - { - ret = IOPMAckImplied; - fHeadNotePendingAcks--; - theNub->setAwaitingAck(false); - childPower = theChild->currentPowerConsumption(); - if ( childPower == kIOPMUnknown ) - { - fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown; - } else { - if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown ) - fHeadNotePowerArrayEntry->staticPower += childPower; - } - } - - theChild->release(); - return (IOPMAckImplied == ret); +bool +IOService::notifyChild( IOPowerConnection * theNub ) +{ + IOReturn ret = IOPMAckImplied; + unsigned long childPower; + IOService * theChild; + IOPMRequest * childRequest; + IOPMPowerChangeFlags requestArg2; + int requestType; + + PM_ASSERT_IN_GATE(); + theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane)); + if (!theChild) { + return true; + } + + // Unless the child handles the notification immediately and returns + // kIOPMAckImplied, we'll be awaiting their acknowledgement later. + fHeadNotePendingAcks++; + theNub->setAwaitingAck(true); + + requestArg2 = fHeadNoteChangeFlags; + if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) { + requestArg2 |= kIOPMDomainPowerDrop; + } + + requestType = fIsPreChange ? + kIOPMRequestTypePowerDomainWillChange : + kIOPMRequestTypePowerDomainDidChange; + + childRequest = acquirePMRequest( theChild, requestType ); + if (childRequest) { + theNub->retain(); + childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags; + childRequest->fArg1 = (void *) theNub; + childRequest->fArg2 = (void *)(uintptr_t) requestArg2; + theChild->submitPMRequest( childRequest ); + ret = IOPMWillAckLater; + } else { + ret = IOPMAckImplied; + fHeadNotePendingAcks--; + theNub->setAwaitingAck(false); + childPower = theChild->currentPowerConsumption(); + if (childPower == kIOPMUnknown) { + fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown; + } else { + if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown) { + fHeadNotePowerArrayEntry->staticPower += childPower; + } + } + } + + theChild->release(); + return IOPMAckImplied == ret; } //********************************************************************************* // [private] notifyControllingDriver //********************************************************************************* -bool IOService::notifyControllingDriver( void ) +bool +IOService::notifyControllingDriver( void ) { - DriverCallParam * param; - - PM_ASSERT_IN_GATE(); - assert( fDriverCallParamCount == 0 ); - assert( fControllingDriver ); + DriverCallParam * param; - if (fInitialSetPowerState) - { - fInitialSetPowerState = false; - fHeadNoteChangeFlags |= kIOPMInitialPowerChange; + PM_ASSERT_IN_GATE(); + assert( fDriverCallParamCount == 0 ); + assert( fControllingDriver ); - // Driver specified flag to skip the inital setPowerState() - if (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState) - { - return false; - } - } + if (fInitialSetPowerState) { + fInitialSetPowerState = false; + fHeadNoteChangeFlags |= kIOPMInitialPowerChange; - param = (DriverCallParam *) fDriverCallParamPtr; - if (!param) - { - param = IONew(DriverCallParam, 1); - if (!param) - return false; // no memory + // Driver specified flag to skip the inital setPowerState() + if (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState) { + return false; + } + } - fDriverCallParamPtr = (void *) param; - fDriverCallParamSlots = 1; - } + param = (DriverCallParam *) fDriverCallParamPtr; + if (!param) { + param = IONew(DriverCallParam, 1); + if (!param) { + return false; // no memory + } + fDriverCallParamPtr = (void *) param; + fDriverCallParamSlots = 1; + } - param->Target = fControllingDriver; - fDriverCallParamCount = 1; - fDriverTimer = -1; + param->Target = fControllingDriver; + fDriverCallParamCount = 1; + fDriverTimer = -1; - // Block state machine and wait for callout completion. - assert(!fDriverCallBusy); - fDriverCallBusy = true; - thread_call_enter( fDriverCallEntry ); + // Block state machine and wait for callout completion. + assert(!fDriverCallBusy); + fDriverCallBusy = true; + thread_call_enter( fDriverCallEntry ); - return true; + return true; } //********************************************************************************* // [private] notifyControllingDriverDone //********************************************************************************* -void IOService::notifyControllingDriverDone( void ) +void +IOService::notifyControllingDriverDone( void ) { - DriverCallParam * param; - IOReturn result; + DriverCallParam * param; + IOReturn result; - PM_ASSERT_IN_GATE(); - param = (DriverCallParam *) fDriverCallParamPtr; + PM_ASSERT_IN_GATE(); + param = (DriverCallParam *) fDriverCallParamPtr; - assert( fDriverCallBusy == false ); - assert( fMachineState == kIOPM_DriverThreadCallDone ); + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); - if (param && fDriverCallParamCount) - { - assert(fDriverCallParamCount == 1); + if (param && fDriverCallParamCount) { + assert(fDriverCallParamCount == 1); - // the return value from setPowerState() - result = param->Result; + // the return value from setPowerState() + result = param->Result; - if ((result == IOPMAckImplied) || (result < 0)) - { - fDriverTimer = 0; - } - else if (fDriverTimer) - { - assert(fDriverTimer == -1); + if ((result == IOPMAckImplied) || (result < 0)) { + fDriverTimer = 0; + } else if (fDriverTimer) { + assert(fDriverTimer == -1); - // Driver has not acked, and has returned a positive result. - // Enforce a minimum permissible timeout value. - // Make the min value large enough so timeout is less likely - // to occur if a driver misinterpreted that the return value - // should be in microsecond units. And make it large enough - // to be noticeable if a driver neglects to ack. + // Driver has not acked, and has returned a positive result. + // Enforce a minimum permissible timeout value. + // Make the min value large enough so timeout is less likely + // to occur if a driver misinterpreted that the return value + // should be in microsecond units. And make it large enough + // to be noticeable if a driver neglects to ack. - if (result < kMinAckTimeoutTicks) - result = kMinAckTimeoutTicks; + if (result < kMinAckTimeoutTicks) { + result = kMinAckTimeoutTicks; + } - fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; - } - // else, child has already acked and driver_timer reset to 0. + fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; + } + // else, child has already acked and driver_timer reset to 0. - fDriverCallParamCount = 0; + fDriverCallParamCount = 0; - if ( fDriverTimer ) - { - OUR_PMLog(kPMLogStartAckTimer, 0, 0); - start_ack_timer(); - } - } + if (fDriverTimer) { + OUR_PMLog(kPMLogStartAckTimer, 0, 0); + start_ack_timer(); + getPMRootDomain()->reset_watchdog_timer(this, result / USEC_PER_SEC + 1); + } + } - MS_POP(); // pushed by OurChangeSetPowerState() - fIsPreChange = false; + MS_POP(); // pushed by OurChangeSetPowerState() + fIsPreChange = false; } //********************************************************************************* @@ -4244,182 +4283,167 @@ void IOService::notifyControllingDriverDone( void ) // A power change is done. //********************************************************************************* -void IOService::all_done( void ) -{ - IOPMPowerStateIndex prevPowerState; - const IOPMPSEntry * powerStatePtr; - IOPMDriverCallEntry callEntry; - uint32_t prevMachineState = fMachineState; - bool actionCalled = false; - uint64_t ts; - - fMachineState = kIOPM_Finished; - - if ((fHeadNoteChangeFlags & kIOPMSynchronize) && - ((prevMachineState == kIOPM_Finished) || - (prevMachineState == kIOPM_SyncFinish))) - { - // Sync operation and no power change occurred. - // Do not inform driver and clients about this request completion, - // except for the originator (root domain). - - PM_ACTION_2(actionPowerChangeDone, - fHeadNotePowerState, fHeadNoteChangeFlags); - - if (getPMRequestType() == kIOPMRequestTypeSynchronizePowerTree) - { - powerChangeDone(fCurrentPowerState); - } - else if (fAdvisoryTickleUsed) - { - // Not root domain and advisory tickle target. - // Re-adjust power after power tree sync at the 'did' pass - // to recompute desire and adjust power state between dark - // and full wake transitions. Root domain is responsible - // for calling setAdvisoryTickleEnable() before starting - // the kIOPMSynchronize power change. - - if (!fAdjustPowerScheduled && - (fHeadNoteChangeFlags & kIOPMDomainDidChange)) - { - IOPMRequest * request; - request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); - if (request) - { - submitPMRequest( request ); - fAdjustPowerScheduled = true; - } - } - } - - return; - } - - // our power change - if (fHeadNoteChangeFlags & kIOPMSelfInitiated) - { - // power state changed - if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) - { - trackSystemSleepPreventers( - fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); - - // we changed, tell our parent - requestDomainPower(fHeadNotePowerState); - - // yes, did power raise? - if ( StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState) ) - { - // yes, inform clients and apps - tellChangeUp (fHeadNotePowerState); - } - prevPowerState = fCurrentPowerState; - // either way - fCurrentPowerState = fHeadNotePowerState; - PM_LOCK(); - if (fReportBuf) { - ts = mach_absolute_time(); - STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); - } - PM_UNLOCK(); +void +IOService::all_done( void ) +{ + IOPMPowerStateIndex prevPowerState; + const IOPMPSEntry * powerStatePtr; + IOPMDriverCallEntry callEntry; + uint32_t prevMachineState = fMachineState; + bool actionCalled = false; + uint64_t ts; + + fMachineState = kIOPM_Finished; + + if ((fHeadNoteChangeFlags & kIOPMSynchronize) && + ((prevMachineState == kIOPM_Finished) || + (prevMachineState == kIOPM_SyncFinish))) { + // Sync operation and no power change occurred. + // Do not inform driver and clients about this request completion, + // except for the originator (root domain). + + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); + + if (getPMRequestType() == kIOPMRequestTypeSynchronizePowerTree) { + powerChangeDone(fCurrentPowerState); + } else if (fAdvisoryTickleUsed) { + // Not root domain and advisory tickle target. + // Re-adjust power after power tree sync at the 'did' pass + // to recompute desire and adjust power state between dark + // and full wake transitions. Root domain is responsible + // for calling setAdvisoryTickleEnable() before starting + // the kIOPMSynchronize power change. + + if (!fAdjustPowerScheduled && + (fHeadNoteChangeFlags & kIOPMDomainDidChange)) { + IOPMRequest * request; + request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); + if (request) { + submitPMRequest( request ); + fAdjustPowerScheduled = true; + } + } + } + + return; + } + + // our power change + if (fHeadNoteChangeFlags & kIOPMSelfInitiated) { + // power state changed + if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) { + trackSystemSleepPreventers( + fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); + + // we changed, tell our parent + requestDomainPower(fHeadNotePowerState); + + // yes, did power raise? + if (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState)) { + // yes, inform clients and apps + tellChangeUp(fHeadNotePowerState); + } + prevPowerState = fCurrentPowerState; + // either way + fCurrentPowerState = fHeadNotePowerState; + PM_LOCK(); + if (fReportBuf) { + ts = mach_absolute_time(); + STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); + } + PM_UNLOCK(); #if PM_VARS_SUPPORT - fPMVars->myCurrentState = fCurrentPowerState; + fPMVars->myCurrentState = fCurrentPowerState; #endif - OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); - PM_ACTION_2(actionPowerChangeDone, - fHeadNotePowerState, fHeadNoteChangeFlags); - actionCalled = true; - - powerStatePtr = &fPowerStates[fCurrentPowerState]; - fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; - if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) - fCurrentPowerConsumption = powerStatePtr->staticPower; - - if (fHeadNoteChangeFlags & kIOPMRootChangeDown) - { - // Bump tickle generation count once the entire tree is down - gIOPMTickleGeneration++; - } - - // inform subclass policy-maker - if (fPCDFunctionOverride && fParentsKnowState && - assertPMDriverCall(&callEntry, kIOPMADC_NoInactiveCheck)) - { - powerChangeDone(prevPowerState); - deassertPMDriverCall(&callEntry); - } - } - else if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) - { - // changePowerStateWithOverrideTo() was cancelled - fOverrideMaxPowerState = kIOPMPowerStateMax; - } - } - - // parent-initiated power change - if (fHeadNoteChangeFlags & kIOPMParentInitiated) - { - if (fHeadNoteChangeFlags & kIOPMRootChangeDown) - ParentChangeRootChangeDown(); - - // power state changed - if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) - { - trackSystemSleepPreventers( - fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); - - // did power raise? - if ( StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState) ) - { - // yes, inform clients and apps - tellChangeUp (fHeadNotePowerState); - } - // either way - prevPowerState = fCurrentPowerState; - fCurrentPowerState = fHeadNotePowerState; - PM_LOCK(); - if (fReportBuf) { - ts = mach_absolute_time(); - STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); - } - PM_UNLOCK(); + OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); + actionCalled = true; + + powerStatePtr = &fPowerStates[fCurrentPowerState]; + fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; + if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) { + fCurrentPowerConsumption = powerStatePtr->staticPower; + } + + if (fHeadNoteChangeFlags & kIOPMRootChangeDown) { + // Bump tickle generation count once the entire tree is down + gIOPMTickleGeneration++; + } + + // inform subclass policy-maker + if (fPCDFunctionOverride && fParentsKnowState && + assertPMDriverCall(&callEntry, kIOPMDriverCallMethodChangeDone, NULL, kIOPMDriverCallNoInactiveCheck)) { + powerChangeDone(prevPowerState); + deassertPMDriverCall(&callEntry); + } + } else if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) { + // changePowerStateWithOverrideTo() was cancelled + fOverrideMaxPowerState = kIOPMPowerStateMax; + } + } + + // parent-initiated power change + if (fHeadNoteChangeFlags & kIOPMParentInitiated) { + if (fHeadNoteChangeFlags & kIOPMRootChangeDown) { + ParentChangeRootChangeDown(); + } + + // power state changed + if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) { + trackSystemSleepPreventers( + fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); + + // did power raise? + if (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState)) { + // yes, inform clients and apps + tellChangeUp(fHeadNotePowerState); + } + // either way + prevPowerState = fCurrentPowerState; + fCurrentPowerState = fHeadNotePowerState; + PM_LOCK(); + if (fReportBuf) { + ts = mach_absolute_time(); + STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); + } + PM_UNLOCK(); #if PM_VARS_SUPPORT - fPMVars->myCurrentState = fCurrentPowerState; + fPMVars->myCurrentState = fCurrentPowerState; #endif - OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); - PM_ACTION_2(actionPowerChangeDone, - fHeadNotePowerState, fHeadNoteChangeFlags); - actionCalled = true; - - powerStatePtr = &fPowerStates[fCurrentPowerState]; - fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; - if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) - fCurrentPowerConsumption = powerStatePtr->staticPower; - - // inform subclass policy-maker - if (fPCDFunctionOverride && fParentsKnowState && - assertPMDriverCall(&callEntry, kIOPMADC_NoInactiveCheck)) - { - powerChangeDone(prevPowerState); - deassertPMDriverCall(&callEntry); - } - } - } - - // When power rises enough to satisfy the tickle's desire for more power, - // the condition preventing idle-timer from dropping power is removed. - - if (StateOrder(fCurrentPowerState) >= StateOrder(fIdleTimerMinPowerState)) - { - fIdleTimerMinPowerState = kPowerStateZero; - } - - if (!actionCalled) - { - PM_ACTION_2(actionPowerChangeDone, - fHeadNotePowerState, fHeadNoteChangeFlags); - } + OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); + actionCalled = true; + + powerStatePtr = &fPowerStates[fCurrentPowerState]; + fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; + if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) { + fCurrentPowerConsumption = powerStatePtr->staticPower; + } + + // inform subclass policy-maker + if (fPCDFunctionOverride && fParentsKnowState && + assertPMDriverCall(&callEntry, kIOPMDriverCallMethodChangeDone, NULL, kIOPMDriverCallNoInactiveCheck)) { + powerChangeDone(prevPowerState); + deassertPMDriverCall(&callEntry); + } + } + } + + // When power rises enough to satisfy the tickle's desire for more power, + // the condition preventing idle-timer from dropping power is removed. + + if (StateOrder(fCurrentPowerState) >= StateOrder(fIdleTimerMinPowerState)) { + fIdleTimerMinPowerState = kPowerStateZero; + } + + if (!actionCalled) { + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); + } } // MARK: - @@ -4431,77 +4455,72 @@ void IOService::all_done( void ) // Begin the processing of a power change initiated by us. //********************************************************************************* -void IOService::OurChangeStart( void ) -{ - PM_ASSERT_IN_GATE(); - OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState ); - - // fMaxPowerState is our maximum possible power state based on the current - // power state of our parents. If we are trying to raise power beyond the - // maximum, send an async request for more power to all parents. - - if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState))) - { - fHeadNoteChangeFlags |= kIOPMNotDone; - requestDomainPower(fHeadNotePowerState); - OurChangeFinish(); - return; - } - - // Redundant power changes skips to the end of the state machine. - - if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState)) - { - OurChangeFinish(); - return; - } - fInitialPowerChange = false; - - // Change started, but may not complete... - // Can be canceled (power drop) or deferred (power rise). - - PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); - - // Two separate paths, depending if power is being raised or lowered. - // Lowering power is subject to approval by clients of this service. - - if (IS_POWER_DROP) - { - fDoNotPowerDown = false; - - // Ask for persmission to drop power state - fMachineState = kIOPM_OurChangeTellClientsPowerDown; - fOutOfBandParameter = kNotifyApps; - askChangeDown(fHeadNotePowerState); - } - else - { - // This service is raising power and parents are able to support the - // new power state. However a parent may have already committed to - // drop power, which might force this object to temporarily drop power. - // This results in "oscillations" before the state machines converge - // to a steady state. - // - // To prevent this, a child must make a power reservation against all - // parents before raising power. If the reservation fails, indicating - // that the child will be unable to sustain the higher power state, - // then the child will signal the parent to adjust power, and the child - // will defer its power change. - - IOReturn ret; - - // Reserve parent power necessary to achieve fHeadNotePowerState. - ret = requestDomainPower( fHeadNotePowerState, kReserveDomainPower ); - if (ret != kIOReturnSuccess) - { - // Reservation failed, defer power rise. - fHeadNoteChangeFlags |= kIOPMNotDone; - OurChangeFinish(); - return; - } - - OurChangeTellCapabilityWillChange(); - } +void +IOService::OurChangeStart( void ) +{ + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState ); + + // fMaxPowerState is our maximum possible power state based on the current + // power state of our parents. If we are trying to raise power beyond the + // maximum, send an async request for more power to all parents. + + if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState))) { + fHeadNoteChangeFlags |= kIOPMNotDone; + requestDomainPower(fHeadNotePowerState); + OurChangeFinish(); + return; + } + + // Redundant power changes skips to the end of the state machine. + + if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState)) { + OurChangeFinish(); + return; + } + fInitialPowerChange = false; + + // Change started, but may not complete... + // Can be canceled (power drop) or deferred (power rise). + + PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); + + // Two separate paths, depending if power is being raised or lowered. + // Lowering power is subject to approval by clients of this service. + + if (IS_POWER_DROP) { + fDoNotPowerDown = false; + + // Ask for persmission to drop power state + fMachineState = kIOPM_OurChangeTellClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + askChangeDown(fHeadNotePowerState); + } else { + // This service is raising power and parents are able to support the + // new power state. However a parent may have already committed to + // drop power, which might force this object to temporarily drop power. + // This results in "oscillations" before the state machines converge + // to a steady state. + // + // To prevent this, a child must make a power reservation against all + // parents before raising power. If the reservation fails, indicating + // that the child will be unable to sustain the higher power state, + // then the child will signal the parent to adjust power, and the child + // will defer its power change. + + IOReturn ret; + + // Reserve parent power necessary to achieve fHeadNotePowerState. + ret = requestDomainPower( fHeadNotePowerState, kReserveDomainPower ); + if (ret != kIOReturnSuccess) { + // Reservation failed, defer power rise. + fHeadNoteChangeFlags |= kIOPMNotDone; + OurChangeFinish(); + return; + } + + OurChangeTellCapabilityWillChange(); + } } //********************************************************************************* @@ -4511,37 +4530,38 @@ void IOService::OurChangeStart( void ) //********************************************************************************* struct IOPMRequestDomainPowerContext { - IOService * child; // the requesting child - IOPMPowerFlags requestPowerFlags; // power flags requested by child + IOService * child; // the requesting child + IOPMPowerFlags requestPowerFlags;// power flags requested by child }; static void requestDomainPowerApplier( - IORegistryEntry * entry, - void * inContext ) + IORegistryEntry * entry, + void * inContext ) { - IOPowerConnection * connection; - IOService * parent; - IOPMRequestDomainPowerContext * context; + IOPowerConnection * connection; + IOService * parent; + IOPMRequestDomainPowerContext * context; - if ((connection = OSDynamicCast(IOPowerConnection, entry)) == 0) - return; - parent = (IOService *) connection->copyParentEntry(gIOPowerPlane); - if (!parent) - return; + if ((connection = OSDynamicCast(IOPowerConnection, entry)) == NULL) { + return; + } + parent = (IOService *) connection->copyParentEntry(gIOPowerPlane); + if (!parent) { + return; + } - assert(inContext); - context = (IOPMRequestDomainPowerContext *) inContext; + assert(inContext); + context = (IOPMRequestDomainPowerContext *) inContext; - if (connection->parentKnowsState() && connection->getReadyFlag()) - { - parent->requestPowerDomainState( - context->requestPowerFlags, - connection, - IOPMLowestState); - } + if (connection->parentKnowsState() && connection->getReadyFlag()) { + parent->requestPowerDomainState( + context->requestPowerFlags, + connection, + IOPMLowestState); + } - parent->release(); + parent->release(); } //********************************************************************************* @@ -4552,94 +4572,92 @@ requestDomainPowerApplier( // allow its parents to adjust power state. //********************************************************************************* -IOReturn IOService::requestDomainPower( - IOPMPowerStateIndex ourPowerState, - IOOptionBits options ) -{ - IOPMPowerFlags requestPowerFlags; - IOPMPowerStateIndex maxPowerState; - IOPMRequestDomainPowerContext context; - - PM_ASSERT_IN_GATE(); - assert(ourPowerState < fNumberOfPowerStates); - if (ourPowerState >= fNumberOfPowerStates) - return kIOReturnBadArgument; - if (IS_PM_ROOT) - return kIOReturnSuccess; - - // Fetch our input power flags for the requested power state. - // Parent request is stated in terms of required power flags. - - requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags; - - // Disregard the "previous request" for power reservation. - - if (((options & kReserveDomainPower) == 0) && - (fPreviousRequestPowerFlags == requestPowerFlags)) - { - // skip if domain already knows our requirements - goto done; - } - fPreviousRequestPowerFlags = requestPowerFlags; - - // The results will be collected by fHeadNoteDomainTargetFlags - context.child = this; - context.requestPowerFlags = requestPowerFlags; - fHeadNoteDomainTargetFlags = 0; - applyToParents(requestDomainPowerApplier, &context, gIOPowerPlane); - - if (options & kReserveDomainPower) - { - maxPowerState = fControllingDriver->maxCapabilityForDomainState( - fHeadNoteDomainTargetFlags ); - - if (StateOrder(maxPowerState) < StateOrder(ourPowerState)) - { - PM_LOG1("%s: power desired %u:0x%x got %u:0x%x\n", - getName(), - (uint32_t) ourPowerState, (uint32_t) requestPowerFlags, - (uint32_t) maxPowerState, (uint32_t) fHeadNoteDomainTargetFlags); - return kIOReturnNoPower; - } - } +IOReturn +IOService::requestDomainPower( + IOPMPowerStateIndex ourPowerState, + IOOptionBits options ) +{ + IOPMPowerFlags requestPowerFlags; + IOPMPowerStateIndex maxPowerState; + IOPMRequestDomainPowerContext context; + + PM_ASSERT_IN_GATE(); + assert(ourPowerState < fNumberOfPowerStates); + if (ourPowerState >= fNumberOfPowerStates) { + return kIOReturnBadArgument; + } + if (IS_PM_ROOT) { + return kIOReturnSuccess; + } + + // Fetch our input power flags for the requested power state. + // Parent request is stated in terms of required power flags. + + requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags; + + // Disregard the "previous request" for power reservation. + + if (((options & kReserveDomainPower) == 0) && + (fPreviousRequestPowerFlags == requestPowerFlags)) { + // skip if domain already knows our requirements + goto done; + } + fPreviousRequestPowerFlags = requestPowerFlags; + + // The results will be collected by fHeadNoteDomainTargetFlags + context.child = this; + context.requestPowerFlags = requestPowerFlags; + fHeadNoteDomainTargetFlags = 0; + applyToParents(requestDomainPowerApplier, &context, gIOPowerPlane); + + if (options & kReserveDomainPower) { + maxPowerState = fControllingDriver->maxCapabilityForDomainState( + fHeadNoteDomainTargetFlags ); + + if (StateOrder(maxPowerState) < StateOrder(ourPowerState)) { + PM_LOG1("%s: power desired %u:0x%x got %u:0x%x\n", + getName(), + (uint32_t) ourPowerState, (uint32_t) requestPowerFlags, + (uint32_t) maxPowerState, (uint32_t) fHeadNoteDomainTargetFlags); + return kIOReturnNoPower; + } + } done: - return kIOReturnSuccess; + return kIOReturnSuccess; } //********************************************************************************* // [private] OurSyncStart //********************************************************************************* -void IOService::OurSyncStart( void ) +void +IOService::OurSyncStart( void ) { - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); - if (fInitialPowerChange) - return; + if (fInitialPowerChange) { + return; + } - PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); + PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); - if (fHeadNoteChangeFlags & kIOPMNotDone) - { - OurChangeFinish(); - return; - } + if (fHeadNoteChangeFlags & kIOPMNotDone) { + OurChangeFinish(); + return; + } - if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown) - { - fDoNotPowerDown = false; + if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown) { + fDoNotPowerDown = false; - // Ask for permission to drop power state - fMachineState = kIOPM_SyncTellClientsPowerDown; - fOutOfBandParameter = kNotifyApps; - askChangeDown(fHeadNotePowerState); - } - else - { - // Only inform capability app and clients. - tellSystemCapabilityChange( kIOPM_SyncNotifyWillChange ); - } + // Ask for permission to drop power state + fMachineState = kIOPM_SyncTellClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + askChangeDown(fHeadNotePowerState); + } else { + // Only inform capability app and clients. + tellSystemCapabilityChange( kIOPM_SyncNotifyWillChange ); + } } //********************************************************************************* @@ -4649,15 +4667,15 @@ void IOService::OurSyncStart( void ) // power. Here we notify them that we will lower the power and wait for acks. //********************************************************************************* -void IOService::OurChangeTellClientsPowerDown( void ) +void +IOService::OurChangeTellClientsPowerDown( void ) { - if(!IS_ROOT_DOMAIN) - fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; - else - { - fMachineState = kIOPM_OurChangeTellUserPMPolicyPowerDown; - } - tellChangeDown1(fHeadNotePowerState); + if (!IS_ROOT_DOMAIN) { + fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; + } else { + fMachineState = kIOPM_OurChangeTellUserPMPolicyPowerDown; + } + tellChangeDown1(fHeadNotePowerState); } //********************************************************************************* @@ -4667,12 +4685,13 @@ void IOService::OurChangeTellClientsPowerDown( void ) // power. Here we notify power management policy in user-space and wait for acks // one last time before we lower power //********************************************************************************* -void IOService::OurChangeTellUserPMPolicyPowerDown ( void ) +void +IOService::OurChangeTellUserPMPolicyPowerDown( void ) { - fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; - fOutOfBandParameter = kNotifyApps; + fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; + fOutOfBandParameter = kNotifyApps; - tellClientsWithResponse(kIOPMMessageLastCallBeforeSleep); + tellClientsWithResponse(kIOPMMessageLastCallBeforeSleep); } //********************************************************************************* @@ -4682,10 +4701,11 @@ void IOService::OurChangeTellUserPMPolicyPowerDown ( void ) // power. Here we notify "priority" clients that we are lowering power. //********************************************************************************* -void IOService::OurChangeTellPriorityClientsPowerDown( void ) +void +IOService::OurChangeTellPriorityClientsPowerDown( void ) { - fMachineState = kIOPM_OurChangeNotifyInterestedDriversWillChange; - tellChangeDown2(fHeadNotePowerState); + fMachineState = kIOPM_OurChangeNotifyInterestedDriversWillChange; + tellChangeDown2(fHeadNotePowerState); } //********************************************************************************* @@ -4695,12 +4715,14 @@ void IOService::OurChangeTellPriorityClientsPowerDown( void ) // system capability change when raising power state. //********************************************************************************* -void IOService::OurChangeTellCapabilityWillChange( void ) +void +IOService::OurChangeTellCapabilityWillChange( void ) { - if (!IS_ROOT_DOMAIN) - return OurChangeNotifyInterestedDriversWillChange(); + if (!IS_ROOT_DOMAIN) { + return OurChangeNotifyInterestedDriversWillChange(); + } - tellSystemCapabilityChange( kIOPM_OurChangeNotifyInterestedDriversWillChange ); + tellSystemCapabilityChange( kIOPM_OurChangeNotifyInterestedDriversWillChange ); } //********************************************************************************* @@ -4710,20 +4732,19 @@ void IOService::OurChangeTellCapabilityWillChange( void ) // Here we notify interested drivers pre-change. //********************************************************************************* -void IOService::OurChangeNotifyInterestedDriversWillChange( void ) -{ - IOPMrootDomain * rootDomain; - if ((rootDomain = getPMRootDomain()) == this) - { - if (IS_POWER_DROP) - { - rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests ); - } - else - rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests ); - } +void +IOService::OurChangeNotifyInterestedDriversWillChange( void ) +{ + IOPMrootDomain * rootDomain; + if ((rootDomain = getPMRootDomain()) == this) { + if (IS_POWER_DROP) { + rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests ); + } else { + rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests ); + } + } - notifyAll( kIOPM_OurChangeSetPowerState ); + notifyAll( kIOPM_OurChangeSetPowerState ); } //********************************************************************************* @@ -4733,14 +4754,16 @@ void IOService::OurChangeNotifyInterestedDriversWillChange( void ) // change. Wait for async completions. //********************************************************************************* -void IOService::OurChangeSetPowerState( void ) +void +IOService::OurChangeSetPowerState( void ) { - MS_PUSH( kIOPM_OurChangeWaitForPowerSettle ); - fMachineState = kIOPM_DriverThreadCallDone; - fDriverCallReason = kDriverCallSetPowerState; + MS_PUSH( kIOPM_OurChangeWaitForPowerSettle ); + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = kDriverCallSetPowerState; - if (notifyControllingDriver() == false) - notifyControllingDriverDone(); + if (notifyControllingDriver() == false) { + notifyControllingDriverDone(); + } } //********************************************************************************* @@ -4750,10 +4773,11 @@ void IOService::OurChangeSetPowerState( void ) // Wait for the driver specified settle time to expire. //********************************************************************************* -void IOService::OurChangeWaitForPowerSettle( void ) +void +IOService::OurChangeWaitForPowerSettle( void ) { - fMachineState = kIOPM_OurChangeNotifyInterestedDriversDidChange; - startSettleTimer(); + fMachineState = kIOPM_OurChangeNotifyInterestedDriversDidChange; + startSettleTimer(); } //********************************************************************************* @@ -4763,17 +4787,17 @@ void IOService::OurChangeWaitForPowerSettle( void ) // all our interested drivers post-change. //********************************************************************************* -void IOService::OurChangeNotifyInterestedDriversDidChange( void ) +void +IOService::OurChangeNotifyInterestedDriversDidChange( void ) { - IOPMrootDomain * rootDomain; - if ((rootDomain = getPMRootDomain()) == this) - { - rootDomain->tracePoint( IS_POWER_DROP ? - kIOPMTracePointSleepDidChangeInterests : - kIOPMTracePointWakeDidChangeInterests ); - } + IOPMrootDomain * rootDomain; + if ((rootDomain = getPMRootDomain()) == this) { + rootDomain->tracePoint( IS_POWER_DROP ? + kIOPMTracePointSleepDidChangeInterests : + kIOPMTracePointWakeDidChangeInterests ); + } - notifyAll( kIOPM_OurChangeTellCapabilityDidChange ); + notifyAll( kIOPM_OurChangeTellCapabilityDidChange ); } //********************************************************************************* @@ -4782,16 +4806,18 @@ void IOService::OurChangeNotifyInterestedDriversDidChange( void ) // For root domain to notify capability power-change. //********************************************************************************* -void IOService::OurChangeTellCapabilityDidChange( void ) +void +IOService::OurChangeTellCapabilityDidChange( void ) { - if (!IS_ROOT_DOMAIN) - return OurChangeFinish(); + if (!IS_ROOT_DOMAIN) { + return OurChangeFinish(); + } - getPMRootDomain()->tracePoint( IS_POWER_DROP ? - kIOPMTracePointSleepCapabilityClients : - kIOPMTracePointWakeCapabilityClients ); + getPMRootDomain()->tracePoint( IS_POWER_DROP ? + kIOPMTracePointSleepCapabilityClients : + kIOPMTracePointWakeCapabilityClients ); - tellSystemCapabilityChange( kIOPM_OurChangeFinish ); + tellSystemCapabilityChange( kIOPM_OurChangeFinish ); } //********************************************************************************* @@ -4800,9 +4826,10 @@ void IOService::OurChangeTellCapabilityDidChange( void ) // Done with this self-induced power state change. //********************************************************************************* -void IOService::OurChangeFinish( void ) +void +IOService::OurChangeFinish( void ) { - all_done(); + all_done(); } // MARK: - @@ -4814,83 +4841,74 @@ void IOService::OurChangeFinish( void ) // Here we begin the processing of a power change initiated by our parent. //********************************************************************************* -IOReturn IOService::ParentChangeStart( void ) -{ - PM_ASSERT_IN_GATE(); - OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState ); - - // Root power domain has transitioned to its max power state - if ((fHeadNoteChangeFlags & (kIOPMDomainDidChange | kIOPMRootChangeUp)) == - (kIOPMDomainDidChange | kIOPMRootChangeUp)) - { - // Restart the idle timer stopped by ParentChangeRootChangeDown() - if (fIdleTimerPeriod && fIdleTimerStopped) - { - restartIdleTimer(); - } - } - - // Power domain is forcing us to lower power - if ( StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState) ) - { - PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); - - // Tell apps and kernel clients - fInitialPowerChange = false; - fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown; - tellChangeDown1(fHeadNotePowerState); - return IOPMWillAckLater; - } - - // Power domain is allowing us to raise power up to fHeadNotePowerState - if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) ) - { - if ( StateOrder(fDesiredPowerState) > StateOrder(fCurrentPowerState) ) - { - if ( StateOrder(fDesiredPowerState) < StateOrder(fHeadNotePowerState) ) - { - // We power up, but not all the way - fHeadNotePowerState = fDesiredPowerState; - fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState]; - OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); - } - } else { - // We don't need to change - fHeadNotePowerState = fCurrentPowerState; - fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState]; - OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); - } - } - - if ( fHeadNoteChangeFlags & kIOPMDomainDidChange ) - { - if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) ) - { - PM_ACTION_2(actionPowerChangeStart, - fHeadNotePowerState, &fHeadNoteChangeFlags); - - // Parent did change up - start our change up - fInitialPowerChange = false; - ParentChangeTellCapabilityWillChange(); - return IOPMWillAckLater; - } - else if (fHeadNoteChangeFlags & kIOPMRootBroadcastFlags) - { - // No need to change power state, but broadcast change - // to our children. - fMachineState = kIOPM_SyncNotifyDidChange; - fDriverCallReason = kDriverCallInformPreChange; - fHeadNoteChangeFlags |= kIOPMNotDone; - notifyChildren(); - return IOPMWillAckLater; - } - } - - // No power state change necessary - fHeadNoteChangeFlags |= kIOPMNotDone; - - all_done(); - return IOPMAckImplied; +IOReturn +IOService::ParentChangeStart( void ) +{ + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState ); + + // Root power domain has transitioned to its max power state + if ((fHeadNoteChangeFlags & (kIOPMDomainDidChange | kIOPMRootChangeUp)) == + (kIOPMDomainDidChange | kIOPMRootChangeUp)) { + // Restart the idle timer stopped by ParentChangeRootChangeDown() + if (fIdleTimerPeriod && fIdleTimerStopped) { + restartIdleTimer(); + } + } + + // Power domain is forcing us to lower power + if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) { + PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); + + // Tell apps and kernel clients + fInitialPowerChange = false; + fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown; + tellChangeDown1(fHeadNotePowerState); + return IOPMWillAckLater; + } + + // Power domain is allowing us to raise power up to fHeadNotePowerState + if (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState)) { + if (StateOrder(fDesiredPowerState) > StateOrder(fCurrentPowerState)) { + if (StateOrder(fDesiredPowerState) < StateOrder(fHeadNotePowerState)) { + // We power up, but not all the way + fHeadNotePowerState = fDesiredPowerState; + fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState]; + OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); + } + } else { + // We don't need to change + fHeadNotePowerState = fCurrentPowerState; + fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState]; + OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); + } + } + + if (fHeadNoteChangeFlags & kIOPMDomainDidChange) { + if (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState)) { + PM_ACTION_2(actionPowerChangeStart, + fHeadNotePowerState, &fHeadNoteChangeFlags); + + // Parent did change up - start our change up + fInitialPowerChange = false; + ParentChangeTellCapabilityWillChange(); + return IOPMWillAckLater; + } else if (fHeadNoteChangeFlags & kIOPMRootBroadcastFlags) { + // No need to change power state, but broadcast change + // to our children. + fMachineState = kIOPM_SyncNotifyDidChange; + fDriverCallReason = kDriverCallInformPreChange; + fHeadNoteChangeFlags |= kIOPMNotDone; + notifyChildren(); + return IOPMWillAckLater; + } + } + + // No power state change necessary + fHeadNoteChangeFlags |= kIOPMNotDone; + + all_done(); + return IOPMAckImplied; } //****************************************************************************** @@ -4902,93 +4920,83 @@ IOReturn IOService::ParentChangeStart( void ) // automatically restored on wake. //****************************************************************************** -void IOService::ParentChangeRootChangeDown( void ) -{ - // Always stop the idle timer before root power down - if (fIdleTimerPeriod && !fIdleTimerStopped) - { - fIdleTimerStopped = true; - if (fIdleTimer && thread_call_cancel(fIdleTimer)) - release(); - } - - if (fResetPowerStateOnWake) - { - // Reset device desire down to the lowest power state. - // Advisory tickle desire is intentionally untouched since - // it has no effect until system is promoted to full wake. - - if (fDeviceDesire != kPowerStateZero) - { - updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero); - computeDesiredState(kPowerStateZero, true); - requestDomainPower( fDesiredPowerState ); - PM_LOG1("%s: tickle desire removed\n", fName); - } - - // Invalidate tickle cache so the next tickle will issue a request - IOLockLock(fActivityLock); - fDeviceWasActive = false; - fActivityTicklePowerState = kInvalidTicklePowerState; - IOLockUnlock(fActivityLock); - - fIdleTimerMinPowerState = kPowerStateZero; - } - else if (fAdvisoryTickleUsed) - { - // Less aggressive mechanism to accelerate idle timer expiration - // before system sleep. May not always allow the driver to wake - // up from system sleep in the min power state. - - AbsoluteTime now; - uint64_t nsec; - bool dropTickleDesire = false; - - if (fIdleTimerPeriod && !fIdleTimerIgnored && - (fIdleTimerMinPowerState == kPowerStateZero) && - (fDeviceDesire != kPowerStateZero)) - { - IOLockLock(fActivityLock); - - if (!fDeviceWasActive) - { - // No tickles since the last idle timer expiration. - // Safe to drop the device desire to zero. - dropTickleDesire = true; - } - else - { - // Was tickled since the last idle timer expiration, - // but not in the last minute. - clock_get_uptime(&now); - SUB_ABSOLUTETIME(&now, &fDeviceActiveTimestamp); - absolutetime_to_nanoseconds(now, &nsec); - if (nsec >= kNoTickleCancelWindow) - { - dropTickleDesire = true; - } - } - - if (dropTickleDesire) - { - // Force the next tickle to raise power state - fDeviceWasActive = false; - fActivityTicklePowerState = kInvalidTicklePowerState; - } - - IOLockUnlock(fActivityLock); - } - - if (dropTickleDesire) - { - // Advisory tickle desire is intentionally untouched since - // it has no effect until system is promoted to full wake. - - updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero); - computeDesiredState(kPowerStateZero, true); - PM_LOG1("%s: tickle desire dropped\n", fName); - } - } +void +IOService::ParentChangeRootChangeDown( void ) +{ + // Always stop the idle timer before root power down + if (fIdleTimerPeriod && !fIdleTimerStopped) { + fIdleTimerStopped = true; + if (fIdleTimer && thread_call_cancel(fIdleTimer)) { + release(); + } + } + + if (fResetPowerStateOnWake) { + // Reset device desire down to the lowest power state. + // Advisory tickle desire is intentionally untouched since + // it has no effect until system is promoted to full wake. + + if (fDeviceDesire != kPowerStateZero) { + updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero); + computeDesiredState(kPowerStateZero, true); + requestDomainPower( fDesiredPowerState ); + PM_LOG1("%s: tickle desire removed\n", fName); + } + + // Invalidate tickle cache so the next tickle will issue a request + IOLockLock(fActivityLock); + fDeviceWasActive = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); + + fIdleTimerMinPowerState = kPowerStateZero; + } else if (fAdvisoryTickleUsed) { + // Less aggressive mechanism to accelerate idle timer expiration + // before system sleep. May not always allow the driver to wake + // up from system sleep in the min power state. + + AbsoluteTime now; + uint64_t nsec; + bool dropTickleDesire = false; + + if (fIdleTimerPeriod && !fIdleTimerIgnored && + (fIdleTimerMinPowerState == kPowerStateZero) && + (fDeviceDesire != kPowerStateZero)) { + IOLockLock(fActivityLock); + + if (!fDeviceWasActive) { + // No tickles since the last idle timer expiration. + // Safe to drop the device desire to zero. + dropTickleDesire = true; + } else { + // Was tickled since the last idle timer expiration, + // but not in the last minute. + clock_get_uptime(&now); + SUB_ABSOLUTETIME(&now, &fDeviceActiveTimestamp); + absolutetime_to_nanoseconds(now, &nsec); + if (nsec >= kNoTickleCancelWindow) { + dropTickleDesire = true; + } + } + + if (dropTickleDesire) { + // Force the next tickle to raise power state + fDeviceWasActive = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + } + + IOLockUnlock(fActivityLock); + } + + if (dropTickleDesire) { + // Advisory tickle desire is intentionally untouched since + // it has no effect until system is promoted to full wake. + + updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero); + computeDesiredState(kPowerStateZero, true); + PM_LOG1("%s: tickle desire dropped\n", fName); + } + } } //********************************************************************************* @@ -4998,10 +5006,11 @@ void IOService::ParentChangeRootChangeDown( void ) // power. Here we notify "priority" clients that we are lowering power. //********************************************************************************* -void IOService::ParentChangeTellPriorityClientsPowerDown( void ) +void +IOService::ParentChangeTellPriorityClientsPowerDown( void ) { - fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange; - tellChangeDown2(fHeadNotePowerState); + fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange; + tellChangeDown2(fHeadNotePowerState); } //********************************************************************************* @@ -5011,12 +5020,14 @@ void IOService::ParentChangeTellPriorityClientsPowerDown( void ) // root domain to notify apps and drivers about the system capability change. //********************************************************************************* -void IOService::ParentChangeTellCapabilityWillChange( void ) +void +IOService::ParentChangeTellCapabilityWillChange( void ) { - if (!IS_ROOT_DOMAIN) - return ParentChangeNotifyInterestedDriversWillChange(); + if (!IS_ROOT_DOMAIN) { + return ParentChangeNotifyInterestedDriversWillChange(); + } - tellSystemCapabilityChange( kIOPM_ParentChangeNotifyInterestedDriversWillChange ); + tellSystemCapabilityChange( kIOPM_ParentChangeNotifyInterestedDriversWillChange ); } //********************************************************************************* @@ -5026,9 +5037,10 @@ void IOService::ParentChangeTellCapabilityWillChange( void ) // Here we notify interested drivers pre-change. //********************************************************************************* -void IOService::ParentChangeNotifyInterestedDriversWillChange( void ) +void +IOService::ParentChangeNotifyInterestedDriversWillChange( void ) { - notifyAll( kIOPM_ParentChangeSetPowerState ); + notifyAll( kIOPM_ParentChangeSetPowerState ); } //********************************************************************************* @@ -5038,14 +5050,16 @@ void IOService::ParentChangeNotifyInterestedDriversWillChange( void ) // change. Wait for async completions. //********************************************************************************* -void IOService::ParentChangeSetPowerState( void ) +void +IOService::ParentChangeSetPowerState( void ) { - MS_PUSH( kIOPM_ParentChangeWaitForPowerSettle ); - fMachineState = kIOPM_DriverThreadCallDone; - fDriverCallReason = kDriverCallSetPowerState; + MS_PUSH( kIOPM_ParentChangeWaitForPowerSettle ); + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = kDriverCallSetPowerState; - if (notifyControllingDriver() == false) - notifyControllingDriverDone(); + if (notifyControllingDriver() == false) { + notifyControllingDriverDone(); + } } //********************************************************************************* @@ -5055,10 +5069,11 @@ void IOService::ParentChangeSetPowerState( void ) // parent. Wait for the driver specified settle time to expire. //********************************************************************************* -void IOService::ParentChangeWaitForPowerSettle( void ) +void +IOService::ParentChangeWaitForPowerSettle( void ) { - fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange; - startSettleTimer(); + fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange; + startSettleTimer(); } //********************************************************************************* @@ -5068,9 +5083,10 @@ void IOService::ParentChangeWaitForPowerSettle( void ) // all our interested drivers post-change. //********************************************************************************* -void IOService::ParentChangeNotifyInterestedDriversDidChange( void ) +void +IOService::ParentChangeNotifyInterestedDriversDidChange( void ) { - notifyAll( kIOPM_ParentChangeTellCapabilityDidChange ); + notifyAll( kIOPM_ParentChangeTellCapabilityDidChange ); } //********************************************************************************* @@ -5079,12 +5095,14 @@ void IOService::ParentChangeNotifyInterestedDriversDidChange( void ) // For root domain to notify capability power-change. //********************************************************************************* -void IOService::ParentChangeTellCapabilityDidChange( void ) +void +IOService::ParentChangeTellCapabilityDidChange( void ) { - if (!IS_ROOT_DOMAIN) - return ParentChangeAcknowledgePowerChange(); + if (!IS_ROOT_DOMAIN) { + return ParentChangeAcknowledgePowerChange(); + } - tellSystemCapabilityChange( kIOPM_ParentChangeAcknowledgePowerChange ); + tellSystemCapabilityChange( kIOPM_ParentChangeAcknowledgePowerChange ); } //********************************************************************************* @@ -5093,21 +5111,21 @@ void IOService::ParentChangeTellCapabilityDidChange( void ) // Acknowledge our power parent that our power change is done. //********************************************************************************* -void IOService::ParentChangeAcknowledgePowerChange( void ) +void +IOService::ParentChangeAcknowledgePowerChange( void ) { - IORegistryEntry * nub; - IOService * parent; + IORegistryEntry * nub; + IOService * parent; - nub = fHeadNoteParentConnection; - nub->retain(); - all_done(); - parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); - if ( parent ) - { - parent->acknowledgePowerChange((IOService *)nub); - parent->release(); - } - nub->release(); + nub = fHeadNoteParentConnection; + nub->retain(); + all_done(); + parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); + if (parent) { + parent->acknowledgePowerChange((IOService *)nub); + parent->release(); + } + nub->release(); } // MARK: - @@ -5120,10 +5138,11 @@ void IOService::ParentChangeAcknowledgePowerChange( void ) // there is a new power state. //********************************************************************************* -void IOService::settleTimerExpired( void ) +void +IOService::settleTimerExpired( void ) { - fSettleTimeUS = 0; - gIOPMWorkQueue->signalWorkAvailable(); + fSettleTimeUS = 0; + gIOPMWorkQueue->signalWorkAvailable(); } //********************************************************************************* @@ -5135,15 +5154,14 @@ void IOService::settleTimerExpired( void ) static void settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) { - IOService * me = (IOService *) arg0; + IOService * me = (IOService *) arg0; - if (gIOPMWorkLoop && gIOPMWorkQueue) - { - gIOPMWorkLoop->runAction( - OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired), - me); - } - me->release(); + if (gIOPMWorkLoop && gIOPMWorkQueue) { + gIOPMWorkLoop->runAction( + OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired), + me); + } + me->release(); } //********************************************************************************* @@ -5152,56 +5170,54 @@ settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) // Calculate a power-settling delay in microseconds and start a timer. //********************************************************************************* -void IOService::startSettleTimer( void ) +void +IOService::startSettleTimer( void ) { #if NOT_USEFUL - // This function is broken and serves no useful purpose since it never - // updates fSettleTimeUS to a non-zero value to stall the state machine, - // yet it starts a delay timer. It appears no driver relies on a delay - // from settleUpTime and settleDownTime in the power state table. - - AbsoluteTime deadline; - IOPMPowerStateIndex stateIndex; - IOPMPowerStateIndex currentOrder, newOrder, i; - uint32_t settleTime = 0; - boolean_t pending; - - PM_ASSERT_IN_GATE(); - - currentOrder = StateOrder(fCurrentPowerState); - newOrder = StateOrder(fHeadNotePowerState); - - i = currentOrder; - - // lowering power - if ( newOrder < currentOrder ) - { - while ( i > newOrder ) - { - stateIndex = fPowerStates[i].stateOrderToIndex; - settleTime += (uint32_t) fPowerStates[stateIndex].settleDownTime; - i--; - } - } - - // raising power - if ( newOrder > currentOrder ) - { - while ( i < newOrder ) - { - stateIndex = fPowerStates[i+1].stateOrderToIndex; - settleTime += (uint32_t) fPowerStates[stateIndex].settleUpTime; - i++; - } - } - - if (settleTime) - { - retain(); - clock_interval_to_deadline(settleTime, kMicrosecondScale, &deadline); - pending = thread_call_enter_delayed(fSettleTimer, deadline); - if (pending) release(); - } + // This function is broken and serves no useful purpose since it never + // updates fSettleTimeUS to a non-zero value to stall the state machine, + // yet it starts a delay timer. It appears no driver relies on a delay + // from settleUpTime and settleDownTime in the power state table. + + AbsoluteTime deadline; + IOPMPowerStateIndex stateIndex; + IOPMPowerStateIndex currentOrder, newOrder, i; + uint32_t settleTime = 0; + boolean_t pending; + + PM_ASSERT_IN_GATE(); + + currentOrder = StateOrder(fCurrentPowerState); + newOrder = StateOrder(fHeadNotePowerState); + + i = currentOrder; + + // lowering power + if (newOrder < currentOrder) { + while (i > newOrder) { + stateIndex = fPowerStates[i].stateOrderToIndex; + settleTime += (uint32_t) fPowerStates[stateIndex].settleDownTime; + i--; + } + } + + // raising power + if (newOrder > currentOrder) { + while (i < newOrder) { + stateIndex = fPowerStates[i + 1].stateOrderToIndex; + settleTime += (uint32_t) fPowerStates[stateIndex].settleUpTime; + i++; + } + } + + if (settleTime) { + retain(); + clock_interval_to_deadline(settleTime, kMicrosecondScale, &deadline); + pending = thread_call_enter_delayed(fSettleTimer, deadline); + if (pending) { + release(); + } + } #endif } @@ -5221,175 +5237,274 @@ void IOService::startSettleTimer( void ) //********************************************************************************* #ifndef __LP64__ -void IOService::ack_timer_ticked ( void ) +#if MACH_ASSERT +__dead2 +#endif +void +IOService::ack_timer_ticked( void ) { - assert(false); + assert(false); } #endif /* !__LP64__ */ -bool IOService::ackTimerTick( void ) -{ - IOPMinformee * nextObject; - bool done = false; - - PM_ASSERT_IN_GATE(); - switch (fMachineState) { - case kIOPM_OurChangeWaitForPowerSettle: - case kIOPM_ParentChangeWaitForPowerSettle: - // are we waiting for controlling driver to acknowledge? - if ( fDriverTimer > 0 ) - { - // yes, decrement timer tick - fDriverTimer--; - if ( fDriverTimer == 0 ) - { - // controlling driver is tardy - uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime); - OUR_PMLog(kPMLogCtrlDriverTardy, 0, 0); - setProperty(kIOPMTardyAckSPSKey, kOSBooleanTrue); - PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n", - fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); - - if (gIOKitDebug & kIOLogDebugPower) - { - panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms", - fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); - } - else - { - // Unblock state machine and pretend driver has acked. - done = true; - } - } else { - // still waiting, set timer again - start_ack_timer(); - } - } - break; - - case kIOPM_NotifyChildrenStart: - // are we waiting for interested parties to acknowledge? - if ( fHeadNotePendingAcks != 0 ) - { - // yes, go through the list of interested drivers - nextObject = fInterestedDrivers->firstInList(); - // and check each one - while ( nextObject != NULL ) - { - if ( nextObject->timer > 0 ) - { - nextObject->timer--; - // this one should have acked by now - if ( nextObject->timer == 0 ) - { - uint64_t nsec = computeTimeDeltaNS(&nextObject->startTime); - OUR_PMLog(kPMLogIntDriverTardy, 0, 0); - nextObject->whatObject->setProperty(kIOPMTardyAckPSCKey, kOSBooleanTrue); - PM_ERROR("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) timed out after %d ms\n", - nextObject->whatObject->getName(), - (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did", - OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState, - NS_TO_MS(nsec)); - - // Pretend driver has acked. - fHeadNotePendingAcks--; - } - } - nextObject = fInterestedDrivers->nextInList(nextObject); - } - - // is that the last? - if ( fHeadNotePendingAcks == 0 ) - { - // yes, we can continue - done = true; - } else { - // no, set timer again - start_ack_timer(); - } - } - break; - - // TODO: aggreggate this - case kIOPM_OurChangeTellClientsPowerDown: - case kIOPM_OurChangeTellUserPMPolicyPowerDown: - case kIOPM_OurChangeTellPriorityClientsPowerDown: - case kIOPM_OurChangeNotifyInterestedDriversWillChange: - case kIOPM_ParentChangeTellPriorityClientsPowerDown: - case kIOPM_ParentChangeNotifyInterestedDriversWillChange: - case kIOPM_SyncTellClientsPowerDown: - case kIOPM_SyncTellPriorityClientsPowerDown: - case kIOPM_SyncNotifyWillChange: - case kIOPM_TellCapabilityChangeDone: - // apps didn't respond in time - cleanClientResponses(true); - OUR_PMLog(kPMLogClientTardy, 0, 1); - // tardy equates to approval - done = true; - break; - - default: - PM_LOG1("%s: unexpected ack timer tick (state = %d)\n", - getName(), fMachineState); - break; - } - return done; +bool +IOService::ackTimerTick( void ) +{ + IOPMinformee * nextObject; + bool done = false; + + PM_ASSERT_IN_GATE(); + switch (fMachineState) { + case kIOPM_OurChangeWaitForPowerSettle: + case kIOPM_ParentChangeWaitForPowerSettle: + // are we waiting for controlling driver to acknowledge? + if (fDriverTimer > 0) { + // yes, decrement timer tick + fDriverTimer--; + if (fDriverTimer == 0) { + // controlling driver is tardy + uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime); + OUR_PMLog(kPMLogCtrlDriverTardy, 0, 0); + setProperty(kIOPMTardyAckSPSKey, kOSBooleanTrue); + PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n", + fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); + +#if DEBUG || DEVELOPMENT || CONFIG_EMBEDDED + uint32_t panic_allowed = -1; + PE_parse_boot_argn("setpowerstate_panic", &panic_allowed, sizeof(panic_allowed)); + if (panic_allowed != 0) { + // rdar://problem/48743340 - excluding AppleSEPManager from panic + const char *whitelist = "AppleSEPManager"; + if (strncmp(fName, whitelist, strlen(whitelist))) { + panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms", + fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); + } + } else { + PM_ERROR("setPowerState panic disabled by setpowerstate_panic boot-arg\n"); + } +#else + if (gIOKitDebug & kIOLogDebugPower) { + panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms", + fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); + } else { + // panic for first party kexts + const void *function_addr = NULL; + OSKext *kext = NULL; + function_addr = OSMemberFunctionCast(const void *, fControllingDriver, &IOService::setPowerState); + kext = OSKext::lookupKextWithAddress((vm_address_t)function_addr); + if (kext) { + const char *bundleID = kext->getIdentifierCString(); + const char *apple_prefix = "com.apple"; + const char *kernel_prefix = "__kernel__"; + if (strncmp(bundleID, apple_prefix, strlen(apple_prefix)) == 0 || strncmp(bundleID, kernel_prefix, strlen(kernel_prefix)) == 0) { + // first party client + panic("%s::setPowerState(%p : %p, %lu -> %lu) timed out after %d ms", + fName, this, function_addr, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); + } + kext->release(); + } + // Unblock state machine and pretend driver has acked. + done = true; + } +#endif + getPMRootDomain()->reset_watchdog_timer(this, 0); + } else { + // still waiting, set timer again + start_ack_timer(); + } + } + break; + + case kIOPM_NotifyChildrenStart: + // are we waiting for interested parties to acknowledge? + if (fHeadNotePendingAcks != 0) { + // yes, go through the list of interested drivers + nextObject = fInterestedDrivers->firstInList(); + // and check each one + while (nextObject != NULL) { + if (nextObject->timer > 0) { + nextObject->timer--; + // this one should have acked by now + if (nextObject->timer == 0) { + uint64_t nsec = computeTimeDeltaNS(&nextObject->startTime); + OUR_PMLog(kPMLogIntDriverTardy, 0, 0); + nextObject->whatObject->setProperty(kIOPMTardyAckPSCKey, kOSBooleanTrue); + PM_ERROR("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) timed out after %d ms\n", + nextObject->whatObject->getName(), + (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did", + OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState, + NS_TO_MS(nsec)); + + // Pretend driver has acked. + fHeadNotePendingAcks--; + } + } + nextObject = fInterestedDrivers->nextInList(nextObject); + } + + // is that the last? + if (fHeadNotePendingAcks == 0) { + // yes, we can continue + done = true; + getPMRootDomain()->reset_watchdog_timer(this, 0); + } else { + // no, set timer again + start_ack_timer(); + } + } + break; + + // TODO: aggreggate this + case kIOPM_OurChangeTellClientsPowerDown: + case kIOPM_OurChangeTellUserPMPolicyPowerDown: + case kIOPM_OurChangeTellPriorityClientsPowerDown: + case kIOPM_OurChangeNotifyInterestedDriversWillChange: + case kIOPM_ParentChangeTellPriorityClientsPowerDown: + case kIOPM_ParentChangeNotifyInterestedDriversWillChange: + case kIOPM_SyncTellClientsPowerDown: + case kIOPM_SyncTellPriorityClientsPowerDown: + case kIOPM_SyncNotifyWillChange: + case kIOPM_TellCapabilityChangeDone: + // apps didn't respond in time + cleanClientResponses(true); + OUR_PMLog(kPMLogClientTardy, 0, 1); + // tardy equates to approval + done = true; + break; + + default: + PM_LOG1("%s: unexpected ack timer tick (state = %d)\n", + getName(), fMachineState); + break; + } + return done; } //********************************************************************************* // [private] start_watchdog_timer //********************************************************************************* -void IOService::start_watchdog_timer( void ) +void +IOService::start_watchdog_timer( void ) { - AbsoluteTime deadline; - boolean_t pending; - static int timeout = -1; + int timeout; + uint64_t deadline; - if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) - return; + if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) { + return; + } - if (thread_call_isactive(fWatchdogTimer)) return; - if (timeout == -1) { - PE_parse_boot_argn("swd_timeout", &timeout, sizeof(timeout)); - } - if (timeout < 60) { - timeout = WATCHDOG_TIMER_PERIOD; - } + IOLockLock(fWatchdogLock); - clock_interval_to_deadline(timeout, kSecondScale, &deadline); + timeout = getPMRootDomain()->getWatchdogTimeout(); + clock_interval_to_deadline(timeout, kSecondScale, &deadline); + fWatchdogDeadline = deadline; + start_watchdog_timer(deadline); + IOLockUnlock(fWatchdogLock); +} - retain(); - pending = thread_call_enter_delayed(fWatchdogTimer, deadline); - if (pending) release(); +void +IOService::start_watchdog_timer(uint64_t deadline) +{ + IOLockAssert(fWatchdogLock, kIOLockAssertOwned); + if (!thread_call_isactive(fWatchdogTimer)) { + thread_call_enter_delayed(fWatchdogTimer, deadline); + } } //********************************************************************************* // [private] stop_watchdog_timer -// Returns true if watchdog was enabled and stopped now //********************************************************************************* -bool IOService::stop_watchdog_timer( void ) +void +IOService::stop_watchdog_timer( void ) { - boolean_t pending; + if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) { + return; + } - if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) - return false; + IOLockLock(fWatchdogLock); - pending = thread_call_cancel(fWatchdogTimer); - if (pending) release(); + thread_call_cancel(fWatchdogTimer); + fWatchdogDeadline = 0; + + while (fBlockedArray->getCount()) { + IOService *obj = OSDynamicCast(IOService, fBlockedArray->getObject(0)); + if (obj) { + PM_ERROR("WDOG:Object %s unexpected in blocked array\n", obj->fName); + fBlockedArray->removeObject(0); + } + } - return pending; + IOLockUnlock(fWatchdogLock); } //********************************************************************************* // reset_watchdog_timer //********************************************************************************* -void IOService::reset_watchdog_timer( void ) +void +IOService::reset_watchdog_timer(IOService *blockedObject, int pendingResponseTimeout) { - if (stop_watchdog_timer()) - start_watchdog_timer(); + unsigned int i; + uint64_t deadline; + IOService *obj; + + if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) { + return; + } + + + IOLockLock(fWatchdogLock); + if (!fWatchdogDeadline) { + goto exit; + } + + i = fBlockedArray->getNextIndexOfObject(blockedObject, 0); + if (pendingResponseTimeout == 0) { + blockedObject->fPendingResponseDeadline = 0; + if (i == (unsigned int)-1) { + goto exit; + } + fBlockedArray->removeObject(i); + } else { + // Set deadline 2secs after the expected response timeout to allow + // ack timer to handle the timeout. + clock_interval_to_deadline(pendingResponseTimeout + 2, kSecondScale, &deadline); + + if (i != (unsigned int)-1) { + PM_ERROR("WDOG:Object %s is already blocked for responses. Ignoring timeout %d\n", + fName, pendingResponseTimeout); + goto exit; + } + + for (i = 0; i < fBlockedArray->getCount(); i++) { + obj = OSDynamicCast(IOService, fBlockedArray->getObject(i)); + if (obj && (obj->fPendingResponseDeadline < deadline)) { + blockedObject->fPendingResponseDeadline = deadline; + fBlockedArray->setObject(i, blockedObject); + break; + } + } + if (i == fBlockedArray->getCount()) { + blockedObject->fPendingResponseDeadline = deadline; + fBlockedArray->setObject(blockedObject); + } + } + + obj = OSDynamicCast(IOService, fBlockedArray->getObject(0)); + if (!obj) { + int timeout = getPMRootDomain()->getWatchdogTimeout(); + clock_interval_to_deadline(timeout, kSecondScale, &deadline); + } else { + deadline = obj->fPendingResponseDeadline; + } + + thread_call_cancel(fWatchdogTimer); + start_watchdog_timer(deadline); + +exit: + IOLockUnlock(fWatchdogLock); } @@ -5402,57 +5517,65 @@ void IOService::reset_watchdog_timer( void ) void IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) { - IOService * me = (IOService *) arg0; + IOService * me = (IOService *) arg0; - gIOPMWatchDogThread = current_thread(); - getPMRootDomain()->sleepWakeDebugTrig(true); - gIOPMWatchDogThread = 0; - thread_call_free(me->fWatchdogTimer); - me->fWatchdogTimer = 0; + gIOPMWatchDogThread = current_thread(); + getPMRootDomain()->sleepWakeDebugTrig(true); + gIOPMWatchDogThread = NULL; + thread_call_free(me->fWatchdogTimer); + me->fWatchdogTimer = NULL; - return ; + return; } +IOWorkLoop * +IOService::getIOPMWorkloop( void ) +{ + return gIOPMWorkLoop; +} + + + //********************************************************************************* // [private] start_ack_timer //********************************************************************************* -void IOService::start_ack_timer( void ) +void +IOService::start_ack_timer( void ) { - start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale ); + start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale ); } -void IOService::start_ack_timer ( UInt32 interval, UInt32 scale ) +void +IOService::start_ack_timer( UInt32 interval, UInt32 scale ) { - AbsoluteTime deadline; - boolean_t pending; - - clock_interval_to_deadline(interval, scale, &deadline); + AbsoluteTime deadline; + boolean_t pending; - retain(); - pending = thread_call_enter_delayed(fAckTimer, deadline); - if (pending) release(); + clock_interval_to_deadline(interval, scale, &deadline); - // Stop watchdog if ack is delayed by more than a sec - if (interval * scale > kSecondScale) { - stop_watchdog_timer(); - } + retain(); + pending = thread_call_enter_delayed(fAckTimer, deadline); + if (pending) { + release(); + } } //********************************************************************************* // [private] stop_ack_timer //********************************************************************************* -void IOService::stop_ack_timer( void ) +void +IOService::stop_ack_timer( void ) { - boolean_t pending; - - pending = thread_call_cancel(fAckTimer); - if (pending) release(); + boolean_t pending; - start_watchdog_timer(); + pending = thread_call_cancel(fAckTimer); + if (pending) { + release(); + } } //********************************************************************************* @@ -5463,24 +5586,22 @@ void IOService::stop_ack_timer( void ) IOReturn IOService::actionAckTimerExpired( - OSObject * target, - void * arg0, void * arg1, - void * arg2, void * arg3 ) + OSObject * target, + void * arg0, void * arg1, + void * arg2, void * arg3 ) { - IOService * me = (IOService *) target; - bool done; + IOService * me = (IOService *) target; + bool done; - // done will be true if the timer tick unblocks the machine state, - // otherwise no need to signal the work loop. + // done will be true if the timer tick unblocks the machine state, + // otherwise no need to signal the work loop. - done = me->ackTimerTick(); - if (done && gIOPMWorkQueue) - { - gIOPMWorkQueue->signalWorkAvailable(); - me->start_watchdog_timer(); - } + done = me->ackTimerTick(); + if (done && gIOPMWorkQueue) { + gIOPMWorkQueue->signalWorkAvailable(); + } - return kIOReturnSuccess; + return kIOReturnSuccess; } //********************************************************************************* @@ -5492,111 +5613,14 @@ IOService::actionAckTimerExpired( void IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) { - IOService * me = (IOService *) arg0; + IOService * me = (IOService *) arg0; - if (gIOPMWorkLoop) - { - gIOPMWorkLoop->runAction(&actionAckTimerExpired, me); - } - me->release(); + if (gIOPMWorkLoop) { + gIOPMWorkLoop->runAction(&actionAckTimerExpired, me); + } + me->release(); } -//********************************************************************************* -// [private] start_spindump_timer -//********************************************************************************* - -void IOService::start_spindump_timer( const char * delay_type ) -{ - AbsoluteTime deadline; - boolean_t pending; - - if (!fSpinDumpTimer || !(kIOKextSpinDump & gIOKitDebug)) - return; - - if (gIOSpinDumpKextName[0] == '\0' && - !(PE_parse_boot_argn("swd_kext_name", &gIOSpinDumpKextName, - sizeof(gIOSpinDumpKextName)))) - { - return; - } - - if (strncmp(gIOSpinDumpKextName, fName, sizeof(gIOSpinDumpKextName)) != 0) - return; - - if (gIOSpinDumpDelayType[0] == '\0' && - !(PE_parse_boot_argn("swd_delay_type", &gIOSpinDumpDelayType, - sizeof(gIOSpinDumpDelayType)))) - { - strncpy(gIOSpinDumpDelayType, "SetState", sizeof(gIOSpinDumpDelayType)); - } - - if (strncmp(delay_type, gIOSpinDumpDelayType, sizeof(gIOSpinDumpDelayType)) != 0) - return; - - if (gIOSpinDumpDelayDuration == 0 && - !(PE_parse_boot_argn("swd_delay_duration", &gIOSpinDumpDelayDuration, - sizeof(gIOSpinDumpDelayDuration)))) - { - gIOSpinDumpDelayDuration = 300; - } - - clock_interval_to_deadline(gIOSpinDumpDelayDuration, kMillisecondScale, &deadline); - - retain(); - pending = thread_call_enter_delayed(fSpinDumpTimer, deadline); - if (pending) release(); -} - -//********************************************************************************* -// [private] stop_spindump_timer -//********************************************************************************* - -void IOService::stop_spindump_timer( void ) -{ - boolean_t pending; - - if (!fSpinDumpTimer || !(kIOKextSpinDump & gIOKitDebug)) - return; - - pending = thread_call_cancel(fSpinDumpTimer); - if (pending) release(); -} - - -//********************************************************************************* -// [static] actionSpinDumpTimerExpired -// -// Inside PM work loop's gate. -//********************************************************************************* - -IOReturn -IOService::actionSpinDumpTimerExpired( - OSObject * target, - void * arg0, void * arg1, - void * arg2, void * arg3 ) -{ - getPMRootDomain()->takeStackshot(false, false, true); - - return kIOReturnSuccess; -} - -//********************************************************************************* -// spindump_timer_expired -// -// Thread call function. Holds a retain while the callout is in flight. -//********************************************************************************* - -void -IOService::spindump_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) -{ - IOService * me = (IOService *) arg0; - - if (gIOPMWorkLoop) - { - gIOPMWorkLoop->runAction(&actionSpinDumpTimerExpired, me); - } - me->release(); -} // MARK: - // MARK: Client Messaging @@ -5605,24 +5629,22 @@ IOService::spindump_timer_expired( thread_call_param_t arg0, thread_call_param_t // [private] tellSystemCapabilityChange //********************************************************************************* -void IOService::tellSystemCapabilityChange( uint32_t nextMS ) +void +IOService::tellSystemCapabilityChange( uint32_t nextMS ) { - MS_PUSH( nextMS ); - fMachineState = kIOPM_TellCapabilityChangeDone; - fOutOfBandMessage = kIOMessageSystemCapabilityChange; + MS_PUSH( nextMS ); + fMachineState = kIOPM_TellCapabilityChangeDone; + fOutOfBandMessage = kIOMessageSystemCapabilityChange; - if (fIsPreChange) - { - // Notify app first on pre-change. - fOutOfBandParameter = kNotifyCapabilityChangeApps; - } - else - { - // Notify kernel clients first on post-change. - fOutOfBandParameter = kNotifyCapabilityChangePriority; - } + if (fIsPreChange) { + // Notify app first on pre-change. + fOutOfBandParameter = kNotifyCapabilityChangeApps; + } else { + // Notify kernel clients first on post-change. + fOutOfBandParameter = kNotifyCapabilityChangePriority; + } - tellClientsWithResponse( fOutOfBandMessage ); + tellClientsWithResponse( fOutOfBandMessage ); } //********************************************************************************* @@ -5637,9 +5659,10 @@ void IOService::tellSystemCapabilityChange( uint32_t nextMS ) // Return true if we don't have to wait for acknowledgements //********************************************************************************* -bool IOService::askChangeDown( unsigned long stateNum ) +bool +IOService::askChangeDown( unsigned long stateNum ) { - return tellClientsWithResponse( kIOMessageCanDevicePowerOff ); + return tellClientsWithResponse( kIOMessageCanDevicePowerOff ); } //********************************************************************************* @@ -5651,10 +5674,11 @@ bool IOService::askChangeDown( unsigned long stateNum ) // Return true if we don't have to wait for acknowledgements //********************************************************************************* -bool IOService::tellChangeDown1( unsigned long stateNum ) +bool +IOService::tellChangeDown1( unsigned long stateNum ) { - fOutOfBandParameter = kNotifyApps; - return tellChangeDown(stateNum); + fOutOfBandParameter = kNotifyApps; + return tellChangeDown(stateNum); } //********************************************************************************* @@ -5665,10 +5689,11 @@ bool IOService::tellChangeDown1( unsigned long stateNum ) // Return true if we don't have to wait for acknowledgements //********************************************************************************* -bool IOService::tellChangeDown2( unsigned long stateNum ) +bool +IOService::tellChangeDown2( unsigned long stateNum ) { - fOutOfBandParameter = kNotifyPriority; - return tellChangeDown(stateNum); + fOutOfBandParameter = kNotifyPriority; + return tellChangeDown(stateNum); } //********************************************************************************* @@ -5683,9 +5708,10 @@ bool IOService::tellChangeDown2( unsigned long stateNum ) // Return true if we don't have to wait for acknowledgements //********************************************************************************* -bool IOService::tellChangeDown( unsigned long stateNum ) +bool +IOService::tellChangeDown( unsigned long stateNum ) { - return tellClientsWithResponse( kIOMessageDeviceWillPowerOff ); + return tellClientsWithResponse( kIOMessageDeviceWillPowerOff ); } //********************************************************************************* @@ -5693,97 +5719,94 @@ bool IOService::tellChangeDown( unsigned long stateNum ) // //********************************************************************************* -static void logAppTimeouts( OSObject * object, void * arg ) -{ - IOPMInterestContext * context = (IOPMInterestContext *) arg; - OSObject * flag; - unsigned int clientIndex; - int pid = -1; - char name[128]; - - if (OSDynamicCast(_IOServiceInterestNotifier, object)) - { - // Discover the 'counter' value or index assigned to this client - // when it was notified, by searching for the array index of the - // client in an array holding the cached interested clients. - - clientIndex = context->notifyClients->getNextIndexOfObject(object, 0); - - if ((clientIndex != (unsigned int) -1) && - (flag = context->responseArray->getObject(clientIndex)) && - (flag != kOSBooleanTrue)) - { - OSNumber *clientID = copyClientIDForNotification(object, context); - - name[0] = '\0'; - if (clientID) { - pid = clientID->unsigned32BitValue(); - proc_name(pid, name, sizeof(name)); - clientID->release(); - } - - PM_ERROR(context->errorLog, pid, name); - - // TODO: record message type if possible - IOService::getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsApplicationResponseTimedOut, - name, 0, (30*1000), pid, object); - - } - } -} - -void IOService::cleanClientResponses( bool logErrors ) -{ - if (logErrors && fResponseArray) - { - switch ( fOutOfBandParameter ) { - case kNotifyApps: - case kNotifyCapabilityChangeApps: - if (fNotifyClientArray) - { - IOPMInterestContext context; - - context.responseArray = fResponseArray; - context.notifyClients = fNotifyClientArray; - context.serialNumber = fSerialNumber; - context.messageType = kIOMessageCopyClientID; - context.notifyType = kNotifyApps; - context.isPreChange = fIsPreChange; - context.enableTracing = false; - context.us = this; - context.maxTimeRequested = 0; - context.stateNumber = fHeadNotePowerState; - context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; - context.changeFlags = fHeadNoteChangeFlags; - context.errorLog = "PM notification timeout (pid %d, %s)\n"; - - applyToInterested(gIOAppPowerStateInterest, logAppTimeouts, (void *) &context); - } - break; - - default: - // kNotifyPriority, kNotifyCapabilityChangePriority - // TODO: identify the priority client that has not acked - PM_ERROR("PM priority notification timeout\n"); - if (gIOKitDebug & kIOLogDebugPower) - { - panic("PM priority notification timeout"); - } - break; - } - } - - if (fResponseArray) - { - fResponseArray->release(); - fResponseArray = NULL; - } - if (fNotifyClientArray) - { - fNotifyClientArray->release(); - fNotifyClientArray = NULL; - } +static void +logAppTimeouts( OSObject * object, void * arg ) +{ + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * flag; + unsigned int clientIndex; + int pid = 0; + char name[128]; + + if (OSDynamicCast(_IOServiceInterestNotifier, object)) { + // Discover the 'counter' value or index assigned to this client + // when it was notified, by searching for the array index of the + // client in an array holding the cached interested clients. + + clientIndex = context->notifyClients->getNextIndexOfObject(object, 0); + + if ((clientIndex != (unsigned int) -1) && + (flag = context->responseArray->getObject(clientIndex)) && + (flag != kOSBooleanTrue)) { + OSNumber *clientID = copyClientIDForNotification(object, context); + + name[0] = '\0'; + if (clientID) { + pid = clientID->unsigned32BitValue(); + proc_name(pid, name, sizeof(name)); + clientID->release(); + } + + PM_ERROR(context->errorLog, pid, name); + + // TODO: record message type if possible + IOService::getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsResponseTimedOut, + name, 0, (30 * 1000), pid, object); + } + } +} + +void +IOService::cleanClientResponses( bool logErrors ) +{ + if (logErrors && fResponseArray) { + switch (fOutOfBandParameter) { + case kNotifyApps: + case kNotifyCapabilityChangeApps: + if (fNotifyClientArray) { + IOPMInterestContext context; + + context.responseArray = fResponseArray; + context.notifyClients = fNotifyClientArray; + context.serialNumber = fSerialNumber; + context.messageType = kIOMessageCopyClientID; + context.notifyType = kNotifyApps; + context.isPreChange = fIsPreChange; + context.enableTracing = false; + context.us = this; + context.maxTimeRequested = 0; + context.stateNumber = fHeadNotePowerState; + context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; + context.changeFlags = fHeadNoteChangeFlags; + context.errorLog = "PM notification timeout (pid %d, %s)\n"; + + applyToInterested(gIOAppPowerStateInterest, logAppTimeouts, (void *) &context); + } + break; + + default: + // kNotifyPriority, kNotifyCapabilityChangePriority + // TODO: identify the priority client that has not acked + PM_ERROR("PM priority notification timeout\n"); + if (gIOKitDebug & kIOLogDebugPower) { + panic("PM priority notification timeout"); + } + break; + } + } + + if (IS_ROOT_DOMAIN) { + getPMRootDomain()->reset_watchdog_timer(this, 0); + } + if (fResponseArray) { + fResponseArray->release(); + fResponseArray = NULL; + } + if (fNotifyClientArray) { + fNotifyClientArray->release(); + fNotifyClientArray = NULL; + } } //********************************************************************************* @@ -5795,143 +5818,149 @@ void IOService::cleanClientResponses( bool logErrors ) // Return true if we don't have to wait for acknowledgements //********************************************************************************* -bool IOService::tellClientsWithResponse( int messageType ) -{ - IOPMInterestContext context; - bool isRootDomain = IS_ROOT_DOMAIN; - uint32_t maxTimeOut = kMaxTimeRequested; - - PM_ASSERT_IN_GATE(); - assert( fResponseArray == NULL ); - assert( fNotifyClientArray == NULL ); - - if(messageType == (int)kIOPMMessageLastCallBeforeSleep) - RD_LOG("tellClientsWithResponse( kIOPMMessageLastCallBeforeSleep, %d )\n", - fOutOfBandParameter); - else - RD_LOG("tellClientsWithResponse( %s, %d )\n", - getIOMessageString(messageType), fOutOfBandParameter); - - fResponseArray = OSArray::withCapacity( 1 ); - if (!fResponseArray) - goto exit; - - fResponseArray->setCapacityIncrement(8); - if (++fSerialNumber == 0) - fSerialNumber++; - - context.responseArray = fResponseArray; - context.notifyClients = 0; - context.serialNumber = fSerialNumber; - context.messageType = messageType; - context.notifyType = fOutOfBandParameter; - context.isPreChange = fIsPreChange; - context.enableTracing = false; - context.us = this; - context.maxTimeRequested = 0; - context.stateNumber = fHeadNotePowerState; - context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; - context.changeFlags = fHeadNoteChangeFlags; - context.messageFilter = (isRootDomain) ? - OSMemberFunctionCast( - IOPMMessageFilter, - this, - &IOPMrootDomain::systemMessageFilter) : 0; - - switch ( fOutOfBandParameter ) { - case kNotifyApps: - applyToInterested( gIOAppPowerStateInterest, - pmTellAppWithResponse, (void *) &context ); - - if (isRootDomain && - (fMachineState != kIOPM_OurChangeTellClientsPowerDown) && - (fMachineState != kIOPM_SyncTellClientsPowerDown) && - (context.messageType != kIOPMMessageLastCallBeforeSleep)) - { - // Notify capability app for tellChangeDown1() - // but not for askChangeDown(). - context.notifyType = kNotifyCapabilityChangeApps; - context.messageType = kIOMessageSystemCapabilityChange; - applyToInterested( gIOAppPowerStateInterest, - pmTellCapabilityAppWithResponse, (void *) &context ); - context.notifyType = fOutOfBandParameter; - context.messageType = messageType; - } - if(context.messageType == kIOMessageCanSystemSleep) - { - maxTimeOut = kCanSleepMaxTimeReq; - if(gCanSleepTimeout) - { - maxTimeOut = (gCanSleepTimeout*us_per_s); - } - } - context.maxTimeRequested = maxTimeOut; - applyToInterested( gIOGeneralInterest, - pmTellClientWithResponse, (void *) &context ); - - fNotifyClientArray = context.notifyClients; - break; - - case kNotifyPriority: - context.enableTracing = isRootDomain; - applyToInterested( gIOPriorityPowerStateInterest, - pmTellClientWithResponse, (void *) &context ); - - if (isRootDomain) - { - // Notify capability clients for tellChangeDown2(). - context.notifyType = kNotifyCapabilityChangePriority; - context.messageType = kIOMessageSystemCapabilityChange; - applyToInterested( gIOPriorityPowerStateInterest, - pmTellCapabilityClientWithResponse, (void *) &context ); - } - break; - - case kNotifyCapabilityChangeApps: - applyToInterested( gIOAppPowerStateInterest, - pmTellCapabilityAppWithResponse, (void *) &context ); - fNotifyClientArray = context.notifyClients; - if(context.messageType == kIOMessageCanSystemSleep) - { - maxTimeOut = kCanSleepMaxTimeReq; - if(gCanSleepTimeout) - { - maxTimeOut = (gCanSleepTimeout*us_per_s); - } - } - context.maxTimeRequested = maxTimeOut; - break; - - case kNotifyCapabilityChangePriority: - applyToInterested( gIOPriorityPowerStateInterest, - pmTellCapabilityClientWithResponse, (void *) &context ); - break; - } - - // do we have to wait for somebody? - if ( !checkForDone() ) - { - OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0); - if (context.enableTracing) - getPMRootDomain()->traceDetail( context.maxTimeRequested / 1000 ); - start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale ); - return false; - } +bool +IOService::tellClientsWithResponse( int messageType ) +{ + IOPMInterestContext context; + bool isRootDomain = IS_ROOT_DOMAIN; + uint32_t maxTimeOut = kMaxTimeRequested; + + PM_ASSERT_IN_GATE(); + assert( fResponseArray == NULL ); + assert( fNotifyClientArray == NULL ); + + if (messageType == (int)kIOPMMessageLastCallBeforeSleep) { + RD_LOG("tellClientsWithResponse( kIOPMMessageLastCallBeforeSleep, %d )\n", + fOutOfBandParameter); + } else { + RD_LOG("tellClientsWithResponse( %s, %d )\n", + getIOMessageString(messageType), fOutOfBandParameter); + } + + fResponseArray = OSArray::withCapacity( 1 ); + if (!fResponseArray) { + goto exit; + } + + fResponseArray->setCapacityIncrement(8); + if (++fSerialNumber == 0) { + fSerialNumber++; + } + + context.responseArray = fResponseArray; + context.notifyClients = NULL; + context.serialNumber = fSerialNumber; + context.messageType = messageType; + context.notifyType = fOutOfBandParameter; + context.skippedInDark = 0; + context.notSkippedInDark = 0; + context.isPreChange = fIsPreChange; + context.enableTracing = false; + context.us = this; + context.maxTimeRequested = 0; + context.stateNumber = fHeadNotePowerState; + context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; + context.changeFlags = fHeadNoteChangeFlags; + context.messageFilter = (isRootDomain) ? + OSMemberFunctionCast( + IOPMMessageFilter, + this, + &IOPMrootDomain::systemMessageFilter) : NULL; + + switch (fOutOfBandParameter) { + case kNotifyApps: + applyToInterested( gIOAppPowerStateInterest, + pmTellAppWithResponse, (void *) &context ); + + if (isRootDomain && + (fMachineState != kIOPM_OurChangeTellClientsPowerDown) && + (fMachineState != kIOPM_SyncTellClientsPowerDown) && + (context.messageType != kIOPMMessageLastCallBeforeSleep)) { + // Notify capability app for tellChangeDown1() + // but not for askChangeDown(). + context.notifyType = kNotifyCapabilityChangeApps; + context.messageType = kIOMessageSystemCapabilityChange; + applyToInterested( gIOAppPowerStateInterest, + pmTellCapabilityAppWithResponse, (void *) &context ); + context.notifyType = fOutOfBandParameter; + context.messageType = messageType; + } + if (context.messageType == kIOMessageCanSystemSleep) { + maxTimeOut = kCanSleepMaxTimeReq; + if (gCanSleepTimeout) { + maxTimeOut = (gCanSleepTimeout * us_per_s); + } + } + context.maxTimeRequested = maxTimeOut; + context.enableTracing = isRootDomain; + applyToInterested( gIOGeneralInterest, + pmTellClientWithResponse, (void *) &context ); + + break; + + case kNotifyPriority: + context.enableTracing = isRootDomain; + applyToInterested( gIOPriorityPowerStateInterest, + pmTellClientWithResponse, (void *) &context ); + + if (isRootDomain) { + // Notify capability clients for tellChangeDown2(). + context.notifyType = kNotifyCapabilityChangePriority; + context.messageType = kIOMessageSystemCapabilityChange; + applyToInterested( gIOPriorityPowerStateInterest, + pmTellCapabilityClientWithResponse, (void *) &context ); + } + break; + + case kNotifyCapabilityChangeApps: + applyToInterested( gIOAppPowerStateInterest, + pmTellCapabilityAppWithResponse, (void *) &context ); + if (context.messageType == kIOMessageCanSystemSleep) { + maxTimeOut = kCanSleepMaxTimeReq; + if (gCanSleepTimeout) { + maxTimeOut = (gCanSleepTimeout * us_per_s); + } + } + context.maxTimeRequested = maxTimeOut; + break; + + case kNotifyCapabilityChangePriority: + context.enableTracing = isRootDomain; + applyToInterested( gIOPriorityPowerStateInterest, + pmTellCapabilityClientWithResponse, (void *) &context ); + break; + } + fNotifyClientArray = context.notifyClients; + + if (context.skippedInDark) { + IOLog("tellClientsWithResponse(%s, %d) %d of %d skipped in dark\n", + getIOMessageString(messageType), fOutOfBandParameter, + context.skippedInDark, context.skippedInDark + context.notSkippedInDark); + } + + // do we have to wait for somebody? + if (!checkForDone()) { + OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0); + if (context.enableTracing) { + getPMRootDomain()->traceDetail(context.messageType, 0, context.maxTimeRequested / 1000); + getPMRootDomain()->reset_watchdog_timer(this, context.maxTimeRequested / USEC_PER_SEC + 1); + } + start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale ); + return false; + } exit: - // everybody responded - if (fResponseArray) - { - fResponseArray->release(); - fResponseArray = NULL; - } - if (fNotifyClientArray) - { - fNotifyClientArray->release(); - fNotifyClientArray = NULL; - } + // everybody responded + if (fResponseArray) { + fResponseArray->release(); + fResponseArray = NULL; + } + if (fNotifyClientArray) { + fNotifyClientArray->release(); + fNotifyClientArray = NULL; + } - return true; + return true; } //********************************************************************************* @@ -5941,97 +5970,94 @@ exit: // cookie we can identify the response with. //********************************************************************************* -void IOService::pmTellAppWithResponse( OSObject * object, void * arg ) -{ - IOPMInterestContext * context = (IOPMInterestContext *) arg; - IOServicePM * pwrMgt = context->us->pwrMgt; - uint32_t msgIndex, msgRef, msgType; - OSNumber *clientID = NULL; - proc_t proc = NULL; - boolean_t proc_suspended = FALSE; - OSObject * waitForReply = kOSBooleanTrue; +void +IOService::pmTellAppWithResponse( OSObject * object, void * arg ) +{ + IOPMInterestContext * context = (IOPMInterestContext *) arg; + IOServicePM * pwrMgt = context->us->pwrMgt; + uint32_t msgIndex, msgRef, msgType; + OSNumber *clientID = NULL; + proc_t proc = NULL; + boolean_t proc_suspended = FALSE; + OSObject * waitForReply = kOSBooleanTrue; #if LOG_APP_RESPONSE_TIMES - AbsoluteTime now; + AbsoluteTime now; #endif - if (!OSDynamicCast(_IOServiceInterestNotifier, object)) - return; - - if (context->us == getPMRootDomain()) - { - if ((clientID = copyClientIDForNotification(object, context))) - { - uint32_t clientPID = clientID->unsigned32BitValue(); - clientID->release(); - proc = proc_find(clientPID); - - if (proc) - { - proc_suspended = get_task_pidsuspended((task_t) proc->task); - proc_rele(proc); - - if (proc_suspended) - { - logClientIDForNotification(object, context, "PMTellAppWithResponse - Suspended"); - return; - } - } - } - } - - if (context->messageFilter && - !context->messageFilter(context->us, object, context, 0, &waitForReply)) - { - if (kIOLogDebugPower & gIOKitDebug) - { - logClientIDForNotification(object, context, "DROP App"); - } - return; - } - - // Create client array (for tracking purposes) only if the service - // has app clients. Usually only root domain does. - if (0 == context->notifyClients) - context->notifyClients = OSArray::withCapacity( 32 ); - - msgType = context->messageType; - msgIndex = context->responseArray->getCount(); - msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); - - OUR_PMLog(kPMLogAppNotify, msgType, msgRef); - if (kIOLogDebugPower & gIOKitDebug) - { - logClientIDForNotification(object, context, "MESG App"); - } - - if (waitForReply == kOSBooleanTrue) - { -#if LOG_APP_RESPONSE_TIMES - OSNumber * num; - clock_get_uptime(&now); - num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8); - if (num) - { - context->responseArray->setObject(msgIndex, num); - num->release(); - } - else -#endif - context->responseArray->setObject(msgIndex, kOSBooleanFalse); - } - else - { - context->responseArray->setObject(msgIndex, kOSBooleanTrue); - if (kIOLogDebugPower & gIOKitDebug) - { - logClientIDForNotification(object, context, "App response ignored"); - } - } + if (!OSDynamicCast(_IOServiceInterestNotifier, object)) { + return; + } + + if (context->us == getPMRootDomain()) { + if ((clientID = copyClientIDForNotification(object, context))) { + uint32_t clientPID = clientID->unsigned32BitValue(); + clientID->release(); + proc = proc_find(clientPID); + + if (proc) { + proc_suspended = get_task_pidsuspended((task_t) proc->task); + if (proc_suspended) { + logClientIDForNotification(object, context, "PMTellAppWithResponse - Suspended"); +#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) + } else if (getPMRootDomain()->isAOTMode() && get_task_suspended((task_t) proc->task)) { + proc_suspended = true; + context->skippedInDark++; +#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + } + proc_rele(proc); + if (proc_suspended) { + return; + } + } + } + } + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, NULL, &waitForReply)) { + if (kIOLogDebugPower & gIOKitDebug) { + logClientIDForNotification(object, context, "DROP App"); + } + return; + } + context->notSkippedInDark++; + + // Create client array (for tracking purposes) only if the service + // has app clients. Usually only root domain does. + if (NULL == context->notifyClients) { + context->notifyClients = OSArray::withCapacity( 32 ); + } + + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + OUR_PMLog(kPMLogAppNotify, msgType, msgRef); + if (kIOLogDebugPower & gIOKitDebug) { + logClientIDForNotification(object, context, "MESG App"); + } + + if (waitForReply == kOSBooleanTrue) { + OSNumber * num; + clock_get_uptime(&now); + num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8); + if (num) { + context->responseArray->setObject(msgIndex, num); + num->release(); + } else { + context->responseArray->setObject(msgIndex, kOSBooleanFalse); + } + } else { + context->responseArray->setObject(msgIndex, kOSBooleanTrue); + if (kIOLogDebugPower & gIOKitDebug) { + logClientIDForNotification(object, context, "App response ignored"); + } + } - if (context->notifyClients) - context->notifyClients->setObject(msgIndex, object); + if (context->notifyClients) { + context->notifyClients->setObject(msgIndex, object); + } - context->us->messageClient(msgType, object, (void *)(uintptr_t) msgRef); + context->us->messageClient(msgType, object, (void *)(uintptr_t) msgRef); } //********************************************************************************* @@ -6041,287 +6067,363 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg ) // so we compute a cookie we can identify the response with. //********************************************************************************* -void IOService::pmTellClientWithResponse( OSObject * object, void * arg ) -{ - IOPowerStateChangeNotification notify; - IOPMInterestContext * context = (IOPMInterestContext *) arg; - OSObject * replied = kOSBooleanTrue; - _IOServiceInterestNotifier * notifier; - uint32_t msgIndex, msgRef, msgType; - IOReturn retCode; - - if (context->messageFilter && - !context->messageFilter(context->us, object, context, 0, 0)) - { - if ((kIOLogDebugPower & gIOKitDebug) && - (OSDynamicCast(_IOServiceInterestNotifier, object))) - { - _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; - PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", - context->us->getName(), - getIOMessageString(context->messageType), - OBFUSCATE(object), OBFUSCATE(n->handler)); - } - return; - } - - notifier = OSDynamicCast(_IOServiceInterestNotifier, object); - msgType = context->messageType; - msgIndex = context->responseArray->getCount(); - msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); - - IOServicePM * pwrMgt = context->us->pwrMgt; - if (gIOKitDebug & kIOLogPower) { - OUR_PMLog(kPMLogClientNotify, msgRef, msgType); - if (OSDynamicCast(IOService, object)) { - const char *who = ((IOService *) object)->getName(); - gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0); - } - else if (notifier) { - OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); - } - } - if ((kIOLogDebugPower & gIOKitDebug) && notifier) - { - PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", - context->us->getName(), - getIOMessageString(msgType), - OBFUSCATE(object), OBFUSCATE(notifier->handler)); - } - - notify.powerRef = (void *)(uintptr_t) msgRef; - notify.returnValue = 0; - notify.stateNumber = context->stateNumber; - notify.stateFlags = context->stateFlags; - - if (context->enableTracing && (notifier != 0)) - { - uint32_t detail = ((msgIndex & 0xff) << 24) | - ((msgType & 0xfff) << 12) | - (((uintptr_t) notifier->handler) & 0xfff); - getPMRootDomain()->traceDetail( detail ); - } - - retCode = context->us->messageClient(msgType, object, (void *) ¬ify, sizeof(notify)); - - if (kIOReturnSuccess == retCode) - { - if (0 == notify.returnValue) { - OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); - } else { - replied = kOSBooleanFalse; - if ( notify.returnValue > context->maxTimeRequested ) - { - if (notify.returnValue > kPriorityClientMaxWait) - { - context->maxTimeRequested = kPriorityClientMaxWait; - PM_ERROR("%s: client %p returned %llu for %s\n", - context->us->getName(), - notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), - (uint64_t) notify.returnValue, - getIOMessageString(msgType)); - } - else - context->maxTimeRequested = notify.returnValue; - } - } - } else { - // not a client of ours - // so we won't be waiting for response - OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); - } - - context->responseArray->setObject(msgIndex, replied); +void +IOService::pmTellClientWithResponse( OSObject * object, void * arg ) +{ + IOPowerStateChangeNotification notify; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * replied = kOSBooleanTrue; + _IOServiceInterestNotifier * notifier; + uint32_t msgIndex, msgRef, msgType; + IOReturn retCode; + AbsoluteTime start, end; + uint64_t nsec; + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, NULL, NULL)) { + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } + return; + } + + notifier = OSDynamicCast(_IOServiceInterestNotifier, object); + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + IOServicePM * pwrMgt = context->us->pwrMgt; + if (gIOKitDebug & kIOLogPower) { + OUR_PMLog(kPMLogClientNotify, msgRef, msgType); + if (OSDynamicCast(IOService, object)) { + const char *who = ((IOService *) object)->getName(); + gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0); + } else if (notifier) { + OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); + } + } + if ((kIOLogDebugPower & gIOKitDebug) && notifier) { + PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(msgType), + OBFUSCATE(object), OBFUSCATE(notifier->handler)); + } + + if (NULL == context->notifyClients) { + context->notifyClients = OSArray::withCapacity( 32 ); + } + + notify.powerRef = (void *)(uintptr_t) msgRef; + notify.returnValue = 0; + notify.stateNumber = context->stateNumber; + notify.stateFlags = context->stateFlags; + + if (context->enableTracing && (notifier != NULL)) { + getPMRootDomain()->traceDetail(notifier, true); + } + + clock_get_uptime(&start); + retCode = context->us->messageClient(msgType, object, (void *) ¬ify, sizeof(notify)); + clock_get_uptime(&end); + + if (context->enableTracing && (notifier != NULL)) { + getPMRootDomain()->traceDetail(notifier, false); + } + + + if (kIOReturnSuccess == retCode) { + if (0 == notify.returnValue) { + OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); + context->responseArray->setObject(msgIndex, replied); + } else { + replied = kOSBooleanFalse; + if (notify.returnValue > context->maxTimeRequested) { + if (notify.returnValue > kPriorityClientMaxWait) { + context->maxTimeRequested = kPriorityClientMaxWait; + PM_ERROR("%s: client %p returned %llu for %s\n", + context->us->getName(), + notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), + (uint64_t) notify.returnValue, + getIOMessageString(msgType)); + } else { + context->maxTimeRequested = notify.returnValue; + } + } + // + // Track time taken to ack, by storing the timestamp of + // callback completion + OSNumber * num; + num = OSNumber::withNumber(AbsoluteTime_to_scalar(&end), sizeof(uint64_t) * 8); + if (num) { + context->responseArray->setObject(msgIndex, num); + num->release(); + } else { + context->responseArray->setObject(msgIndex, replied); + } + } + + if (context->enableTracing) { + SUB_ABSOLUTETIME(&end, &start); + absolutetime_to_nanoseconds(end, &nsec); + + if ((nsec > LOG_KEXT_RESPONSE_TIMES) || (notify.returnValue != 0)) { + getPMRootDomain()->traceAckDelay(notifier, notify.returnValue / 1000, NS_TO_MS(nsec)); + } + } + } else { + // not a client of ours + // so we won't be waiting for response + OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); + context->responseArray->setObject(msgIndex, replied); + } + if (context->notifyClients) { + context->notifyClients->setObject(msgIndex, object); + } } //********************************************************************************* // [static private] pmTellCapabilityAppWithResponse //********************************************************************************* -void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg ) +void +IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg ) { - IOPMSystemCapabilityChangeParameters msgArg; - IOPMInterestContext * context = (IOPMInterestContext *) arg; - OSObject * replied = kOSBooleanTrue; - IOServicePM * pwrMgt = context->us->pwrMgt; - uint32_t msgIndex, msgRef, msgType; + IOPMSystemCapabilityChangeParameters msgArg; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * replied = kOSBooleanTrue; + IOServicePM * pwrMgt = context->us->pwrMgt; + uint32_t msgIndex, msgRef, msgType; #if LOG_APP_RESPONSE_TIMES - AbsoluteTime now; + AbsoluteTime now; #endif - if (!OSDynamicCast(_IOServiceInterestNotifier, object)) - return; - - memset(&msgArg, 0, sizeof(msgArg)); - if (context->messageFilter && - !context->messageFilter(context->us, object, context, &msgArg, &replied)) - { - return; - } - - // Create client array (for tracking purposes) only if the service - // has app clients. Usually only root domain does. - if (0 == context->notifyClients) - context->notifyClients = OSArray::withCapacity( 32 ); - - msgType = context->messageType; - msgIndex = context->responseArray->getCount(); - msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); - - OUR_PMLog(kPMLogAppNotify, msgType, msgRef); - if (kIOLogDebugPower & gIOKitDebug) - { - // Log client pid/name and client array index. - OSNumber * clientID = NULL; - OSString * clientIDString = NULL;; - context->us->messageClient(kIOMessageCopyClientID, object, &clientID); - if (clientID) { - clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue()); - } - - PM_LOG("%s MESG App(%u) %s, wait %u, %s\n", - context->us->getName(), - msgIndex, getIOMessageString(msgType), - (replied != kOSBooleanTrue), - clientIDString ? clientIDString->getCStringNoCopy() : ""); - if (clientID) clientID->release(); - if (clientIDString) clientIDString->release(); - } - - msgArg.notifyRef = msgRef; - msgArg.maxWaitForReply = 0; - - if (replied == kOSBooleanTrue) - { - msgArg.notifyRef = 0; - context->responseArray->setObject(msgIndex, kOSBooleanTrue); - if (context->notifyClients) - context->notifyClients->setObject(msgIndex, kOSBooleanTrue); - } - else - { -#if LOG_APP_RESPONSE_TIMES - OSNumber * num; - clock_get_uptime(&now); - num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8); - if (num) - { - context->responseArray->setObject(msgIndex, num); - num->release(); - } - else -#endif - context->responseArray->setObject(msgIndex, kOSBooleanFalse); + if (!OSDynamicCast(_IOServiceInterestNotifier, object)) { + return; + } + + memset(&msgArg, 0, sizeof(msgArg)); + if (context->messageFilter && + !context->messageFilter(context->us, object, context, &msgArg, &replied)) { + return; + } + + if (context->us == getPMRootDomain() && +#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) + getPMRootDomain()->isAOTMode() +#else /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + false +#endif /* (defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + ) { + OSNumber *clientID = NULL; + boolean_t proc_suspended = FALSE; + proc_t proc = NULL; + if ((clientID = copyClientIDForNotification(object, context))) { + uint32_t clientPID = clientID->unsigned32BitValue(); + clientID->release(); + proc = proc_find(clientPID); + if (proc) { + proc_suspended = get_task_pidsuspended((task_t) proc->task); + if (proc_suspended) { + logClientIDForNotification(object, context, "PMTellCapablityAppWithResponse - Suspended"); + } else if (get_task_suspended((task_t) proc->task)) { + proc_suspended = true; + context->skippedInDark++; + } + proc_rele(proc); + if (proc_suspended) { + return; + } + } + } + } + context->notSkippedInDark++; + + // Create client array (for tracking purposes) only if the service + // has app clients. Usually only root domain does. + if (NULL == context->notifyClients) { + context->notifyClients = OSArray::withCapacity( 32 ); + } + + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + OUR_PMLog(kPMLogAppNotify, msgType, msgRef); + if (kIOLogDebugPower & gIOKitDebug) { + // Log client pid/name and client array index. + OSNumber * clientID = NULL; + OSString * clientIDString = NULL;; + context->us->messageClient(kIOMessageCopyClientID, object, &clientID); + if (clientID) { + clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue()); + } - if (context->notifyClients) - context->notifyClients->setObject(msgIndex, object); - } + PM_LOG("%s MESG App(%u) %s, wait %u, %s\n", + context->us->getName(), + msgIndex, getIOMessageString(msgType), + (replied != kOSBooleanTrue), + clientIDString ? clientIDString->getCStringNoCopy() : ""); + if (clientID) { + clientID->release(); + } + if (clientIDString) { + clientIDString->release(); + } + } - context->us->messageClient(msgType, object, (void *) &msgArg, sizeof(msgArg)); + msgArg.notifyRef = msgRef; + msgArg.maxWaitForReply = 0; + + if (replied == kOSBooleanTrue) { + msgArg.notifyRef = 0; + context->responseArray->setObject(msgIndex, kOSBooleanTrue); + if (context->notifyClients) { + context->notifyClients->setObject(msgIndex, kOSBooleanTrue); + } + } else { + OSNumber * num; + clock_get_uptime(&now); + num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8); + if (num) { + context->responseArray->setObject(msgIndex, num); + num->release(); + } else { + context->responseArray->setObject(msgIndex, kOSBooleanFalse); + } + + if (context->notifyClients) { + context->notifyClients->setObject(msgIndex, object); + } + } + + context->us->messageClient(msgType, object, (void *) &msgArg, sizeof(msgArg)); } //********************************************************************************* // [static private] pmTellCapabilityClientWithResponse //********************************************************************************* -void IOService::pmTellCapabilityClientWithResponse( - OSObject * object, void * arg ) -{ - IOPMSystemCapabilityChangeParameters msgArg; - IOPMInterestContext * context = (IOPMInterestContext *) arg; - OSObject * replied = kOSBooleanTrue; - _IOServiceInterestNotifier * notifier; - uint32_t msgIndex, msgRef, msgType; - IOReturn retCode; - - memset(&msgArg, 0, sizeof(msgArg)); - if (context->messageFilter && - !context->messageFilter(context->us, object, context, &msgArg, 0)) - { - if ((kIOLogDebugPower & gIOKitDebug) && - (OSDynamicCast(_IOServiceInterestNotifier, object))) - { - _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; - PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", - context->us->getName(), - getIOMessageString(context->messageType), - OBFUSCATE(object), OBFUSCATE(n->handler)); - } - return; - } - - notifier = OSDynamicCast(_IOServiceInterestNotifier, object); - msgType = context->messageType; - msgIndex = context->responseArray->getCount(); - msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); - - IOServicePM * pwrMgt = context->us->pwrMgt; - if (gIOKitDebug & kIOLogPower) { - OUR_PMLog(kPMLogClientNotify, msgRef, msgType); - if (OSDynamicCast(IOService, object)) { - const char *who = ((IOService *) object)->getName(); - gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0); - } - else if (notifier) { - OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); - } - } - if ((kIOLogDebugPower & gIOKitDebug) && notifier) - { - PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", - context->us->getName(), - getIOMessageString(msgType), - OBFUSCATE(object), OBFUSCATE(notifier->handler)); - } - - msgArg.notifyRef = msgRef; - msgArg.maxWaitForReply = 0; - - if (context->enableTracing && (notifier != 0)) - { - uint32_t detail = ((msgIndex & 0xff) << 24) | - ((msgType & 0xfff) << 12) | - (((uintptr_t) notifier->handler) & 0xfff); - getPMRootDomain()->traceDetail( detail ); - } - - retCode = context->us->messageClient( - msgType, object, (void *) &msgArg, sizeof(msgArg)); - - if ( kIOReturnSuccess == retCode ) - { - if ( 0 == msgArg.maxWaitForReply ) - { - // client doesn't want time to respond - OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); - } - else - { - replied = kOSBooleanFalse; - if ( msgArg.maxWaitForReply > context->maxTimeRequested ) - { - if (msgArg.maxWaitForReply > kCapabilityClientMaxWait) - { - context->maxTimeRequested = kCapabilityClientMaxWait; - PM_ERROR("%s: client %p returned %u for %s\n", - context->us->getName(), - notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), - msgArg.maxWaitForReply, - getIOMessageString(msgType)); - } - else - context->maxTimeRequested = msgArg.maxWaitForReply; - } - } - } - else - { - // not a client of ours - // so we won't be waiting for response - OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); - } - - context->responseArray->setObject(msgIndex, replied); +void +IOService::pmTellCapabilityClientWithResponse( + OSObject * object, void * arg ) +{ + IOPMSystemCapabilityChangeParameters msgArg; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * replied = kOSBooleanTrue; + _IOServiceInterestNotifier * notifier; + uint32_t msgIndex, msgRef, msgType; + IOReturn retCode; + AbsoluteTime start, end; + uint64_t nsec; + + memset(&msgArg, 0, sizeof(msgArg)); + if (context->messageFilter && + !context->messageFilter(context->us, object, context, &msgArg, NULL)) { + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } + return; + } + + if (NULL == context->notifyClients) { + context->notifyClients = OSArray::withCapacity( 32 ); + } + notifier = OSDynamicCast(_IOServiceInterestNotifier, object); + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + IOServicePM * pwrMgt = context->us->pwrMgt; + if (gIOKitDebug & kIOLogPower) { + OUR_PMLog(kPMLogClientNotify, msgRef, msgType); + if (OSDynamicCast(IOService, object)) { + const char *who = ((IOService *) object)->getName(); + gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0); + } else if (notifier) { + OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); + } + } + if ((kIOLogDebugPower & gIOKitDebug) && notifier) { + PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(msgType), + OBFUSCATE(object), OBFUSCATE(notifier->handler)); + } + + msgArg.notifyRef = msgRef; + msgArg.maxWaitForReply = 0; + + if (context->enableTracing && (notifier != NULL)) { + getPMRootDomain()->traceDetail(notifier, true); + } + + clock_get_uptime(&start); + retCode = context->us->messageClient( + msgType, object, (void *) &msgArg, sizeof(msgArg)); + clock_get_uptime(&end); + if (context->enableTracing && (notifier != NULL)) { + getPMRootDomain()->traceDetail(notifier, false); + } + + if (kIOReturnSuccess == retCode) { + if (0 == msgArg.maxWaitForReply) { + // client doesn't want time to respond + OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); + context->responseArray->setObject(msgIndex, replied); + } else { + replied = kOSBooleanFalse; + if (msgArg.maxWaitForReply > context->maxTimeRequested) { + if (msgArg.maxWaitForReply > kCapabilityClientMaxWait) { + context->maxTimeRequested = kCapabilityClientMaxWait; + PM_ERROR("%s: client %p returned %u for %s\n", + context->us->getName(), + notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), + msgArg.maxWaitForReply, + getIOMessageString(msgType)); + } else { + context->maxTimeRequested = msgArg.maxWaitForReply; + } + } + + // Track time taken to ack, by storing the timestamp of + // callback completion + OSNumber * num; + num = OSNumber::withNumber(AbsoluteTime_to_scalar(&end), sizeof(uint64_t) * 8); + if (num) { + context->responseArray->setObject(msgIndex, num); + num->release(); + } else { + context->responseArray->setObject(msgIndex, replied); + } + } + + if (context->enableTracing) { + SUB_ABSOLUTETIME(&end, &start); + absolutetime_to_nanoseconds(end, &nsec); + + if ((nsec > LOG_KEXT_RESPONSE_TIMES) || (msgArg.maxWaitForReply != 0)) { + getPMRootDomain()->traceAckDelay(notifier, msgArg.maxWaitForReply / 1000, NS_TO_MS(nsec)); + } + } + } else { + // not a client of ours + // so we won't be waiting for response + OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); + context->responseArray->setObject(msgIndex, replied); + } + if (context->notifyClients) { + context->notifyClients->setObject(msgIndex, object); + } } //********************************************************************************* @@ -6334,9 +6436,10 @@ void IOService::pmTellCapabilityClientWithResponse( // the aborted destination state number. //********************************************************************************* -void IOService::tellNoChangeDown( unsigned long ) +void +IOService::tellNoChangeDown( unsigned long ) { - return tellClients( kIOMessageDeviceWillNotPowerOff ); + return tellClients( kIOMessageDeviceWillNotPowerOff ); } //********************************************************************************* @@ -6348,9 +6451,10 @@ void IOService::tellNoChangeDown( unsigned long ) // the aborted destination state number. //********************************************************************************* -void IOService::tellChangeUp( unsigned long ) +void +IOService::tellChangeUp( unsigned long ) { - return tellClients( kIOMessageDeviceHasPoweredOn ); + return tellClients( kIOMessageDeviceHasPoweredOn ); } //********************************************************************************* @@ -6359,35 +6463,37 @@ void IOService::tellChangeUp( unsigned long ) // Notify registered applications and kernel clients of something. //********************************************************************************* -void IOService::tellClients( int messageType ) +void +IOService::tellClients( int messageType ) { - IOPMInterestContext context; + IOPMInterestContext context; - RD_LOG("tellClients( %s )\n", getIOMessageString(messageType)); + RD_LOG("tellClients( %s )\n", getIOMessageString(messageType)); - memset(&context, 0, sizeof(context)); - context.messageType = messageType; - context.isPreChange = fIsPreChange; - context.us = this; - context.stateNumber = fHeadNotePowerState; - context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; - context.changeFlags = fHeadNoteChangeFlags; - context.messageFilter = (IS_ROOT_DOMAIN) ? - OSMemberFunctionCast( - IOPMMessageFilter, - this, - &IOPMrootDomain::systemMessageFilter) : 0; + memset(&context, 0, sizeof(context)); + context.messageType = messageType; + context.isPreChange = fIsPreChange; + context.us = this; + context.stateNumber = fHeadNotePowerState; + context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; + context.changeFlags = fHeadNoteChangeFlags; + context.enableTracing = IS_ROOT_DOMAIN; + context.messageFilter = (IS_ROOT_DOMAIN) ? + OSMemberFunctionCast( + IOPMMessageFilter, + this, + &IOPMrootDomain::systemMessageFilter) : NULL; - context.notifyType = kNotifyPriority; - applyToInterested( gIOPriorityPowerStateInterest, - tellKernelClientApplier, (void *) &context ); + context.notifyType = kNotifyPriority; + applyToInterested( gIOPriorityPowerStateInterest, + tellKernelClientApplier, (void *) &context ); - context.notifyType = kNotifyApps; - applyToInterested( gIOAppPowerStateInterest, - tellAppClientApplier, (void *) &context ); + context.notifyType = kNotifyApps; + applyToInterested( gIOAppPowerStateInterest, + tellAppClientApplier, (void *) &context ); - applyToInterested( gIOGeneralInterest, - tellKernelClientApplier, (void *) &context ); + applyToInterested( gIOGeneralInterest, + tellKernelClientApplier, (void *) &context ); } //********************************************************************************* @@ -6396,249 +6502,253 @@ void IOService::tellClients( int messageType ) // Message a kernel client. //********************************************************************************* -static void tellKernelClientApplier( OSObject * object, void * arg ) -{ - IOPowerStateChangeNotification notify; - IOPMInterestContext * context = (IOPMInterestContext *) arg; - - if (context->messageFilter && - !context->messageFilter(context->us, object, context, 0, 0)) - { - if ((kIOLogDebugPower & gIOKitDebug) && - (OSDynamicCast(_IOServiceInterestNotifier, object))) - { - _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; - PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", - context->us->getName(), - IOService::getIOMessageString(context->messageType), - OBFUSCATE(object), OBFUSCATE(n->handler)); - } - return; - } - - notify.powerRef = (void *) 0; - notify.returnValue = 0; - notify.stateNumber = context->stateNumber; - notify.stateFlags = context->stateFlags; - - context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify)); - - if ((kIOLogDebugPower & gIOKitDebug) && - (OSDynamicCast(_IOServiceInterestNotifier, object))) - { - _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; - PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", - context->us->getName(), - IOService::getIOMessageString(context->messageType), - OBFUSCATE(object), OBFUSCATE(n->handler)); - } +static void +tellKernelClientApplier( OSObject * object, void * arg ) +{ + IOPowerStateChangeNotification notify; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, NULL, NULL)) { + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", + context->us->getName(), + IOService::getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } + return; + } + + notify.powerRef = (void *) NULL; + notify.returnValue = 0; + notify.stateNumber = context->stateNumber; + notify.stateFlags = context->stateFlags; + + if (context->enableTracing && object) { + IOService::getPMRootDomain()->traceDetail(object, true); + } + context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify)); + if (context->enableTracing && object) { + IOService::getPMRootDomain()->traceDetail(object, false); + } + + + + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", + context->us->getName(), + IOService::getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } } -static OSNumber * copyClientIDForNotification( - OSObject *object, - IOPMInterestContext *context) +static OSNumber * +copyClientIDForNotification( + OSObject *object, + IOPMInterestContext *context) { - OSNumber *clientID = NULL; - context->us->messageClient(kIOMessageCopyClientID, object, &clientID); - return clientID; + OSNumber *clientID = NULL; + context->us->messageClient(kIOMessageCopyClientID, object, &clientID); + return clientID; } -static void logClientIDForNotification( - OSObject *object, - IOPMInterestContext *context, - const char *logString) +static void +logClientIDForNotification( + OSObject *object, + IOPMInterestContext *context, + const char *logString) { - OSString *logClientID = NULL; - OSNumber *clientID = copyClientIDForNotification(object, context); + OSString *logClientID = NULL; + OSNumber *clientID = copyClientIDForNotification(object, context); - if (logString) - { - if (clientID) - logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue()); + if (logString) { + if (clientID) { + logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue()); + } - PM_LOG("%s %s %s, %s\n", - context->us->getName(), logString, - IOService::getIOMessageString(context->messageType), - logClientID ? logClientID->getCStringNoCopy() : ""); + PM_LOG("%s %s %s, %s\n", + context->us->getName(), logString, + IOService::getIOMessageString(context->messageType), + logClientID ? logClientID->getCStringNoCopy() : ""); - if (logClientID) - logClientID->release(); - } + if (logClientID) { + logClientID->release(); + } + } - if (clientID) - clientID->release(); + if (clientID) { + clientID->release(); + } - return; + return; } -static void tellAppClientApplier( OSObject * object, void * arg ) -{ - IOPMInterestContext * context = (IOPMInterestContext *) arg; - OSNumber * clientID = NULL; - proc_t proc = NULL; - boolean_t proc_suspended = FALSE; - - if (context->us == IOService::getPMRootDomain()) - { - if ((clientID = copyClientIDForNotification(object, context))) - { - uint32_t clientPID = clientID->unsigned32BitValue(); - clientID->release(); - proc = proc_find(clientPID); - - if (proc) - { - proc_suspended = get_task_pidsuspended((task_t) proc->task); - proc_rele(proc); - - if (proc_suspended) - { - logClientIDForNotification(object, context, "tellAppClientApplier - Suspended"); - return; - } - } - } - } +static void +tellAppClientApplier( OSObject * object, void * arg ) +{ + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSNumber * clientID = NULL; + proc_t proc = NULL; + boolean_t proc_suspended = FALSE; + + if (context->us == IOService::getPMRootDomain()) { + if ((clientID = copyClientIDForNotification(object, context))) { + uint32_t clientPID = clientID->unsigned32BitValue(); + clientID->release(); + proc = proc_find(clientPID); + + if (proc) { + proc_suspended = get_task_pidsuspended((task_t) proc->task); + if (proc_suspended) { + logClientIDForNotification(object, context, "tellAppClientApplier - Suspended"); +#if !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) + } else if (IOService::getPMRootDomain()->isAOTMode() && get_task_suspended((task_t) proc->task)) { + proc_suspended = true; + context->skippedInDark++; +#endif /* !(defined(RC_HIDE_N144) || defined(RC_HIDE_N146)) */ + } + proc_rele(proc); + if (proc_suspended) { + return; + } + } + } + } - if (context->messageFilter && - !context->messageFilter(context->us, object, context, 0, 0)) - { - if (kIOLogDebugPower & gIOKitDebug) - { - logClientIDForNotification(object, context, "DROP App"); - } - return; - } + if (context->messageFilter && + !context->messageFilter(context->us, object, context, NULL, NULL)) { + if (kIOLogDebugPower & gIOKitDebug) { + logClientIDForNotification(object, context, "DROP App"); + } + return; + } + context->notSkippedInDark++; - if (kIOLogDebugPower & gIOKitDebug) - { - logClientIDForNotification(object, context, "MESG App"); - } + if (kIOLogDebugPower & gIOKitDebug) { + logClientIDForNotification(object, context, "MESG App"); + } - context->us->messageClient(context->messageType, object, 0); + context->us->messageClient(context->messageType, object, NULL); } //********************************************************************************* // [private] checkForDone //********************************************************************************* -bool IOService::checkForDone( void ) +bool +IOService::checkForDone( void ) { - int i = 0; - OSObject * theFlag; + int i = 0; + OSObject * theFlag; - if (fResponseArray == NULL) { - return true; - } + if (fResponseArray == NULL) { + return true; + } - for (i = 0; ; i++) { - theFlag = fResponseArray->getObject(i); + for (i = 0;; i++) { + theFlag = fResponseArray->getObject(i); - if (NULL == theFlag) { - break; - } + if (NULL == theFlag) { + break; + } - if (kOSBooleanTrue != theFlag) { - return false; - } - } - return true; + if (kOSBooleanTrue != theFlag) { + return false; + } + } + return true; } //********************************************************************************* // [public] responseValid //********************************************************************************* -bool IOService::responseValid( uint32_t refcon, int pid ) -{ - UInt16 serialComponent; - UInt16 ordinalComponent; - OSObject * theFlag; - OSObject *object = 0; - - serialComponent = (refcon >> 16) & 0xFFFF; - ordinalComponent = (refcon & 0xFFFF); - - if ( serialComponent != fSerialNumber ) - { - return false; - } - - if ( fResponseArray == NULL ) - { - return false; - } - - theFlag = fResponseArray->getObject(ordinalComponent); - - if ( theFlag == 0 ) - { - return false; - } - - if (fNotifyClientArray) - object = fNotifyClientArray->getObject(ordinalComponent); - - OSNumber * num; - if ((num = OSDynamicCast(OSNumber, theFlag))) - { -#if LOG_APP_RESPONSE_TIMES - AbsoluteTime now; - AbsoluteTime start; - uint64_t nsec; - char name[128]; - - name[0] = '\0'; - proc_name(pid, name, sizeof(name)); - clock_get_uptime(&now); - AbsoluteTime_to_scalar(&start) = num->unsigned64BitValue(); - SUB_ABSOLUTETIME(&now, &start); - absolutetime_to_nanoseconds(now, &nsec); - - if (kIOLogDebugPower & gIOKitDebug) - { - PM_LOG("Ack(%u) %u ms\n", - (uint32_t) ordinalComponent, - NS_TO_MS(nsec)); - } - - // > 100 ms - if (nsec > LOG_APP_RESPONSE_TIMES) - { - IOLog("PM response took %d ms (%d, %s)\n", NS_TO_MS(nsec), - pid, name); - } - - if (nsec > LOG_APP_RESPONSE_MSG_TRACER) - { - // TODO: populate the messageType argument - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsApplicationResponseSlow, - name, 0, NS_TO_MS(nsec), pid, object); - } - else - { - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsApplicationResponsePrompt, - name, 0, NS_TO_MS(nsec), pid, object); - } - -#endif - theFlag = kOSBooleanFalse; - } - else if (object) { - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsApplicationResponsePrompt, - 0, 0, 0, pid, object); +bool +IOService::responseValid( uint32_t refcon, int pid ) +{ + UInt16 serialComponent; + UInt16 ordinalComponent; + OSObject * theFlag; + OSObject *object = NULL; + + serialComponent = (refcon >> 16) & 0xFFFF; + ordinalComponent = (refcon & 0xFFFF); + + if (serialComponent != fSerialNumber) { + return false; + } + + if (fResponseArray == NULL) { + return false; + } + + theFlag = fResponseArray->getObject(ordinalComponent); + + if (theFlag == NULL) { + return false; + } + + if (fNotifyClientArray) { + object = fNotifyClientArray->getObject(ordinalComponent); + } + + OSNumber * num; + if ((num = OSDynamicCast(OSNumber, theFlag))) { + AbsoluteTime now; + AbsoluteTime start; + uint64_t nsec; + char name[128]; + + clock_get_uptime(&now); + AbsoluteTime_to_scalar(&start) = num->unsigned64BitValue(); + SUB_ABSOLUTETIME(&now, &start); + absolutetime_to_nanoseconds(now, &nsec); + + if (pid != 0) { + name[0] = '\0'; + proc_name(pid, name, sizeof(name)); + + if (nsec > LOG_APP_RESPONSE_TIMES) { + IOLog("PM response took %d ms (%d, %s)\n", NS_TO_MS(nsec), + pid, name); + } + + + if (nsec > LOG_APP_RESPONSE_MSG_TRACER) { + // TODO: populate the messageType argument + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsResponseSlow, + name, 0, NS_TO_MS(nsec), pid, object); + } else { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsResponsePrompt, + name, 0, NS_TO_MS(nsec), pid, object); + } + } else { + getPMRootDomain()->traceAckDelay(object, 0, NS_TO_MS(nsec)); + } - } + if (kIOLogDebugPower & gIOKitDebug) { + PM_LOG("Ack(%u) %u ms\n", + (uint32_t) ordinalComponent, + NS_TO_MS(nsec)); + } + theFlag = kOSBooleanFalse; + } else if (object) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsResponsePrompt, + NULL, 0, 0, pid, object); + } - if ( kOSBooleanFalse == theFlag ) - { - fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue); - } + if (kOSBooleanFalse == theFlag) { + fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue); + } - return true; + return true; } //********************************************************************************* @@ -6649,33 +6759,35 @@ bool IOService::responseValid( uint32_t refcon, int pid ) // so, and all acknowledgements are positive, we continue with the power change. //********************************************************************************* -IOReturn IOService::allowPowerChange( unsigned long refcon ) +IOReturn +IOService::allowPowerChange( unsigned long refcon ) { - IOPMRequest * request; + IOPMRequest * request; - if ( !initialized ) - { - // we're unloading - return kIOReturnSuccess; - } + if (!initialized) { + // we're unloading + return kIOReturnSuccess; + } - request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange ); + if (!request) { + return kIOReturnNoMemory; + } - request->fArg0 = (void *) refcon; - request->fArg1 = (void *)(uintptr_t) proc_selfpid(); - request->fArg2 = (void *) 0; - submitPMRequest( request ); + request->fArg0 = (void *) refcon; + request->fArg1 = (void *)(uintptr_t) proc_selfpid(); + request->fArg2 = (void *) NULL; + submitPMRequest( request ); - return kIOReturnSuccess; + return kIOReturnSuccess; } #ifndef __LP64__ -IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon ) +IOReturn +IOService::serializedAllowPowerChange2( unsigned long refcon ) { - // [deprecated] public - return kIOReturnUnsupported; + // [deprecated] public + return kIOReturnUnsupported; } #endif /* !__LP64__ */ @@ -6687,41 +6799,58 @@ IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon ) // client to respond, we abandon the power change. //********************************************************************************* -IOReturn IOService::cancelPowerChange( unsigned long refcon ) +IOReturn +IOService::cancelPowerChange( unsigned long refcon ) { - IOPMRequest * request; - char name[128]; - pid_t pid = proc_selfpid(); + IOPMRequest * request; + char name[128]; + pid_t pid = proc_selfpid(); - if ( !initialized ) - { - // we're unloading - return kIOReturnSuccess; - } + if (!initialized) { + // we're unloading + return kIOReturnSuccess; + } - name[0] = '\0'; - proc_name(pid, name, sizeof(name)); - PM_ERROR("PM notification cancel (pid %d, %s)\n", pid, name); + name[0] = '\0'; + proc_name(pid, name, sizeof(name)); + PM_ERROR("PM notification cancel (pid %d, %s)\n", pid, name); - request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange ); - if (!request) - { - return kIOReturnNoMemory; - } + request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange ); + if (!request) { + return kIOReturnNoMemory; + } - request->fArg0 = (void *) refcon; - request->fArg1 = (void *)(uintptr_t) proc_selfpid(); - request->fArg2 = (void *) OSString::withCString(name); - submitPMRequest( request ); + request->fArg0 = (void *) refcon; + request->fArg1 = (void *)(uintptr_t) proc_selfpid(); + request->fArg2 = (void *) OSString::withCString(name); + submitPMRequest( request ); - return kIOReturnSuccess; + return kIOReturnSuccess; +} + +//********************************************************************************* +// cancelIdlePowerDown +// +// Internal method to trigger an idle cancel or revert +//********************************************************************************* + +void +IOService::cancelIdlePowerDown( IOService * service ) +{ + IOPMRequest * request; + + request = acquirePMRequest(service, kIOPMRequestTypeIdleCancel); + if (request) { + submitPMRequest(request); + } } #ifndef __LP64__ -IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon ) +IOReturn +IOService::serializedCancelPowerChange2( unsigned long refcon ) { - // [deprecated] public - return kIOReturnUnsupported; + // [deprecated] public + return kIOReturnUnsupported; } //********************************************************************************* @@ -6730,7 +6859,8 @@ IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon ) // called when clamp timer expires...set power state to 0. //********************************************************************************* -void IOService::PM_Clamp_Timer_Expired( void ) +void +IOService::PM_Clamp_Timer_Expired( void ) { } @@ -6740,7 +6870,8 @@ void IOService::PM_Clamp_Timer_Expired( void ) // Set to highest available power state for a minimum of duration milliseconds //********************************************************************************* -void IOService::clampPowerOn( unsigned long duration ) +void +IOService::clampPowerOn( unsigned long duration ) { } #endif /* !__LP64__ */ @@ -6750,79 +6881,82 @@ void IOService::clampPowerOn( unsigned long duration ) // // Configures the IOStateReport for kPMPowerStateChannel //********************************************************************************* -IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action, void *result ) -{ - - IOReturn rc = kIOReturnSuccess; - size_t reportSize; - unsigned long i; - uint64_t ts; - - if (!pwrMgt) - return kIOReturnUnsupported; - - if (!fNumberOfPowerStates) - return kIOReturnSuccess; // For drivers which are in power plane, but haven't called registerPowerDriver() - PM_LOCK(); - - switch (action) - { - case kIOReportEnable: - if (fReportBuf) - { - fReportClientCnt++; - break; - } - reportSize = STATEREPORT_BUFSIZE(fNumberOfPowerStates); - fReportBuf = IOMalloc(reportSize); - if (!fReportBuf) { - rc = kIOReturnNoMemory; - break; - } - memset(fReportBuf, 0, reportSize); - - STATEREPORT_INIT(fNumberOfPowerStates, fReportBuf, reportSize, - getRegistryEntryID(), kPMPowerStatesChID, kIOReportCategoryPower); - - for (i = 0; i < fNumberOfPowerStates; i++) { - unsigned bits = 0; - - if (fPowerStates[i].capabilityFlags & kIOPMPowerOn) - bits |= kPMReportPowerOn; - if (fPowerStates[i].capabilityFlags & kIOPMDeviceUsable) - bits |= kPMReportDeviceUsable; - if (fPowerStates[i].capabilityFlags & kIOPMLowPower) - bits |= kPMReportLowPower; - - STATEREPORT_SETSTATEID(fReportBuf, i, ((bits & 0xff) << 8) | - ((StateOrder(fMaxPowerState) & 0xf) << 4) | (StateOrder(i) & 0xf)); - } - ts = mach_absolute_time(); - STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); - break; - - case kIOReportDisable: - if (fReportClientCnt == 0) { - rc = kIOReturnBadArgument; - break; - } - if (fReportClientCnt == 1) - { - IOFree(fReportBuf, STATEREPORT_BUFSIZE(fNumberOfPowerStates)); - fReportBuf = NULL; - } - fReportClientCnt--; - break; - - case kIOReportGetDimensions: - if (fReportBuf) - STATEREPORT_UPDATERES(fReportBuf, kIOReportGetDimensions, result); - break; - } - - PM_UNLOCK(); - - return rc; +IOReturn +IOService::configurePowerStatesReport( IOReportConfigureAction action, void *result ) +{ + IOReturn rc = kIOReturnSuccess; + size_t reportSize; + unsigned long i; + uint64_t ts; + + if (!pwrMgt) { + return kIOReturnUnsupported; + } + + if (!fNumberOfPowerStates) { + return kIOReturnSuccess; // For drivers which are in power plane, but haven't called registerPowerDriver() + } + PM_LOCK(); + + switch (action) { + case kIOReportEnable: + if (fReportBuf) { + fReportClientCnt++; + break; + } + reportSize = STATEREPORT_BUFSIZE(fNumberOfPowerStates); + fReportBuf = IOMalloc(reportSize); + if (!fReportBuf) { + rc = kIOReturnNoMemory; + break; + } + memset(fReportBuf, 0, reportSize); + + STATEREPORT_INIT(fNumberOfPowerStates, fReportBuf, reportSize, + getRegistryEntryID(), kPMPowerStatesChID, kIOReportCategoryPower); + + for (i = 0; i < fNumberOfPowerStates; i++) { + unsigned bits = 0; + + if (fPowerStates[i].capabilityFlags & kIOPMPowerOn) { + bits |= kPMReportPowerOn; + } + if (fPowerStates[i].capabilityFlags & kIOPMDeviceUsable) { + bits |= kPMReportDeviceUsable; + } + if (fPowerStates[i].capabilityFlags & kIOPMLowPower) { + bits |= kPMReportLowPower; + } + + STATEREPORT_SETSTATEID(fReportBuf, i, ((bits & 0xff) << 8) | + ((StateOrder(fMaxPowerState) & 0xf) << 4) | (StateOrder(i) & 0xf)); + } + ts = mach_absolute_time(); + STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); + break; + + case kIOReportDisable: + if (fReportClientCnt == 0) { + rc = kIOReturnBadArgument; + break; + } + if (fReportClientCnt == 1) { + IOFree(fReportBuf, STATEREPORT_BUFSIZE(fNumberOfPowerStates)); + fReportBuf = NULL; + } + fReportClientCnt--; + break; + + case kIOReportGetDimensions: + if (fReportBuf) { + STATEREPORT_UPDATERES(fReportBuf, kIOReportGetDimensions, result); + } + break; + } + + PM_UNLOCK(); + + return rc; } //********************************************************************************* @@ -6830,49 +6964,53 @@ IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action, // // Updates the IOStateReport for kPMPowerStateChannel //********************************************************************************* -IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, void *result, void *destination ) -{ - uint32_t size2cpy; - void *data2cpy; - uint64_t ts; - IOReturn rc = kIOReturnSuccess; - IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination); - - - if (!pwrMgt) - return kIOReturnUnsupported; - if (!fNumberOfPowerStates) - return kIOReturnSuccess; - - if ( !result || !dest ) return kIOReturnBadArgument; - PM_LOCK(); - - switch (action) { - case kIOReportCopyChannelData: - if ( !fReportBuf ) { - rc = kIOReturnNotOpen; - break; - } - - ts = mach_absolute_time(); - STATEREPORT_UPDATEPREP(fReportBuf, ts, data2cpy, size2cpy); - if (size2cpy > (dest->getCapacity() - dest->getLength()) ) { - rc = kIOReturnOverrun; - break; - } - - STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result); - dest->appendBytes(data2cpy, size2cpy); +IOReturn +IOService::updatePowerStatesReport( IOReportConfigureAction action, void *result, void *destination ) +{ + uint32_t size2cpy; + void *data2cpy; + uint64_t ts; + IOReturn rc = kIOReturnSuccess; + IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination); + + + if (!pwrMgt) { + return kIOReturnUnsupported; + } + if (!fNumberOfPowerStates) { + return kIOReturnSuccess; + } + + if (!result || !dest) { + return kIOReturnBadArgument; + } + PM_LOCK(); + + switch (action) { + case kIOReportCopyChannelData: + if (!fReportBuf) { + rc = kIOReturnNotOpen; + break; + } - default: - break; + ts = mach_absolute_time(); + STATEREPORT_UPDATEPREP(fReportBuf, ts, data2cpy, size2cpy); + if (size2cpy > (dest->getCapacity() - dest->getLength())) { + rc = kIOReturnOverrun; + break; + } - } + STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result); + dest->appendBytes(data2cpy, size2cpy); + break; - PM_UNLOCK(); + default: + break; + } - return rc; + PM_UNLOCK(); + return rc; } //********************************************************************************* @@ -6880,30 +7018,31 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi // // Configures the IOSimpleReport for given channel id //********************************************************************************* -IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, void *result ) +IOReturn +IOService::configureSimplePowerReport(IOReportConfigureAction action, void *result ) { + IOReturn rc = kIOReturnSuccess; - IOReturn rc = kIOReturnSuccess; + if (!pwrMgt) { + return kIOReturnUnsupported; + } - if ( !pwrMgt ) - return kIOReturnUnsupported; + if (!fNumberOfPowerStates) { + return rc; + } - if ( !fNumberOfPowerStates ) - return rc; + switch (action) { + case kIOReportEnable: + case kIOReportDisable: + break; - switch (action) - { - case kIOReportEnable: - case kIOReportDisable: - break; + case kIOReportGetDimensions: + SIMPLEREPORT_UPDATERES(kIOReportGetDimensions, result); + break; + } - case kIOReportGetDimensions: - SIMPLEREPORT_UPDATERES(kIOReportGetDimensions, result); - break; - } - - return rc; + return rc; } //********************************************************************************* @@ -6911,58 +7050,65 @@ IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, v // // Updates the IOSimpleReport for the given chanel id //********************************************************************************* -IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, void *result, void *destination ) +IOReturn +IOService::updateSimplePowerReport( IOReportConfigureAction action, void *result, void *destination ) { - uint32_t size2cpy; - void *data2cpy; - uint64_t buf[SIMPLEREPORT_BUFSIZE/sizeof(uint64_t)+1]; // Force a 8-byte alignment - IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination); - IOReturn rc = kIOReturnSuccess; - unsigned bits = 0; - - - if ( !pwrMgt ) - return kIOReturnUnsupported; - if ( !result || !dest ) return kIOReturnBadArgument; + uint32_t size2cpy; + void *data2cpy; + uint64_t buf[SIMPLEREPORT_BUFSIZE / sizeof(uint64_t) + 1]; // Force a 8-byte alignment + IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination); + IOReturn rc = kIOReturnSuccess; + unsigned bits = 0; - if ( !fNumberOfPowerStates ) - return rc; - PM_LOCK(); - switch (action) { - case kIOReportCopyChannelData: + if (!pwrMgt) { + return kIOReturnUnsupported; + } + if (!result || !dest) { + return kIOReturnBadArgument; + } - SIMPLEREPORT_INIT(buf, sizeof(buf), getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower); + if (!fNumberOfPowerStates) { + return rc; + } + PM_LOCK(); - if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMPowerOn) - bits |= kPMReportPowerOn; - if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMDeviceUsable) - bits |= kPMReportDeviceUsable; - if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMLowPower) - bits |= kPMReportLowPower; + switch (action) { + case kIOReportCopyChannelData: + SIMPLEREPORT_INIT(buf, sizeof(buf), getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower); - SIMPLEREPORT_SETVALUE(buf, ((bits & 0xff) << 8) | ((StateOrder(fMaxPowerState) & 0xf) << 4) | - (StateOrder(fCurrentPowerState) & 0xf)); + if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMPowerOn) { + bits |= kPMReportPowerOn; + } + if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMDeviceUsable) { + bits |= kPMReportDeviceUsable; + } + if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMLowPower) { + bits |= kPMReportLowPower; + } - SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy); - if (size2cpy > (dest->getCapacity() - dest->getLength())) { - rc = kIOReturnOverrun; - break; - } - SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result); - dest->appendBytes(data2cpy, size2cpy); + SIMPLEREPORT_SETVALUE(buf, ((bits & 0xff) << 8) | ((StateOrder(fMaxPowerState) & 0xf) << 4) | + (StateOrder(fCurrentPowerState) & 0xf)); - default: - break; + SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy); + if (size2cpy > (dest->getCapacity() - dest->getLength())) { + rc = kIOReturnOverrun; + break; + } - } + SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result); + dest->appendBytes(data2cpy, size2cpy); + break; - PM_UNLOCK(); + default: + break; + } - return kIOReturnSuccess; + PM_UNLOCK(); + return kIOReturnSuccess; } @@ -6976,10 +7122,11 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi // Does nothing here. This should be implemented in a subclass driver. //********************************************************************************* -IOReturn IOService::setPowerState( - unsigned long powerStateOrdinal, IOService * whatDevice ) +IOReturn +IOService::setPowerState( + unsigned long powerStateOrdinal, IOService * whatDevice ) { - return IOPMNoErr; + return IOPMNoErr; } //********************************************************************************* @@ -6990,29 +7137,30 @@ IOReturn IOService::setPowerState( // possible, override this in the subclassed driver. //********************************************************************************* -IOPMPowerStateIndex IOService::getPowerStateForDomainFlags( IOPMPowerFlags flags ) +IOPMPowerStateIndex +IOService::getPowerStateForDomainFlags( IOPMPowerFlags flags ) { - IOPMPowerStateIndex stateIndex; + IOPMPowerStateIndex stateIndex; - if (!fNumberOfPowerStates) - return kPowerStateZero; + if (!fNumberOfPowerStates) { + return kPowerStateZero; + } - for ( int order = fNumberOfPowerStates - 1; order >= 0; order-- ) - { - stateIndex = fPowerStates[order].stateOrderToIndex; + for (int order = fNumberOfPowerStates - 1; order >= 0; order--) { + stateIndex = fPowerStates[order].stateOrderToIndex; - if ( (flags & fPowerStates[stateIndex].inputPowerFlags) == - fPowerStates[stateIndex].inputPowerFlags ) - { - return stateIndex; - } - } - return kPowerStateZero; + if ((flags & fPowerStates[stateIndex].inputPowerFlags) == + fPowerStates[stateIndex].inputPowerFlags) { + return stateIndex; + } + } + return kPowerStateZero; } -unsigned long IOService::maxCapabilityForDomainState( IOPMPowerFlags domainState ) +unsigned long +IOService::maxCapabilityForDomainState( IOPMPowerFlags domainState ) { - return getPowerStateForDomainFlags(domainState); + return getPowerStateForDomainFlags(domainState); } //********************************************************************************* @@ -7021,15 +7169,15 @@ unsigned long IOService::maxCapabilityForDomainState( IOPMPowerFlags domainState // Called to query the power state for the initial power transition. //********************************************************************************* -unsigned long IOService::initialPowerStateForDomainState( IOPMPowerFlags domainState ) +unsigned long +IOService::initialPowerStateForDomainState( IOPMPowerFlags domainState ) { - if (fResetPowerStateOnWake && (domainState & kIOPMRootDomainState)) - { - // Return lowest power state for any root power domain changes - return kPowerStateZero; - } + if (fResetPowerStateOnWake && (domainState & kIOPMRootDomainState)) { + // Return lowest power state for any root power domain changes + return kPowerStateZero; + } - return getPowerStateForDomainFlags(domainState); + return getPowerStateForDomainFlags(domainState); } //********************************************************************************* @@ -7038,9 +7186,10 @@ unsigned long IOService::initialPowerStateForDomainState( IOPMPowerFlags domainS // This method is not called from PM. //********************************************************************************* -unsigned long IOService::powerStateForDomainState( IOPMPowerFlags domainState ) +unsigned long +IOService::powerStateForDomainState( IOPMPowerFlags domainState ) { - return getPowerStateForDomainFlags(domainState); + return getPowerStateForDomainFlags(domainState); } #ifndef __LP64__ @@ -7050,9 +7199,10 @@ unsigned long IOService::powerStateForDomainState( IOPMPowerFlags domainState ) // Does nothing here. This should be implemented in a subclass driver. //********************************************************************************* -bool IOService::didYouWakeSystem( void ) +bool +IOService::didYouWakeSystem( void ) { - return false; + return false; } #endif /* !__LP64__ */ @@ -7062,9 +7212,10 @@ bool IOService::didYouWakeSystem( void ) // Does nothing here. This should be implemented in a subclass driver. //********************************************************************************* -IOReturn IOService::powerStateWillChangeTo( IOPMPowerFlags, unsigned long, IOService * ) +IOReturn +IOService::powerStateWillChangeTo( IOPMPowerFlags, unsigned long, IOService * ) { - return kIOPMAckImplied; + return kIOPMAckImplied; } //********************************************************************************* @@ -7073,9 +7224,10 @@ IOReturn IOService::powerStateWillChangeTo( IOPMPowerFlags, unsigned long, IOSer // Does nothing here. This should be implemented in a subclass driver. //********************************************************************************* -IOReturn IOService::powerStateDidChangeTo( IOPMPowerFlags, unsigned long, IOService * ) +IOReturn +IOService::powerStateDidChangeTo( IOPMPowerFlags, unsigned long, IOService * ) { - return kIOPMAckImplied; + return kIOPMAckImplied; } //********************************************************************************* @@ -7085,7 +7237,8 @@ IOReturn IOService::powerStateDidChangeTo( IOPMPowerFlags, unsigned long, IOServ // Does nothing here. This should be implemented in a subclass policy-maker. //********************************************************************************* -void IOService::powerChangeDone( unsigned long ) +void +IOService::powerChangeDone( unsigned long ) { } @@ -7096,9 +7249,10 @@ void IOService::powerChangeDone( unsigned long ) // Does nothing here. This should be implemented in a subclass driver. //********************************************************************************* -IOReturn IOService::newTemperature( long currentTemp, IOService * whichZone ) +IOReturn +IOService::newTemperature( long currentTemp, IOService * whichZone ) { - return IOPMNoErr; + return IOPMNoErr; } #endif /* !__LP64__ */ @@ -7108,11 +7262,13 @@ IOReturn IOService::newTemperature( long currentTemp, IOService * whichZone ) // System shutdown and restart notification. //********************************************************************************* -void IOService::systemWillShutdown( IOOptionBits specifier ) +void +IOService::systemWillShutdown( IOOptionBits specifier ) { - IOPMrootDomain * rootDomain = IOService::getPMRootDomain(); - if (rootDomain) - rootDomain->acknowledgeSystemWillShutdown( this ); + IOPMrootDomain * rootDomain = IOService::getPMRootDomain(); + if (rootDomain) { + rootDomain->acknowledgeSystemWillShutdown( this ); + } } // MARK: - @@ -7124,82 +7280,82 @@ void IOService::systemWillShutdown( IOOptionBits specifier ) IOPMRequest * IOService::acquirePMRequest( IOService * target, IOOptionBits requestType, - IOPMRequest * active ) + IOPMRequest * active ) { - IOPMRequest * request; + IOPMRequest * request; - assert(target); + assert(target); - request = IOPMRequest::create(); - if (request) - { - request->init( target, requestType ); - if (active) - { - IOPMRequest * root = active->getRootRequest(); - if (root) request->attachRootRequest(root); - } - } - else - { - PM_ERROR("%s: No memory for PM request type 0x%x\n", - target->getName(), (uint32_t) requestType); - } - return request; + request = IOPMRequest::create(); + if (request) { + request->init( target, requestType ); + if (active) { + IOPMRequest * root = active->getRootRequest(); + if (root) { + request->attachRootRequest(root); + } + } + } else { + PM_ERROR("%s: No memory for PM request type 0x%x\n", + target->getName(), (uint32_t) requestType); + } + return request; } //********************************************************************************* // [private static] releasePMRequest //********************************************************************************* -void IOService::releasePMRequest( IOPMRequest * request ) +void +IOService::releasePMRequest( IOPMRequest * request ) { - if (request) - { - request->reset(); - request->release(); - } + if (request) { + request->reset(); + request->release(); + } } //********************************************************************************* // [private static] submitPMRequest //********************************************************************************* -void IOService::submitPMRequest( IOPMRequest * request ) +void +IOService::submitPMRequest( IOPMRequest * request ) { - assert( request ); - assert( gIOPMReplyQueue ); - assert( gIOPMRequestQueue ); + assert( request ); + assert( gIOPMReplyQueue ); + assert( gIOPMRequestQueue ); - PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n", - (long)request->getType(), OBFUSCATE(request), - OBFUSCATE(request->getTarget()), request->getTarget()->getName(), - OBFUSCATE(request->fArg0), - OBFUSCATE(request->fArg1), OBFUSCATE(request->fArg2)); + PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n", + (long)request->getType(), OBFUSCATE(request), + OBFUSCATE(request->getTarget()), request->getTarget()->getName(), + OBFUSCATE(request->fArg0), + OBFUSCATE(request->fArg1), OBFUSCATE(request->fArg2)); - if (request->isReplyType()) - gIOPMReplyQueue->queuePMRequest( request ); - else - gIOPMRequestQueue->queuePMRequest( request ); + if (request->isReplyType()) { + gIOPMReplyQueue->queuePMRequest( request ); + } else { + gIOPMRequestQueue->queuePMRequest( request ); + } } -void IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count ) +void +IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count ) { - assert( requests ); - assert( count > 0 ); - assert( gIOPMRequestQueue ); + assert( requests ); + assert( count > 0 ); + assert( gIOPMRequestQueue ); - for (IOItemCount i = 0; i < count; i++) - { - IOPMRequest * req = requests[i]; - PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n", - (long)req->getType(), OBFUSCATE(req), - OBFUSCATE(req->getTarget()), req->getTarget()->getName(), - OBFUSCATE(req->fArg0), - OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2)); - } + for (IOItemCount i = 0; i < count; i++) { + IOPMRequest * req = requests[i]; + PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n", + (long)req->getType(), OBFUSCATE(req), + OBFUSCATE(req->getTarget()), req->getTarget()->getName(), + OBFUSCATE(req->fArg0), + OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2)); + } - gIOPMRequestQueue->queuePMRequestChain( requests, count ); + gIOPMRequestQueue->queuePMRequestChain( requests, count ); } //********************************************************************************* @@ -7208,34 +7364,34 @@ void IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count ) // IOPMRequestQueue::checkForWork() passing a new request to the request target. //********************************************************************************* -bool IOService::actionPMRequestQueue( - IOPMRequest * request, - IOPMRequestQueue * queue ) +bool +IOService::actionPMRequestQueue( + IOPMRequest * request, + IOPMRequestQueue * queue ) { - bool more; + bool more; - if (initialized) - { - // Work queue will immediately execute the request if the per-service - // request queue is empty. Note pwrMgt is the target's IOServicePM. + if (initialized) { + // Work queue will immediately execute the request if the per-service + // request queue is empty. Note pwrMgt is the target's IOServicePM. - more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt); - } - else - { - // Calling PM without PMinit() is not allowed, fail the request. - // Need to signal more when completing attached requests. + more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt); + } else { + // Calling PM without PMinit() is not allowed, fail the request. + // Need to signal more when completing attached requests. - PM_LOG("%s: PM not initialized\n", getName()); - PM_LOG1("[- %02x] %p [%p %s] !initialized\n", - request->getType(), OBFUSCATE(request), - OBFUSCATE(this), getName()); + PM_LOG("%s: PM not initialized\n", getName()); + PM_LOG1("[- %02x] %p [%p %s] !initialized\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName()); - more = gIOPMCompletionQueue->queuePMRequest(request); - if (more) gIOPMWorkQueue->incrementProducerCount(); - } + more = gIOPMCompletionQueue->queuePMRequest(request); + if (more) { + gIOPMWorkQueue->incrementProducerCount(); + } + } - return more; + return more; } //********************************************************************************* @@ -7245,20 +7401,23 @@ bool IOService::actionPMRequestQueue( // request target. //********************************************************************************* -bool IOService::actionPMCompletionQueue( - IOPMRequest * request, - IOPMCompletionQueue * queue ) +bool +IOService::actionPMCompletionQueue( + IOPMRequest * request, + IOPMCompletionQueue * queue ) { - bool more = (request->getNextRequest() != 0); - IOPMRequest * root = request->getRootRequest(); + bool more = (request->getNextRequest() != NULL); + IOPMRequest * root = request->getRootRequest(); - if (root && (root != request)) - more = true; - if (more) - gIOPMWorkQueue->incrementProducerCount(); + if (root && (root != request)) { + more = true; + } + if (more) { + gIOPMWorkQueue->incrementProducerCount(); + } - releasePMRequest( request ); - return more; + releasePMRequest( request ); + return more; } //********************************************************************************* @@ -7267,36 +7426,33 @@ bool IOService::actionPMCompletionQueue( // IOPMWorkQueue::checkForWork() passing a retired request to the request target. //********************************************************************************* -bool IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * queue ) +bool +IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * queue ) { - assert(request && queue); + assert(request && queue); - PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n", - request->getType(), OBFUSCATE(request), - OBFUSCATE(this), getName(), - fMachineState, gIOPMBusyRequestCount); + PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), + fMachineState, gIOPMBusyRequestCount); - // Catch requests created by idleTimerExpired() - if (request->getType() == kIOPMRequestTypeActivityTickle) - { - uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1; + // Catch requests created by idleTimerExpired() + if (request->getType() == kIOPMRequestTypeActivityTickle) { + uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1; + + if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod) { + restartIdleTimer(); + } else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise)) { + // Invalidate any idle power drop that got queued while + // processing this request. + fIdleTimerGeneration++; + } + } - if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod) - { - restartIdleTimer(); - } - else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise)) - { - // Invalidate any idle power drop that got queued while - // processing this request. - fIdleTimerGeneration++; - } - } - - // When the completed request is linked, tell work queue there is - // more work pending. + // When the completed request is linked, tell work queue there is + // more work pending. - return (gIOPMCompletionQueue->queuePMRequest( request )); + return gIOPMCompletionQueue->queuePMRequest( request ); } //********************************************************************************* @@ -7305,66 +7461,62 @@ bool IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * // Check if machine state transition is blocked. //********************************************************************************* -bool IOService::isPMBlocked( IOPMRequest * request, int count ) +bool +IOService::isPMBlocked( IOPMRequest * request, int count ) { - int reason = 0; + int reason = 0; - do { - if (kIOPM_Finished == fMachineState) - break; + do { + if (kIOPM_Finished == fMachineState) { + break; + } - if (kIOPM_DriverThreadCallDone == fMachineState) - { - // 5 = kDriverCallInformPreChange - // 6 = kDriverCallInformPostChange - // 7 = kDriverCallSetPowerState - // 8 = kRootDomainInformPreChange - if (fDriverCallBusy) - reason = 5 + fDriverCallReason; - break; - } + if (kIOPM_DriverThreadCallDone == fMachineState) { + // 5 = kDriverCallInformPreChange + // 6 = kDriverCallInformPostChange + // 7 = kDriverCallSetPowerState + // 8 = kRootDomainInformPreChange + if (fDriverCallBusy) { + reason = 5 + fDriverCallReason; + } + break; + } - // Waiting on driver's setPowerState() timeout. - if (fDriverTimer) - { - reason = 1; break; - } + // Waiting on driver's setPowerState() timeout. + if (fDriverTimer) { + reason = 1; break; + } - // Child or interested driver acks pending. - if (fHeadNotePendingAcks) - { - reason = 2; break; - } + // Child or interested driver acks pending. + if (fHeadNotePendingAcks) { + reason = 2; break; + } - // Waiting on apps or priority power interest clients. - if (fResponseArray) - { - reason = 3; break; - } + // Waiting on apps or priority power interest clients. + if (fResponseArray) { + reason = 3; break; + } - // Waiting on settle timer expiration. - if (fSettleTimeUS) - { - reason = 4; break; - } - } while (false); + // Waiting on settle timer expiration. + if (fSettleTimeUS) { + reason = 4; break; + } + } while (false); - fWaitReason = reason; + fWaitReason = reason; - if (reason) - { - if (count) - { - PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n", - request->getType(), OBFUSCATE(request), - OBFUSCATE(this), getName(), - fMachineState, reason); - } + if (reason) { + if (count) { + PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), + fMachineState, reason); + } - return true; - } + return true; + } - return false; + return false; } //********************************************************************************* @@ -7374,389 +7526,372 @@ bool IOService::isPMBlocked( IOPMRequest * request, int count ) // request target for execution. //********************************************************************************* -bool IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue ) -{ - bool done = false; - int loop = 0; - - assert(request && queue); - - while (isPMBlocked(request, loop++) == false) - { - PM_LOG1("[W %02x] %p [%p %s] state %d\n", - request->getType(), OBFUSCATE(request), - OBFUSCATE(this), getName(), fMachineState); - - gIOPMRequest = request; - gIOPMWorkInvokeCount++; - - // Every PM machine states must be handled in one of the cases below. - - switch ( fMachineState ) - { - case kIOPM_Finished: - start_watchdog_timer(); - - executePMRequest( request ); - break; - - case kIOPM_OurChangeTellClientsPowerDown: - // Root domain might self cancel due to assertions. - if (IS_ROOT_DOMAIN) - { - bool cancel = (bool) fDoNotPowerDown; - getPMRootDomain()->askChangeDownDone( - &fHeadNoteChangeFlags, &cancel); - fDoNotPowerDown = cancel; - } - - // askChangeDown() done, was it vetoed? - if (!fDoNotPowerDown) - { - // no, we can continue - OurChangeTellClientsPowerDown(); - } - else - { - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); - // yes, rescind the warning - tellNoChangeDown(fHeadNotePowerState); - // mark the change note un-actioned - fHeadNoteChangeFlags |= kIOPMNotDone; - // and we're done - OurChangeFinish(); - } - break; - - case kIOPM_OurChangeTellUserPMPolicyPowerDown: - // PMRD: tellChangeDown/kNotifyApps done, was it cancelled? - if (fDoNotPowerDown) - { - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); - // yes, rescind the warning - tellNoChangeDown(fHeadNotePowerState); - // mark the change note un-actioned - fHeadNoteChangeFlags |= kIOPMNotDone; - // and we're done - OurChangeFinish(); - } - else - OurChangeTellUserPMPolicyPowerDown(); - break; - - case kIOPM_OurChangeTellPriorityClientsPowerDown: - // PMRD: LastCallBeforeSleep notify done - // Non-PMRD: tellChangeDown/kNotifyApps done - if (fDoNotPowerDown) - { - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState); - // no, tell clients we're back in the old state - tellChangeUp(fCurrentPowerState); - // mark the change note un-actioned - fHeadNoteChangeFlags |= kIOPMNotDone; - // and we're done - OurChangeFinish(); - } - else - { - // yes, we can continue - OurChangeTellPriorityClientsPowerDown(); - } - break; - - case kIOPM_OurChangeNotifyInterestedDriversWillChange: - OurChangeNotifyInterestedDriversWillChange(); - break; - - case kIOPM_OurChangeSetPowerState: - OurChangeSetPowerState(); - break; - - case kIOPM_OurChangeWaitForPowerSettle: - OurChangeWaitForPowerSettle(); - break; - - case kIOPM_OurChangeNotifyInterestedDriversDidChange: - OurChangeNotifyInterestedDriversDidChange(); - break; - - case kIOPM_OurChangeTellCapabilityDidChange: - OurChangeTellCapabilityDidChange(); - break; - - case kIOPM_OurChangeFinish: - OurChangeFinish(); - break; - - case kIOPM_ParentChangeTellPriorityClientsPowerDown: - ParentChangeTellPriorityClientsPowerDown(); - break; - - case kIOPM_ParentChangeNotifyInterestedDriversWillChange: - ParentChangeNotifyInterestedDriversWillChange(); - break; - - case kIOPM_ParentChangeSetPowerState: - ParentChangeSetPowerState(); - break; - - case kIOPM_ParentChangeWaitForPowerSettle: - ParentChangeWaitForPowerSettle(); - break; - - case kIOPM_ParentChangeNotifyInterestedDriversDidChange: - ParentChangeNotifyInterestedDriversDidChange(); - break; - - case kIOPM_ParentChangeTellCapabilityDidChange: - ParentChangeTellCapabilityDidChange(); - break; - - case kIOPM_ParentChangeAcknowledgePowerChange: - ParentChangeAcknowledgePowerChange(); - break; - - case kIOPM_DriverThreadCallDone: - switch (fDriverCallReason) - { - case kDriverCallInformPreChange: - case kDriverCallInformPostChange: - notifyInterestedDriversDone(); - break; - case kDriverCallSetPowerState: - notifyControllingDriverDone(); - break; - case kRootDomainInformPreChange: - notifyRootDomainDone(); - break; - default: - panic("%s: bad call reason %x", - getName(), fDriverCallReason); - } - break; - - case kIOPM_NotifyChildrenOrdered: - notifyChildrenOrdered(); - break; - - case kIOPM_NotifyChildrenDelayed: - notifyChildrenDelayed(); - break; - - case kIOPM_NotifyChildrenStart: - // pop notifyAll() state saved by notifyInterestedDriversDone() - MS_POP(); - notifyRootDomain(); - break; - - case kIOPM_SyncTellClientsPowerDown: - // Root domain might self cancel due to assertions. - if (IS_ROOT_DOMAIN) - { - bool cancel = (bool) fDoNotPowerDown; - getPMRootDomain()->askChangeDownDone( - &fHeadNoteChangeFlags, &cancel); - fDoNotPowerDown = cancel; - } - if (!fDoNotPowerDown) - { - fMachineState = kIOPM_SyncTellPriorityClientsPowerDown; - fOutOfBandParameter = kNotifyApps; - tellChangeDown(fHeadNotePowerState); - } - else - { - // Cancelled by IOPMrootDomain::askChangeDownDone() or - // askChangeDown/kNotifyApps - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); - tellNoChangeDown(fHeadNotePowerState); - fHeadNoteChangeFlags |= kIOPMNotDone; - OurChangeFinish(); - } - break; - - case kIOPM_SyncTellPriorityClientsPowerDown: - // PMRD: tellChangeDown/kNotifyApps done, was it cancelled? - if (!fDoNotPowerDown) - { - fMachineState = kIOPM_SyncNotifyWillChange; - fOutOfBandParameter = kNotifyPriority; - tellChangeDown(fHeadNotePowerState); - } - else - { - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState); - tellChangeUp(fCurrentPowerState); - fHeadNoteChangeFlags |= kIOPMNotDone; - OurChangeFinish(); - } - break; - - case kIOPM_SyncNotifyWillChange: - if (kIOPMSyncNoChildNotify & fHeadNoteChangeFlags) - { - fMachineState = kIOPM_SyncFinish; - continue; - } - fMachineState = kIOPM_SyncNotifyDidChange; - fDriverCallReason = kDriverCallInformPreChange; - notifyChildren(); - break; - - case kIOPM_SyncNotifyDidChange: - fIsPreChange = false; - - if (fHeadNoteChangeFlags & kIOPMParentInitiated) - { - fMachineState = kIOPM_SyncFinish; - } - else - { - assert(IS_ROOT_DOMAIN); - fMachineState = kIOPM_SyncTellCapabilityDidChange; - } - - fDriverCallReason = kDriverCallInformPostChange; - notifyChildren(); - break; - - case kIOPM_SyncTellCapabilityDidChange: - tellSystemCapabilityChange( kIOPM_SyncFinish ); - break; - - case kIOPM_SyncFinish: - if (fHeadNoteChangeFlags & kIOPMParentInitiated) - ParentChangeAcknowledgePowerChange(); - else - OurChangeFinish(); - break; - - case kIOPM_TellCapabilityChangeDone: - if (fIsPreChange) - { - if (fOutOfBandParameter == kNotifyCapabilityChangePriority) - { - MS_POP(); // tellSystemCapabilityChange() - continue; - } - fOutOfBandParameter = kNotifyCapabilityChangePriority; - } - else - { - if (fOutOfBandParameter == kNotifyCapabilityChangeApps) - { - MS_POP(); // tellSystemCapabilityChange() - continue; - } - fOutOfBandParameter = kNotifyCapabilityChangeApps; - } - tellClientsWithResponse( fOutOfBandMessage ); - break; - - default: - panic("PMWorkQueueInvoke: unknown machine state %x", - fMachineState); - } - - gIOPMRequest = 0; - - if (fMachineState == kIOPM_Finished) - { - stop_watchdog_timer(); - done = true; - break; - } - } - - return done; +bool +IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue ) +{ + bool done = false; + int loop = 0; + + assert(request && queue); + + while (isPMBlocked(request, loop++) == false) { + PM_LOG1("[W %02x] %p [%p %s] state %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), fMachineState); + + gIOPMRequest = request; + gIOPMWorkInvokeCount++; + + // Every PM machine states must be handled in one of the cases below. + + switch (fMachineState) { + case kIOPM_Finished: + start_watchdog_timer(); + + executePMRequest( request ); + break; + + case kIOPM_OurChangeTellClientsPowerDown: + // Root domain might self cancel due to assertions. + if (IS_ROOT_DOMAIN) { + bool cancel = (bool) fDoNotPowerDown; + getPMRootDomain()->askChangeDownDone( + &fHeadNoteChangeFlags, &cancel); + fDoNotPowerDown = cancel; + } + + // askChangeDown() done, was it vetoed? + if (!fDoNotPowerDown) { + // no, we can continue + OurChangeTellClientsPowerDown(); + } else { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); + if (IS_ROOT_DOMAIN) { + // RootDomain already sent "WillSleep" to its clients + tellChangeUp(fCurrentPowerState); + } else { + tellNoChangeDown(fHeadNotePowerState); + } + // mark the change note un-actioned + fHeadNoteChangeFlags |= kIOPMNotDone; + // and we're done + OurChangeFinish(); + } + break; + + case kIOPM_OurChangeTellUserPMPolicyPowerDown: + // PMRD: tellChangeDown/kNotifyApps done, was it cancelled? + if (fDoNotPowerDown) { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); + if (IS_ROOT_DOMAIN) { + // RootDomain already sent "WillSleep" to its clients + tellChangeUp(fCurrentPowerState); + } else { + tellNoChangeDown(fHeadNotePowerState); + } + // mark the change note un-actioned + fHeadNoteChangeFlags |= kIOPMNotDone; + // and we're done + OurChangeFinish(); + } else { + OurChangeTellUserPMPolicyPowerDown(); + } + break; + + case kIOPM_OurChangeTellPriorityClientsPowerDown: + // PMRD: LastCallBeforeSleep notify done + // Non-PMRD: tellChangeDown/kNotifyApps done + if (fDoNotPowerDown) { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState); + // no, tell clients we're back in the old state + tellChangeUp(fCurrentPowerState); + // mark the change note un-actioned + fHeadNoteChangeFlags |= kIOPMNotDone; + // and we're done + OurChangeFinish(); + } else { + // yes, we can continue + OurChangeTellPriorityClientsPowerDown(); + } + break; + + case kIOPM_OurChangeNotifyInterestedDriversWillChange: + OurChangeNotifyInterestedDriversWillChange(); + break; + + case kIOPM_OurChangeSetPowerState: + OurChangeSetPowerState(); + break; + + case kIOPM_OurChangeWaitForPowerSettle: + OurChangeWaitForPowerSettle(); + break; + + case kIOPM_OurChangeNotifyInterestedDriversDidChange: + OurChangeNotifyInterestedDriversDidChange(); + break; + + case kIOPM_OurChangeTellCapabilityDidChange: + OurChangeTellCapabilityDidChange(); + break; + + case kIOPM_OurChangeFinish: + OurChangeFinish(); + break; + + case kIOPM_ParentChangeTellPriorityClientsPowerDown: + ParentChangeTellPriorityClientsPowerDown(); + break; + + case kIOPM_ParentChangeNotifyInterestedDriversWillChange: + ParentChangeNotifyInterestedDriversWillChange(); + break; + + case kIOPM_ParentChangeSetPowerState: + ParentChangeSetPowerState(); + break; + + case kIOPM_ParentChangeWaitForPowerSettle: + ParentChangeWaitForPowerSettle(); + break; + + case kIOPM_ParentChangeNotifyInterestedDriversDidChange: + ParentChangeNotifyInterestedDriversDidChange(); + break; + + case kIOPM_ParentChangeTellCapabilityDidChange: + ParentChangeTellCapabilityDidChange(); + break; + + case kIOPM_ParentChangeAcknowledgePowerChange: + ParentChangeAcknowledgePowerChange(); + break; + + case kIOPM_DriverThreadCallDone: + switch (fDriverCallReason) { + case kDriverCallInformPreChange: + case kDriverCallInformPostChange: + notifyInterestedDriversDone(); + break; + case kDriverCallSetPowerState: + notifyControllingDriverDone(); + break; + case kRootDomainInformPreChange: + notifyRootDomainDone(); + break; + default: + panic("%s: bad call reason %x", + getName(), fDriverCallReason); + } + break; + + case kIOPM_NotifyChildrenOrdered: + notifyChildrenOrdered(); + break; + + case kIOPM_NotifyChildrenDelayed: + notifyChildrenDelayed(); + break; + + case kIOPM_NotifyChildrenStart: + // pop notifyAll() state saved by notifyInterestedDriversDone() + MS_POP(); + notifyRootDomain(); + break; + + case kIOPM_SyncTellClientsPowerDown: + // Root domain might self cancel due to assertions. + if (IS_ROOT_DOMAIN) { + bool cancel = (bool) fDoNotPowerDown; + getPMRootDomain()->askChangeDownDone( + &fHeadNoteChangeFlags, &cancel); + fDoNotPowerDown = cancel; + } + if (!fDoNotPowerDown) { + fMachineState = kIOPM_SyncTellPriorityClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + tellChangeDown(fHeadNotePowerState); + } else { + // Cancelled by IOPMrootDomain::askChangeDownDone() or + // askChangeDown/kNotifyApps + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); + tellNoChangeDown(fHeadNotePowerState); + fHeadNoteChangeFlags |= kIOPMNotDone; + OurChangeFinish(); + } + break; + + case kIOPM_SyncTellPriorityClientsPowerDown: + // PMRD: tellChangeDown/kNotifyApps done, was it cancelled? + if (!fDoNotPowerDown) { + fMachineState = kIOPM_SyncNotifyWillChange; + fOutOfBandParameter = kNotifyPriority; + tellChangeDown(fHeadNotePowerState); + } else { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState); + tellChangeUp(fCurrentPowerState); + fHeadNoteChangeFlags |= kIOPMNotDone; + OurChangeFinish(); + } + break; + + case kIOPM_SyncNotifyWillChange: + if (kIOPMSyncNoChildNotify & fHeadNoteChangeFlags) { + fMachineState = kIOPM_SyncFinish; + continue; + } + fMachineState = kIOPM_SyncNotifyDidChange; + fDriverCallReason = kDriverCallInformPreChange; + notifyChildren(); + break; + + case kIOPM_SyncNotifyDidChange: + fIsPreChange = false; + + if (fHeadNoteChangeFlags & kIOPMParentInitiated) { + fMachineState = kIOPM_SyncFinish; + } else { + assert(IS_ROOT_DOMAIN); + fMachineState = kIOPM_SyncTellCapabilityDidChange; + } + + fDriverCallReason = kDriverCallInformPostChange; + notifyChildren(); + break; + + case kIOPM_SyncTellCapabilityDidChange: + tellSystemCapabilityChange( kIOPM_SyncFinish ); + break; + + case kIOPM_SyncFinish: + if (fHeadNoteChangeFlags & kIOPMParentInitiated) { + ParentChangeAcknowledgePowerChange(); + } else { + OurChangeFinish(); + } + break; + + case kIOPM_TellCapabilityChangeDone: + if (fIsPreChange) { + if (fOutOfBandParameter == kNotifyCapabilityChangePriority) { + MS_POP(); // tellSystemCapabilityChange() + continue; + } + fOutOfBandParameter = kNotifyCapabilityChangePriority; + } else { + if (fOutOfBandParameter == kNotifyCapabilityChangeApps) { + MS_POP(); // tellSystemCapabilityChange() + continue; + } + fOutOfBandParameter = kNotifyCapabilityChangeApps; + } + tellClientsWithResponse( fOutOfBandMessage ); + break; + + default: + panic("PMWorkQueueInvoke: unknown machine state %x", + fMachineState); + } + + gIOPMRequest = NULL; + + if (fMachineState == kIOPM_Finished) { + stop_watchdog_timer(); + done = true; + break; + } + } + + return done; } //********************************************************************************* // [private] executePMRequest //********************************************************************************* -void IOService::executePMRequest( IOPMRequest * request ) -{ - assert( kIOPM_Finished == fMachineState ); - - switch (request->getType()) - { - case kIOPMRequestTypePMStop: - handlePMstop( request ); - break; - - case kIOPMRequestTypeAddPowerChild1: - addPowerChild1( request ); - break; - - case kIOPMRequestTypeAddPowerChild2: - addPowerChild2( request ); - break; - - case kIOPMRequestTypeAddPowerChild3: - addPowerChild3( request ); - break; - - case kIOPMRequestTypeRegisterPowerDriver: - handleRegisterPowerDriver( request ); - break; - - case kIOPMRequestTypeAdjustPowerState: - fAdjustPowerScheduled = false; - adjustPowerState(); - break; - - case kIOPMRequestTypePowerDomainWillChange: - handlePowerDomainWillChangeTo( request ); - break; - - case kIOPMRequestTypePowerDomainDidChange: - handlePowerDomainDidChangeTo( request ); - break; - - case kIOPMRequestTypeRequestPowerState: - case kIOPMRequestTypeRequestPowerStateOverride: - handleRequestPowerState( request ); - break; - - case kIOPMRequestTypePowerOverrideOnPriv: - case kIOPMRequestTypePowerOverrideOffPriv: - handlePowerOverrideChanged( request ); - break; - - case kIOPMRequestTypeActivityTickle: - handleActivityTickle( request ); - break; - - case kIOPMRequestTypeSynchronizePowerTree: - handleSynchronizePowerTree( request ); - break; - - case kIOPMRequestTypeSetIdleTimerPeriod: - { - fIdleTimerPeriod = (uintptr_t) request->fArg0; - fNextIdleTimerPeriod = fIdleTimerPeriod; - if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0)) - restartIdleTimer(); - } - break; +void +IOService::executePMRequest( IOPMRequest * request ) +{ + assert( kIOPM_Finished == fMachineState ); + + switch (request->getType()) { + case kIOPMRequestTypePMStop: + handlePMstop( request ); + break; + + case kIOPMRequestTypeAddPowerChild1: + addPowerChild1( request ); + break; + + case kIOPMRequestTypeAddPowerChild2: + addPowerChild2( request ); + break; + + case kIOPMRequestTypeAddPowerChild3: + addPowerChild3( request ); + break; + + case kIOPMRequestTypeRegisterPowerDriver: + handleRegisterPowerDriver( request ); + break; + + case kIOPMRequestTypeAdjustPowerState: + fAdjustPowerScheduled = false; + adjustPowerState(); + break; + + case kIOPMRequestTypePowerDomainWillChange: + handlePowerDomainWillChangeTo( request ); + break; + + case kIOPMRequestTypePowerDomainDidChange: + handlePowerDomainDidChangeTo( request ); + break; + + case kIOPMRequestTypeRequestPowerState: + case kIOPMRequestTypeRequestPowerStateOverride: + handleRequestPowerState( request ); + break; + + case kIOPMRequestTypePowerOverrideOnPriv: + case kIOPMRequestTypePowerOverrideOffPriv: + handlePowerOverrideChanged( request ); + break; + + case kIOPMRequestTypeActivityTickle: + handleActivityTickle( request ); + break; + + case kIOPMRequestTypeSynchronizePowerTree: + handleSynchronizePowerTree( request ); + break; + + case kIOPMRequestTypeSetIdleTimerPeriod: + { + fIdleTimerPeriod = (uintptr_t) request->fArg0; + fNextIdleTimerPeriod = fIdleTimerPeriod; + if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0)) { + restartIdleTimer(); + } + } + break; - case kIOPMRequestTypeIgnoreIdleTimer: - fIdleTimerIgnored = request->fArg0 ? 1 : 0; - break; + case kIOPMRequestTypeIgnoreIdleTimer: + fIdleTimerIgnored = request->fArg0 ? 1 : 0; + break; - case kIOPMRequestTypeQuiescePowerTree: - gIOPMWorkQueue->finishQuiesceRequest(request); - break; + case kIOPMRequestTypeQuiescePowerTree: + gIOPMWorkQueue->finishQuiesceRequest(request); + break; - default: - panic("executePMRequest: unknown request type %x", request->getType()); - } + default: + panic("executePMRequest: unknown request type %x", request->getType()); + } } //********************************************************************************* @@ -7766,290 +7901,330 @@ void IOService::executePMRequest( IOPMRequest * request ) // request target. //********************************************************************************* -bool IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue ) -{ - bool more = false; - - assert( request && queue ); - assert( request->isReplyType() ); - - PM_LOG1("[A %02x] %p [%p %s] state %d\n", - request->getType(), OBFUSCATE(request), - OBFUSCATE(this), getName(), fMachineState); - - switch ( request->getType() ) - { - case kIOPMRequestTypeAllowPowerChange: - case kIOPMRequestTypeCancelPowerChange: - // Check if we are expecting this response. - if (responseValid((uint32_t)(uintptr_t) request->fArg0, - (int)(uintptr_t) request->fArg1)) - { - if (kIOPMRequestTypeCancelPowerChange == request->getType()) - { - // Clients are not allowed to cancel when kIOPMSkipAskPowerDown - // flag is set. Only root domain will set this flag. - // However, there is one exception to this rule. User-space PM - // policy may choose to cancel sleep even after all clients have - // been notified that we will lower power. - - if ((fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) - || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) - || ((fHeadNoteChangeFlags & kIOPMSkipAskPowerDown) == 0)) - { - fDoNotPowerDown = true; - - OSString * name = (OSString *) request->fArg2; - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsApplicationResponseCancel, - name ? name->getCStringNoCopy() : "", 0, - 0, (int)(uintptr_t) request->fArg1, 0); - } - } - - if (checkForDone()) - { - stop_ack_timer(); - cleanClientResponses(false); - more = true; - } - } - // OSString containing app name in Arg2 must be released. - if (request->getType() == kIOPMRequestTypeCancelPowerChange) - { - OSObject * obj = (OSObject *) request->fArg2; - if (obj) obj->release(); - } - break; - - case kIOPMRequestTypeAckPowerChange: - more = handleAcknowledgePowerChange( request ); - break; - - case kIOPMRequestTypeAckSetPowerState: - if (fDriverTimer == -1) - { - // driver acked while setPowerState() call is in-flight. - // take this ack, return value from setPowerState() is irrelevant. - OUR_PMLog(kPMLogDriverAcknowledgeSet, - (uintptr_t) this, fDriverTimer); - fDriverTimer = 0; - } - else if (fDriverTimer > 0) - { - // expected ack, stop the timer - stop_ack_timer(); - -#if LOG_SETPOWER_TIMES - uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime); - if (nsec > LOG_SETPOWER_TIMES) { - getPMRootDomain()->pmStatsRecordApplicationResponse( - gIOPMStatsDriverPSChangeSlow, - fName, kDriverCallSetPowerState, NS_TO_MS(nsec), 0, NULL, fHeadNotePowerState); - } -#endif - OUR_PMLog(kPMLogDriverAcknowledgeSet, (uintptr_t) this, fDriverTimer); - fDriverTimer = 0; - more = true; - } - else - { - // unexpected ack - OUR_PMLog(kPMLogAcknowledgeErr4, (uintptr_t) this, 0); - } - break; - - case kIOPMRequestTypeInterestChanged: - handleInterestChanged( request ); - more = true; - break; - - case kIOPMRequestTypeIdleCancel: - if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) - || (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) - || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) - || (fMachineState == kIOPM_SyncTellClientsPowerDown) - || (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown)) - { - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_LOG2("%s: cancel from machine state %d\n", - getName(), fMachineState); - fDoNotPowerDown = true; - // Stop waiting for app replys. - if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) || - (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) || - (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown) || - (fMachineState == kIOPM_SyncTellClientsPowerDown) ) - cleanClientResponses(false); - more = true; - } - break; - - case kIOPMRequestTypeChildNotifyDelayCancel: - if (fMachineState == kIOPM_NotifyChildrenDelayed) - { - PM_LOG2("%s: delay notify cancelled\n", getName()); - notifyChildrenDelayed(); - } - break; - - default: - panic("PMReplyQueue: unknown reply type %x", request->getType()); - } - - more |= gIOPMCompletionQueue->queuePMRequest(request); - if (more) - gIOPMWorkQueue->incrementProducerCount(); - - return more; +bool +IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue ) +{ + bool more = false; + + assert( request && queue ); + assert( request->isReplyType()); + + PM_LOG1("[A %02x] %p [%p %s] state %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), fMachineState); + + switch (request->getType()) { + case kIOPMRequestTypeAllowPowerChange: + case kIOPMRequestTypeCancelPowerChange: + // Check if we are expecting this response. + if (responseValid((uint32_t)(uintptr_t) request->fArg0, + (int)(uintptr_t) request->fArg1)) { + if (kIOPMRequestTypeCancelPowerChange == request->getType()) { + // Clients are not allowed to cancel when kIOPMSkipAskPowerDown + // flag is set. Only root domain will set this flag. + // However, there is one exception to this rule. User-space PM + // policy may choose to cancel sleep even after all clients have + // been notified that we will lower power. + + if ((fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) + || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) + || ((fHeadNoteChangeFlags & kIOPMSkipAskPowerDown) == 0)) { + fDoNotPowerDown = true; + + OSString * name = (OSString *) request->fArg2; + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsResponseCancel, + name ? name->getCStringNoCopy() : "", 0, + 0, (int)(uintptr_t) request->fArg1, NULL); + } + } + + if (checkForDone()) { + stop_ack_timer(); + cleanClientResponses(false); + more = true; + } + } + // OSString containing app name in Arg2 must be released. + if (request->getType() == kIOPMRequestTypeCancelPowerChange) { + OSObject * obj = (OSObject *) request->fArg2; + if (obj) { + obj->release(); + } + } + break; + + case kIOPMRequestTypeAckPowerChange: + more = handleAcknowledgePowerChange( request ); + break; + + case kIOPMRequestTypeAckSetPowerState: + if (fDriverTimer == -1) { + // driver acked while setPowerState() call is in-flight. + // take this ack, return value from setPowerState() is irrelevant. + OUR_PMLog(kPMLogDriverAcknowledgeSet, + (uintptr_t) this, fDriverTimer); + fDriverTimer = 0; + } else if (fDriverTimer > 0) { + // expected ack, stop the timer + stop_ack_timer(); + + getPMRootDomain()->reset_watchdog_timer(this, 0); + + uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, + fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(), + NULL, fHeadNotePowerState); + } + + OUR_PMLog(kPMLogDriverAcknowledgeSet, (uintptr_t) this, fDriverTimer); + fDriverTimer = 0; + more = true; + } else { + // unexpected ack + OUR_PMLog(kPMLogAcknowledgeErr4, (uintptr_t) this, 0); + } + break; + + case kIOPMRequestTypeInterestChanged: + handleInterestChanged( request ); + more = true; + break; + + case kIOPMRequestTypeIdleCancel: + if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) + || (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) + || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) + || (fMachineState == kIOPM_SyncTellClientsPowerDown) + || (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown)) { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_LOG2("%s: cancel from machine state %d\n", + getName(), fMachineState); + fDoNotPowerDown = true; + // Stop waiting for app replys. + if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) || + (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) || + (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown) || + (fMachineState == kIOPM_SyncTellClientsPowerDown)) { + cleanClientResponses(false); + } + more = true; + } + break; + + case kIOPMRequestTypeChildNotifyDelayCancel: + if (fMachineState == kIOPM_NotifyChildrenDelayed) { + PM_LOG2("%s: delay notify cancelled\n", getName()); + notifyChildrenDelayed(); + } + break; + + default: + panic("PMReplyQueue: unknown reply type %x", request->getType()); + } + + more |= gIOPMCompletionQueue->queuePMRequest(request); + if (more) { + gIOPMWorkQueue->incrementProducerCount(); + } + + return more; } //********************************************************************************* // [private] assertPMDriverCall / deassertPMDriverCall //********************************************************************************* -bool IOService::assertPMDriverCall( - IOPMDriverCallEntry * entry, - IOOptionBits options, - IOPMinformee * inform ) +bool +IOService::assertPMDriverCall( + IOPMDriverCallEntry * entry, + IOOptionBits method, + const IOPMinformee * inform, + IOOptionBits options ) { - IOService * target = 0; - bool ok = false; - - if (!initialized) - return false; + IOService * target = NULL; + bool ok = false; - PM_LOCK(); + if (!initialized) { + return false; + } - if (fLockedFlags.PMStop) - { - goto fail; - } + PM_LOCK(); - if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive()) - { - goto fail; - } + if (fLockedFlags.PMStop) { + goto fail; + } - if (inform) - { - if (!inform->active) - { - goto fail; - } - target = inform->whatObject; - if (target->isInactive()) - { - goto fail; - } - } + if (((options & kIOPMDriverCallNoInactiveCheck) == 0) && isInactive()) { + goto fail; + } - entry->thread = current_thread(); - entry->target = target; - queue_enter(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link); - ok = true; + if (inform) { + if (!inform->active) { + goto fail; + } + target = inform->whatObject; + if (target->isInactive()) { + goto fail; + } + } + + // Record calling address for sleep failure diagnostics + switch (method) { + case kIOPMDriverCallMethodSetPowerState: + entry->callMethod = OSMemberFunctionCast(const void *, fControllingDriver, &IOService::setPowerState); + break; + case kIOPMDriverCallMethodWillChange: + entry->callMethod = OSMemberFunctionCast(const void *, target, &IOService::powerStateWillChangeTo); + break; + case kIOPMDriverCallMethodDidChange: + entry->callMethod = OSMemberFunctionCast(const void *, target, &IOService::powerStateDidChangeTo); + break; + case kIOPMDriverCallMethodUnknown: + case kIOPMDriverCallMethodSetAggressive: + default: + entry->callMethod = NULL; + break; + } + + entry->thread = current_thread(); + entry->target = target; + queue_enter(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link); + ok = true; fail: - PM_UNLOCK(); + PM_UNLOCK(); - return ok; + return ok; } -void IOService::deassertPMDriverCall( IOPMDriverCallEntry * entry ) +void +IOService::deassertPMDriverCall( IOPMDriverCallEntry * entry ) { - bool wakeup = false; + bool wakeup = false; - PM_LOCK(); + PM_LOCK(); - assert( !queue_empty(&fPMDriverCallQueue) ); - queue_remove(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link); - if (fLockedFlags.PMDriverCallWait) - { - wakeup = true; - } + assert( !queue_empty(&fPMDriverCallQueue)); + queue_remove(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link); + if (fLockedFlags.PMDriverCallWait) { + wakeup = true; + } - PM_UNLOCK(); + PM_UNLOCK(); - if (wakeup) - PM_LOCK_WAKEUP(&fPMDriverCallQueue); + if (wakeup) { + PM_LOCK_WAKEUP(&fPMDriverCallQueue); + } } -void IOService::waitForPMDriverCall( IOService * target ) +bool +IOService::getBlockingDriverCall(thread_t *thread, const void **callMethod) { - const IOPMDriverCallEntry * entry; - thread_t thread = current_thread(); - AbsoluteTime deadline; - int waitResult; - bool log = true; - bool wait; + const IOPMDriverCallEntry * entry = NULL; + bool blocked = false; + + if (!initialized) { + return false; + } - do { - wait = false; - queue_iterate(&fPMDriverCallQueue, entry, const IOPMDriverCallEntry *, link) - { - // Target of interested driver call - if (target && (target != entry->target)) - continue; + if (current_thread() != gIOPMWatchDogThread) { + // Meant to be accessed only from watchdog thread + return false; + } - if (entry->thread == thread) - { - if (log) - { - PM_LOG("%s: %s(%s) on PM thread\n", - fName, __FUNCTION__, target ? target->getName() : ""); - OSReportWithBacktrace("%s: %s(%s) on PM thread\n", - fName, __FUNCTION__, target ? target->getName() : ""); - log = false; - } - continue; - } + PM_LOCK(); + entry = qe_queue_first(&fPMDriverCallQueue, IOPMDriverCallEntry, link); + if (entry) { + *thread = entry->thread; + *callMethod = entry->callMethod; + blocked = true; + } + PM_UNLOCK(); + + return blocked; +} - wait = true; - break; - } - if (wait) - { - fLockedFlags.PMDriverCallWait = true; - clock_interval_to_deadline(15, kSecondScale, &deadline); - waitResult = PM_LOCK_SLEEP(&fPMDriverCallQueue, deadline); - fLockedFlags.PMDriverCallWait = false; - if (THREAD_TIMED_OUT == waitResult) - { - PM_ERROR("%s: waitForPMDriverCall timeout\n", fName); - wait = false; - } - } - } while (wait); +void +IOService::waitForPMDriverCall( IOService * target ) +{ + const IOPMDriverCallEntry * entry; + thread_t thread = current_thread(); + AbsoluteTime deadline; + int waitResult; + bool log = true; + bool wait; + + do { + wait = false; + queue_iterate(&fPMDriverCallQueue, entry, const IOPMDriverCallEntry *, link) + { + // Target of interested driver call + if (target && (target != entry->target)) { + continue; + } + + if (entry->thread == thread) { + if (log) { + PM_LOG("%s: %s(%s) on PM thread\n", + fName, __FUNCTION__, target ? target->getName() : ""); + OSReportWithBacktrace("%s: %s(%s) on PM thread\n", + fName, __FUNCTION__, target ? target->getName() : ""); + log = false; + } + continue; + } + + wait = true; + break; + } + + if (wait) { + fLockedFlags.PMDriverCallWait = true; + clock_interval_to_deadline(15, kSecondScale, &deadline); + waitResult = PM_LOCK_SLEEP(&fPMDriverCallQueue, deadline); + fLockedFlags.PMDriverCallWait = false; + if (THREAD_TIMED_OUT == waitResult) { + PM_ERROR("%s: waitForPMDriverCall timeout\n", fName); + wait = false; + } + } + } while (wait); } //********************************************************************************* // [private] Debug helpers //********************************************************************************* -const char * IOService::getIOMessageString( uint32_t msg ) +const char * +IOService::getIOMessageString( uint32_t msg ) { #define MSG_ENTRY(x) {(int) x, #x} - static const IONamedValue msgNames[] = { - MSG_ENTRY( kIOMessageCanDevicePowerOff ), - MSG_ENTRY( kIOMessageDeviceWillPowerOff ), - MSG_ENTRY( kIOMessageDeviceWillNotPowerOff ), - MSG_ENTRY( kIOMessageDeviceHasPoweredOn ), - MSG_ENTRY( kIOMessageCanSystemPowerOff ), - MSG_ENTRY( kIOMessageSystemWillPowerOff ), - MSG_ENTRY( kIOMessageSystemWillNotPowerOff ), - MSG_ENTRY( kIOMessageCanSystemSleep ), - MSG_ENTRY( kIOMessageSystemWillSleep ), - MSG_ENTRY( kIOMessageSystemWillNotSleep ), - MSG_ENTRY( kIOMessageSystemHasPoweredOn ), - MSG_ENTRY( kIOMessageSystemWillRestart ), - MSG_ENTRY( kIOMessageSystemWillPowerOn ), - MSG_ENTRY( kIOMessageSystemCapabilityChange ), - MSG_ENTRY( kIOPMMessageLastCallBeforeSleep ) - }; - - return IOFindNameForValue(msg, msgNames); + static const IONamedValue msgNames[] = { + MSG_ENTRY( kIOMessageCanDevicePowerOff ), + MSG_ENTRY( kIOMessageDeviceWillPowerOff ), + MSG_ENTRY( kIOMessageDeviceWillNotPowerOff ), + MSG_ENTRY( kIOMessageDeviceHasPoweredOn ), + MSG_ENTRY( kIOMessageCanSystemPowerOff ), + MSG_ENTRY( kIOMessageSystemWillPowerOff ), + MSG_ENTRY( kIOMessageSystemWillNotPowerOff ), + MSG_ENTRY( kIOMessageCanSystemSleep ), + MSG_ENTRY( kIOMessageSystemWillSleep ), + MSG_ENTRY( kIOMessageSystemWillNotSleep ), + MSG_ENTRY( kIOMessageSystemHasPoweredOn ), + MSG_ENTRY( kIOMessageSystemWillRestart ), + MSG_ENTRY( kIOMessageSystemWillPowerOn ), + MSG_ENTRY( kIOMessageSystemCapabilityChange ), + MSG_ENTRY( kIOPMMessageLastCallBeforeSleep ), + MSG_ENTRY( kIOMessageSystemPagingOff ), + { 0, NULL } + }; + + return IOFindNameForValue(msg, msgNames); } @@ -8064,147 +8239,151 @@ const char * IOService::getIOMessageString( uint32_t msg ) OSDefineMetaClassAndStructors( IOPMRequest, IOCommand ); -IOPMRequest * IOPMRequest::create( void ) +IOPMRequest * +IOPMRequest::create( void ) { - IOPMRequest * me = OSTypeAlloc(IOPMRequest); - if (me && !me->init(0, kIOPMRequestTypeInvalid)) - { - me->release(); - me = 0; - } - return me; + IOPMRequest * me = OSTypeAlloc(IOPMRequest); + if (me && !me->init(NULL, kIOPMRequestTypeInvalid)) { + me->release(); + me = NULL; + } + return me; } -bool IOPMRequest::init( IOService * target, IOOptionBits type ) +bool +IOPMRequest::init( IOService * target, IOOptionBits type ) { - if (!IOCommand::init()) - return false; + if (!IOCommand::init()) { + return false; + } - fRequestType = type; - fTarget = target; + fRequestType = type; + fTarget = target; - if (fTarget) - fTarget->retain(); + if (fTarget) { + fTarget->retain(); + } - // Root node and root domain requests does not prevent the power tree from - // becoming quiescent. + // Root node and root domain requests does not prevent the power tree from + // becoming quiescent. - fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) && - (fTarget != IOService::getPMRootDomain())); + fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) && + (fTarget != IOService::getPMRootDomain())); - return true; + return true; } -void IOPMRequest::reset( void ) +void +IOPMRequest::reset( void ) { - assert( fWorkWaitCount == 0 ); - assert( fFreeWaitCount == 0 ); + assert( fWorkWaitCount == 0 ); + assert( fFreeWaitCount == 0 ); - detachNextRequest(); - detachRootRequest(); + detachNextRequest(); + detachRootRequest(); - if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree)) - { - // Call the completion on PM work loop context - fCompletionAction(fCompletionTarget, fCompletionParam); - fCompletionAction = 0; - } + if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree)) { + // Call the completion on PM work loop context + fCompletionAction(fCompletionTarget, fCompletionParam); + fCompletionAction = NULL; + } - fRequestType = kIOPMRequestTypeInvalid; + fRequestType = kIOPMRequestTypeInvalid; - if (fTarget) - { - fTarget->release(); - fTarget = 0; - } + if (fTarget) { + fTarget->release(); + fTarget = NULL; + } } -bool IOPMRequest::attachNextRequest( IOPMRequest * next ) +bool +IOPMRequest::attachNextRequest( IOPMRequest * next ) { - bool ok = false; + bool ok = false; - if (!fRequestNext) - { - // Postpone the execution of the next request after - // this request. - fRequestNext = next; - fRequestNext->fWorkWaitCount++; + if (!fRequestNext) { + // Postpone the execution of the next request after + // this request. + fRequestNext = next; + fRequestNext->fWorkWaitCount++; #if LOG_REQUEST_ATTACH - PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n", - OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext), - fRequestNext->fRequestType, - (uint32_t) fRequestNext->fWorkWaitCount, - fTarget->getName()); + PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext), + fRequestNext->fRequestType, + (uint32_t) fRequestNext->fWorkWaitCount, + fTarget->getName()); #endif - ok = true; - } - return ok; + ok = true; + } + return ok; } -bool IOPMRequest::detachNextRequest( void ) +bool +IOPMRequest::detachNextRequest( void ) { - bool ok = false; + bool ok = false; - if (fRequestNext) - { - assert(fRequestNext->fWorkWaitCount); - if (fRequestNext->fWorkWaitCount) - fRequestNext->fWorkWaitCount--; + if (fRequestNext) { + assert(fRequestNext->fWorkWaitCount); + if (fRequestNext->fWorkWaitCount) { + fRequestNext->fWorkWaitCount--; + } #if LOG_REQUEST_ATTACH - PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n", - OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext), - fRequestNext->fRequestType, - (uint32_t) fRequestNext->fWorkWaitCount, - fTarget->getName()); + PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext), + fRequestNext->fRequestType, + (uint32_t) fRequestNext->fWorkWaitCount, + fTarget->getName()); #endif - fRequestNext = 0; - ok = true; - } - return ok; + fRequestNext = NULL; + ok = true; + } + return ok; } -bool IOPMRequest::attachRootRequest( IOPMRequest * root ) +bool +IOPMRequest::attachRootRequest( IOPMRequest * root ) { - bool ok = false; + bool ok = false; - if (!fRequestRoot) - { - // Delay the completion of the root request after - // this request. - fRequestRoot = root; - fRequestRoot->fFreeWaitCount++; + if (!fRequestRoot) { + // Delay the completion of the root request after + // this request. + fRequestRoot = root; + fRequestRoot->fFreeWaitCount++; #if LOG_REQUEST_ATTACH - PM_LOG("Attached root: %p [0x%x] -> %p [0x%x, %u] %s\n", - OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot), - (uint32_t) fRequestRoot->fType, - (uint32_t) fRequestRoot->fFreeWaitCount, - fTarget->getName()); + PM_LOG("Attached root: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot), + (uint32_t) fRequestRoot->fType, + (uint32_t) fRequestRoot->fFreeWaitCount, + fTarget->getName()); #endif - ok = true; - } - return ok; + ok = true; + } + return ok; } -bool IOPMRequest::detachRootRequest( void ) +bool +IOPMRequest::detachRootRequest( void ) { - bool ok = false; + bool ok = false; - if (fRequestRoot) - { - assert(fRequestRoot->fFreeWaitCount); - if (fRequestRoot->fFreeWaitCount) - fRequestRoot->fFreeWaitCount--; + if (fRequestRoot) { + assert(fRequestRoot->fFreeWaitCount); + if (fRequestRoot->fFreeWaitCount) { + fRequestRoot->fFreeWaitCount--; + } #if LOG_REQUEST_ATTACH - PM_LOG("Detached root: %p [0x%x] -> %p [0x%x, %u] %s\n", - OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot), - (uint32_t) fRequestRoot->fType, - (uint32_t) fRequestRoot->fFreeWaitCount, - fTarget->getName()); + PM_LOG("Detached root: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot), + (uint32_t) fRequestRoot->fType, + (uint32_t) fRequestRoot->fFreeWaitCount, + fTarget->getName()); #endif - fRequestRoot = 0; - ok = true; - } - return ok; + fRequestRoot = NULL; + ok = true; + } + return ok; } // MARK: - @@ -8218,92 +8397,97 @@ bool IOPMRequest::detachRootRequest( void ) OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource ); -IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction ) +IOPMRequestQueue * +IOPMRequestQueue::create( IOService * inOwner, Action inAction ) { - IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue); - if (me && !me->init(inOwner, inAction)) - { - me->release(); - me = 0; - } - return me; + IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue); + if (me && !me->init(inOwner, inAction)) { + me->release(); + me = NULL; + } + return me; } -bool IOPMRequestQueue::init( IOService * inOwner, Action inAction ) +bool +IOPMRequestQueue::init( IOService * inOwner, Action inAction ) { - if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) - return false; + if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) { + return false; + } - queue_init(&fQueue); - fLock = IOLockAlloc(); - return (fLock != 0); + queue_init(&fQueue); + fLock = IOLockAlloc(); + return fLock != NULL; } -void IOPMRequestQueue::free( void ) +void +IOPMRequestQueue::free( void ) { - if (fLock) - { - IOLockFree(fLock); - fLock = 0; - } - return IOEventSource::free(); + if (fLock) { + IOLockFree(fLock); + fLock = NULL; + } + return IOEventSource::free(); } -void IOPMRequestQueue::queuePMRequest( IOPMRequest * request ) +void +IOPMRequestQueue::queuePMRequest( IOPMRequest * request ) { - assert(request); - IOLockLock(fLock); - queue_enter(&fQueue, request, typeof(request), fCommandChain); - IOLockUnlock(fLock); - if (workLoop) signalWorkAvailable(); + assert(request); + IOLockLock(fLock); + queue_enter(&fQueue, request, typeof(request), fCommandChain); + IOLockUnlock(fLock); + if (workLoop) { + signalWorkAvailable(); + } } void IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count ) { - IOPMRequest * next; - - assert(requests && count); - IOLockLock(fLock); - while (count--) - { - next = *requests; - requests++; - queue_enter(&fQueue, next, typeof(next), fCommandChain); - } - IOLockUnlock(fLock); - if (workLoop) signalWorkAvailable(); -} - -bool IOPMRequestQueue::checkForWork( void ) -{ - Action dqAction = (Action) action; - IOPMRequest * request; - IOService * target; - int dequeueCount = 0; - bool more = false; - - IOLockLock( fLock ); - - while (!queue_empty(&fQueue)) - { - if (dequeueCount++ >= kMaxDequeueCount) - { - // Allow other queues a chance to work - more = true; - break; - } - - queue_remove_first(&fQueue, request, typeof(request), fCommandChain); - IOLockUnlock(fLock); - target = request->getTarget(); - assert(target); - more |= (*dqAction)( target, request, this ); - IOLockLock( fLock ); - } - - IOLockUnlock( fLock ); - return more; + IOPMRequest * next; + + assert(requests && count); + IOLockLock(fLock); + while (count--) { + next = *requests; + requests++; + queue_enter(&fQueue, next, typeof(next), fCommandChain); + } + IOLockUnlock(fLock); + if (workLoop) { + signalWorkAvailable(); + } +} + +bool +IOPMRequestQueue::checkForWork( void ) +{ + Action dqAction = (Action) action; + IOPMRequest * request; + IOService * target; + int dequeueCount = 0; + bool more = false; + + IOLockLock( fLock ); + + while (!queue_empty(&fQueue)) { + if (dequeueCount++ >= kMaxDequeueCount) { + // Allow other queues a chance to work + more = true; + break; + } + + queue_remove_first(&fQueue, request, typeof(request), fCommandChain); + IOLockUnlock(fLock); + target = request->getTarget(); + assert(target); + more |= (*dqAction)( target, request, this ); + IOLockLock( fLock ); + } + + IOLockUnlock( fLock ); + return more; } // MARK: - @@ -8321,245 +8505,239 @@ OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource ); IOPMWorkQueue * IOPMWorkQueue::create( IOService * inOwner, Action invoke, Action retire ) { - IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue); - if (me && !me->init(inOwner, invoke, retire)) - { - me->release(); - me = 0; - } - return me; -} - -bool IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire ) -{ - if (!invoke || !retire || - !IOEventSource::init(inOwner, (IOEventSourceAction)0)) - return false; - - queue_init(&fWorkQueue); - - fInvokeAction = invoke; - fRetireAction = retire; - fConsumerCount = fProducerCount = 0; - - return true; -} - -bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt ) -{ - queue_head_t * requestQueue; - bool more = false; - bool empty; - - assert( request ); - assert( pwrMgt ); - assert( onThread() ); - assert( queue_next(&request->fCommandChain) == - queue_prev(&request->fCommandChain) ); - - gIOPMBusyRequestCount++; - - if (request->isQuiesceType()) - { - if ((request->getTarget() == gIOPMRootNode) && !fQuiesceStartTime) - { - // Attach new quiesce request to all quiesce blockers in the queue - fQuiesceStartTime = mach_absolute_time(); - attachQuiesceRequest(request); - fQuiesceRequest = request; - } - } - else if (fQuiesceRequest && request->isQuiesceBlocker()) - { - // Attach the new quiesce blocker to the blocked quiesce request - request->attachNextRequest(fQuiesceRequest); - } - - // Add new request to the tail of the per-service request queue. - // Then immediately check the request queue to minimize latency - // if the queue was empty. - - requestQueue = &pwrMgt->RequestHead; - empty = queue_empty(requestQueue); - queue_enter(requestQueue, request, typeof(request), fCommandChain); - if (empty) - { - more = checkRequestQueue(requestQueue, &empty); - if (!empty) - { - // Request just added is blocked, add its target IOServicePM - // to the work queue. - assert( queue_next(&pwrMgt->WorkChain) == - queue_prev(&pwrMgt->WorkChain) ); - - queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain); - fQueueLength++; - PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n", - fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt)); - } - } - - return more; -} - -bool IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty ) -{ - IOPMRequest * request; - IOService * target; - bool more = false; - bool done = false; - - assert(!queue_empty(requestQueue)); - do { - request = (typeof(request)) queue_first(requestQueue); - if (request->isWorkBlocked()) - break; // request dispatch blocked on attached request - - target = request->getTarget(); - if (fInvokeAction) - { - done = (*fInvokeAction)( target, request, this ); - } - else - { - PM_LOG("PM request 0x%x dropped\n", request->getType()); - done = true; - } - if (!done) - break; // PM state machine blocked - - assert(gIOPMBusyRequestCount > 0); - if (gIOPMBusyRequestCount) - gIOPMBusyRequestCount--; - - if (request == fQuiesceRequest) - { - fQuiesceRequest = 0; - } - - queue_remove_first(requestQueue, request, typeof(request), fCommandChain); - more |= (*fRetireAction)( target, request, this ); - done = queue_empty(requestQueue); - } while (!done); - - *empty = done; - - if (more) - { - // Retired a request that may unblock a previously visited request - // that is still waiting on the work queue. Must trigger another - // queue check. - fProducerCount++; - } - - return more; -} - -bool IOPMWorkQueue::checkForWork( void ) -{ - IOServicePM * entry; - IOServicePM * next; - bool more = false; - bool empty; + IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue); + if (me && !me->init(inOwner, invoke, retire)) { + me->release(); + me = NULL; + } + return me; +} + +bool +IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire ) +{ + if (!invoke || !retire || + !IOEventSource::init(inOwner, (IOEventSourceAction)NULL)) { + return false; + } + + queue_init(&fWorkQueue); + + fInvokeAction = invoke; + fRetireAction = retire; + fConsumerCount = fProducerCount = 0; + + return true; +} + +bool +IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt ) +{ + queue_head_t * requestQueue; + bool more = false; + bool empty; + + assert( request ); + assert( pwrMgt ); + assert( onThread()); + assert( queue_next(&request->fCommandChain) == + queue_prev(&request->fCommandChain)); + + gIOPMBusyRequestCount++; + + if (request->isQuiesceType()) { + if ((request->getTarget() == gIOPMRootNode) && !fQuiesceStartTime) { + // Attach new quiesce request to all quiesce blockers in the queue + fQuiesceStartTime = mach_absolute_time(); + attachQuiesceRequest(request); + fQuiesceRequest = request; + } + } else if (fQuiesceRequest && request->isQuiesceBlocker()) { + // Attach the new quiesce blocker to the blocked quiesce request + request->attachNextRequest(fQuiesceRequest); + } + + // Add new request to the tail of the per-service request queue. + // Then immediately check the request queue to minimize latency + // if the queue was empty. + + requestQueue = &pwrMgt->RequestHead; + empty = queue_empty(requestQueue); + queue_enter(requestQueue, request, typeof(request), fCommandChain); + if (empty) { + more = checkRequestQueue(requestQueue, &empty); + if (!empty) { + // Request just added is blocked, add its target IOServicePM + // to the work queue. + assert( queue_next(&pwrMgt->WorkChain) == + queue_prev(&pwrMgt->WorkChain)); + + queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain); + fQueueLength++; + PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n", + fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt)); + } + } + + return more; +} + +bool +IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty ) +{ + IOPMRequest * request; + IOService * target; + bool more = false; + bool done = false; + + assert(!queue_empty(requestQueue)); + do { + request = (typeof(request))queue_first(requestQueue); + if (request->isWorkBlocked()) { + break; // request dispatch blocked on attached request + } + target = request->getTarget(); + if (fInvokeAction) { + done = (*fInvokeAction)( target, request, this ); + } else { + PM_LOG("PM request 0x%x dropped\n", request->getType()); + done = true; + } + if (!done) { + break; // PM state machine blocked + } + assert(gIOPMBusyRequestCount > 0); + if (gIOPMBusyRequestCount) { + gIOPMBusyRequestCount--; + } + + if (request == fQuiesceRequest) { + fQuiesceRequest = NULL; + } + + queue_remove_first(requestQueue, request, typeof(request), fCommandChain); + more |= (*fRetireAction)( target, request, this ); + done = queue_empty(requestQueue); + } while (!done); + + *empty = done; + + if (more) { + // Retired a request that may unblock a previously visited request + // that is still waiting on the work queue. Must trigger another + // queue check. + fProducerCount++; + } + + return more; +} + +bool +IOPMWorkQueue::checkForWork( void ) +{ + IOServicePM * entry; + IOServicePM * next; + bool more = false; + bool empty; #if WORK_QUEUE_STATS - fStatCheckForWork++; + fStatCheckForWork++; #endif - // Iterate over all IOServicePM entries in the work queue, - // and check each entry's request queue. + // Iterate over all IOServicePM entries in the work queue, + // and check each entry's request queue. - while (fConsumerCount != fProducerCount) - { - PM_LOG3("IOPMWorkQueue: checkForWork %u %u\n", - fProducerCount, fConsumerCount); + while (fConsumerCount != fProducerCount) { + PM_LOG3("IOPMWorkQueue: checkForWork %u %u\n", + fProducerCount, fConsumerCount); - fConsumerCount = fProducerCount; + fConsumerCount = fProducerCount; #if WORK_QUEUE_STATS - if (queue_empty(&fWorkQueue)) - { - fStatQueueEmpty++; - break; - } - fStatScanEntries++; - uint32_t cachedWorkCount = gIOPMWorkInvokeCount; + if (queue_empty(&fWorkQueue)) { + fStatQueueEmpty++; + break; + } + fStatScanEntries++; + uint32_t cachedWorkCount = gIOPMWorkInvokeCount; #endif - __IGNORE_WCASTALIGN(entry = (typeof(entry)) queue_first(&fWorkQueue)); - while (!queue_end(&fWorkQueue, (queue_entry_t) entry)) - { - more |= checkRequestQueue(&entry->RequestHead, &empty); - - // Get next entry, points to head if current entry is last. - __IGNORE_WCASTALIGN(next = (typeof(next)) queue_next(&entry->WorkChain)); - - // if request queue is empty, remove IOServicePM from work queue. - if (empty) - { - assert(fQueueLength); - if (fQueueLength) fQueueLength--; - PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n", - fQueueLength, entry->Name, OBFUSCATE(entry)); - queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain); - } - entry = next; - } + __IGNORE_WCASTALIGN(entry = (typeof(entry))queue_first(&fWorkQueue)); + while (!queue_end(&fWorkQueue, (queue_entry_t) entry)) { + more |= checkRequestQueue(&entry->RequestHead, &empty); + + // Get next entry, points to head if current entry is last. + __IGNORE_WCASTALIGN(next = (typeof(next))queue_next(&entry->WorkChain)); + + // if request queue is empty, remove IOServicePM from work queue. + if (empty) { + assert(fQueueLength); + if (fQueueLength) { + fQueueLength--; + } + PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n", + fQueueLength, entry->Name, OBFUSCATE(entry)); + queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain); + } + entry = next; + } #if WORK_QUEUE_STATS - if (cachedWorkCount == gIOPMWorkInvokeCount) - fStatNoWorkDone++; + if (cachedWorkCount == gIOPMWorkInvokeCount) { + fStatNoWorkDone++; + } #endif - } + } - return more; + return more; } -void IOPMWorkQueue::signalWorkAvailable( void ) +void +IOPMWorkQueue::signalWorkAvailable( void ) { - fProducerCount++; - IOEventSource::signalWorkAvailable(); + fProducerCount++; + IOEventSource::signalWorkAvailable(); } -void IOPMWorkQueue::incrementProducerCount( void ) +void +IOPMWorkQueue::incrementProducerCount( void ) { - fProducerCount++; + fProducerCount++; } -void IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest ) +void +IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest ) { - IOServicePM * entry; - IOPMRequest * request; + IOServicePM * entry; + IOPMRequest * request; + + if (queue_empty(&fWorkQueue)) { + return; + } - if (queue_empty(&fWorkQueue)) - { - return; - } + queue_iterate(&fWorkQueue, entry, typeof(entry), WorkChain) + { + queue_iterate(&entry->RequestHead, request, typeof(request), fCommandChain) + { + // Attach the quiesce request to any request in the queue that + // is not linked to a next request. These requests will block + // the quiesce request. - queue_iterate(&fWorkQueue, entry, typeof(entry), WorkChain) - { - queue_iterate(&entry->RequestHead, request, typeof(request), fCommandChain) - { - // Attach the quiesce request to any request in the queue that - // is not linked to a next request. These requests will block - // the quiesce request. - - if (request->isQuiesceBlocker()) - { - request->attachNextRequest(quiesceRequest); - } - } - } + if (request->isQuiesceBlocker()) { + request->attachNextRequest(quiesceRequest); + } + } + } } -void IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest ) +void +IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest ) { - if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) && - (fQuiesceStartTime != 0)) - { - fInvokeAction = 0; - fQuiesceFinishTime = mach_absolute_time(); - } + if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) && + (fQuiesceStartTime != 0)) { + fInvokeAction = NULL; + fQuiesceFinishTime = mach_absolute_time(); + } } // MARK: - @@ -8574,58 +8752,59 @@ OSDefineMetaClassAndStructors( IOPMCompletionQueue, IOEventSource ); IOPMCompletionQueue * IOPMCompletionQueue::create( IOService * inOwner, Action inAction ) { - IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue); - if (me && !me->init(inOwner, inAction)) - { - me->release(); - me = 0; - } - return me; + IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue); + if (me && !me->init(inOwner, inAction)) { + me->release(); + me = NULL; + } + return me; } -bool IOPMCompletionQueue::init( IOService * inOwner, Action inAction ) +bool +IOPMCompletionQueue::init( IOService * inOwner, Action inAction ) { - if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) - return false; + if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) { + return false; + } - queue_init(&fQueue); - return true; + queue_init(&fQueue); + return true; } -bool IOPMCompletionQueue::queuePMRequest( IOPMRequest * request ) +bool +IOPMCompletionQueue::queuePMRequest( IOPMRequest * request ) { - bool more; + bool more; - assert(request); - // unblock dependent request - more = request->detachNextRequest(); - queue_enter(&fQueue, request, typeof(request), fCommandChain); - return more; + assert(request); + // unblock dependent request + more = request->detachNextRequest(); + queue_enter(&fQueue, request, typeof(request), fCommandChain); + return more; } -bool IOPMCompletionQueue::checkForWork( void ) +bool +IOPMCompletionQueue::checkForWork( void ) { - Action dqAction = (Action) action; - IOPMRequest * request; - IOPMRequest * next; - IOService * target; - bool more = false; + Action dqAction = (Action) action; + IOPMRequest * request; + IOPMRequest * next; + IOService * target; + bool more = false; - request = (typeof(request)) queue_first(&fQueue); - while (!queue_end(&fQueue, (queue_entry_t) request)) - { - next = (typeof(next)) queue_next(&request->fCommandChain); - if (!request->isFreeBlocked()) - { - queue_remove(&fQueue, request, typeof(request), fCommandChain); - target = request->getTarget(); - assert(target); - more |= (*dqAction)( target, request, this ); - } - request = next; - } + request = (typeof(request))queue_first(&fQueue); + while (!queue_end(&fQueue, (queue_entry_t) request)) { + next = (typeof(next))queue_next(&request->fCommandChain); + if (!request->isFreeBlocked()) { + queue_remove(&fQueue, request, typeof(request), fCommandChain); + target = request->getTarget(); + assert(target); + more |= (*dqAction)( target, request, this ); + } + request = next; + } - return more; + return more; } // MARK: - @@ -8642,181 +8821,163 @@ OSDefineMetaClassAndStructors(IOServicePM, OSObject) static void setPMProperty( OSDictionary * dict, const char * key, uint64_t value ) { - OSNumber * num = OSNumber::withNumber(value, sizeof(value) * 8); - if (num) - { - dict->setObject(key, num); - num->release(); - } + OSNumber * num = OSNumber::withNumber(value, sizeof(value) * 8); + if (num) { + dict->setObject(key, num); + num->release(); + } } -IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) const -{ - OSDictionary * dict; - bool ok = false; - int powerClamp = -1; - int dictSize = 6; - - if (IdleTimerPeriod) - dictSize += 4; - - if (PMActions.parameter & kPMActionsFlagLimitPower) - { - dictSize += 1; - powerClamp = 0; - if (PMActions.parameter & - (kPMActionsFlagIsDisplayWrangler | kPMActionsFlagIsGraphicsDevice)) - powerClamp++; - } +IOReturn +IOServicePM::gatedSerialize( OSSerialize * s ) const +{ + OSDictionary * dict; + bool ok = false; + int powerClamp = -1; + int dictSize = 6; + + if (IdleTimerPeriod) { + dictSize += 4; + } + + if (PMActions.parameter & kPMActionsFlagLimitPower) { + dictSize += 1; + powerClamp = 0; + if (PMActions.parameter & + (kPMActionsFlagIsDisplayWrangler | kPMActionsFlagIsGraphicsDevice)) { + powerClamp++; + } + } #if WORK_QUEUE_STATS - if (gIOPMRootNode == ControllingDriver) - dictSize += 4; + if (gIOPMRootNode == ControllingDriver) { + dictSize += 4; + } #endif - if (PowerClients) - dict = OSDictionary::withDictionary( - PowerClients, PowerClients->getCount() + dictSize); - else - dict = OSDictionary::withCapacity(dictSize); - - if (dict) - { - setPMProperty(dict, "CurrentPowerState", CurrentPowerState); - setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags); - if (NumberOfPowerStates) - setPMProperty(dict, "MaxPowerState", NumberOfPowerStates-1); - if (DesiredPowerState != CurrentPowerState) - setPMProperty(dict, "DesiredPowerState", DesiredPowerState); - if (kIOPM_Finished != MachineState) - setPMProperty(dict, "MachineState", MachineState); - if (DeviceOverrideEnabled) - dict->setObject("PowerOverrideOn", kOSBooleanTrue); - if (powerClamp >= 0) - setPMProperty(dict, "PowerClamp", powerClamp); - - if (IdleTimerPeriod) - { - AbsoluteTime now; - AbsoluteTime delta; - uint64_t nsecs; - - clock_get_uptime(&now); - - // The idle timer period in milliseconds - setPMProperty(dict, "IdleTimerPeriod", NextIdleTimerPeriod * 1000ULL); - - // Number of tickles since the last idle timer expiration - setPMProperty(dict, "ActivityTickles", ActivityTickleCount); - - if (AbsoluteTime_to_scalar(&DeviceActiveTimestamp)) - { - // Milliseconds since the last activity tickle - delta = now; - SUB_ABSOLUTETIME(&delta, &DeviceActiveTimestamp); - absolutetime_to_nanoseconds(delta, &nsecs); - setPMProperty(dict, "TimeSinceLastTickle", NS_TO_MS(nsecs)); - } - - if (!IdleTimerStopped && AbsoluteTime_to_scalar(&IdleTimerStartTime)) - { - // Idle timer elapsed time in milliseconds - delta = now; - SUB_ABSOLUTETIME(&delta, &IdleTimerStartTime); - absolutetime_to_nanoseconds(delta, &nsecs); - setPMProperty(dict, "IdleTimerElapsedTime", NS_TO_MS(nsecs)); - } - } + if (PowerClients) { + dict = OSDictionary::withDictionary( + PowerClients, PowerClients->getCount() + dictSize); + } else { + dict = OSDictionary::withCapacity(dictSize); + } + + if (dict) { + setPMProperty(dict, "CurrentPowerState", CurrentPowerState); + setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags); + if (NumberOfPowerStates) { + setPMProperty(dict, "MaxPowerState", NumberOfPowerStates - 1); + } + if (DesiredPowerState != CurrentPowerState) { + setPMProperty(dict, "DesiredPowerState", DesiredPowerState); + } + if (kIOPM_Finished != MachineState) { + setPMProperty(dict, "MachineState", MachineState); + } + if (DeviceOverrideEnabled) { + dict->setObject("PowerOverrideOn", kOSBooleanTrue); + } + if (powerClamp >= 0) { + setPMProperty(dict, "PowerClamp", powerClamp); + } + + if (IdleTimerPeriod) { + AbsoluteTime now; + AbsoluteTime delta; + uint64_t nsecs; + + clock_get_uptime(&now); + + // The idle timer period in milliseconds + setPMProperty(dict, "IdleTimerPeriod", NextIdleTimerPeriod * 1000ULL); + + // Number of tickles since the last idle timer expiration + setPMProperty(dict, "ActivityTickles", ActivityTickleCount); + + if (AbsoluteTime_to_scalar(&DeviceActiveTimestamp)) { + // Milliseconds since the last activity tickle + delta = now; + SUB_ABSOLUTETIME(&delta, &DeviceActiveTimestamp); + absolutetime_to_nanoseconds(delta, &nsecs); + setPMProperty(dict, "TimeSinceLastTickle", NS_TO_MS(nsecs)); + } + + if (!IdleTimerStopped && AbsoluteTime_to_scalar(&IdleTimerStartTime)) { + // Idle timer elapsed time in milliseconds + delta = now; + SUB_ABSOLUTETIME(&delta, &IdleTimerStartTime); + absolutetime_to_nanoseconds(delta, &nsecs); + setPMProperty(dict, "IdleTimerElapsedTime", NS_TO_MS(nsecs)); + } + } #if WORK_QUEUE_STATS - if (gIOPMRootNode == Owner) - { - setPMProperty(dict, "WQ-CheckForWork", - gIOPMWorkQueue->fStatCheckForWork); - setPMProperty(dict, "WQ-ScanEntries", - gIOPMWorkQueue->fStatScanEntries); - setPMProperty(dict, "WQ-QueueEmpty", - gIOPMWorkQueue->fStatQueueEmpty); - setPMProperty(dict, "WQ-NoWorkDone", - gIOPMWorkQueue->fStatNoWorkDone); - } + if (gIOPMRootNode == Owner) { + setPMProperty(dict, "WQ-CheckForWork", + gIOPMWorkQueue->fStatCheckForWork); + setPMProperty(dict, "WQ-ScanEntries", + gIOPMWorkQueue->fStatScanEntries); + setPMProperty(dict, "WQ-QueueEmpty", + gIOPMWorkQueue->fStatQueueEmpty); + setPMProperty(dict, "WQ-NoWorkDone", + gIOPMWorkQueue->fStatNoWorkDone); + } #endif - if (HasAdvisoryDesire && !gIOPMAdvisoryTickleEnabled) - { - // Don't report advisory tickle when it has no influence - dict->removeObject(gIOPMPowerClientAdvisoryTickle); - } + if (HasAdvisoryDesire && !gIOPMAdvisoryTickleEnabled) { + // Don't report advisory tickle when it has no influence + dict->removeObject(gIOPMPowerClientAdvisoryTickle); + } - ok = dict->serialize(s); - dict->release(); - } + ok = dict->serialize(s); + dict->release(); + } - return (ok ? kIOReturnSuccess : kIOReturnNoMemory); + return ok ? kIOReturnSuccess : kIOReturnNoMemory; } -bool IOServicePM::serialize( OSSerialize * s ) const +bool +IOServicePM::serialize( OSSerialize * s ) const { - IOReturn ret = kIOReturnNotReady; + IOReturn ret = kIOReturnNotReady; - if (gIOPMWatchDogThread == current_thread()) - { - // Calling without lock as this data is collected for debug purpose, before reboot. - // The workloop is probably already hung in state machine. - ret = gatedSerialize(s); - } - else if (gIOPMWorkLoop) - { - ret = gIOPMWorkLoop->runAction( - OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize), - (OSObject *) this, (void *) s); - } + if (gIOPMWatchDogThread == current_thread()) { + // Calling without lock as this data is collected for debug purpose, before reboot. + // The workloop is probably already hung in state machine. + ret = gatedSerialize(s); + } else if (gIOPMWorkLoop) { + ret = gIOPMWorkLoop->runAction( + OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize), + (OSObject *) this, (void *) s); + } - return (kIOReturnSuccess == ret); + return kIOReturnSuccess == ret; } -void IOServicePM::pmPrint( - uint32_t event, - uintptr_t param1, - uintptr_t param2 ) const +void +IOServicePM::pmPrint( + uint32_t event, + uintptr_t param1, + uintptr_t param2 ) const { - gPlatform->PMLog(Name, event, param1, param2); + gPlatform->PMLog(Name, event, param1, param2); } -void IOServicePM::pmTrace( - uint32_t event, - uintptr_t param1, - uintptr_t param2 ) const +void +IOServicePM::pmTrace( + uint32_t event, + uint32_t eventFunc, + uintptr_t param1, + uintptr_t param2 ) const { - const char * who = Name; - uint64_t regId = Owner->getRegistryEntryID(); - uintptr_t name = 0; + uintptr_t nameAsArg = 0; - static const uint32_t sStartStopBitField[] = - { 0x00000000, 0x00000040 }; // Only Program Hardware so far + assert(event < KDBG_CODE_MAX); + assert((eventFunc & ~KDBG_FUNC_MASK) == 0); - // Arcane formula from Hacker's Delight by Warren - // abs(x) = ((int) x >> 31) ^ (x + ((int) x >> 31)) - uint32_t sgnevent = ((int) event >> 31); - uint32_t absevent = sgnevent ^ (event + sgnevent); - uint32_t code = IODBG_POWER(absevent); + // Copy the first characters of the name into an uintptr_t. + // NULL termination is not required. + strncpy((char*)&nameAsArg, Name, sizeof(nameAsArg)); - uint32_t bit = 1 << (absevent & 0x1f); - if ((absevent < (sizeof(sStartStopBitField) * 8)) && - (sStartStopBitField[absevent >> 5] & bit)) - { - // Or in the START or END bits, Start = 1 & END = 2 - // If sgnevent == 0 then START - 0 => START - // else if sgnevent == -1 then START - -1 => END - code |= DBG_FUNC_START - sgnevent; - } - - // Copy the first characters of the name into an uintptr_t - for (uint32_t i = 0; (i < sizeof(uintptr_t) && who[i] != 0); i++) - { - ((char *) &name)[sizeof(uintptr_t) - i - 1] = who[i]; - } - - IOTimeStampConstant(code, name, (uintptr_t) regId, param1, param2); + IOTimeStampConstant(IODBG_POWER(event) | eventFunc, nameAsArg, (uintptr_t)Owner->getRegistryEntryID(), (uintptr_t)(OBFUSCATE(param1)), (uintptr_t)(OBFUSCATE(param2))); } -