X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/db6096698656d32db7df630594bd9617ee54f828..3e170ce000f1506b7b5d2c5c7faec85ceabb573d:/iokit/Kernel/IOServicePM.cpp diff --git a/iokit/Kernel/IOServicePM.cpp b/iokit/Kernel/IOServicePM.cpp index e46b02482..30612ce42 100644 --- a/iokit/Kernel/IOServicePM.cpp +++ b/iokit/Kernel/IOServicePM.cpp @@ -26,9 +26,6 @@ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ -//#undef IOASSERT -//#define IOASSERT 1 - #include #include #include @@ -38,6 +35,8 @@ #include #include #include +#include +#include #include #include @@ -48,13 +47,16 @@ #include #include +#include #include +#include // Required for notification instrumentation #include "IOServicePrivate.h" #include "IOServicePMPrivate.h" #include "IOKitKernelInternal.h" + static void settle_timer_expired(thread_call_param_t, thread_call_param_t); static void idle_timer_expired(thread_call_param_t, thread_call_param_t); static void tellKernelClientApplier(OSObject * object, void * arg); @@ -75,46 +77,75 @@ static uint64_t computeTimeDeltaNS( const AbsoluteTime * start ) OSDefineMetaClassAndStructors(IOPMprot, OSObject) #endif -// Container class for recording system power events -OSDefineMetaClassAndStructors( PMEventDetails, OSObject ); - //****************************************************************************** // Globals //****************************************************************************** -static bool gIOPMInitialized = false; -static uint32_t gIOPMBusyCount = 0; -static uint32_t gIOPMWorkCount = 0; -static IOWorkLoop * gIOPMWorkLoop = 0; -static IOPMRequestQueue * gIOPMRequestQueue = 0; -static IOPMRequestQueue * gIOPMReplyQueue = 0; -static IOPMWorkQueue * gIOPMWorkQueue = 0; -static IOPMCompletionQueue * gIOPMFreeQueue = 0; -static IOPMRequest * gIOPMRequest = 0; -static IOService * gIOPMRootNode = 0; -static IOPlatformExpert * gPlatform = 0; - -static const OSSymbol * gIOPMPowerClientDevice = 0; -static const OSSymbol * gIOPMPowerClientDriver = 0; -static const OSSymbol * gIOPMPowerClientChildProxy = 0; -static const OSSymbol * gIOPMPowerClientChildren = 0; +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 bool gIOPMAdvisoryTickleEnabled = true; +static thread_t gIOPMWatchDogThread = NULL; +uint32_t gCanSleepTimeout = 0; static uint32_t getPMRequestType( void ) { uint32_t type = kIOPMRequestTypeInvalid; - if (gIOPMRequest) + if (gIOPMRequest) type = gIOPMRequest->getType(); return type; } +static IOPMRequestTag getPMRequestTag( void ) +{ + 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"); + //****************************************************************************** // Macros //****************************************************************************** -#define PM_ERROR(x...) do { kprintf(x); IOLog(x); } while (false) +#define PM_ERROR(x...) do { kprintf(x);IOLog(x); \ + } while (false) #define PM_LOG(x...) do { kprintf(x); } while (false) #define PM_LOG1(x...) do { \ @@ -133,9 +164,9 @@ static uint32_t getPMRequestType( void ) #define RD_LOG(x...) do { \ if ((kIOLogPMRootDomain & gIOKitDebug) && \ - (getPMRootDomain() == this)) \ - kprintf("PMRD: " x); } while (false) - + (getPMRootDomain() == this)) { \ + kprintf("PMRD: " x); \ + }} while (false) #define PM_ASSERT_IN_GATE(x) \ do { \ assert(gIOPMWorkLoop->inGate()); \ @@ -146,35 +177,45 @@ do { \ #define PM_LOCK_SLEEP(event, dl) IOLockSleepDeadline(fPMLock, event, dl, THREAD_UNINT) #define PM_LOCK_WAKEUP(event) IOLockWakeup(fPMLock, event, false) +#define us_per_s 1000000 #define ns_per_us 1000 -#define k30Seconds (30*1000000) +#define k30Seconds (30*us_per_s) +#define k5Seconds ( 5*us_per_s) +#define kCanSleepMaxTimeReq k30Seconds +#define kMaxTimeRequested k30Seconds #define kMinAckTimeoutTicks (10*1000000) #define kIOPMTardyAckSPSKey "IOPMTardyAckSetPowerState" #define kIOPMTardyAckPSCKey "IOPMTardyAckPowerStateChange" #define kPwrMgtKey "IOPowerManagement" -#define OUR_PMLog(t, a, b) \ - do { gPlatform->PMLog( fName, t, a, b); } while(0) +#define OUR_PMLog(t, a, b) do { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, a, b); \ + } while(0) #define NS_TO_MS(nsec) ((int)((nsec) / 1000000ULL)) #define NS_TO_US(nsec) ((int)((nsec) / 1000ULL)) -#if CONFIG_EMBEDDED #define SUPPORT_IDLE_CANCEL 1 -#endif -#define kIOPMPowerStateMax 0xFFFFFFFF -#define kInvalidTicklePowerState (-1) +#define kIOPMPowerStateMax 0xFFFFFFFF +#define kInvalidTicklePowerState kIOPMPowerStateMax #define kNoTickleCancelWindow (60ULL * 1000ULL * 1000ULL * 1000ULL) #define IS_PM_ROOT (this == gIOPMRootNode) #define IS_ROOT_DOMAIN (getPMRootDomain() == this) -#define IS_POWER_DROP (fHeadNotePowerState < fCurrentPowerState) -#define IS_POWER_RISE (fHeadNotePowerState > fCurrentPowerState) +#define IS_POWER_DROP (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) +#define IS_POWER_RISE (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState)) // log setPowerStates longer than (ns): +#if defined(__i386__) || defined(__x86_64__) +#define LOG_SETPOWER_TIMES (300ULL * 1000ULL * 1000ULL) +#else #define LOG_SETPOWER_TIMES (50ULL * 1000ULL * 1000ULL) +#endif // log app responses longer than (ns): #define LOG_APP_RESPONSE_TIMES (100ULL * 1000ULL * 1000ULL) // use message tracer to log messages longer than (ns): @@ -201,16 +242,22 @@ enum { #define PM_ACTION_2(a, x, y) \ do { if (fPMActions.a) { \ - (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y); } \ + (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) - + static OSNumber * copyClientIDForNotification( - OSObject *object, + OSObject *object, IOPMInterestContext *context); static void logClientIDForNotification( OSObject *object, - IOPMInterestContext *context, + IOPMInterestContext *context, const char *logString); //********************************************************************************* @@ -223,13 +270,14 @@ enum { kIOPM_Finished = 0, kIOPM_OurChangeTellClientsPowerDown = 1, - kIOPM_OurChangeTellPriorityClientsPowerDown = 2, - kIOPM_OurChangeNotifyInterestedDriversWillChange = 3, - kIOPM_OurChangeSetPowerState = 4, - kIOPM_OurChangeWaitForPowerSettle = 5, - kIOPM_OurChangeNotifyInterestedDriversDidChange = 6, - kIOPM_OurChangeTellCapabilityDidChange = 7, - kIOPM_OurChangeFinish = 8, + 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, @@ -254,207 +302,39 @@ enum { kIOPM_BadMachineState = 0xFFFFFFFF }; - - /* - Power Management defines a few roles that drivers can play in their own, - and other drivers', power management. We briefly define those here. - - Many drivers implement their policy maker and power controller within the same - IOService object, but that is not required. - -== Policy Maker == - * Virtual IOService PM methods a "policy maker" may implement - * maxCapabilityForDomainState() - * initialPowerStateForDomainState() - * powerStateForDomainState() - - * Virtual IOService PM methods a "policy maker" may CALL - * PMinit() - -== Power Controller == - * Virtual IOService PM methods a "power controller" may implement - * setPowerState() - - * Virtual IOService PM methods a "power controller" may CALL - * joinPMtree() - * registerPowerDriver() - -======================= - There are two different kinds of power state changes. - * One is initiated by a subclassed device object which has either decided - to change power state, or its controlling driver has suggested it, or - some other driver wants to use the idle device and has asked it to become - usable. - * The second kind of power state change is initiated by the power domain - parent. - The two are handled through different code paths. - - We maintain a queue of "change notifications," or change notes. - * Usually the queue is empty. - * When it isn't, usually there is one change note in it - * It's possible to have more than one power state change pending at one - time, so a queue is implemented. - Example: - * The subclass device decides it's idle and initiates a change to a lower - power state. This causes interested parties to be notified, but they - don't all acknowledge right away. This causes the change note to sit - in the queue until all the acks are received. During this time, the - device decides it isn't idle anymore and wants to raise power back up - again. This change can't be started, however, because the previous one - isn't complete yet, so the second one waits in the queue. During this - time, the parent decides to lower or raise the power state of the entire - power domain and notifies the device, and that notification goes into - the queue, too, and can't be actioned until the others are. - - == SelfInitiated == - This is how a power change initiated by the subclass device is handled: - -> First, all interested parties are notified of the change via their - powerStateWillChangeTo method. If they all don't acknowledge via return - code, then we have to wait. If they do, or when they finally all - acknowledge via our acknowledgePowerChange method, then we can continue. - -> We call the controlling driver, instructing it to change to the new state - -> Then we wait for power to settle. If there is no settling-time, or after - it has passed, - -> we notify interested parties again, this time via their - powerStateDidChangeTo methods. - -> When they have all acked, we're done. - If we lowered power and don't need the power domain to be in its current power - state, we suggest to the parent that it lower the power domain state. - - == PowerDomainDownInitiated == -How a change to a lower power domain state initiated by the parent is handled: - -> First, we figure out what power state we will be in when the new domain - state is reached. - -> Then all interested parties are notified that we are moving to that new - state. - -> When they have acknowledged, we call the controlling driver to assume - that state and we wait for power to settle. - -> Then we acknowledge our preparedness to our parent. When all its - interested parties have acknowledged, - -> it lowers power and then notifies its interested parties again. - -> When we get this call, we notify our interested parties that the power - state has changed, and when they have all acknowledged, we're done. - - == PowerDomainUpInitiated == -How a change to a higher power domain state initiated by the parent is handled: - -> We figure out what power state we will be in when the new domain state is - reached. - -> If it is different from our current state we acknowledge the parent. - -> When all the parent's interested parties have acknowledged, it raises - power in the domain and waits for power to settle. - -> Then it notifies everyone that the new state has been reached. - -> When we get this call, we call the controlling driver, instructing it to - assume the new state, and wait for power to settle. - -> Then we notify our interested parties. When they all acknowledge we are - done. - - In either of the two power domain state cases above, it is possible that we - will not be changing state even though the domain is. - Examples: - * A change to a lower domain state may not affect us because we are already - in a low enough state, - * We will not take advantage of a change to a higher domain state, because - we have no need of the higher power. In such cases, there is nothing to - do but acknowledge the parent. So when the parent calls our - powerDomainWillChange method, and we decide that we will not be changing - state, we merely acknowledge the parent, via return code, and wait. - When the parent subsequently calls powerStateDidChange, we acknowledge again - via return code, and the change is complete. - - == 4 Paths Through State Machine == - Power state changes are processed in a state machine, and since there are four - varieties of power state changes, there are four major paths through the state - machine. - - == 5. No Need To change == - The fourth is nearly trivial. In this path, the parent is changing the domain - state, but we are not changing the device state. The change starts when the - parent calls powerDomainWillChange. All we do is acknowledge the parent. When - the parent calls powerStateDidChange, we acknowledge the parent again, and - we're done. - - == 1. OurChange Down == XXX gvdl - The first is fairly simple. It starts: - * when a power domain child calls requestPowerDomainState and we decide to - change power states to accomodate the child, - * or if our power-controlling driver calls changePowerStateTo, - * or if some other driver which is using our device calls makeUsable, - * or if a subclassed object calls changePowerStateToPriv. - These are all power changes initiated by us, not forced upon us by the parent. - - -> We start by notifying interested parties. - -> If they all acknowledge via return code, we can go on to state - "msSetPowerState". - -> Otherwise, we start the ack timer and wait for the stragglers to - acknowlege by calling acknowledgePowerChange. - -> We move on to state "msSetPowerState" when all the - stragglers have acknowledged, or when the ack timer expires on - all those which didn't acknowledge. - In "msSetPowerState" we call the power-controlling driver to change the - power state of the hardware. - -> If it returns saying it has done so, we go on to state - "msWaitForPowerSettle". - -> Otherwise, we have to wait for it, so we set the ack timer and wait. - -> When it calls acknowledgeSetPowerState, or when the ack timer - expires, we go on. - In "msWaitForPowerSettle", we look in the power state array to see if - there is any settle time required when changing from our current state to the - new state. - -> If not, we go right away to "msNotifyInterestedDriversDidChange". - -> Otherwise, we set the settle timer and wait. When it expires, we move on. - In "msNotifyInterestedDriversDidChange" state, we notify all our - interested parties via their powerStateDidChange methods that we have finished - changing power state. - -> If they all acknowledge via return code, we move on to "msFinish". - -> Otherwise we set the ack timer and wait. When they have all - acknowledged, or when the ack timer has expired for those that didn't, - we move on to "msFinish". - In "msFinish" we remove the used change note from the head of the queue - and start the next one if one exists. - - == 2. Parent Change Down == - Start at Stage 2 of OurChange Down XXX gvdl - - == 3. Change Up == - Start at Stage 4 of OurChange Down XXX gvdl - -Note all parent requested changes need to acknowledge the power has changed to the parent when done. - */ - //********************************************************************************* // [public] PMinit // // Initialize power management. //********************************************************************************* -void IOService::PMinit ( void ) +void IOService::PMinit( void ) { if ( !initialized ) - { - if ( !gIOPMInitialized ) - { + { + if ( !gIOPMInitialized ) + { gPlatform = getPlatform(); gIOPMWorkLoop = IOWorkLoop::workLoop(); if (gIOPMWorkLoop) { gIOPMRequestQueue = IOPMRequestQueue::create( this, OSMemberFunctionCast(IOPMRequestQueue::Action, - this, &IOService::servicePMRequestQueue)); + this, &IOService::actionPMRequestQueue)); gIOPMReplyQueue = IOPMRequestQueue::create( this, OSMemberFunctionCast(IOPMRequestQueue::Action, - this, &IOService::servicePMReplyQueue)); + this, &IOService::actionPMReplyQueue)); - gIOPMWorkQueue = IOPMWorkQueue::create( - this, + gIOPMWorkQueue = IOPMWorkQueue::create(this, OSMemberFunctionCast(IOPMWorkQueue::Action, this, - &IOService::servicePMRequest), + &IOService::actionPMWorkQueueInvoke), OSMemberFunctionCast(IOPMWorkQueue::Action, this, - &IOService::retirePMRequest)); + &IOService::actionPMWorkQueueRetire)); - gIOPMFreeQueue = IOPMCompletionQueue::create( + gIOPMCompletionQueue = IOPMCompletionQueue::create( this, OSMemberFunctionCast(IOPMCompletionQueue::Action, - this, &IOService::servicePMFreeQueue)); + this, &IOService::actionPMCompletionQueue)); if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) != kIOReturnSuccess) @@ -477,11 +357,13 @@ void IOService::PMinit ( void ) gIOPMWorkQueue = 0; } - if (gIOPMWorkLoop->addEventSource(gIOPMFreeQueue) != + // Must be added after the work queue, which pushes request + // to the completion queue without signaling the work loop. + if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) != kIOReturnSuccess) { - gIOPMFreeQueue->release(); - gIOPMFreeQueue = 0; + gIOPMCompletionQueue->release(); + gIOPMCompletionQueue = 0; } gIOPMPowerClientDevice = @@ -498,9 +380,15 @@ void IOService::PMinit ( void ) gIOPMPowerClientAdvisoryTickle = OSSymbol::withCStringNoCopy( "AdvisoryTicklePowerState" ); + + gIOPMPowerClientRootDomain = + OSSymbol::withCStringNoCopy( "RootDomainPower" ); + + gIOSpinDumpKextName[0] = '\0'; + gIOSpinDumpDelayType[0] = '\0'; } - if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMFreeQueue) + if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue) gIOPMInitialized = true; } if (!gIOPMInitialized) @@ -518,15 +406,15 @@ void IOService::PMinit ( void ) fPMLock = IOLockAlloc(); fInterestedDrivers = new IOPMinformeeList; fInterestedDrivers->initialize(); - fDesiredPowerState = 0; - fDeviceDesire = 0; + fDesiredPowerState = kPowerStateZero; + fDeviceDesire = kPowerStateZero; fInitialPowerChange = true; fInitialSetPowerState = true; fPreviousRequestPowerFlags = 0; fDeviceOverrideEnabled = false; fMachineState = kIOPM_Finished; fSavedMachineState = kIOPM_BadMachineState; - fIdleTimerMinPowerState = 0; + fIdleTimerMinPowerState = kPowerStateZero; fActivityLock = IOLockAlloc(); fStrictTreeOrder = false; fActivityTicklePowerState = kInvalidTicklePowerState; @@ -534,9 +422,9 @@ void IOService::PMinit ( void ) fControllingDriver = NULL; fPowerStates = NULL; fNumberOfPowerStates = 0; - fCurrentPowerState = 0; + fCurrentPowerState = kPowerStateZero; fParentsCurrentPowerFlags = 0; - fMaxPowerState = 0; + fMaxPowerState = kPowerStateZero; fName = getName(); fParentsKnowState = false; fSerialNumber = 0; @@ -550,22 +438,37 @@ void IOService::PMinit ( void ) 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); + &IOService::ack_timer_expired, (thread_call_param_t)this); fSettleTimer = thread_call_allocate( - &settle_timer_expired, (thread_call_param_t)this); + &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); + (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)) + getResourceService(), &IOService::powerChangeDone) != + OSMemberFunctionCast(void (*)(void), + this, &IOService::powerChangeDone)) { fPCDFunctionOverride = true; } @@ -579,7 +482,7 @@ void IOService::PMinit ( void ) prot->thePlatform = gPlatform; fPMVars = prot; pm_vars = prot; - } + } #else pm_vars = (void *) (uintptr_t) true; #endif @@ -594,7 +497,7 @@ void IOService::PMinit ( void ) // Free the data created by PMinit. Only called from IOService::free(). //********************************************************************************* -void IOService::PMfree ( void ) +void IOService::PMfree( void ) { initialized = false; pm_vars = 0; @@ -608,6 +511,12 @@ void IOService::PMfree ( void ) 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); @@ -627,6 +536,11 @@ void IOService::PMfree ( void ) thread_call_free(fDriverCallEntry); fDriverCallEntry = NULL; } + if ( fSpinDumpTimer ) { + thread_call_cancel(fSpinDumpTimer); + thread_call_free(fSpinDumpTimer); + fSpinDumpTimer = NULL; + } if ( fPMLock ) { IOLockFree(fPMLock); fPMLock = NULL; @@ -675,6 +589,11 @@ void IOService::PMfree ( void ) } } +void IOService::PMDebug( uint32_t event, uintptr_t param1, uintptr_t param2 ) +{ + OUR_PMLog(event, param1, param2); +} + //********************************************************************************* // [public] joinPMtree // @@ -688,7 +607,7 @@ void IOService::PMfree ( void ) // meaning it may not be initialized for power management. //********************************************************************************* -void IOService::joinPMtree ( IOService * driver ) +void IOService::joinPMtree( IOService * driver ) { IOPlatformExpert * platform; @@ -704,7 +623,7 @@ 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; } @@ -717,7 +636,7 @@ IOReturn IOService::youAreRoot ( void ) // from power plane. //********************************************************************************* -void IOService::PMstop ( void ) +void IOService::PMstop( void ) { IOPMRequest * request; @@ -745,7 +664,7 @@ void IOService::PMstop ( void ) request = acquirePMRequest( this, kIOPMRequestTypePMStop ); if (request) { - PM_LOG2("%s: %p PMstop\n", getName(), this); + PM_LOG2("%s: %p PMstop\n", getName(), OBFUSCATE(this)); submitPMRequest( request ); } } @@ -756,23 +675,23 @@ void IOService::PMstop ( void ) // Disconnect the node from all parents and children in the power plane. //********************************************************************************* -void IOService::handlePMstop ( IOPMRequest * request ) +void IOService::handlePMstop( IOPMRequest * request ) { OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - IOService * theChild; - IOService * theParent; + OSObject * next; + IOPowerConnection * connection; + IOService * theChild; + IOService * theParent; - PM_ASSERT_IN_GATE(); - PM_LOG2("%s: %p %s start\n", getName(), this, __FUNCTION__); + 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); + removeProperty(kPwrMgtKey); // detach parents iter = getParentIterator(gIOPowerPlane); @@ -795,7 +714,7 @@ void IOService::handlePMstop ( IOPMRequest * request ) // detach IOConnections detachAbove( gIOPowerPlane ); - + // no more power state changes fParentsKnowState = false; @@ -831,8 +750,8 @@ void IOService::handlePMstop ( IOPMRequest * request ) if ( fInterestedDrivers ) { - IOPMinformeeList * list = fInterestedDrivers; - IOPMinformee * item; + IOPMinformeeList * list = fInterestedDrivers; + IOPMinformee * item; PM_LOCK(); while ((item = list->firstInList())) @@ -842,12 +761,14 @@ void IOService::handlePMstop ( IOPMRequest * request ) PM_UNLOCK(); } - // Tell idleTimerExpired() to ignore idle timer. + // 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(), this, __FUNCTION__); + PM_LOG2("%s: %p %s done\n", getName(), OBFUSCATE(this), __FUNCTION__); } //********************************************************************************* @@ -856,106 +777,106 @@ void IOService::handlePMstop ( IOPMRequest * request ) // Power Management is informing us who our children are. //********************************************************************************* -IOReturn IOService::addPowerChild ( IOService * child ) +IOReturn IOService::addPowerChild( IOService * child ) { - IOPowerConnection * connection = 0; - IOPMRequest * requests[3] = {0, 0, 0}; - OSIterator * iter; - bool ok = true; + IOPowerConnection * connection = 0; + IOPMRequest * requests[3] = {0, 0, 0}; + OSIterator * iter; + bool ok = true; - if (!child) - return kIOReturnBadArgument; + if (!child) + return kIOReturnBadArgument; if (!initialized || !child->initialized) - return IOPMNotYetInitialized; + return IOPMNotYetInitialized; OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 ); - do { - // Is this child already one of our children? + 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(), child); - break; - } + 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; + } - // 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; - submitPMRequest( 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; } //********************************************************************************* @@ -964,24 +885,25 @@ 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 ) { - unsigned long tempDesire = 0; + IOPMPowerStateIndex tempDesire = kPowerStateZero; - // Make us temporary usable before adding the child. + // Make us temporary usable before adding the child. - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 ); - if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState) - { - tempDesire = fNumberOfPowerStates - 1; - } + if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState) + { + tempDesire = fHighestPowerState; + } - if (tempDesire && (IS_PM_ROOT || (fMaxPowerState >= tempDesire))) - { - adjustPowerState(tempDesire); - } + if ((tempDesire != kPowerStateZero) && + (IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire)))) + { + adjustPowerState(tempDesire); + } } //********************************************************************************* @@ -991,42 +913,42 @@ 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); - setParentInfo( powerFlags, connection, knowsState ); + setParentInfo( powerFlags, connection, knowsState ); - connection->setReadyFlag(true); + connection->setReadyFlag(true); if ( fControllingDriver && fParentsKnowState ) { @@ -1047,32 +969,32 @@ 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; + 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()); - } + } + else + { + PM_LOG("%s: addPowerChild3 not in power plane\n", getName()); + } - connection->release(); + connection->release(); } #ifndef __LP64__ @@ -1085,10 +1007,10 @@ 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__ */ @@ -1098,17 +1020,17 @@ IOReturn IOService::setPowerParent ( // Called on a parent whose child is being removed by PMstop(). //********************************************************************************* -IOReturn IOService::removePowerChild ( IOPowerConnection * theNub ) +IOReturn IOService::removePowerChild( IOPowerConnection * theNub ) { - IORegistryEntry * theChild; + IORegistryEntry * theChild; - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); OUR_PMLog( kPMLogRemoveChild, 0, 0 ); theNub->retain(); // detach nub from child - theChild = theNub->copyChildEntry(gIOPowerPlane); + theChild = theNub->copyChildEntry(gIOPowerPlane); if ( theChild ) { theNub->detachFromChild(theChild, gIOPowerPlane); @@ -1119,41 +1041,45 @@ IOReturn IOService::removePowerChild ( IOPowerConnection * theNub ) // 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(); - - // Request unblocked, work queue - // should re-scan all busy requests. - gIOPMWorkQueue->incrementProducerCount(); - } - } - } + { + // yes, pretend we got one + theNub->setAwaitingAck(false); + if (fHeadNotePendingAcks != 0 ) + { + // that's one fewer ack to worry about + fHeadNotePendingAcks--; - theNub->release(); + // is that the last? + if ( fHeadNotePendingAcks == 0 ) + { + stop_ack_timer(); - // A child has gone away, re-scan children desires and clamp bits. - // The fPendingAdjustPowerRequest helps to reduce redundant parent work. + // 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. - if (!fAdjustPowerScheduled) - { - IOPMRequest * request; - request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); - if (request) - { - submitPMRequest( request ); - fAdjustPowerScheduled = true; - } - } + gIOPMWorkQueue->incrementProducerCount(); + } + } + } + + theNub->release(); + + // 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; + } + } return IOPMNoErr; } @@ -1164,41 +1090,49 @@ IOReturn IOService::removePowerChild ( IOPowerConnection * theNub ) // A driver has called us volunteering to control power to our device. //********************************************************************************* -IOReturn IOService::registerPowerDriver ( - IOService * powerDriver, - IOPMPowerState * powerStates, - unsigned long numberOfStates ) +IOReturn IOService::registerPowerDriver( + IOService * powerDriver, + IOPMPowerState * powerStates, + unsigned long numberOfStates ) { - IOPMRequest * request; - IOPMPSEntry * powerStatesCopy = 0; + IOPMRequest * request; + IOPMPSEntry * powerStatesCopy = 0; + IOPMPowerStateIndex stateOrder; + IOReturn error = kIOReturnSuccess; if (!initialized) - return IOPMNotYetInitialized; - - // Validate arguments. - 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 != kIOPMPowerStateVersion1) - { - 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) - break; + 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++) { @@ -1208,129 +1142,161 @@ IOReturn IOService::registerPowerDriver ( 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; } - request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver ); - if (!request) - break; + powerDriver->retain(); + request->fArg0 = (void *) powerDriver; + request->fArg1 = (void *) powerStatesCopy; + request->fArg2 = (void *) numberOfStates; - powerDriver->retain(); - request->fArg0 = (void *) powerDriver; - request->fArg1 = (void *) powerStatesCopy; - request->fArg2 = (void *) numberOfStates; + submitPMRequest( request ); + return kIOReturnSuccess; + } + while (false); - submitPMRequest( request ); - return kIOReturnSuccess; - } - while (false); + if (powerStatesCopy) + IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates); - if (powerStatesCopy) - IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates); - return kIOReturnNoMemory; + return error; } //********************************************************************************* // [private] handleRegisterPowerDriver //********************************************************************************* -void IOService::handleRegisterPowerDriver ( IOPMRequest * request ) +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; - IOService * root; - OSIterator * iter; + 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); + PM_ASSERT_IN_GATE(); + assert(powerStates); + assert(powerDriver); + assert(numberOfStates > 1); if ( !fNumberOfPowerStates ) { - OUR_PMLog(kPMLogControllingDriver, - (unsigned long) numberOfStates, - (unsigned long) kIOPMPowerStateVersion1); + OUR_PMLog(kPMLogControllingDriver, + (unsigned long) numberOfStates, + (unsigned long) kIOPMPowerStateVersion1); fPowerStates = powerStates; - fNumberOfPowerStates = numberOfStates; - fControllingDriver = powerDriver; + fNumberOfPowerStates = numberOfStates; + fControllingDriver = powerDriver; fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags; - // make a mask of all the character bits we know about - fOutputPowerCharacterFlags = 0; - for ( i = 0; i < numberOfStates; i++ ) { - fOutputPowerCharacterFlags |= fPowerStates[i].outputPowerFlags; - if (!fDeviceUsablePowerState && - (fPowerStates[i].capabilityFlags & IOPMDeviceUsable)) + 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 = i; + 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(); - } - } + // 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. + // Examine all existing power clients and perform limit check. - if (fPowerClients) + if (fPowerClients && + (iter = OSCollectionIterator::withCollection(fPowerClients))) { - iter = OSCollectionIterator::withCollection(fPowerClients); - if (iter) + const OSSymbol * client; + while ((client = (const OSSymbol *) iter->getNextObject())) { - const OSSymbol * client; - while ((client = (const OSSymbol *) iter->getNextObject())) + IOPMPowerStateIndex powerState = getPowerStateForClient(client); + if (powerState >= numberOfStates) { - uint32_t powerState = getPowerStateForClient(client); - if (powerState >= numberOfStates) - { - updatePowerClient(client, numberOfStates - 1); - } + updatePowerClient(client, fHighestPowerState); } - iter->release(); } + iter->release(); } - if ( inPlane(gIOPowerPlane) && fParentsKnowState ) - { - unsigned long 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); + 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(); + powerDriver->release(); } //********************************************************************************* @@ -1342,10 +1308,10 @@ 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; @@ -1373,17 +1339,16 @@ IOPMPowerFlags IOService::registerInterestedDriver ( IOService * driver ) // for those clients that care. OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2); - return kIOPMDeviceUsable; + return kIOPMDeviceUsable; } //********************************************************************************* // [public] deRegisterInterestedDriver //********************************************************************************* -IOReturn IOService::deRegisterInterestedDriver ( IOService * driver ) +IOReturn IOService::deRegisterInterestedDriver( IOService * driver ) { - IOPMinformeeList * list; - IOPMinformee * item; + IOPMinformee * item; IOPMRequest * request; bool signal; @@ -1393,18 +1358,25 @@ IOReturn IOService::deRegisterInterestedDriver ( IOService * driver ) 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 (fInsertInterestSet) - fInsertInterestSet->removeObject(driver); - - list = fInterestedDrivers; - item = list->findItem(driver); - if (item && item->active) + if (item->active) { item->active = false; waitForPMDriverCall( driver ); @@ -1430,9 +1402,9 @@ IOReturn IOService::deRegisterInterestedDriver ( IOService * driver ) void IOService::handleInterestChanged( IOPMRequest * request ) { - IOService * driver; - IOPMinformee * informee; - IOPMinformeeList * list = fInterestedDrivers; + IOService * driver; + IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; PM_LOCK(); @@ -1488,23 +1460,23 @@ 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; + 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 ); + submitPMRequest( request ); return IOPMNoErr; } @@ -1512,26 +1484,26 @@ IOReturn IOService::acknowledgePowerChange ( IOService * whichObject ) // [private] handleAcknowledgePowerChange //********************************************************************************* -bool IOService::handleAcknowledgePowerChange ( IOPMRequest * request ) +bool IOService::handleAcknowledgePowerChange( IOPMRequest * request ) { - IOPMinformee * informee; - unsigned long childPower = kIOPMUnknown; - IOService * theChild; - IOService * whichObject; - bool all_acked = false; + IOPMinformee * informee; + unsigned long childPower = kIOPMUnknown; + IOService * theChild; + IOService * whichObject; + bool all_acked = false; - PM_ASSERT_IN_GATE(); - whichObject = (IOService *) request->fArg0; - assert(whichObject); + PM_ASSERT_IN_GATE(); + whichObject = (IOService *) request->fArg0; + assert(whichObject); // one of our interested drivers? - informee = fInterestedDrivers->findItem( whichObject ); + informee = fInterestedDrivers->findItem( whichObject ); if ( informee == NULL ) { if ( !isChild(whichObject, gIOPowerPlane) ) { - OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0); - goto no_err; + OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0); + goto no_err; } else { OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0); } @@ -1554,26 +1526,11 @@ bool IOService::handleAcknowledgePowerChange ( IOPMRequest * request ) if (informee->timer > 0) { uint64_t nsec = computeTimeDeltaNS(&informee->startTime); - if (nsec > LOG_SETPOWER_TIMES) - PM_LOG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) async took %d ms\n", - informee->whatObject->getName(), - (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did", - informee->whatObject, - fName, fCurrentPowerState, fHeadNotePowerState, NS_TO_US(nsec)); - - uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange) - ? kIOPMEventTypePSWillChangeTo - : kIOPMEventTypePSDidChangeTo; - - PMEventDetails *details = PMEventDetails::eventDetails( - logType, - fName, - (uintptr_t)this, - informee->whatObject->getName(), - 0, 0, 0, - NS_TO_MS(nsec)); - - getPMRootDomain()->recordAndReleasePMEventGated( details ); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, informee->whatObject->getName(), + fDriverCallReason, NS_TO_MS(nsec), 0, NULL, fHeadNotePowerState); + } } #endif // mark it acked @@ -1608,21 +1565,21 @@ bool IOService::handleAcknowledgePowerChange ( IOPMRequest * request ) } } } - } + } - if ( fHeadNotePendingAcks == 0 ) { - // yes, stop the timer - stop_ack_timer(); - // and now we can continue - all_acked = true; - } + 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 + OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack } no_err: - if (whichObject) - whichObject->release(); + if (whichObject) + whichObject->release(); return all_acked; } @@ -1635,64 +1592,66 @@ 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; + 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); - if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane)) - { + PM_ASSERT_IN_GATE(); + computeDesiredState(clamp, false); + if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane)) + { IOPMPowerChangeFlags changeFlags = kIOPMSelfInitiated; - // Indicate that children desires were ignored, and do not ask + // 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); - startPowerChange( - /* flags */ changeFlags, - /* power state */ fDesiredPowerState, - /* domain flags */ 0, - /* connection */ 0, - /* parent flags */ 0); - } + startPowerChange( + /* flags */ changeFlags, + /* power state */ fDesiredPowerState, + /* domain flags */ 0, + /* connection */ 0, + /* parent flags */ 0); + } } //********************************************************************************* // [public] synchronizePowerTree //********************************************************************************* -IOReturn IOService::synchronizePowerTree ( +IOReturn IOService::synchronizePowerTree( IOOptionBits options, IOService * notifyRoot ) { - IOPMRequest * request_c = 0; + IOPMRequest * request_c = 0; IOPMRequest * request_s; if (this != getPMRootDomain()) return kIOReturnBadArgument; - if (!initialized) - return kIOPMNotYetInitialized; + if (!initialized) + return kIOPMNotYetInitialized; + + OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0)); if (notifyRoot) { @@ -1700,7 +1659,7 @@ IOReturn IOService::synchronizePowerTree ( // Cancels don't need to be synchronized. nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel); - if (nr) submitPMRequest(nr); + if (nr) submitPMRequest(nr); nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel); if (nr) submitPMRequest(nr); } @@ -1716,15 +1675,15 @@ IOReturn IOService::synchronizePowerTree ( request_c->attachNextRequest( request_s ); submitPMRequest(request_c); } - + request_s->fArg0 = (void *)(uintptr_t) options; submitPMRequest(request_s); return kIOReturnSuccess; error_no_memory: - if (request_c) releasePMRequest(request_c); - if (request_s) releasePMRequest(request_s); + if (request_c) releasePMRequest(request_c); + if (request_s) releasePMRequest(request_s); return kIOReturnNoMemory; } @@ -1732,22 +1691,22 @@ error_no_memory: // [private] handleSynchronizePowerTree //********************************************************************************* -void IOService::handleSynchronizePowerTree ( IOPMRequest * request ) +void IOService::handleSynchronizePowerTree( IOPMRequest * request ) { - PM_ASSERT_IN_GATE(); - if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) && - (fCurrentPowerState == fNumberOfPowerStates - 1)) - { + PM_ASSERT_IN_GATE(); + if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) && + (fCurrentPowerState == fHighestPowerState)) + { IOOptionBits options = (uintptr_t) request->fArg0; - startPowerChange( - /* flags */ kIOPMSelfInitiated | kIOPMSynchronize | + startPowerChange( + /* flags */ kIOPMSelfInitiated | kIOPMSynchronize | (options & kIOPMSyncNoChildNotify), - /* power state */ fCurrentPowerState, - /* domain flags */ 0, - /* connection */ 0, - /* parent flags */ 0); - } + /* power state */ fCurrentPowerState, + /* domain flags */ 0, + /* connection */ 0, + /* parent flags */ 0); + } } #ifndef __LP64__ @@ -1761,12 +1720,12 @@ 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__ */ @@ -1774,34 +1733,34 @@ IOReturn IOService::powerDomainWillChangeTo ( // [private] handlePowerDomainWillChangeTo //********************************************************************************* -void IOService::handlePowerDomainWillChangeTo ( IOPMRequest * request ) +void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request ) { - IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; - IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; + 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 newPowerState; - IOPMPowerFlags combinedPowerFlags; - bool savedParentsKnowState; - IOReturn result = IOPMAckImplied; - - PM_ASSERT_IN_GATE(); + 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__); + if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) + { + PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); goto exit_no_ack; - } + } - savedParentsKnowState = fParentsKnowState; + savedParentsKnowState = fParentsKnowState; // Combine parents' output power flags. - combinedPowerFlags = 0; + combinedPowerFlags = 0; iter = getParentIterator(gIOPowerPlane); if ( iter ) @@ -1824,45 +1783,56 @@ void IOService::handlePowerDomainWillChangeTo ( IOPMRequest * request ) if ( fControllingDriver && !fInitialPowerChange ) { - newPowerState = fControllingDriver->maxCapabilityForDomainState( - combinedPowerFlags); + 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. - // Absorb parent's kIOPMSynchronize flag. myChangeFlags = kIOPMParentInitiated | kIOPMDomainWillChange | (parentChangeFlags & kIOPMSynchronize); - result = startPowerChange( - /* flags */ myChangeFlags, - /* power state */ newPowerState, - /* 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(); - } - } + 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(). @@ -1880,12 +1850,12 @@ 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__ */ @@ -1893,113 +1863,158 @@ IOReturn IOService::powerDomainDidChangeTo ( // [private] handlePowerDomainDidChangeTo //********************************************************************************* -void IOService::handlePowerDomainDidChangeTo ( IOPMRequest * request ) +void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request ) { - IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; - IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; + IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; + IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; IOPMPowerChangeFlags myChangeFlags; - IOPMPowerStateIndex newPowerState; - IOPMPowerStateIndex initialDesire; - bool savedParentsKnowState; - IOReturn result = IOPMAckImplied; + IOPMPowerStateIndex maxPowerState; + IOPMPowerStateIndex initialDesire = kPowerStateZero; + bool computeDesire = false; + bool desireChanged = false; + bool savedParentsKnowState; + IOReturn result = IOPMAckImplied; - PM_ASSERT_IN_GATE(); + 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__); + if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) + { + PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); goto exit_no_ack; - } + } - savedParentsKnowState = fParentsKnowState; + savedParentsKnowState = fParentsKnowState; setParentInfo(parentPowerFlags, whichParent, true); if ( fControllingDriver ) - { - newPowerState = fControllingDriver->maxCapabilityForDomainState( - fParentsCurrentPowerFlags); + { + 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); - computeDesiredState(initialDesire); + fParentsCurrentPowerFlags); } - else if (fAdvisoryTickleUsed && (newPowerState > 0) && - ((parentChangeFlags & kIOPMSynchronize) == 0)) + else if (parentChangeFlags & kIOPMRootChangeUp) { - // re-compute desired state in case advisory tickle was enabled - computeDesiredState(); - } + 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. - // Absorb parent's kIOPMSynchronize flag. - myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange | - (parentChangeFlags & kIOPMSynchronize); + desireChanged = true; + } - result = startPowerChange( - /* flags */ myChangeFlags, - /* power state */ newPowerState, - /* 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 (fResetPowerStateOnWake) + { + // Query the driver for the desired power state on system wake. + // Default implementation returns the lowest power state. - // If the parent registers its power driver late, then this is the - // first opportunity to tell our parent about our desire. + IOPMPowerStateIndex wakePowerState = + fControllingDriver->initialPowerStateForDomainState( + kIOPMRootDomainState | kIOPMPowerOn ); - if (!savedParentsKnowState && fParentsKnowState) - { - PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState = true\n", - getName()); - requestDomainPower( fDesiredPowerState ); - } + // fDesiredPowerState was adjusted before going to sleep + // with fDeviceDesire at min. -exit_no_ack: - // Drop the retain from notifyChild(). - if (whichParent) whichParent->release(); -} + 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. -//********************************************************************************* -// [private] setParentInfo -// -// Set our connection data for one specific parent, and then combine all the parent + 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 ); + } + +exit_no_ack: + // Drop the retain from notifyChild(). + if (whichParent) whichParent->release(); +} + +//********************************************************************************* +// [private] setParentInfo +// +// Set our connection data for one specific parent, and then combine all the parent // data together. //********************************************************************************* - -void IOService::setParentInfo ( - IOPMPowerFlags newPowerFlags, - IOPowerConnection * whichParent, - bool knowsState ) + +void IOService::setParentInfo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent, + bool knowsState ) { - OSIterator * iter; - OSObject * next; - IOPowerConnection * conn; + OSIterator * iter; + OSObject * next; + IOPowerConnection * conn; - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); // set our connection data whichParent->setParentCurrentPowerFlags(newPowerFlags); whichParent->setParentKnowsState(knowsState); - + // recompute our parent info fParentsCurrentPowerFlags = 0; fParentsKnowState = true; @@ -2042,26 +2057,25 @@ void IOService::trackSystemSleepPreventers( if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep) { + bool enablePrevention = ((oldCapability & kIOPMPreventIdleSleep) == 0); + bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList( + this, enablePrevention); #if SUPPORT_IDLE_CANCEL - if ((oldCapability & kIOPMPreventIdleSleep) == 0) + if (idleCancelAllowed && enablePrevention) { IOPMRequest * cancelRequest; - cancelRequest = acquirePMRequest( this, kIOPMRequestTypeIdleCancel ); + cancelRequest = acquirePMRequest( getPMRootDomain(), kIOPMRequestTypeIdleCancel ); if (cancelRequest) { - getPMRootDomain()->submitPMRequest( cancelRequest ); + submitPMRequest( cancelRequest ); } } #endif - - getPMRootDomain()->updatePreventIdleSleepList(this, - ((oldCapability & kIOPMPreventIdleSleep) == 0)); } if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep) { - getPMRootDomain()->updatePreventSystemSleepList(this, ((oldCapability & kIOPMPreventSystemSleep) == 0)); } @@ -2076,97 +2090,101 @@ void IOService::trackSystemSleepPreventers( IOReturn IOService::requestPowerDomainState( IOPMPowerFlags childRequestPowerFlags, IOPowerConnection * childConnection, - unsigned long specification ) + unsigned long specification ) { - IOPMPowerStateIndex ps; - IOPMPowerFlags outputPowerFlags; + IOPMPowerStateIndex order, powerState; + IOPMPowerFlags outputPowerFlags; IOService * child; - IOPMRequest * subRequest; + IOPMRequest * subRequest; bool adjustPower = false; if (!initialized) - return IOPMNotYetInitialized; + return IOPMNotYetInitialized; - if (gIOPMWorkLoop->onThread() == false) - { - PM_LOG("%s::requestPowerDomainState\n", getName()); - return kIOReturnSuccess; - } + if (gIOPMWorkLoop->onThread() == false) + { + PM_LOG("%s::requestPowerDomainState\n", getName()); + return kIOReturnSuccess; + } OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification); - if (!isChild(childConnection, gIOPowerPlane)) - return kIOReturnNotAttached; + if (!isChild(childConnection, gIOPowerPlane)) + return kIOReturnNotAttached; if (!fControllingDriver || !fNumberOfPowerStates) return kIOReturnNotReady; - child = (IOService *) childConnection->getChildEntry(gIOPowerPlane); - assert(child); + 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. + // 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 canceled - // 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 permit - // 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(); - } + 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 (ps = 0; ps < fNumberOfPowerStates; ps++) + for (order = 0; order < fNumberOfPowerStates; order++) { - if ((fPowerStates[ps].outputPowerFlags & childRequestPowerFlags) == - (fOutputPowerCharacterFlags & childRequestPowerFlags)) + powerState = fPowerStates[order].stateOrderToIndex; + if ((fPowerStates[powerState].outputPowerFlags & childRequestPowerFlags) + == childRequestPowerFlags) break; } - if (ps >= fNumberOfPowerStates) + if (order >= fNumberOfPowerStates) { - ps = 0; // should never happen + powerState = kPowerStateZero; } // Conditions that warrants a power adjustment on this parent. @@ -2174,7 +2192,7 @@ IOReturn IOService::requestPowerDomainState( // prevent idle/sleep flags towards the root domain. if (!childConnection->childHasRequestedPower() || - (ps != childConnection->getDesiredDomainState())) + (powerState != childConnection->getDesiredDomainState())) adjustPower = true; #if ENABLE_DEBUG_LOGS @@ -2184,28 +2202,28 @@ IOReturn IOService::requestPowerDomainState( getName(), child->getName(), !childConnection->childHasRequestedPower(), (uint32_t) childConnection->getDesiredDomainState(), - (uint32_t) ps); + (uint32_t) powerState); } #endif - // Record the child's desires on the connection. - childConnection->setChildHasRequestedPower(); - childConnection->setDesiredDomainState( ps ); + // 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. + // 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( + subRequest = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest ); - if (subRequest) - { - submitPMRequest( subRequest ); - fAdjustPowerScheduled = true; - } + if (subRequest) + { + submitPMRequest( subRequest ); + fAdjustPowerScheduled = true; + } } return kIOReturnSuccess; @@ -2220,7 +2238,7 @@ IOReturn IOService::requestPowerDomainState( // We enter the highest state until addPowerChild is called. //********************************************************************************* -IOReturn IOService::temporaryPowerClampOn ( void ) +IOReturn IOService::temporaryPowerClampOn( void ) { return requestPowerState( gIOPMPowerClientChildProxy, kIOPMPowerStateMax ); } @@ -2237,7 +2255,7 @@ IOReturn IOService::temporaryPowerClampOn ( void ) // highest power state. //********************************************************************************* -IOReturn IOService::makeUsable ( void ) +IOReturn IOService::makeUsable( void ) { OUR_PMLog(kPMLogMakeUsable, 0, 0); return requestPowerState( gIOPMPowerClientDevice, kIOPMPowerStateMax ); @@ -2247,10 +2265,10 @@ IOReturn IOService::makeUsable ( void ) // [public] currentCapability //********************************************************************************* -IOPMPowerFlags IOService::currentCapability ( void ) +IOPMPowerFlags IOService::currentCapability( void ) { - if (!initialized) - return IOPMNotPowerManaged; + if (!initialized) + return IOPMNotPowerManaged; return fCurrentCapabilityFlags; } @@ -2263,7 +2281,7 @@ 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 ); @@ -2277,14 +2295,14 @@ 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 ); } //********************************************************************************* -// [protected] changePowerStateWithOverrideTo +// [public] changePowerStateWithOverrideTo // // Called by our driver subclass to change power state. The new desired power // state is computed and compared against the current power state. If those @@ -2292,20 +2310,22 @@ IOReturn IOService::changePowerStateToPriv ( unsigned long ordinal ) // Override enforced - Children and Driver desires are ignored. //********************************************************************************* -IOReturn IOService::changePowerStateWithOverrideTo ( unsigned long ordinal ) +IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal, + IOPMRequestTag tag ) { - IOPMRequest * request; + IOPMRequest * request; - if (!initialized) - return kIOPMNotYetInitialized; + if (!initialized) + return kIOPMNotYetInitialized; 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; @@ -2314,60 +2334,110 @@ IOReturn IOService::changePowerStateWithOverrideTo ( unsigned long ordinal ) 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 = max(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 ); + submitPMRequest( request ); return IOPMNoErr; } +//********************************************************************************* +// [public] changePowerStateForRootDomain +// +// Adjust the root domain's power desire on the target +//********************************************************************************* + +IOReturn IOService::changePowerStateForRootDomain( IOPMPowerStateIndex ordinal ) +{ + OUR_PMLog(kPMLogChangeStateForRootDomain, ordinal, 0); + return requestPowerState( gIOPMPowerClientRootDomain, ordinal ); +} + +//********************************************************************************* +// [public for PMRD] quiescePowerTree +// +// For root domain to issue a request to quiesce the power tree. +// Supplied callback invoked upon completion. +//********************************************************************************* + +IOReturn IOService::quiescePowerTree( + void * target, IOPMCompletionAction action, void * param ) +{ + IOPMRequest * request; + + if (!initialized) + return kIOPMNotYetInitialized; + if (!target || !action) + return kIOReturnBadArgument; + + 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. + + request = acquirePMRequest(gIOPMRootNode, kIOPMRequestTypeQuiescePowerTree); + if (!request) + return kIOReturnNoMemory; + + 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. + + submitPMRequest( request ); + return kIOReturnSuccess; +} + //********************************************************************************* // [private] requestPowerState //********************************************************************************* -IOReturn IOService::requestPowerState ( +IOReturn IOService::requestPowerState( const OSSymbol * client, uint32_t state ) { - IOPMRequest * request; + IOPMRequest * request; if (!client) return kIOReturnBadArgument; - if (!initialized) - return kIOPMNotYetInitialized; + if (!initialized) + return kIOPMNotYetInitialized; - request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState ); - if (!request) - return kIOReturnNoMemory; + request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState ); + if (!request) + return kIOReturnNoMemory; client->retain(); - request->fArg0 = (void *) state; - request->fArg1 = (void *) client; + request->fArg0 = (void *)(uintptr_t) state; + request->fArg1 = (void *) client; request->fArg2 = 0; #if NOT_READY 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 = max(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 ); + submitPMRequest( request ); return IOPMNoErr; } @@ -2375,21 +2445,21 @@ IOReturn IOService::requestPowerState ( // [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; - PM_ASSERT_IN_GATE(); - if (request->fArg2) - { - assert(fTempClampCount != 0); - if (fTempClampCount) fTempClampCount--; - if (!fTempClampCount) fTempClampPowerState = 0; - } + PM_ASSERT_IN_GATE(); + if (request->fArg2) + { + assert(fTempClampCount != 0); + if (fTempClampCount) fTempClampCount--; + if (!fTempClampCount) fTempClampPowerState = kPowerStateZero; + } - if (fNumberOfPowerStates && (state >= fNumberOfPowerStates)) - state = fNumberOfPowerStates - 1; + if (fNumberOfPowerStates && (state >= fNumberOfPowerStates)) + state = fHighestPowerState; // The power suppression due to changePowerStateWithOverrideTo() expires // upon the next "device" power request - changePowerStateToPriv(). @@ -2398,15 +2468,15 @@ void IOService::handleRequestPowerState ( IOPMRequest * request ) (client == gIOPMPowerClientDevice)) fOverrideMaxPowerState = kIOPMPowerStateMax; - if ((state == 0) && - (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(); + adjustPowerState(); client->release(); } @@ -2416,13 +2486,18 @@ void IOService::handleRequestPowerState ( IOPMRequest * request ) 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); @@ -2432,6 +2507,8 @@ void IOService::updatePowerClient( const OSSymbol * client, uint32_t powerState num->release(); } } + + PM_ACTION_3(actionUpdatePowerClient, client, oldPowerState, powerState); } } @@ -2443,7 +2520,7 @@ void IOService::removePowerClient( const OSSymbol * client ) uint32_t IOService::getPowerStateForClient( const OSSymbol * client ) { - uint32_t powerState = 0; + uint32_t powerState = kPowerStateZero; if (fPowerClients && client) { @@ -2457,24 +2534,24 @@ uint32_t IOService::getPowerStateForClient( const OSSymbol * client ) // [protected] powerOverrideOnPriv //********************************************************************************* -IOReturn IOService::powerOverrideOnPriv ( void ) +IOReturn IOService::powerOverrideOnPriv( void ) { - IOPMRequest * request; + IOPMRequest * request; if (!initialized) - return IOPMNotYetInitialized; + 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 ); + submitPMRequest( request ); return IOPMNoErr; } @@ -2482,24 +2559,24 @@ IOReturn IOService::powerOverrideOnPriv ( void ) // [protected] powerOverrideOffPriv //********************************************************************************* -IOReturn IOService::powerOverrideOffPriv ( void ) +IOReturn IOService::powerOverrideOffPriv( void ) { - IOPMRequest * request; + IOPMRequest * request; if (!initialized) - return IOPMNotYetInitialized; + 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 ); + submitPMRequest( request ); return IOPMNoErr; } @@ -2507,44 +2584,43 @@ IOReturn IOService::powerOverrideOffPriv ( void ) // [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; + PM_ASSERT_IN_GATE(); + if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv) + { + OUR_PMLog(kPMLogOverrideOn, 0, 0); + fDeviceOverrideEnabled = true; + } + else + { + OUR_PMLog(kPMLogOverrideOff, 0, 0); + fDeviceOverrideEnabled = false; } - else - { - OUR_PMLog(kPMLogOverrideOff, 0, 0); - fDeviceOverrideEnabled = false; - } - adjustPowerState(); + adjustPowerState(); } //********************************************************************************* // [private] computeDesiredState //********************************************************************************* -void IOService::computeDesiredState ( unsigned long localClamp ) +void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly ) { - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - uint32_t desiredState = 0; - uint32_t newPowerState = 0; + 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. + // Desired power state is always 0 without a controlling driver. - if (!fNumberOfPowerStates) - { - fDesiredPowerState = 0; - //PM_LOG("%s::%s no controlling driver\n", getName(), __FUNCTION__); - return; - } + if (!fNumberOfPowerStates) + { + fDesiredPowerState = kPowerStateZero; + return; + } // Examine the children's desired power state. @@ -2563,8 +2639,7 @@ void IOService::computeDesiredState ( unsigned long localClamp ) } if (connection->childHasRequestedPower()) hasChildren = true; - if (connection->getDesiredDomainState() > desiredState) - desiredState = connection->getDesiredDomainState(); + desiredState = StateMax(connection->getDesiredDomainState(), desiredState); } } iter->release(); @@ -2582,27 +2657,28 @@ void IOService::computeDesiredState ( unsigned long localClamp ) const OSSymbol * client; while ((client = (const OSSymbol *) iter->getNextObject())) { - // Ignore child and driver when override is in effect. + // 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. + // 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()); + assert(desiredState < fNumberOfPowerStates); + PM_LOG1(" %u %s\n", + desiredState, client->getCStringNoCopy()); - newPowerState = max(newPowerState, desiredState); + newPowerState = StateMax(newPowerState, desiredState); if (client == gIOPMPowerClientDevice) fDeviceDesire = desiredState; @@ -2612,55 +2688,48 @@ void IOService::computeDesiredState ( unsigned long localClamp ) // Factor in the temporary power desires. - newPowerState = max(newPowerState, localClamp); - newPowerState = max(newPowerState, fTempClampPowerState); + newPowerState = StateMax(newPowerState, localClamp); + newPowerState = StateMax(newPowerState, fTempClampPowerState); // Limit check against max power override. - newPowerState = min(newPowerState, fOverrideMaxPowerState); + newPowerState = StateMin(newPowerState, fOverrideMaxPowerState); // Limit check against number of power states. if (newPowerState >= fNumberOfPowerStates) - newPowerState = fNumberOfPowerStates - 1; + 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); + (uint32_t) fCurrentPowerState, newPowerState); - // Restart idle timer if stopped and device desire has increased. - // Or if advisory desire exists. - - if (fIdleTimerStopped) + if (!computeOnly) { - if (fDeviceDesire > 0) - { - fIdleTimerStopped = false; - fActivityTickleCount = 0; - clock_get_uptime(&fIdleTimerStartTime); - start_PM_idle_timer(); - } - else if (fHasAdvisoryDesire) + // Restart idle timer if possible when device desire has increased. + // Or if an advisory desire exists. + + if (fIdleTimerPeriod && fIdleTimerStopped) { - fIdleTimerStopped = false; - start_PM_idle_timer(); + restartIdleTimer(); } - } - // Invalidate cached tickle power state when desires change, and not - // due to a tickle request. This invalidation must occur before the - // power state change to minimize races. We want to err on the side - // of servicing more activity tickles rather than dropping one when - // the device is in a low power state. + // 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); + if ((getPMRequestType() != kIOPMRequestTypeActivityTickle) && + (fActivityTicklePowerState != kInvalidTicklePowerState)) + { + IOLockLock(fActivityLock); + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); + } } } @@ -2669,7 +2738,7 @@ void IOService::computeDesiredState ( unsigned long localClamp ) // //********************************************************************************* -unsigned long IOService::currentPowerConsumption ( void ) +unsigned long IOService::currentPowerConsumption( void ) { if (!initialized) return kIOPMUnknown; @@ -2681,9 +2750,9 @@ unsigned long IOService::currentPowerConsumption ( void ) // [deprecated] getPMworkloop //********************************************************************************* -IOWorkLoop * IOService::getPMworkloop ( void ) +IOWorkLoop * IOService::getPMworkloop( void ) { - return gIOPMWorkLoop; + return gIOPMWorkLoop; } #if NOT_YET @@ -2693,13 +2762,13 @@ IOWorkLoop * IOService::getPMworkloop ( void ) //********************************************************************************* static void -applyToPowerChildren( +applyToPowerChildren( IOService * service, IOServiceApplierFunction applier, void * context, IOOptionBits options ) { - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); IORegistryEntry * entry; IORegistryIterator * iter; @@ -2727,13 +2796,13 @@ applyToPowerChildren( } static void -applyToPowerParent( +applyToPowerParent( IOService * service, IOServiceApplierFunction applier, void * context, IOOptionBits options ) { - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); IORegistryEntry * entry; IORegistryIterator * iter; @@ -2781,19 +2850,20 @@ 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; + IOPMRequest * request; + bool noPowerChange = true; + uint32_t tickleFlags; if (!initialized) return true; // no power change - if ((type == kIOPMSuperclassPolicy1) && stateNumber) - { + 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++; @@ -2801,55 +2871,58 @@ bool IOService::activityTickle ( unsigned long type, unsigned long stateNumber ) 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 < (int)stateNumber) - { - fActivityTicklePowerState = stateNumber; - noPowerChange = false; - - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *) stateNumber; // power state - request->fArg1 = (void *) true; // power rise - request->fArg2 = (void *) false; // regular tickle - submitPMRequest(request); - } - } + 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); - } + IOLockUnlock(fActivityLock); + } else if ((type == kIOPMActivityTickleTypeAdvisory) && - ((stateNumber = fDeviceUsablePowerState))) + ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero)) { IOLockLock(fActivityLock); fAdvisoryTickled = true; - if (fAdvisoryTicklePowerState != (int)stateNumber) - { - fAdvisoryTicklePowerState = stateNumber; - noPowerChange = false; - - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *) stateNumber; // power state - request->fArg1 = (void *) true; // power rise - request->fArg2 = (void *) true; // advisory tickle - submitPMRequest(request); - } - } + 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; } @@ -2858,19 +2931,34 @@ bool IOService::activityTickle ( unsigned long type, unsigned long stateNumber ) // [private] handleActivityTickle //********************************************************************************* -void IOService::handleActivityTickle ( IOPMRequest * request ) +void IOService::handleActivityTickle( IOPMRequest * request ) { - uint32_t ticklePowerState = (uint32_t)(uintptr_t) request->fArg0; - bool deviceWasActive = (request->fArg1 == (void *) true); - bool isRegularTickle = (request->fArg2 == (void *) false); + 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 (isRegularTickle) + + 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) { - if (deviceWasActive) + IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire); + uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop + + if (tickleFlags & kTickleTypePowerRise) { - if ((ticklePowerState > fDeviceDesire) && + if ((StateOrder(ticklePowerState) > deviceDesireOrder) && (ticklePowerState < fNumberOfPowerStates)) { fIdleTimerMinPowerState = ticklePowerState; @@ -2878,7 +2966,8 @@ void IOService::handleActivityTickle ( IOPMRequest * request ) adjustPower = true; } } - else if (fDeviceDesire > fIdleTimerMinPowerState) + 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. @@ -2887,14 +2976,18 @@ void IOService::handleActivityTickle ( IOPMRequest * request ) // system wakes up to doze state, while the device is unable to // raise its power state to satisfy the tickle. - ticklePowerState = fDeviceDesire - 1; - updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); - adjustPower = true; + deviceDesireOrder--; + if (deviceDesireOrder < fNumberOfPowerStates) + { + ticklePowerState = fPowerStates[deviceDesireOrder].stateOrderToIndex; + updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); + adjustPower = true; + } } } else // advisory tickle { - if (deviceWasActive) + if (tickleFlags & kTickleTypePowerRise) { if ((ticklePowerState == fDeviceUsablePowerState) && (ticklePowerState < fNumberOfPowerStates)) @@ -2919,10 +3012,10 @@ void IOService::handleActivityTickle ( IOPMRequest * request ) } } - if (adjustPower) - { - adjustPowerState(); - } + if (adjustPower) + { + adjustPowerState(); + } } //****************************************************************************** @@ -2932,10 +3025,10 @@ 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; + return IOPMNotYetInitialized; OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod); @@ -2953,7 +3046,7 @@ IOReturn IOService::setIdleTimerPeriod ( unsigned long period ) IOReturn IOService::setIgnoreIdleTimer( bool ignore ) { if (!initialized) - return IOPMNotYetInitialized; + return IOPMNotYetInitialized; OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0); @@ -2977,7 +3070,7 @@ IOReturn IOService::setIgnoreIdleTimer( bool ignore ) SInt32 IOService::nextIdleTimeout( AbsoluteTime currentTime, - AbsoluteTime lastActivity, + AbsoluteTime lastActivity, unsigned int powerState) { AbsoluteTime delta; @@ -2988,7 +3081,7 @@ SInt32 IOService::nextIdleTimeout( // 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); @@ -2998,7 +3091,7 @@ SInt32 IOService::nextIdleTimeout( delay_secs = (int) fIdleTimerPeriod - delta_secs; else delay_secs = (int) fIdleTimerPeriod; - + return (SInt32)delay_secs; } @@ -3006,16 +3099,16 @@ SInt32 IOService::nextIdleTimeout( // [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; + boolean_t pending; - if (!initialized || !fIdleTimerPeriod) - return; + if (!initialized || !fIdleTimerPeriod) + return; IOLockLock(fActivityLock); @@ -3037,6 +3130,9 @@ void IOService::start_PM_idle_timer ( void ) IOLockUnlock(fActivityLock); + fNextIdleTimerPeriod = idle_in; + fIdleTimerStartTime = uptime; + retain(); clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline); ADD_ABSOLUTETIME(&deadline, &uptime); @@ -3044,23 +3140,46 @@ void IOService::start_PM_idle_timer ( void ) if (pending) release(); } +//********************************************************************************* +// [private] restartIdleTimer +//********************************************************************************* + +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; + } +} + //********************************************************************************* // idle_timer_expired //********************************************************************************* static void -idle_timer_expired ( +idle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) { - IOService * me = (IOService *) arg0; + IOService * me = (IOService *) arg0; - if (gIOPMWorkLoop) - gIOPMWorkLoop->runAction( + if (gIOPMWorkLoop) + gIOPMWorkLoop->runAction( OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::idleTimerExpired), me); - me->release(); + me->release(); } //********************************************************************************* @@ -3073,44 +3192,50 @@ idle_timer_expired ( void IOService::idleTimerExpired( void ) { - IOPMRequest * request; - bool restartTimer = true; + IOPMRequest * request; + bool restartTimer = true; + uint32_t tickleFlags; - if ( !initialized || !fIdleTimerPeriod || fLockedFlags.PMStop ) + if ( !initialized || !fIdleTimerPeriod || fIdleTimerStopped || + fLockedFlags.PMStop ) return; - IOLockLock(fActivityLock); + fIdleTimerStartTime = 0; - // Check for device activity (tickles) over last timer period. + IOLockLock(fActivityLock); + + // 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 (-1) 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 > 0) - fActivityTicklePowerState--; + if ((fActivityTicklePowerState != kInvalidTicklePowerState) && + (fActivityTicklePowerState != kPowerStateZero)) + fActivityTicklePowerState--; - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *) 0; // power state (irrelevant) - request->fArg1 = (void *) false; // timer expiration (not tickle) - request->fArg2 = (void *) false; // regular tickle - 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) @@ -3122,25 +3247,26 @@ void IOService::idleTimerExpired( void ) // Want new tickles to turn into pm request after we drop the lock fAdvisoryTicklePowerState = kInvalidTicklePowerState; - request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); - if (request) - { - request->fArg0 = (void *) 0; // power state (irrelevant) - request->fArg1 = (void *) false; // timer expiration (not tickle) - request->fArg2 = (void *) true; // advisory tickle - submitPMRequest( request ); + 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. + // Do not restart timer until after the tickle request has been + // processed. - restartTimer = false; - } + restartTimer = false; + } } - IOLockUnlock(fActivityLock); + IOLockUnlock(fActivityLock); - if (restartTimer) - start_PM_idle_timer(); + if (restartTimer) + start_PM_idle_timer(); } #ifndef __LP64__ @@ -3148,7 +3274,7 @@ void IOService::idleTimerExpired( void ) // [deprecated] PM_idle_timer_expiration //********************************************************************************* -void IOService::PM_idle_timer_expiration ( void ) +void IOService::PM_idle_timer_expiration( void ) { } @@ -3156,7 +3282,7 @@ 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__ */ @@ -3168,7 +3294,7 @@ 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; } @@ -3179,13 +3305,13 @@ IOReturn IOService::setAggressiveness ( unsigned long type, unsigned long newLev // 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(); if (!rootDomain) return kIOReturnNotReady; - + return rootDomain->getAggressiveness( type, currentLevel ); } @@ -3194,10 +3320,10 @@ IOReturn IOService::getAggressiveness ( unsigned long type, unsigned long * curr // //********************************************************************************* -UInt32 IOService::getPowerState ( void ) +UInt32 IOService::getPowerState( void ) { if (!initialized) - return 0; + return kPowerStateZero; return fCurrentPowerState; } @@ -3210,12 +3336,12 @@ UInt32 IOService::getPowerState ( void ) // power domains will pass it on to their children, etc. //********************************************************************************* -IOReturn IOService::systemWake ( void ) +IOReturn IOService::systemWake( void ) { - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - IOService * theChild; + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOService * theChild; iter = getChildIterator(gIOPowerPlane); if ( iter ) @@ -3224,17 +3350,17 @@ IOReturn IOService::systemWake ( void ) { if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) { - if (connection->getReadyFlag() == false) - { - PM_LOG3("[%s] %s: connection not ready\n", - getName(), __FUNCTION__); - continue; - } + 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->systemWake(); theChild->release(); } } @@ -3257,11 +3383,11 @@ IOReturn IOService::systemWake ( void ) // [deprecated] temperatureCriticalForZone //********************************************************************************* -IOReturn IOService::temperatureCriticalForZone ( IOService * whichZone ) +IOReturn IOService::temperatureCriticalForZone( IOService * whichZone ) { - IOService * theParent; - IOService * theNub; - + IOService * theParent; + IOService * theNub; + OUR_PMLog(kPMLogCriticalTemp, 0, 0); if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT ) @@ -3298,8 +3424,8 @@ IOReturn IOService::startPowerChange( IOPowerConnection * parentConnection, IOPMPowerFlags parentFlags ) { - PM_ASSERT_IN_GATE(); - assert( fMachineState == kIOPM_Finished ); + PM_ASSERT_IN_GATE(); + assert( fMachineState == kIOPM_Finished ); assert( powerState < fNumberOfPowerStates ); if (powerState >= fNumberOfPowerStates) @@ -3308,41 +3434,66 @@ IOReturn IOService::startPowerChange( fIsPreChange = true; PM_ACTION_2(actionPowerChangeOverride, &powerState, &changeFlags); - // Forks to either Driver or Parent initiated power change paths. + 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; + fHeadNotePowerArrayEntry = &fPowerStates[ powerState ]; + fHeadNoteParentConnection = NULL; - if (changeFlags & kIOPMSelfInitiated) - { + if (changeFlags & kIOPMSelfInitiated) + { if (changeFlags & kIOPMSynchronize) OurSyncStart(); else OurChangeStart(); - return 0; - } - else - { - assert(changeFlags & kIOPMParentInitiated); + return 0; + } + else + { + assert(changeFlags & kIOPMParentInitiated); fHeadNoteDomainFlags = domainFlags; - fHeadNoteParentFlags = parentFlags; + fHeadNoteParentFlags = parentFlags; fHeadNoteParentConnection = parentConnection; - return ParentChangeStart(); - } + return ParentChangeStart(); + } } //********************************************************************************* // [private] notifyInterestedDrivers //********************************************************************************* -bool IOService::notifyInterestedDrivers ( void ) +bool IOService::notifyInterestedDrivers( void ) { - IOPMinformee * informee; - IOPMinformeeList * list = fInterestedDrivers; - DriverCallParam * param; - IOItemCount count; + IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; + DriverCallParam * param; + IOItemCount count; PM_ASSERT_IN_GATE(); assert( fDriverCallParamCount == 0 ); @@ -3352,7 +3503,7 @@ bool IOService::notifyInterestedDrivers ( void ) count = list->numberOfItems(); if (!count) - goto done; // no interested drivers + 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 @@ -3372,7 +3523,7 @@ bool IOService::notifyInterestedDrivers ( void ) param = IONew(DriverCallParam, count); if (!param) - goto done; // no memory + goto done; // no memory fDriverCallParamPtr = (void *) param; fDriverCallParamSlots = count; @@ -3407,41 +3558,41 @@ done: // [private] notifyInterestedDriversDone //********************************************************************************* -void IOService::notifyInterestedDriversDone ( void ) +void IOService::notifyInterestedDriversDone( void ) { - IOPMinformee * informee; - IOItemCount count; + IOPMinformee * informee; + IOItemCount count; DriverCallParam * param; IOReturn result; - PM_ASSERT_IN_GATE(); - assert( fDriverCallBusy == false ); - assert( fMachineState == kIOPM_DriverThreadCallDone ); + PM_ASSERT_IN_GATE(); + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); - param = (DriverCallParam *) fDriverCallParamPtr; - count = fDriverCallParamCount; + param = (DriverCallParam *) fDriverCallParamPtr; + count = fDriverCallParamCount; - if (param && count) - { - for (IOItemCount i = 0; i < count; i++, param++) - { - informee = (IOPMinformee *) param->Target; - result = param->Result; + 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 ((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) + if (fHeadNotePendingAcks && informee->timer) fHeadNotePendingAcks--; informee->timer = 0; - } - else if (informee->timer) - { + } + else if (informee->timer) + { assert(informee->timer == -1); // Driver has not acked, and has returned a positive result. @@ -3455,56 +3606,88 @@ void IOService::notifyInterestedDriversDone ( void ) result = kMinAckTimeoutTicks; informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; - } - // else, child has already acked or driver has removed interest, + } + // 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, + // informee may have been removed from the interested drivers list, // thus the informee must be retained across the callout. - informee->release(); - } + 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(); + } + } - MS_POP(); // pushed by notifyAll() + MS_POP(); // pop the machine state passed to notifyAll() - // If interest acks are outstanding, wait for fHeadNotePendingAcks to become - // zero before notifying children. This enforces the children after interest - // ordering even for async interest clients. + // 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) { - notifyChildren(); + notifyRootDomain(); } else { MS_PUSH(fMachineState); fMachineState = kIOPM_NotifyChildrenStart; - PM_LOG2("%s: %u outstanding async interest\n", - getName(), fHeadNotePendingAcks); } } +//********************************************************************************* +// [private] notifyRootDomain +//********************************************************************************* + +void IOService::notifyRootDomain( void ) +{ + assert( fDriverCallBusy == false ); + + // 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; + + // Call IOPMrootDomain::willNotifyPowerChildren() on a thread call + // to avoid a deadlock. + fDriverCallReason = kRootDomainInformPreChange; + fDriverCallBusy = true; + thread_call_enter( fDriverCallEntry ); +} + +void IOService::notifyRootDomainDone( void ) +{ + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); + + MS_POP(); // pop notifyAll() machine state + notifyChildren(); +} + //********************************************************************************* // [private] notifyChildren //********************************************************************************* -void IOService::notifyChildren ( void ) +void IOService::notifyChildren( void ) { - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - OSArray * children = 0; + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + OSArray * children = 0; IOPMrootDomain * rootDomain; bool delayNotify = false; - + if ((fHeadNotePowerState != fCurrentPowerState) && (IS_POWER_DROP == fIsPreChange) && ((rootDomain = getPMRootDomain()) == this)) @@ -3514,8 +3697,8 @@ void IOService::notifyChildren ( void ) kIOPMTracePointWakePowerPlaneDrivers ); } - if (fStrictTreeOrder) - children = OSArray::withCapacity(8); + if (fStrictTreeOrder) + children = OSArray::withCapacity(8); // Sum child power consumption in notifyChild() fHeadNotePowerArrayEntry->staticPower = 0; @@ -3527,19 +3710,19 @@ void IOService::notifyChildren ( void ) { if ((connection = OSDynamicCast(IOPowerConnection, next))) { - if (connection->getReadyFlag() == false) - { - PM_LOG3("[%s] %s: connection not ready\n", - getName(), __FUNCTION__); - continue; - } + 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) && + connection->delayChildNotification && getPMRootDomain()->shouldDelayChildNotification(this)) { if (!children) @@ -3555,11 +3738,11 @@ void IOService::notifyChildren ( void ) } } - if (!delayNotify && children) - children->setObject( connection ); - else - notifyChild( connection ); - } + if (!delayNotify && children) + children->setObject( connection ); + else + notifyChild( connection ); + } } iter->release(); } @@ -3569,92 +3752,101 @@ void IOService::notifyChildren ( void ) children->release(); children = 0; } - if (children) - { + if (children) + { assert(fNotifyChildArray == 0); - fNotifyChildArray = children; + fNotifyChildArray = children; MS_PUSH(fMachineState); if (delayNotify) { - // Wait for exiting child notifications to complete, - // before notifying the children in the array. + // 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 ) -{ - 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. - - if (fNotifyChildArray->getCount()) - { - IOPowerConnection * connection; - connection = (IOPowerConnection *) fNotifyChildArray->getObject(0); - notifyChild( connection ); - fNotifyChildArray->removeObject(0); - } - else - { - fNotifyChildArray->release(); - fNotifyChildArray = 0; +void IOService::notifyChildrenOrdered( void ) +{ + 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. + + if (fNotifyChildArray->getCount()) + { + IOPowerConnection * connection; + connection = (IOPowerConnection *) fNotifyChildArray->getObject(0); + notifyChild( connection ); + fNotifyChildArray->removeObject(0); + } + else + { + fNotifyChildArray->release(); + fNotifyChildArray = 0; 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. When explicitly cancelled, interest - // acks (and ack timer) may still be outstanding. + // 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); + connection = (IOPowerConnection *) fNotifyChildArray->getObject(i); if (!connection) break; - notifyChild( connection ); + notifyChild( connection ); } PM_LOG2("%s: notified delayed children\n", getName()); fNotifyChildArray->release(); fNotifyChildArray = 0; - + MS_POP(); // pushed by notifyChildren() } @@ -3662,20 +3854,20 @@ void IOService::notifyChildrenDelayed ( void ) // [private] notifyAll //********************************************************************************* -IOReturn IOService::notifyAll ( uint32_t nextMS ) +IOReturn IOService::notifyAll( uint32_t nextMS ) { - // Save the next machine_state to be restored by notifyInterestedDriversDone() + // Save the machine state to be restored by notifyInterestedDriversDone() - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); MS_PUSH(nextMS); - fMachineState = kIOPM_DriverThreadCallDone; - fDriverCallReason = fIsPreChange ? - kDriverCallInformPreChange : kDriverCallInformPostChange; + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = fIsPreChange ? + kDriverCallInformPreChange : kDriverCallInformPostChange; - if (!notifyInterestedDrivers()) - notifyInterestedDriversDone(); + if (!notifyInterestedDrivers()) + notifyInterestedDriversDone(); - return IOPMWillAckLater; + return IOPMWillAckLater; } //********************************************************************************* @@ -3684,10 +3876,10 @@ 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; @@ -3700,28 +3892,32 @@ IOReturn IOService::actionDriverCalloutDone ( 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; - default: - panic("IOService::pmDriverCallout bad machine state %x", + 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 ); } //********************************************************************************* @@ -3730,10 +3926,10 @@ void IOService::pmDriverCallout ( IOService * from ) // Thread call context //********************************************************************************* -void IOService::driverSetPowerState ( void ) +void IOService::driverSetPowerState( void ) { IOPMPowerStateIndex powerState; - DriverCallParam * param; + DriverCallParam * param; IOPMDriverCallEntry callEntry; AbsoluteTime end; IOReturn result; @@ -3749,17 +3945,26 @@ void IOService::driverSetPowerState ( void ) 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, this, fCurrentPowerState, powerState, result); + fName, OBFUSCATE(this), fCurrentPowerState, powerState, result); } #if LOG_SETPOWER_TIMES @@ -3769,21 +3974,11 @@ void IOService::driverSetPowerState ( void ) SUB_ABSOLUTETIME(&end, &fDriverCallStartTime); absolutetime_to_nanoseconds(end, &nsec); - if (nsec > LOG_SETPOWER_TIMES) - PM_LOG("%s::setPowerState(%p, %lu -> %lu) took %d ms\n", - fName, this, fCurrentPowerState, powerState, NS_TO_MS(nsec)); - - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeSetPowerStateImmediate, // type - fName, // who - (uintptr_t)this, // owner unique - NULL, // interest name - (uint8_t)oldPowerState, // old - (uint8_t)powerState, // new - 0, // result - NS_TO_US(nsec)); // usec completion time - - getPMRootDomain()->recordAndReleasePMEventGated( details ); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, + fName, kDriverCallSetPowerState, NS_TO_MS(nsec), 0, NULL, powerState); + } } #endif } @@ -3799,17 +3994,17 @@ void IOService::driverSetPowerState ( void ) // Thread call context //********************************************************************************* -void IOService::driverInformPowerChange ( void ) +void IOService::driverInformPowerChange( void ) { - IOPMinformee * informee; - IOService * driver; - DriverCallParam * param; + IOPMinformee * informee; + IOService * driver; + DriverCallParam * param; IOPMDriverCallEntry callEntry; - IOPMPowerFlags powerFlags; + IOPMPowerFlags powerFlags; IOPMPowerStateIndex powerState; AbsoluteTime end; IOReturn result; - IOItemCount count; + IOItemCount count; assert( fDriverCallBusy ); assert( fDriverCallParamPtr ); @@ -3831,20 +4026,24 @@ void IOService::driverInformPowerChange ( void ) 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 @@ -3854,27 +4053,11 @@ void IOService::driverInformPowerChange ( void ) SUB_ABSOLUTETIME(&end, &informee->startTime); absolutetime_to_nanoseconds(end, &nsec); - if (nsec > LOG_SETPOWER_TIMES) - PM_LOG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) took %d ms\n", - driver->getName(), - (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did", - driver, fName, fCurrentPowerState, powerState, NS_TO_MS(nsec)); - - uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange) - ? kIOPMEventTypePSWillChangeTo - : kIOPMEventTypePSDidChangeTo; - - PMEventDetails *details = PMEventDetails::eventDetails( - logType, // type - fName, // who - (uintptr_t)this, // owner unique - driver->getName(), // interest name - (uint8_t)fCurrentPowerState, // old - (uint8_t)fHeadNotePowerState, // new - 0, // result - NS_TO_US(nsec)); // usec completion time - - getPMRootDomain()->recordAndReleasePMEventGated( details ); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, driver->getName(), + fDriverCallReason, NS_TO_MS(nsec), 0, NULL, powerState); + } } #endif } @@ -3893,16 +4076,16 @@ void IOService::driverInformPowerChange ( void ) // If the object acknowledges the current change, we return TRUE. //********************************************************************************* -bool IOService::notifyChild ( IOPowerConnection * theNub ) +bool IOService::notifyChild( IOPowerConnection * theNub ) { IOReturn ret = IOPMAckImplied; unsigned long childPower; IOService * theChild; - IOPMRequest * childRequest; + IOPMRequest * childRequest; IOPMPowerChangeFlags requestArg2; - int requestType; + int requestType; - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane)); if (!theChild) { @@ -3911,32 +4094,32 @@ bool IOService::notifyChild ( IOPowerConnection * theNub ) // Unless the child handles the notification immediately and returns // kIOPMAckImplied, we'll be awaiting their acknowledgement later. - fHeadNotePendingAcks++; + fHeadNotePendingAcks++; theNub->setAwaitingAck(true); requestArg2 = fHeadNoteChangeFlags; - if (fHeadNotePowerState < fCurrentPowerState) + if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) requestArg2 |= kIOPMDomainPowerDrop; requestType = fIsPreChange ? kIOPMRequestTypePowerDomainWillChange : kIOPMRequestTypePowerDomainDidChange; - childRequest = acquirePMRequest( theChild, requestType ); - if (childRequest) - { + childRequest = acquirePMRequest( theChild, requestType ); + if (childRequest) + { theNub->retain(); - childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags; - childRequest->fArg1 = (void *) theNub; - childRequest->fArg2 = (void *) requestArg2; - theChild->submitPMRequest( childRequest ); - ret = IOPMWillAckLater; - } - else - { - ret = IOPMAckImplied; - fHeadNotePendingAcks--; - theNub->setAwaitingAck(false); + 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 ) { @@ -3948,16 +4131,16 @@ bool IOService::notifyChild ( IOPowerConnection * theNub ) } theChild->release(); - return (IOPMAckImplied == ret); + return (IOPMAckImplied == ret); } //********************************************************************************* // [private] notifyControllingDriver //********************************************************************************* -bool IOService::notifyControllingDriver ( void ) +bool IOService::notifyControllingDriver( void ) { - DriverCallParam * param; + DriverCallParam * param; PM_ASSERT_IN_GATE(); assert( fDriverCallParamCount == 0 ); @@ -3980,7 +4163,7 @@ bool IOService::notifyControllingDriver ( void ) { param = IONew(DriverCallParam, 1); if (!param) - return false; // no memory + return false; // no memory fDriverCallParamPtr = (void *) param; fDriverCallParamSlots = 1; @@ -4004,28 +4187,28 @@ bool IOService::notifyControllingDriver ( 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)) - { + if ((result == IOPMAckImplied) || (result < 0)) + { fDriverTimer = 0; - } - else if (fDriverTimer) - { + } + else if (fDriverTimer) + { assert(fDriverTimer == -1); // Driver has not acked, and has returned a positive result. @@ -4039,17 +4222,17 @@ void IOService::notifyControllingDriverDone( void ) result = kMinAckTimeoutTicks; fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; - } - // else, child has already acked and driver_timer reset to 0. + } + // 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(); + } + } MS_POP(); // pushed by OurChangeSetPowerState() fIsPreChange = false; @@ -4061,13 +4244,14 @@ void IOService::notifyControllingDriverDone( void ) // A power change is done. //********************************************************************************* -void IOService::all_done ( void ) +void IOService::all_done( void ) { IOPMPowerStateIndex prevPowerState; const IOPMPSEntry * powerStatePtr; IOPMDriverCallEntry callEntry; uint32_t prevMachineState = fMachineState; - bool callAction = false; + bool actionCalled = false; + uint64_t ts; fMachineState = kIOPM_Finished; @@ -4088,8 +4272,13 @@ void IOService::all_done ( void ) } else if (fAdvisoryTickleUsed) { - // Not root domain and advisory tickle target + // 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)) { @@ -4107,19 +4296,19 @@ void IOService::all_done ( void ) } // our power change - if ( fHeadNoteChangeFlags & kIOPMSelfInitiated ) + if (fHeadNoteChangeFlags & kIOPMSelfInitiated) { - // could our driver switch to the new state? - if ( !( fHeadNoteChangeFlags & kIOPMNotDone) ) + // power state changed + if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) { trackSystemSleepPreventers( fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); - // we changed, tell our parent + // we changed, tell our parent requestDomainPower(fHeadNotePowerState); // yes, did power raise? - if ( fCurrentPowerState < fHeadNotePowerState ) + if ( StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState) ) { // yes, inform clients and apps tellChangeUp (fHeadNotePowerState); @@ -4127,19 +4316,31 @@ void IOService::all_done ( void ) 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; #endif - OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, 0); + OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); PM_ACTION_2(actionPowerChangeDone, fHeadNotePowerState, fHeadNoteChangeFlags); - callAction = true; + 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)) @@ -4155,19 +4356,20 @@ void IOService::all_done ( void ) } } - // parent's power change - if ( fHeadNoteChangeFlags & kIOPMParentInitiated) + // parent-initiated power change + if (fHeadNoteChangeFlags & kIOPMParentInitiated) { - if (((fHeadNoteChangeFlags & kIOPMDomainWillChange) && - (fCurrentPowerState >= fHeadNotePowerState)) || - ((fHeadNoteChangeFlags & kIOPMDomainDidChange) && - (fCurrentPowerState < fHeadNotePowerState))) + if (fHeadNoteChangeFlags & kIOPMRootChangeDown) + ParentChangeRootChangeDown(); + + // power state changed + if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) { trackSystemSleepPreventers( fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); // did power raise? - if ( fCurrentPowerState < fHeadNotePowerState ) + if ( StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState) ) { // yes, inform clients and apps tellChangeUp (fHeadNotePowerState); @@ -4175,15 +4377,20 @@ void IOService::all_done ( void ) // 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; #endif - fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fHeadNoteDomainFlags); - OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, 0); + OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); PM_ACTION_2(actionPowerChangeDone, fHeadNotePowerState, fHeadNoteChangeFlags); - callAction = true; + actionCalled = true; powerStatePtr = &fPowerStates[fCurrentPowerState]; fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; @@ -4203,12 +4410,12 @@ void IOService::all_done ( void ) // When power rises enough to satisfy the tickle's desire for more power, // the condition preventing idle-timer from dropping power is removed. - if (fCurrentPowerState >= fIdleTimerMinPowerState) + if (StateOrder(fCurrentPowerState) >= StateOrder(fIdleTimerMinPowerState)) { - fIdleTimerMinPowerState = 0; + fIdleTimerMinPowerState = kPowerStateZero; } - if (!callAction) + if (!actionCalled) { PM_ACTION_2(actionPowerChangeDone, fHeadNotePowerState, fHeadNoteChangeFlags); @@ -4224,16 +4431,16 @@ void IOService::all_done ( void ) // Begin the processing of a power change initiated by us. //********************************************************************************* -void IOService::OurChangeStart ( void ) +void IOService::OurChangeStart( void ) { - PM_ASSERT_IN_GATE(); + 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. + // 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 && (fMaxPowerState < fHeadNotePowerState)) + if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState))) { fHeadNoteChangeFlags |= kIOPMNotDone; requestDomainPower(fHeadNotePowerState); @@ -4241,12 +4448,12 @@ void IOService::OurChangeStart ( void ) return; } - // Redundant power changes skips to the end of the state machine. + // Redundant power changes skips to the end of the state machine. if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState)) - { - OurChangeFinish(); - return; + { + OurChangeFinish(); + return; } fInitialPowerChange = false; @@ -4255,8 +4462,8 @@ void IOService::OurChangeStart ( void ) 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. + // 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) { @@ -4267,8 +4474,8 @@ void IOService::OurChangeStart ( void ) fOutOfBandParameter = kNotifyApps; askChangeDown(fHeadNotePowerState); } - else - { + 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. @@ -4297,6 +4504,10 @@ void IOService::OurChangeStart ( void ) } } +//********************************************************************************* +// [private] requestDomainPowerApplier +// +// Call requestPowerDomainState() on all power parents. //********************************************************************************* struct IOPMRequestDomainPowerContext { @@ -4335,6 +4546,10 @@ requestDomainPowerApplier( //********************************************************************************* // [private] requestDomainPower +// +// Called by a power child to broadcast its desired power state to all parents. +// If the child self-initiates a power change, it must call this function to +// allow its parents to adjust power state. //********************************************************************************* IOReturn IOService::requestDomainPower( @@ -4345,17 +4560,17 @@ IOReturn IOService::requestDomainPower( IOPMPowerStateIndex maxPowerState; IOPMRequestDomainPowerContext context; - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); assert(ourPowerState < fNumberOfPowerStates); if (ourPowerState >= fNumberOfPowerStates) return kIOReturnBadArgument; if (IS_PM_ROOT) return kIOReturnSuccess; - // Fetch the input power flags for the requested power state. + // Fetch our input power flags for the requested power state. // Parent request is stated in terms of required power flags. - requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags; + requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags; // Disregard the "previous request" for power reservation. @@ -4367,6 +4582,7 @@ IOReturn IOService::requestDomainPower( } fPreviousRequestPowerFlags = requestPowerFlags; + // The results will be collected by fHeadNoteDomainTargetFlags context.child = this; context.requestPowerFlags = requestPowerFlags; fHeadNoteDomainTargetFlags = 0; @@ -4377,7 +4593,7 @@ IOReturn IOService::requestDomainPower( maxPowerState = fControllingDriver->maxCapabilityForDomainState( fHeadNoteDomainTargetFlags ); - if (maxPowerState < fHeadNotePowerState) + if (StateOrder(maxPowerState) < StateOrder(ourPowerState)) { PM_LOG1("%s: power desired %u:0x%x got %u:0x%x\n", getName(), @@ -4395,9 +4611,9 @@ done: // [private] OurSyncStart //********************************************************************************* -void IOService::OurSyncStart ( void ) +void IOService::OurSyncStart( void ) { - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); if (fInitialPowerChange) return; @@ -4406,8 +4622,8 @@ void IOService::OurSyncStart ( void ) if (fHeadNoteChangeFlags & kIOPMNotDone) { - OurChangeFinish(); - return; + OurChangeFinish(); + return; } if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown) @@ -4430,15 +4646,35 @@ void IOService::OurSyncStart ( void ) // [private] OurChangeTellClientsPowerDown // // All applications and kernel clients have acknowledged our permission to drop -// power. Here we notify them that we will lower the power and wait for acks. +// power. Here we notify them that we will lower the power and wait for acks. //********************************************************************************* -void IOService::OurChangeTellClientsPowerDown ( void ) +void IOService::OurChangeTellClientsPowerDown( void ) { - fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; + if(!IS_ROOT_DOMAIN) + fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; + else + { + fMachineState = kIOPM_OurChangeTellUserPMPolicyPowerDown; + } tellChangeDown1(fHeadNotePowerState); } +//********************************************************************************* +// [private] OurChangeTellUserPMPolicyPowerDown +// +// All applications and kernel clients have acknowledged our permission to drop +// 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 ) +{ + fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + + tellClientsWithResponse(kIOPMMessageLastCallBeforeSleep); +} + //********************************************************************************* // [private] OurChangeTellPriorityClientsPowerDown // @@ -4446,7 +4682,7 @@ void IOService::OurChangeTellClientsPowerDown ( 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); @@ -4459,7 +4695,7 @@ 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(); @@ -4474,7 +4710,7 @@ void IOService::OurChangeTellCapabilityWillChange ( void ) // Here we notify interested drivers pre-change. //********************************************************************************* -void IOService::OurChangeNotifyInterestedDriversWillChange ( void ) +void IOService::OurChangeNotifyInterestedDriversWillChange( void ) { IOPMrootDomain * rootDomain; if ((rootDomain = getPMRootDomain()) == this) @@ -4482,13 +4718,6 @@ void IOService::OurChangeNotifyInterestedDriversWillChange ( void ) if (IS_POWER_DROP) { rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests ); - - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeAppNotificationsFinished, - NULL, - 100, - kIOReturnSuccess); - rootDomain->recordAndReleasePMEventGated( details ); } else rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests ); @@ -4504,7 +4733,7 @@ void IOService::OurChangeNotifyInterestedDriversWillChange ( void ) // change. Wait for async completions. //********************************************************************************* -void IOService::OurChangeSetPowerState ( void ) +void IOService::OurChangeSetPowerState( void ) { MS_PUSH( kIOPM_OurChangeWaitForPowerSettle ); fMachineState = kIOPM_DriverThreadCallDone; @@ -4521,7 +4750,7 @@ 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(); @@ -4534,7 +4763,7 @@ void IOService::OurChangeWaitForPowerSettle ( void ) // all our interested drivers post-change. //********************************************************************************* -void IOService::OurChangeNotifyInterestedDriversDidChange ( void ) +void IOService::OurChangeNotifyInterestedDriversDidChange( void ) { IOPMrootDomain * rootDomain; if ((rootDomain = getPMRootDomain()) == this) @@ -4553,7 +4782,7 @@ 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(); @@ -4571,7 +4800,7 @@ void IOService::OurChangeTellCapabilityDidChange ( void ) // Done with this self-induced power state change. //********************************************************************************* -void IOService::OurChangeFinish ( void ) +void IOService::OurChangeFinish( void ) { all_done(); } @@ -4585,77 +4814,183 @@ void IOService::OurChangeFinish ( void ) // Here we begin the processing of a power change initiated by our parent. //********************************************************************************* -IOReturn IOService::ParentChangeStart ( void ) +IOReturn IOService::ParentChangeStart( void ) { - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState ); - // Power domain is lowering power - if ( fHeadNotePowerState < fCurrentPowerState ) + // Root power domain has transitioned to its max power state + if ((fHeadNoteChangeFlags & (kIOPMDomainDidChange | kIOPMRootChangeUp)) == + (kIOPMDomainDidChange | kIOPMRootChangeUp)) { - // Piggy-back idle timer cancellation on a parent down - if (0 == fHeadNotePowerState) - ParentChangeCancelIdleTimer(fHeadNotePowerState); - - // TODO: redundant? See handlePowerDomainWillChangeTo() - setParentInfo( fHeadNoteParentFlags, fHeadNoteParentConnection, true ); + // 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; + // Tell apps and kernel clients + fInitialPowerChange = false; fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown; - tellChangeDown1(fHeadNotePowerState); + tellChangeDown1(fHeadNotePowerState); return IOPMWillAckLater; } - // Power domain is raising power - if ( fHeadNotePowerState > fCurrentPowerState ) + // Power domain is allowing us to raise power up to fHeadNotePowerState + if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) ) { - if ( fDesiredPowerState > fCurrentPowerState ) + if ( StateOrder(fDesiredPowerState) > StateOrder(fCurrentPowerState) ) { - if ( fDesiredPowerState < fHeadNotePowerState ) + if ( StateOrder(fDesiredPowerState) < StateOrder(fHeadNotePowerState) ) { // We power up, but not all the way fHeadNotePowerState = fDesiredPowerState; - fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState]; + fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState]; OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); } } else { // We don't need to change fHeadNotePowerState = fCurrentPowerState; - fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState]; + fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState]; OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); } } if ( fHeadNoteChangeFlags & kIOPMDomainDidChange ) - { - if ( fHeadNotePowerState > fCurrentPowerState ) + { + if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) ) { PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); // Parent did change up - start our change up - fInitialPowerChange = false; + fInitialPowerChange = false; ParentChangeTellCapabilityWillChange(); return IOPMWillAckLater; } - else if (fHeadNoteChangeFlags & kIOPMSynchronize) + else if (fHeadNoteChangeFlags & kIOPMRootBroadcastFlags) { - // We do not need to change power state, but notify - // children to propagate tree synchronization. + // 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; } +//****************************************************************************** +// [private] ParentChangeRootChangeDown +// +// Root domain has finished the transition to the system sleep state. And all +// drivers in the power plane should have powered down. Cancel the idle timer, +// and also reset the device desire for those drivers that don't want power +// 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); + } + } +} + //********************************************************************************* // [private] ParentChangeTellPriorityClientsPowerDown // @@ -4663,10 +4998,10 @@ IOReturn IOService::ParentChangeStart ( 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); + tellChangeDown2(fHeadNotePowerState); } //********************************************************************************* @@ -4676,7 +5011,7 @@ 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(); @@ -4691,9 +5026,9 @@ 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 ); } //********************************************************************************* @@ -4703,7 +5038,7 @@ void IOService::ParentChangeNotifyInterestedDriversWillChange ( void ) // change. Wait for async completions. //********************************************************************************* -void IOService::ParentChangeSetPowerState ( void ) +void IOService::ParentChangeSetPowerState( void ) { MS_PUSH( kIOPM_ParentChangeWaitForPowerSettle ); fMachineState = kIOPM_DriverThreadCallDone; @@ -4720,9 +5055,9 @@ 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; + fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange; startSettleTimer(); } @@ -4733,9 +5068,9 @@ void IOService::ParentChangeWaitForPowerSettle ( void ) // all our interested drivers post-change. //********************************************************************************* -void IOService::ParentChangeNotifyInterestedDriversDidChange ( void ) +void IOService::ParentChangeNotifyInterestedDriversDidChange( void ) { - notifyAll( kIOPM_ParentChangeTellCapabilityDidChange ); + notifyAll( kIOPM_ParentChangeTellCapabilityDidChange ); } //********************************************************************************* @@ -4744,7 +5079,7 @@ 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(); @@ -4755,13 +5090,13 @@ void IOService::ParentChangeTellCapabilityDidChange ( void ) //********************************************************************************* // [private] ParentAcknowledgePowerChange // -// Acknowledge our power parent that our power change is done. +// 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(); @@ -4775,72 +5110,6 @@ void IOService::ParentChangeAcknowledgePowerChange ( void ) nub->release(); } -void IOService::ParentChangeCancelIdleTimer( IOPMPowerStateIndex newPowerState ) -{ - AbsoluteTime now; - uint64_t nsec; - bool cancel = false; - - // No ready or idle timer not in use - if (!initialized || !fIdleTimerPeriod || fLockedFlags.PMStop || - !fAdvisoryTickleUsed) - return; - - // Not allowed to induce artifical idle timeout - if (fIdleTimerIgnored || fIdleTimerMinPowerState) - goto done; - - // Idle timer already has no influence - if (!fDesiredPowerState || fIdleTimerStopped) - goto done; - - IOLockLock(fActivityLock); - - if (!fDeviceWasActive) - { - // No tickles since the last idle timer expiration. - // Safe to drop the device desire to zero. - cancel = 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) - { - cancel = true; - } - } - - if (cancel) - { - // Force the next tickle to raise power state - fActivityTicklePowerState = kInvalidTicklePowerState; - fDeviceWasActive = false; - } - - IOLockUnlock(fActivityLock); - - if (cancel) - { - // cancel idle timer - if (fIdleTimer && thread_call_cancel(fIdleTimer)) - release(); - - updatePowerClient(gIOPMPowerClientDevice, 0); - computeDesiredState(); - - fIdleTimerStopped = true; - } - -done: - OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState ); - PM_LOG("%s::%s cancel=%d\n", fName, __FUNCTION__, cancel); -} - // MARK: - // MARK: Ack and Settle timers @@ -4853,8 +5122,8 @@ done: void IOService::settleTimerExpired( void ) { - fSettleTimeUS = 0; - gIOPMWorkQueue->signalWorkAvailable(); + fSettleTimeUS = 0; + gIOPMWorkQueue->signalWorkAvailable(); } //********************************************************************************* @@ -4866,15 +5135,15 @@ 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( + if (gIOPMWorkLoop && gIOPMWorkQueue) + { + gIOPMWorkLoop->runAction( OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired), me); - } - me->release(); + } + me->release(); } //********************************************************************************* @@ -4885,31 +5154,43 @@ settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) 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 i; + IOPMPowerStateIndex stateIndex; + IOPMPowerStateIndex currentOrder, newOrder, i; uint32_t settleTime = 0; - boolean_t pending; + boolean_t pending; + + PM_ASSERT_IN_GATE(); - PM_ASSERT_IN_GATE(); + currentOrder = StateOrder(fCurrentPowerState); + newOrder = StateOrder(fHeadNotePowerState); - i = fCurrentPowerState; + i = currentOrder; // lowering power - if ( fHeadNotePowerState < fCurrentPowerState ) + if ( newOrder < currentOrder ) { - while ( i > fHeadNotePowerState ) + while ( i > newOrder ) { - settleTime += (uint32_t) fPowerStates[i].settleDownTime; + stateIndex = fPowerStates[i].stateOrderToIndex; + settleTime += (uint32_t) fPowerStates[stateIndex].settleDownTime; i--; } } // raising power - if ( fHeadNotePowerState > fCurrentPowerState ) + if ( newOrder > currentOrder ) { - while ( i < fHeadNotePowerState ) + while ( i < newOrder ) { - settleTime += (uint32_t) fPowerStates[i+1].settleUpTime; + stateIndex = fPowerStates[i+1].stateOrderToIndex; + settleTime += (uint32_t) fPowerStates[stateIndex].settleUpTime; i++; } } @@ -4921,6 +5202,7 @@ void IOService::startSettleTimer( void ) pending = thread_call_enter_delayed(fSettleTimer, deadline); if (pending) release(); } +#endif } //********************************************************************************* @@ -4941,16 +5223,16 @@ void IOService::startSettleTimer( void ) #ifndef __LP64__ void IOService::ack_timer_ticked ( void ) { - assert(false); + assert(false); } #endif /* !__LP64__ */ bool IOService::ackTimerTick( void ) { - IOPMinformee * nextObject; - bool done = false; + IOPMinformee * nextObject; + bool done = false; - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); switch (fMachineState) { case kIOPM_OurChangeWaitForPowerSettle: case kIOPM_ParentChangeWaitForPowerSettle: @@ -4966,21 +5248,7 @@ bool IOService::ackTimerTick( void ) OUR_PMLog(kPMLogCtrlDriverTardy, 0, 0); setProperty(kIOPMTardyAckSPSKey, kOSBooleanTrue); PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n", - fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); - -#if LOG_SETPOWER_TIMES - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeSetPowerStateDelayed, // type - fName, // who - (uintptr_t)this, // owner unique - NULL, // interest name - (uint8_t)getPowerState(), // old - 0, // new - kIOReturnTimeout, // result - NS_TO_US(nsec)); // usec completion time - - getPMRootDomain()->recordAndReleasePMEventGated( details ); -#endif + fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); if (gIOKitDebug & kIOLogDebugPower) { @@ -4988,10 +5256,10 @@ bool IOService::ackTimerTick( void ) fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); } else - { - // Unblock state machine and pretend driver has acked. - done = true; - } + { + // Unblock state machine and pretend driver has acked. + done = true; + } } else { // still waiting, set timer again start_ack_timer(); @@ -5020,27 +5288,9 @@ bool IOService::ackTimerTick( void ) PM_ERROR("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) timed out after %d ms\n", nextObject->whatObject->getName(), (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did", - nextObject->whatObject, fName, fCurrentPowerState, fHeadNotePowerState, + OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); -#if LOG_SETPOWER_TIMES - uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange) - ? kIOPMEventTypePSWillChangeTo - : kIOPMEventTypePSDidChangeTo; - - PMEventDetails *details = PMEventDetails::eventDetails( - logType, // type - fName, // who - (uintptr_t)this, // owner unique - nextObject->whatObject->getName(), // interest name - (uint8_t)fCurrentPowerState, // old - (uint8_t)fHeadNotePowerState, // new - kIOReturnTimeout, // result - NS_TO_US(nsec)); // usec completion time - - getPMRootDomain()->recordAndReleasePMEventGated( details ); -#endif - // Pretend driver has acked. fHeadNotePendingAcks--; } @@ -5052,7 +5302,7 @@ bool IOService::ackTimerTick( void ) if ( fHeadNotePendingAcks == 0 ) { // yes, we can continue - done = true; + done = true; } else { // no, set timer again start_ack_timer(); @@ -5062,6 +5312,7 @@ bool IOService::ackTimerTick( void ) // TODO: aggreggate this case kIOPM_OurChangeTellClientsPowerDown: + case kIOPM_OurChangeTellUserPMPolicyPowerDown: case kIOPM_OurChangeTellPriorityClientsPowerDown: case kIOPM_OurChangeNotifyInterestedDriversWillChange: case kIOPM_ParentChangeTellPriorityClientsPowerDown: @@ -5070,52 +5321,138 @@ bool IOService::ackTimerTick( void ) case kIOPM_SyncTellPriorityClientsPowerDown: case kIOPM_SyncNotifyWillChange: case kIOPM_TellCapabilityChangeDone: - // apps didn't respond in time + // apps didn't respond in time cleanClientResponses(true); OUR_PMLog(kPMLogClientTardy, 0, 1); - // tardy equates to approval - done = true; + // tardy equates to approval + done = true; break; default: PM_LOG1("%s: unexpected ack timer tick (state = %d)\n", - getName(), fMachineState); + getName(), fMachineState); break; } - return done; + return done; } //********************************************************************************* -// [private] start_ack_timer +// [private] start_watchdog_timer //********************************************************************************* - -void IOService::start_ack_timer ( void ) +void IOService::start_watchdog_timer( void ) { - start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale ); -} + AbsoluteTime deadline; + boolean_t pending; + static int timeout = -1; -void IOService::start_ack_timer ( UInt32 interval, UInt32 scale ) -{ - AbsoluteTime deadline; - boolean_t pending; + if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) + return; - clock_interval_to_deadline(interval, scale, &deadline); + 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; + } - retain(); - pending = thread_call_enter_delayed(fAckTimer, deadline); - if (pending) release(); -} + clock_interval_to_deadline(timeout, kSecondScale, &deadline); + + retain(); + pending = thread_call_enter_delayed(fWatchdogTimer, deadline); + if (pending) release(); + +} + +//********************************************************************************* +// [private] stop_watchdog_timer +// Returns true if watchdog was enabled and stopped now +//********************************************************************************* + +bool IOService::stop_watchdog_timer( void ) +{ + boolean_t pending; + + if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) + return false; + + pending = thread_call_cancel(fWatchdogTimer); + if (pending) release(); + + return pending; +} + +//********************************************************************************* +// reset_watchdog_timer +//********************************************************************************* + +void IOService::reset_watchdog_timer( void ) +{ + if (stop_watchdog_timer()) + start_watchdog_timer(); +} + + +//********************************************************************************* +// [static] watchdog_timer_expired +// +// Inside PM work loop's gate. +//********************************************************************************* + +void +IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) +{ + IOService * me = (IOService *) arg0; + + + gIOPMWatchDogThread = current_thread(); + getPMRootDomain()->sleepWakeDebugTrig(true); + gIOPMWatchDogThread = 0; + thread_call_free(me->fWatchdogTimer); + me->fWatchdogTimer = 0; + + return ; +} + + +//********************************************************************************* +// [private] start_ack_timer +//********************************************************************************* + +void IOService::start_ack_timer( void ) +{ + start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale ); +} + +void IOService::start_ack_timer ( UInt32 interval, UInt32 scale ) +{ + AbsoluteTime deadline; + boolean_t pending; + + clock_interval_to_deadline(interval, scale, &deadline); + + retain(); + pending = thread_call_enter_delayed(fAckTimer, deadline); + if (pending) release(); + + // Stop watchdog if ack is delayed by more than a sec + if (interval * scale > kSecondScale) { + stop_watchdog_timer(); + } +} //********************************************************************************* // [private] stop_ack_timer //********************************************************************************* -void IOService::stop_ack_timer ( void ) +void IOService::stop_ack_timer( void ) { - boolean_t pending; + boolean_t pending; pending = thread_call_cancel(fAckTimer); - if (pending) release(); + if (pending) release(); + + start_watchdog_timer(); } //********************************************************************************* @@ -5125,22 +5462,25 @@ void IOService::stop_ack_timer ( void ) //********************************************************************************* IOReturn -IOService::actionAckTimerExpired ( - OSObject * target, - void * arg0, void * arg1, - void * arg2, void * arg3 ) +IOService::actionAckTimerExpired( + 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(); + done = me->ackTimerTick(); + if (done && gIOPMWorkQueue) + { + gIOPMWorkQueue->signalWorkAvailable(); + me->start_watchdog_timer(); + } - return kIOReturnSuccess; + return kIOReturnSuccess; } //********************************************************************************* @@ -5150,15 +5490,112 @@ IOService::actionAckTimerExpired ( //********************************************************************************* void -IOService::ack_timer_expired ( thread_call_param_t arg0, thread_call_param_t arg1 ) +IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) +{ + IOService * me = (IOService *) arg0; + + 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; + IOService * me = (IOService *) arg0; - if (gIOPMWorkLoop) - { - gIOPMWorkLoop->runAction(&actionAckTimerExpired, me); - } - me->release(); + if (gIOPMWorkLoop) + { + gIOPMWorkLoop->runAction(&actionSpinDumpTimerExpired, me); + } + me->release(); } // MARK: - @@ -5170,7 +5607,7 @@ IOService::ack_timer_expired ( thread_call_param_t arg0, thread_call_param_t arg void IOService::tellSystemCapabilityChange( uint32_t nextMS ) { - MS_PUSH( nextMS ); + MS_PUSH( nextMS ); fMachineState = kIOPM_TellCapabilityChangeDone; fOutOfBandMessage = kIOMessageSystemCapabilityChange; @@ -5200,7 +5637,7 @@ 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 ); } @@ -5214,7 +5651,7 @@ 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); @@ -5228,7 +5665,7 @@ 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); @@ -5246,7 +5683,7 @@ 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 ); } @@ -5256,11 +5693,13 @@ bool IOService::tellChangeDown ( unsigned long stateNum ) // //********************************************************************************* -static void logAppTimeouts ( OSObject * object, void * arg ) +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)) { @@ -5274,29 +5713,27 @@ static void logAppTimeouts ( OSObject * object, void * arg ) (flag = context->responseArray->getObject(clientIndex)) && (flag != kOSBooleanTrue)) { - OSString *logClientID = NULL; - OSNumber *clientID = copyClientIDForNotification(object, context); - + OSNumber *clientID = copyClientIDForNotification(object, context); + + name[0] = '\0'; if (clientID) { - logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue()); + pid = clientID->unsigned32BitValue(); + proc_name(pid, name, sizeof(name)); clientID->release(); } - - PM_ERROR(context->errorLog, logClientID ? logClientID->getCStringNoCopy() : ""); + + PM_ERROR(context->errorLog, pid, name); // TODO: record message type if possible IOService::getPMRootDomain()->pmStatsRecordApplicationResponse( gIOPMStatsApplicationResponseTimedOut, - logClientID ? logClientID->getCStringNoCopy() : "", - 0, (30*1000), -1); + name, 0, (30*1000), pid, object); - if (logClientID) - logClientID->release(); } } } -void IOService::cleanClientResponses ( bool logErrors ) +void IOService::cleanClientResponses( bool logErrors ) { if (logErrors && fResponseArray) { @@ -5319,7 +5756,7 @@ void IOService::cleanClientResponses ( bool logErrors ) context.stateNumber = fHeadNotePowerState; context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; context.changeFlags = fHeadNoteChangeFlags; - context.errorLog = "PM notification timeout (%s)\n"; + context.errorLog = "PM notification timeout (pid %d, %s)\n"; applyToInterested(gIOAppPowerStateInterest, logAppTimeouts, (void *) &context); } @@ -5358,17 +5795,22 @@ void IOService::cleanClientResponses ( bool logErrors ) // Return true if we don't have to wait for acknowledgements //********************************************************************************* -bool IOService::tellClientsWithResponse ( int messageType ) +bool IOService::tellClientsWithResponse( int messageType ) { IOPMInterestContext context; bool isRootDomain = IS_ROOT_DOMAIN; + uint32_t maxTimeOut = kMaxTimeRequested; - PM_ASSERT_IN_GATE(); + PM_ASSERT_IN_GATE(); assert( fResponseArray == NULL ); assert( fNotifyClientArray == NULL ); - RD_LOG("tellClientsWithResponse( %s, %d )\n", - getIOMessageString(messageType), fOutOfBandParameter); + 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) @@ -5376,7 +5818,7 @@ bool IOService::tellClientsWithResponse ( int messageType ) fResponseArray->setCapacityIncrement(8); if (++fSerialNumber == 0) - fSerialNumber++; + fSerialNumber++; context.responseArray = fResponseArray; context.notifyClients = 0; @@ -5399,25 +5841,33 @@ bool IOService::tellClientsWithResponse ( int messageType ) switch ( fOutOfBandParameter ) { case kNotifyApps: applyToInterested( gIOAppPowerStateInterest, - pmTellAppWithResponse, (void *) &context ); + pmTellAppWithResponse, (void *) &context ); if (isRootDomain && (fMachineState != kIOPM_OurChangeTellClientsPowerDown) && - (fMachineState != kIOPM_SyncTellClientsPowerDown)) + (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 ); + pmTellCapabilityAppWithResponse, (void *) &context ); context.notifyType = fOutOfBandParameter; context.messageType = messageType; } - context.maxTimeRequested = k30Seconds; - + if(context.messageType == kIOMessageCanSystemSleep) + { + maxTimeOut = kCanSleepMaxTimeReq; + if(gCanSleepTimeout) + { + maxTimeOut = (gCanSleepTimeout*us_per_s); + } + } + context.maxTimeRequested = maxTimeOut; applyToInterested( gIOGeneralInterest, - pmTellClientWithResponse, (void *) &context ); + pmTellClientWithResponse, (void *) &context ); fNotifyClientArray = context.notifyClients; break; @@ -5425,7 +5875,7 @@ bool IOService::tellClientsWithResponse ( int messageType ) case kNotifyPriority: context.enableTracing = isRootDomain; applyToInterested( gIOPriorityPowerStateInterest, - pmTellClientWithResponse, (void *) &context ); + pmTellClientWithResponse, (void *) &context ); if (isRootDomain) { @@ -5439,14 +5889,22 @@ bool IOService::tellClientsWithResponse ( int messageType ) case kNotifyCapabilityChangeApps: applyToInterested( gIOAppPowerStateInterest, - pmTellCapabilityAppWithResponse, (void *) &context ); + pmTellCapabilityAppWithResponse, (void *) &context ); fNotifyClientArray = context.notifyClients; - context.maxTimeRequested = k30Seconds; + if(context.messageType == kIOMessageCanSystemSleep) + { + maxTimeOut = kCanSleepMaxTimeReq; + if(gCanSleepTimeout) + { + maxTimeOut = (gCanSleepTimeout*us_per_s); + } + } + context.maxTimeRequested = maxTimeOut; break; case kNotifyCapabilityChangePriority: applyToInterested( gIOPriorityPowerStateInterest, - pmTellCapabilityClientWithResponse, (void *) &context ); + pmTellCapabilityClientWithResponse, (void *) &context ); break; } @@ -5456,7 +5914,7 @@ bool IOService::tellClientsWithResponse ( int messageType ) OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0); if (context.enableTracing) getPMRootDomain()->traceDetail( context.maxTimeRequested / 1000 ); - start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale ); + start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale ); return false; } @@ -5483,7 +5941,7 @@ exit: // cookie we can identify the response with. //********************************************************************************* -void IOService::pmTellAppWithResponse ( OSObject * object, void * arg ) +void IOService::pmTellAppWithResponse( OSObject * object, void * arg ) { IOPMInterestContext * context = (IOPMInterestContext *) arg; IOServicePM * pwrMgt = context->us->pwrMgt; @@ -5491,6 +5949,7 @@ void IOService::pmTellAppWithResponse ( OSObject * object, void * arg ) OSNumber *clientID = NULL; proc_t proc = NULL; boolean_t proc_suspended = FALSE; + OSObject * waitForReply = kOSBooleanTrue; #if LOG_APP_RESPONSE_TIMES AbsoluteTime now; #endif @@ -5519,9 +5978,9 @@ void IOService::pmTellAppWithResponse ( OSObject * object, void * arg ) } } } - + if (context->messageFilter && - !context->messageFilter(context->us, object, context, 0, 0)) + !context->messageFilter(context->us, object, context, 0, &waitForReply)) { if (kIOLogDebugPower & gIOKitDebug) { @@ -5545,23 +6004,34 @@ void IOService::pmTellAppWithResponse ( OSObject * object, void * arg ) 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) + 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, num); - num->release(); + context->responseArray->setObject(msgIndex, kOSBooleanTrue); + if (kIOLogDebugPower & gIOKitDebug) + { + logClientIDForNotification(object, context, "App response ignored"); + } } - else -#endif - context->responseArray->setObject(msgIndex, kOSBooleanFalse); if (context->notifyClients) context->notifyClients->setObject(msgIndex, object); - context->us->messageClient(msgType, object, (void *) msgRef); + context->us->messageClient(msgType, object, (void *)(uintptr_t) msgRef); } //********************************************************************************* @@ -5571,7 +6041,7 @@ 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 ) +void IOService::pmTellClientWithResponse( OSObject * object, void * arg ) { IOPowerStateChangeNotification notify; IOPMInterestContext * context = (IOPMInterestContext *) arg; @@ -5590,8 +6060,8 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", context->us->getName(), getIOMessageString(context->messageType), - object, n->handler); - } + OBFUSCATE(object), OBFUSCATE(n->handler)); + } return; } @@ -5602,13 +6072,13 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) 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); - } + 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); + OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); } } if ((kIOLogDebugPower & gIOKitDebug) && notifier) @@ -5616,7 +6086,7 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", context->us->getName(), getIOMessageString(msgType), - object, notifier->handler); + OBFUSCATE(object), OBFUSCATE(notifier->handler)); } notify.powerRef = (void *)(uintptr_t) msgRef; @@ -5637,7 +6107,7 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) if (kIOReturnSuccess == retCode) { if (0 == notify.returnValue) { - OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); + OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); } else { replied = kOSBooleanFalse; if ( notify.returnValue > context->maxTimeRequested ) @@ -5647,7 +6117,7 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) context->maxTimeRequested = kPriorityClientMaxWait; PM_ERROR("%s: client %p returned %llu for %s\n", context->us->getName(), - notifier ? (void *) notifier->handler : object, + notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), (uint64_t) notify.returnValue, getIOMessageString(msgType)); } @@ -5658,7 +6128,7 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) } else { // not a client of ours // so we won't be waiting for response - OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); + OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); } context->responseArray->setObject(msgIndex, replied); @@ -5668,7 +6138,7 @@ void IOService::pmTellClientWithResponse ( OSObject * object, void * arg ) // [static private] pmTellCapabilityAppWithResponse //********************************************************************************* -void IOService::pmTellCapabilityAppWithResponse ( OSObject * object, void * arg ) +void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg ) { IOPMSystemCapabilityChangeParameters msgArg; IOPMInterestContext * context = (IOPMInterestContext *) arg; @@ -5708,7 +6178,7 @@ void IOService::pmTellCapabilityAppWithResponse ( OSObject * object, void * arg if (clientID) { clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue()); } - + PM_LOG("%s MESG App(%u) %s, wait %u, %s\n", context->us->getName(), msgIndex, getIOMessageString(msgType), @@ -5775,8 +6245,8 @@ void IOService::pmTellCapabilityClientWithResponse( PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", context->us->getName(), getIOMessageString(context->messageType), - object, n->handler); - } + OBFUSCATE(object), OBFUSCATE(n->handler)); + } return; } @@ -5787,21 +6257,21 @@ void IOService::pmTellCapabilityClientWithResponse( 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); - } + 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); - } + 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), - object, notifier->handler); + OBFUSCATE(object), OBFUSCATE(notifier->handler)); } msgArg.notifyRef = msgRef; @@ -5823,7 +6293,7 @@ void IOService::pmTellCapabilityClientWithResponse( if ( 0 == msgArg.maxWaitForReply ) { // client doesn't want time to respond - OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); + OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); } else { @@ -5835,7 +6305,7 @@ void IOService::pmTellCapabilityClientWithResponse( context->maxTimeRequested = kCapabilityClientMaxWait; PM_ERROR("%s: client %p returned %u for %s\n", context->us->getName(), - notifier ? (void *) notifier->handler : object, + notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), msgArg.maxWaitForReply, getIOMessageString(msgType)); } @@ -5848,7 +6318,7 @@ void IOService::pmTellCapabilityClientWithResponse( { // not a client of ours // so we won't be waiting for response - OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); + OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); } context->responseArray->setObject(msgIndex, replied); @@ -5864,7 +6334,7 @@ void IOService::pmTellCapabilityClientWithResponse( // the aborted destination state number. //********************************************************************************* -void IOService::tellNoChangeDown ( unsigned long ) +void IOService::tellNoChangeDown( unsigned long ) { return tellClients( kIOMessageDeviceWillNotPowerOff ); } @@ -5878,7 +6348,7 @@ void IOService::tellNoChangeDown ( unsigned long ) // the aborted destination state number. //********************************************************************************* -void IOService::tellChangeUp ( unsigned long ) +void IOService::tellChangeUp( unsigned long ) { return tellClients( kIOMessageDeviceHasPoweredOn ); } @@ -5889,7 +6359,7 @@ 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; @@ -5926,9 +6396,9 @@ void IOService::tellClients ( int messageType ) // Message a kernel client. //********************************************************************************* -static void tellKernelClientApplier ( OSObject * object, void * arg ) +static void tellKernelClientApplier( OSObject * object, void * arg ) { - IOPowerStateChangeNotification notify; + IOPowerStateChangeNotification notify; IOPMInterestContext * context = (IOPMInterestContext *) arg; if (context->messageFilter && @@ -5941,15 +6411,15 @@ static void tellKernelClientApplier ( OSObject * object, void * arg ) PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", context->us->getName(), IOService::getIOMessageString(context->messageType), - object, n->handler); - } + OBFUSCATE(object), OBFUSCATE(n->handler)); + } return; } notify.powerRef = (void *) 0; - notify.returnValue = 0; - notify.stateNumber = context->stateNumber; - notify.stateFlags = context->stateFlags; + notify.returnValue = 0; + notify.stateNumber = context->stateNumber; + notify.stateFlags = context->stateFlags; context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify)); @@ -5960,12 +6430,12 @@ static void tellKernelClientApplier ( OSObject * object, void * arg ) PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", context->us->getName(), IOService::getIOMessageString(context->messageType), - object, n->handler); + OBFUSCATE(object), OBFUSCATE(n->handler)); } } static OSNumber * copyClientIDForNotification( - OSObject *object, + OSObject *object, IOPMInterestContext *context) { OSNumber *clientID = NULL; @@ -5975,40 +6445,39 @@ static OSNumber * copyClientIDForNotification( static void logClientIDForNotification( OSObject *object, - IOPMInterestContext *context, + IOPMInterestContext *context, const char *logString) { OSString *logClientID = NULL; - OSNumber *clientID = copyClientIDForNotification(object, context); + OSNumber *clientID = copyClientIDForNotification(object, context); - if (logString) + 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() : ""); - if (logClientID) + if (logClientID) logClientID->release(); } - - if (clientID) + + if (clientID) clientID->release(); return; } - -static void tellAppClientApplier ( OSObject * object, void * arg ) +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))) @@ -6053,15 +6522,15 @@ static void tellAppClientApplier ( OSObject * object, void * arg ) // [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; } - + for (i = 0; ; i++) { theFlag = fResponseArray->getObject(i); @@ -6080,11 +6549,12 @@ bool IOService::checkForDone ( void ) // [public] responseValid //********************************************************************************* -bool IOService::responseValid ( uint32_t refcon, int pid ) +bool IOService::responseValid( uint32_t refcon, int pid ) { - UInt16 serialComponent; - UInt16 ordinalComponent; - OSObject * theFlag; + UInt16 serialComponent; + UInt16 ordinalComponent; + OSObject * theFlag; + OSObject *object = 0; serialComponent = (refcon >> 16) & 0xFFFF; ordinalComponent = (refcon & 0xFFFF); @@ -6093,44 +6563,37 @@ bool IOService::responseValid ( uint32_t refcon, int pid ) { 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; + AbsoluteTime now; + AbsoluteTime start; uint64_t nsec; - OSString *name = IOCopyLogNameForPID(pid); + 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); - - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeAppResponse, // type - name ? name->getCStringNoCopy() : "", // who - (uintptr_t)pid, // owner unique - NULL, // interest name - 0, // old - 0, // new - 0, // result - NS_TO_US(nsec)); // usec completion time - - getPMRootDomain()->recordAndReleasePMEventGated( details ); if (kIOLogDebugPower & gIOKitDebug) { @@ -6142,30 +6605,39 @@ bool IOService::responseValid ( uint32_t refcon, int pid ) // > 100 ms if (nsec > LOG_APP_RESPONSE_TIMES) { - PM_LOG("PM response took %d ms (%s)\n", NS_TO_MS(nsec), - name ? name->getCStringNoCopy() : ""); + 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 ? name->getCStringNoCopy() : "", 0, - NS_TO_MS(nsec), pid); - } + 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); } - if (name) - name->release(); #endif theFlag = kOSBooleanFalse; } + else if (object) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsApplicationResponsePrompt, + 0, 0, 0, pid, object); + + } - if ( kOSBooleanFalse == theFlag ) + if ( kOSBooleanFalse == theFlag ) { fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue); } - + return true; } @@ -6177,9 +6649,9 @@ 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 ) { @@ -6187,23 +6659,23 @@ IOReturn IOService::allowPowerChange ( unsigned long refcon ) 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 *) proc_selfpid(); - request->fArg2 = (void *) 0; - submitPMRequest( request ); + request->fArg0 = (void *) refcon; + request->fArg1 = (void *)(uintptr_t) proc_selfpid(); + request->fArg2 = (void *) 0; + 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__ */ @@ -6215,10 +6687,11 @@ 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; - OSString * name; + IOPMRequest * request; + char name[128]; + pid_t pid = proc_selfpid(); if ( !initialized ) { @@ -6226,30 +6699,29 @@ IOReturn IOService::cancelPowerChange ( unsigned long refcon ) return kIOReturnSuccess; } - name = IOCopyLogNameForPID(proc_selfpid()); - PM_ERROR("PM notification cancel (%s)\n", name ? name->getCStringNoCopy() : ""); + 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) + request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange ); + if (!request) { - if (name) - name->release(); return kIOReturnNoMemory; } - request->fArg0 = (void *) refcon; - request->fArg1 = (void *) proc_selfpid(); - request->fArg2 = (void *) name; + request->fArg0 = (void *) refcon; + request->fArg1 = (void *)(uintptr_t) proc_selfpid(); + request->fArg2 = (void *) OSString::withCString(name); submitPMRequest( request ); return kIOReturnSuccess; } #ifndef __LP64__ -IOReturn IOService::serializedCancelPowerChange2 ( unsigned long refcon ) +IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon ) { - // [deprecated] public - return kIOReturnUnsupported; + // [deprecated] public + return kIOReturnUnsupported; } //********************************************************************************* @@ -6258,7 +6730,7 @@ 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 ) { } @@ -6268,105 +6740,307 @@ 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__ */ -// MARK: - -// MARK: Driver Overrides - //********************************************************************************* -// [public] setPowerState +// configurePowerStateReport // -// Does nothing here. This should be implemented in a subclass driver. +// Configures the IOStateReport for kPMPowerStateChannel //********************************************************************************* - -IOReturn IOService::setPowerState ( - unsigned long powerStateOrdinal, IOService * whatDevice ) +IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action, void *result ) { - return IOPMNoErr; -} -//********************************************************************************* -// [public] maxCapabilityForDomainState -// -// Finds the highest power state in the array whose input power -// requirement is equal to the input parameter. Where a more intelligent -// decision is possible, override this in the subclassed driver. -//********************************************************************************* + IOReturn rc = kIOReturnSuccess; + size_t reportSize; + unsigned long i; + uint64_t ts; -unsigned long IOService::maxCapabilityForDomainState ( IOPMPowerFlags domainState ) -{ - int i; + if (!pwrMgt) + return kIOReturnUnsupported; - if (fNumberOfPowerStates == 0 ) - { - return 0; - } - for ( i = fNumberOfPowerStates - 1; i >= 0; i-- ) - { - if ( (domainState & fPowerStates[i].inputPowerFlags) == - fPowerStates[i].inputPowerFlags ) - { - return i; - } - } - return 0; -} + if (!fNumberOfPowerStates) + return kIOReturnSuccess; // For drivers which are in power plane, but haven't called registerPowerDriver() + PM_LOCK(); -//********************************************************************************* -// [public] initialPowerStateForDomainState -// -// Finds the highest power state in the array whose input power -// requirement is equal to the input parameter. Where a more intelligent -// decision is possible, override this in the subclassed driver. -//********************************************************************************* + switch (action) + { + case kIOReportEnable: + if (fReportBuf) + { + fReportClientCnt++; + break; + } + reportSize = STATEREPORT_BUFSIZE(fNumberOfPowerStates); + fReportBuf = IOMalloc(reportSize); + if (!fReportBuf) { + rc = kIOReturnNoMemory; + break; + } + memset(fReportBuf, 0, reportSize); -unsigned long IOService::initialPowerStateForDomainState ( IOPMPowerFlags domainState ) -{ - int i; + STATEREPORT_INIT(fNumberOfPowerStates, fReportBuf, reportSize, + getRegistryEntryID(), kPMPowerStatesChID, kIOReportCategoryPower); - if (fNumberOfPowerStates == 0 ) - { - return 0; - } - for ( i = fNumberOfPowerStates - 1; i >= 0; i-- ) - { - if ( (domainState & fPowerStates[i].inputPowerFlags) == - fPowerStates[i].inputPowerFlags ) - { - return i; - } + 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; } - return 0; + + PM_UNLOCK(); + + return rc; } //********************************************************************************* -// [public] powerStateForDomainState +// updatePowerStateReport // -// Finds the highest power state in the array whose input power -// requirement is equal to the input parameter. Where a more intelligent -// decision is possible, override this in the subclassed driver. +// Updates the IOStateReport for kPMPowerStateChannel //********************************************************************************* - -unsigned long IOService::powerStateForDomainState ( IOPMPowerFlags domainState ) +IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, void *result, void *destination ) { - int i; + 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); + + default: + break; + + } + + PM_UNLOCK(); + + return rc; + +} + +//********************************************************************************* +// configureSimplePowerReport +// +// Configures the IOSimpleReport for given channel id +//********************************************************************************* +IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, void *result ) +{ + + IOReturn rc = kIOReturnSuccess; + + if ( !pwrMgt ) + return kIOReturnUnsupported; + + if ( !fNumberOfPowerStates ) + return rc; + + switch (action) + { + case kIOReportEnable: + case kIOReportDisable: + break; + + case kIOReportGetDimensions: + SIMPLEREPORT_UPDATERES(kIOReportGetDimensions, result); + break; + } + + + return rc; +} + +//********************************************************************************* +// updateSimplePowerReport +// +// Updates the IOSimpleReport for the given chanel id +//********************************************************************************* +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; + + if ( !fNumberOfPowerStates ) + return rc; + PM_LOCK(); + + switch (action) { + case kIOReportCopyChannelData: + + SIMPLEREPORT_INIT(buf, sizeof(buf), getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower); + + if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMPowerOn) + bits |= kPMReportPowerOn; + if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMDeviceUsable) + bits |= kPMReportDeviceUsable; + if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMLowPower) + bits |= kPMReportLowPower; + + + SIMPLEREPORT_SETVALUE(buf, ((bits & 0xff) << 8) | ((StateOrder(fMaxPowerState) & 0xf) << 4) | + (StateOrder(fCurrentPowerState) & 0xf)); + + SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy); + if (size2cpy > (dest->getCapacity() - dest->getLength())) { + rc = kIOReturnOverrun; + break; + } + + SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result); + dest->appendBytes(data2cpy, size2cpy); + + default: + break; - if (fNumberOfPowerStates == 0 ) - { - return 0; } - for ( i = fNumberOfPowerStates - 1; i >= 0; i-- ) + + PM_UNLOCK(); + + return kIOReturnSuccess; + +} + + + +// MARK: - +// MARK: Driver Overrides + +//********************************************************************************* +// [public] setPowerState +// +// Does nothing here. This should be implemented in a subclass driver. +//********************************************************************************* + +IOReturn IOService::setPowerState( + unsigned long powerStateOrdinal, IOService * whatDevice ) +{ + return IOPMNoErr; +} + +//********************************************************************************* +// [public] maxCapabilityForDomainState +// +// Finds the highest power state in the array whose input power requirement +// is equal to the input parameter. Where a more intelligent decision is +// possible, override this in the subclassed driver. +//********************************************************************************* + +IOPMPowerStateIndex IOService::getPowerStateForDomainFlags( IOPMPowerFlags flags ) +{ + IOPMPowerStateIndex stateIndex; + + if (!fNumberOfPowerStates) + return kPowerStateZero; + + for ( int order = fNumberOfPowerStates - 1; order >= 0; order-- ) { - if ( (domainState & fPowerStates[i].inputPowerFlags) == - fPowerStates[i].inputPowerFlags ) + stateIndex = fPowerStates[order].stateOrderToIndex; + + if ( (flags & fPowerStates[stateIndex].inputPowerFlags) == + fPowerStates[stateIndex].inputPowerFlags ) { - return i; + return stateIndex; } } - return 0; + return kPowerStateZero; +} + +unsigned long IOService::maxCapabilityForDomainState( IOPMPowerFlags domainState ) +{ + return getPowerStateForDomainFlags(domainState); +} + +//********************************************************************************* +// [public] initialPowerStateForDomainState +// +// Called to query the power state for the initial power transition. +//********************************************************************************* + +unsigned long IOService::initialPowerStateForDomainState( IOPMPowerFlags domainState ) +{ + if (fResetPowerStateOnWake && (domainState & kIOPMRootDomainState)) + { + // Return lowest power state for any root power domain changes + return kPowerStateZero; + } + + return getPowerStateForDomainFlags(domainState); +} + +//********************************************************************************* +// [public] powerStateForDomainState +// +// This method is not called from PM. +//********************************************************************************* + +unsigned long IOService::powerStateForDomainState( IOPMPowerFlags domainState ) +{ + return getPowerStateForDomainFlags(domainState); } #ifndef __LP64__ @@ -6376,7 +7050,7 @@ 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; } @@ -6388,7 +7062,7 @@ 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; } @@ -6399,7 +7073,7 @@ IOReturn IOService::powerStateWillChangeTo ( IOPMPowerFlags, unsigned long, IOSe // 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; } @@ -6411,7 +7085,7 @@ IOReturn IOService::powerStateDidChangeTo ( IOPMPowerFlags, unsigned long, IOSer // Does nothing here. This should be implemented in a subclass policy-maker. //********************************************************************************* -void IOService::powerChangeDone ( unsigned long ) +void IOService::powerChangeDone( unsigned long ) { } @@ -6422,7 +7096,7 @@ 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; } @@ -6436,9 +7110,9 @@ IOReturn IOService::newTemperature ( long currentTemp, IOService * whichZone ) void IOService::systemWillShutdown( IOOptionBits specifier ) { - IOPMrootDomain * rootDomain = IOService::getPMRootDomain(); - if (rootDomain) - rootDomain->acknowledgeSystemWillShutdown( this ); + IOPMrootDomain * rootDomain = IOService::getPMRootDomain(); + if (rootDomain) + rootDomain->acknowledgeSystemWillShutdown( this ); } // MARK: - @@ -6452,26 +7126,26 @@ IOPMRequest * IOService::acquirePMRequest( IOService * target, IOOptionBits requestType, IOPMRequest * active ) { - IOPMRequest * request; + IOPMRequest * request; - assert(target); + assert(target); - request = IOPMRequest::create(); - if (request) - { - request->init( target, requestType ); + request = IOPMRequest::create(); + if (request) + { + request->init( target, requestType ); if (active) { IOPMRequest * root = active->getRootRequest(); if (root) request->attachRootRequest(root); } } - else - { + else + { PM_ERROR("%s: No memory for PM request type 0x%x\n", target->getName(), (uint32_t) requestType); - } - return request; + } + return request; } //********************************************************************************* @@ -6480,94 +7154,102 @@ IOService::acquirePMRequest( IOService * target, IOOptionBits requestType, void IOService::releasePMRequest( IOPMRequest * request ) { - if (request) - { - request->reset(); - request->release(); - } + if (request) + { + request->reset(); + request->release(); + } } //********************************************************************************* -// [private] submitPMRequest +// [private static] submitPMRequest //********************************************************************************* 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(), request, - request->getTarget(), request->getTarget()->getName(), - request->fArg0, request->fArg1, 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::submitPMRequest( 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(), req, - req->getTarget(), req->getTarget()->getName(), - req->fArg0, req->fArg1, 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 ); } //********************************************************************************* -// [private] servicePMRequestQueue +// [private] actionPMRequestQueue // -// Called from IOPMRequestQueue::checkForWork(). +// IOPMRequestQueue::checkForWork() passing a new request to the request target. //********************************************************************************* -bool IOService::servicePMRequestQueue( - IOPMRequest * request, - IOPMRequestQueue * queue ) +bool IOService::actionPMRequestQueue( + IOPMRequest * request, + IOPMRequestQueue * queue ) { bool more; if (initialized) { - // Work queue will immediately execute the queue'd request if possible. - // If execution blocks, the work queue will wait for a producer signal. - // Only need to signal more when completing attached requests. + // 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); - return more; } + else + { + // Calling PM without PMinit() is not allowed, fail the request. + // Need to signal more when completing attached requests. - // Calling PM without PMinit() is not allowed, fail the request. + 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()); - fAdjustPowerScheduled = false; - more = gIOPMFreeQueue->queuePMRequest(request); - if (more) gIOPMWorkQueue->incrementProducerCount(); - return more; + more = gIOPMCompletionQueue->queuePMRequest(request); + if (more) gIOPMWorkQueue->incrementProducerCount(); + } + + return more; } //********************************************************************************* -// [private] servicePMFreeQueue +// [private] actionPMCompletionQueue // -// Called from IOPMCompletionQueue::checkForWork(). +// IOPMCompletionQueue::checkForWork() passing a completed request to the +// request target. //********************************************************************************* -bool IOService::servicePMFreeQueue( - IOPMRequest * request, - IOPMCompletionQueue * queue ) +bool IOService::actionPMCompletionQueue( + IOPMRequest * request, + IOPMCompletionQueue * queue ) { - bool more = request->getNextRequest(); + bool more = (request->getNextRequest() != 0); IOPMRequest * root = request->getRootRequest(); if (root && (root != request)) @@ -6575,53 +7257,46 @@ bool IOService::servicePMFreeQueue( if (more) gIOPMWorkQueue->incrementProducerCount(); - releasePMRequest( request ); - return more; + releasePMRequest( request ); + return more; } //********************************************************************************* -// [private] retirePMRequest +// [private] actionPMWorkQueueRetire // -// Called by IOPMWorkQueue to retire a completed request. +// IOPMWorkQueue::checkForWork() passing a retired request to the request target. //********************************************************************************* -bool IOService::retirePMRequest( 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(), request, this, getName(), - fMachineState, gIOPMBusyCount); + 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) && - (request->fArg1 == (void *) false)) - { - // Idle timer expiration - power drop request completed. - // Restart the idle timer if deviceDesire can go lower, otherwise set - // a flag so we know to restart idle timer when fDeviceDesire > 0. + // Catch requests created by idleTimerExpired() + if (request->getType() == kIOPMRequestTypeActivityTickle) + { + uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1; - if (fDeviceDesire > 0) - { - fActivityTickleCount = 0; - clock_get_uptime(&fIdleTimerStartTime); - start_PM_idle_timer(); - } - else if (fHasAdvisoryDesire) + if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod) { - start_PM_idle_timer(); + restartIdleTimer(); } - else + else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise)) { - fIdleTimerStopped = true; + // 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. - // If the request is linked, then Work queue has already incremented its - // producer count. - - return (gIOPMFreeQueue->queuePMRequest( request )); + return (gIOPMCompletionQueue->queuePMRequest( request )); } //********************************************************************************* @@ -6630,96 +7305,102 @@ bool IOService::retirePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) // 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) - { + if (kIOPM_DriverThreadCallDone == fMachineState) + { // 5 = kDriverCallInformPreChange // 6 = kDriverCallInformPostChange // 7 = kDriverCallSetPowerState - if (fDriverCallBusy) + // 8 = kRootDomainInformPreChange + if (fDriverCallBusy) reason = 5 + fDriverCallReason; - break; - } + 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(), request, 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; } //********************************************************************************* -// [private] servicePMRequest +// [private] actionPMWorkQueueInvoke // -// Service a request from our work queue. +// IOPMWorkQueue::checkForWork() passing a request to the +// request target for execution. //********************************************************************************* -bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) +bool IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue ) { - bool done = false; - int loop = 0; + bool done = false; + int loop = 0; - assert(request && queue); + assert(request && queue); - while (isPMBlocked(request, loop++) == false) - { - PM_LOG1("[W %02x] %p [%p %s] state %d\n", - request->getType(), request, this, getName(), fMachineState); + 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; - gIOPMWorkCount++; + gIOPMRequest = request; + gIOPMWorkInvokeCount++; - // Every PM machine states must be handled in one of the cases below. + // Every PM machine states must be handled in one of the cases below. - switch ( fMachineState ) - { - case kIOPM_Finished: - executePMRequest( request ); - break; + switch ( fMachineState ) + { + case kIOPM_Finished: + start_watchdog_timer(); + + executePMRequest( request ); + break; - case kIOPM_OurChangeTellClientsPowerDown: + case kIOPM_OurChangeTellClientsPowerDown: // Root domain might self cancel due to assertions. if (IS_ROOT_DOMAIN) { @@ -6730,153 +7411,145 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) } // askChangeDown() done, was it vetoed? - if (!fDoNotPowerDown) - { - if (IS_ROOT_DOMAIN) { - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeAppNotificationsFinished, - NULL, - 0, - 0); - - getPMRootDomain()->recordAndReleasePMEventGated( details ); - } + 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; - // no, we can continue - OurChangeTellClientsPowerDown(); - } - else - { - if (IS_ROOT_DOMAIN) { - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeSleepDone, - NULL, - 1, /* reason: 1 == Ask clients succeeded */ - kIOReturnAborted); /* result */ - - getPMRootDomain()->recordAndReleasePMEventGated( details ); - } + 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; - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle cancel\n", fName); - // yes, rescind the warning - tellNoChangeDown(fHeadNotePowerState); - // mark the change note un-actioned - fHeadNoteChangeFlags |= kIOPMNotDone; - // and we're done - OurChangeFinish(); - } - break; - - case kIOPM_OurChangeTellPriorityClientsPowerDown: - // tellChangeDown(kNotifyApps) done, was it cancelled? - if (fDoNotPowerDown) - { - if (IS_ROOT_DOMAIN) { - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeSleepDone, - NULL, - 2, /* reason: 2 == Client cancelled wake */ - kIOReturnAborted); /* result */ - - getPMRootDomain()->recordAndReleasePMEventGated( details ); - } - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle revert\n", fName); - // 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 - { - if (IS_ROOT_DOMAIN) { - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeAppNotificationsFinished, - NULL, - 2, /* reason: 2 == TellPriorityClientsDone */ - kIOReturnSuccess); /* result */ - - getPMRootDomain()->recordAndReleasePMEventGated( details ); - } - // yes, we can continue - OurChangeTellPriorityClientsPowerDown(); - } - 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_OurChangeNotifyInterestedDriversWillChange: + OurChangeNotifyInterestedDriversWillChange(); + break; - case kIOPM_OurChangeSetPowerState: - OurChangeSetPowerState(); - break; + case kIOPM_OurChangeSetPowerState: + OurChangeSetPowerState(); + break; - case kIOPM_OurChangeWaitForPowerSettle: - OurChangeWaitForPowerSettle(); - break; + case kIOPM_OurChangeWaitForPowerSettle: + OurChangeWaitForPowerSettle(); + break; - case kIOPM_OurChangeNotifyInterestedDriversDidChange: - OurChangeNotifyInterestedDriversDidChange(); - break; + case kIOPM_OurChangeNotifyInterestedDriversDidChange: + OurChangeNotifyInterestedDriversDidChange(); + break; case kIOPM_OurChangeTellCapabilityDidChange: OurChangeTellCapabilityDidChange(); break; - case kIOPM_OurChangeFinish: - OurChangeFinish(); - break; + case kIOPM_OurChangeFinish: + OurChangeFinish(); + break; - case kIOPM_ParentChangeTellPriorityClientsPowerDown: - ParentChangeTellPriorityClientsPowerDown(); - break; + case kIOPM_ParentChangeTellPriorityClientsPowerDown: + ParentChangeTellPriorityClientsPowerDown(); + break; - case kIOPM_ParentChangeNotifyInterestedDriversWillChange: - ParentChangeNotifyInterestedDriversWillChange(); - break; + case kIOPM_ParentChangeNotifyInterestedDriversWillChange: + ParentChangeNotifyInterestedDriversWillChange(); + break; - case kIOPM_ParentChangeSetPowerState: - ParentChangeSetPowerState(); - break; + case kIOPM_ParentChangeSetPowerState: + ParentChangeSetPowerState(); + break; - case kIOPM_ParentChangeWaitForPowerSettle: - ParentChangeWaitForPowerSettle(); - break; + case kIOPM_ParentChangeWaitForPowerSettle: + ParentChangeWaitForPowerSettle(); + break; - case kIOPM_ParentChangeNotifyInterestedDriversDidChange: - ParentChangeNotifyInterestedDriversDidChange(); - break; + case kIOPM_ParentChangeNotifyInterestedDriversDidChange: + ParentChangeNotifyInterestedDriversDidChange(); + break; case kIOPM_ParentChangeTellCapabilityDidChange: ParentChangeTellCapabilityDidChange(); break; - case kIOPM_ParentChangeAcknowledgePowerChange: - ParentChangeAcknowledgePowerChange(); - break; + case kIOPM_ParentChangeAcknowledgePowerChange: + ParentChangeAcknowledgePowerChange(); + break; - case kIOPM_DriverThreadCallDone: - if (fDriverCallReason == kDriverCallSetPowerState) - notifyControllingDriverDone(); - else - notifyInterestedDriversDone(); - 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_NotifyChildrenOrdered: + notifyChildrenOrdered(); + break; - case kIOPM_NotifyChildrenDelayed: - notifyChildrenDelayed(); - break; + case kIOPM_NotifyChildrenDelayed: + notifyChildrenDelayed(); + break; case kIOPM_NotifyChildrenStart: - PM_LOG2("%s: kIOPM_NotifyChildrenStart done\n", getName()); - MS_POP(); // from notifyInterestedDriversDone() - notifyChildren(); + // pop notifyAll() state saved by notifyInterestedDriversDone() + MS_POP(); + notifyRootDomain(); break; case kIOPM_SyncTellClientsPowerDown: @@ -6887,39 +7560,42 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) getPMRootDomain()->askChangeDownDone( &fHeadNoteChangeFlags, &cancel); fDoNotPowerDown = cancel; - } - if (!fDoNotPowerDown) - { + } + if (!fDoNotPowerDown) + { fMachineState = kIOPM_SyncTellPriorityClientsPowerDown; fOutOfBandParameter = kNotifyApps; tellChangeDown(fHeadNotePowerState); - } - else - { - OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); - PM_ERROR("%s: idle cancel\n", fName); - tellNoChangeDown(fHeadNotePowerState); - fHeadNoteChangeFlags |= kIOPMNotDone; - OurChangeFinish(); - } + } + 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: - if (!fDoNotPowerDown) - { + // 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\n", fName); - tellChangeUp(fCurrentPowerState); - fHeadNoteChangeFlags |= kIOPMNotDone; - OurChangeFinish(); - } - break; + 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) @@ -6936,9 +7612,14 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) fIsPreChange = false; if (fHeadNoteChangeFlags & kIOPMParentInitiated) + { fMachineState = kIOPM_SyncFinish; + } else + { + assert(IS_ROOT_DOMAIN); fMachineState = kIOPM_SyncTellCapabilityDidChange; + } fDriverCallReason = kDriverCallInformPostChange; notifyChildren(); @@ -6977,21 +7658,22 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) tellClientsWithResponse( fOutOfBandMessage ); break; - default: - panic("servicePMWorkQueue: unknown machine state %x", + default: + panic("PMWorkQueueInvoke: unknown machine state %x", fMachineState); - } + } - gIOPMRequest = 0; + gIOPMRequest = 0; - if (fMachineState == kIOPM_Finished) - { - done = true; - break; - } - } + if (fMachineState == kIOPM_Finished) + { + stop_watchdog_timer(); + done = true; + break; + } + } - return done; + return done; } //********************************************************************************* @@ -7000,71 +7682,67 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue ) void IOService::executePMRequest( IOPMRequest * request ) { - assert( kIOPM_Finished == fMachineState ); + assert( kIOPM_Finished == fMachineState ); - switch (request->getType()) - { - case kIOPMRequestTypePMStop: - handlePMstop( request ); - break; + switch (request->getType()) + { + case kIOPMRequestTypePMStop: + handlePMstop( request ); + break; - case kIOPMRequestTypeAddPowerChild1: - addPowerChild1( request ); - break; + case kIOPMRequestTypeAddPowerChild1: + addPowerChild1( request ); + break; - case kIOPMRequestTypeAddPowerChild2: - addPowerChild2( request ); - break; + case kIOPMRequestTypeAddPowerChild2: + addPowerChild2( request ); + break; - case kIOPMRequestTypeAddPowerChild3: - addPowerChild3( request ); - break; + case kIOPMRequestTypeAddPowerChild3: + addPowerChild3( request ); + break; - case kIOPMRequestTypeRegisterPowerDriver: - handleRegisterPowerDriver( request ); - break; + case kIOPMRequestTypeRegisterPowerDriver: + handleRegisterPowerDriver( request ); + break; - case kIOPMRequestTypeAdjustPowerState: - fAdjustPowerScheduled = false; - adjustPowerState(); - break; + case kIOPMRequestTypeAdjustPowerState: + fAdjustPowerScheduled = false; + adjustPowerState(); + break; - case kIOPMRequestTypePowerDomainWillChange: - handlePowerDomainWillChangeTo( request ); - break; + case kIOPMRequestTypePowerDomainWillChange: + handlePowerDomainWillChangeTo( request ); + break; - case kIOPMRequestTypePowerDomainDidChange: - handlePowerDomainDidChangeTo( request ); - break; + case kIOPMRequestTypePowerDomainDidChange: + handlePowerDomainDidChangeTo( request ); + break; - case kIOPMRequestTypeRequestPowerState: + case kIOPMRequestTypeRequestPowerState: case kIOPMRequestTypeRequestPowerStateOverride: - handleRequestPowerState( request ); - break; + handleRequestPowerState( request ); + break; - case kIOPMRequestTypePowerOverrideOnPriv: - case kIOPMRequestTypePowerOverrideOffPriv: - handlePowerOverrideChanged( request ); - break; + case kIOPMRequestTypePowerOverrideOnPriv: + case kIOPMRequestTypePowerOverrideOffPriv: + handlePowerOverrideChanged( request ); + break; - case kIOPMRequestTypeActivityTickle: - handleActivityTickle( request ); - break; + case kIOPMRequestTypeActivityTickle: + handleActivityTickle( request ); + break; case kIOPMRequestTypeSynchronizePowerTree: - handleSynchronizePowerTree( request ); - break; + handleSynchronizePowerTree( request ); + break; case kIOPMRequestTypeSetIdleTimerPeriod: { fIdleTimerPeriod = (uintptr_t) request->fArg0; - + fNextIdleTimerPeriod = fIdleTimerPeriod; if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0)) - { - fActivityTickleCount = 0; - clock_get_uptime(&fIdleTimerStartTime); - start_PM_idle_timer(); - } + restartIdleTimer(); } break; @@ -7072,39 +7750,52 @@ void IOService::executePMRequest( IOPMRequest * request ) fIdleTimerIgnored = request->fArg0 ? 1 : 0; break; - default: - panic("executePMRequest: unknown request type %x", request->getType()); - } + case kIOPMRequestTypeQuiescePowerTree: + gIOPMWorkQueue->finishQuiesceRequest(request); + break; + + default: + panic("executePMRequest: unknown request type %x", request->getType()); + } } //********************************************************************************* -// [private] servicePMReplyQueue +// [private] actionPMReplyQueue +// +// IOPMRequestQueue::checkForWork() passing a reply-type request to the +// request target. //********************************************************************************* -bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue ) +bool IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue ) { - bool more = false; + bool more = false; - assert( request && queue ); - assert( request->isReplyType() ); + assert( request && queue ); + assert( request->isReplyType() ); - PM_LOG1("[A %02x] %p [%p %s] state %d\n", - request->getType(), request, this, getName(), fMachineState); + 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, + 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()) + { + 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 ((fHeadNoteChangeFlags & kIOPMSkipAskPowerDown) == 0) + if ((fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) + || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) + || ((fHeadNoteChangeFlags & kIOPMSkipAskPowerDown) == 0)) { fDoNotPowerDown = true; @@ -7112,113 +7803,105 @@ bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * q getPMRootDomain()->pmStatsRecordApplicationResponse( gIOPMStatsApplicationResponseCancel, name ? name->getCStringNoCopy() : "", 0, - 0, (int)(uintptr_t) request->fArg1); + 0, (int)(uintptr_t) request->fArg1, 0); } } - if (checkForDone()) - { - stop_ack_timer(); + if (checkForDone()) + { + stop_ack_timer(); cleanClientResponses(false); - more = true; - } - } + 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(); + 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) - PM_LOG("%s::setPowerState(%p, %lu -> %lu) async took %d ms\n", - fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); - - PMEventDetails *details = PMEventDetails::eventDetails( - kIOPMEventTypeSetPowerStateDelayed, // type - fName, // who - (uintptr_t)this, // owner unique - NULL, // interest name - (uint8_t)getPowerState(), // old - (uint8_t)fHeadNotePowerState, // new - 0, // result - NS_TO_US(nsec)); // usec completion time - - getPMRootDomain()->recordAndReleasePMEventGated( details ); + 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_OurChangeTellPriorityClientsPowerDown) + 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); + { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); PM_LOG2("%s: cancel from machine state %d\n", getName(), fMachineState); - fDoNotPowerDown = true; + fDoNotPowerDown = true; // Stop waiting for app replys. - if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) || - (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown)) - cleanClientResponses(false); - more = true; - } - break; + 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()); + PM_LOG2("%s: delay notify cancelled\n", getName()); notifyChildrenDelayed(); } break; - default: - panic("servicePMReplyQueue: unknown reply type %x", - request->getType()); - } + default: + panic("PMReplyQueue: unknown reply type %x", request->getType()); + } - more |= gIOPMFreeQueue->queuePMRequest(request); + more |= gIOPMCompletionQueue->queuePMRequest(request); if (more) gIOPMWorkQueue->incrementProducerCount(); - return more; + return more; } //********************************************************************************* @@ -7242,7 +7925,7 @@ bool IOService::assertPMDriverCall( { goto fail; } - + if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive()) { goto fail; @@ -7320,7 +8003,7 @@ void IOService::waitForPMDriverCall( IOService * target ) } continue; } - + wait = true; break; } @@ -7346,9 +8029,9 @@ void IOService::waitForPMDriverCall( IOService * target ) const char * IOService::getIOMessageString( uint32_t msg ) { -#define MSG_ENTRY(x) {x, #x} +#define MSG_ENTRY(x) {(int) x, #x} - static const IONamedValue msgNames[] = { + static const IONamedValue msgNames[] = { MSG_ENTRY( kIOMessageCanDevicePowerOff ), MSG_ENTRY( kIOMessageDeviceWillPowerOff ), MSG_ENTRY( kIOMessageDeviceWillNotPowerOff ), @@ -7362,12 +8045,14 @@ const char * IOService::getIOMessageString( uint32_t msg ) MSG_ENTRY( kIOMessageSystemHasPoweredOn ), MSG_ENTRY( kIOMessageSystemWillRestart ), MSG_ENTRY( kIOMessageSystemWillPowerOn ), - MSG_ENTRY( kIOMessageSystemCapabilityChange ) + MSG_ENTRY( kIOMessageSystemCapabilityChange ), + MSG_ENTRY( kIOPMMessageLastCallBeforeSleep ) }; return IOFindNameForValue(msg, msgNames); } + // MARK: - // MARK: IOPMRequest @@ -7381,50 +8066,57 @@ OSDefineMetaClassAndStructors( IOPMRequest, IOCommand ); 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(0, kIOPMRequestTypeInvalid)) + { + me->release(); + me = 0; + } + return me; } bool IOPMRequest::init( IOService * target, IOOptionBits type ) { - if (!IOCommand::init()) - return false; + if (!IOCommand::init()) + return false; + + fRequestType = type; + fTarget = target; + + if (fTarget) + fTarget->retain(); - fType = type; - fTarget = target; - fCompletionStatus = kIOReturnSuccess; + // Root node and root domain requests does not prevent the power tree from + // becoming quiescent. - if (fTarget) - fTarget->retain(); + fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) && + (fTarget != IOService::getPMRootDomain())); - return true; + return true; } void IOPMRequest::reset( void ) { - assert( fWorkWaitCount == 0 ); - assert( fFreeWaitCount == 0 ); + assert( fWorkWaitCount == 0 ); + assert( fFreeWaitCount == 0 ); - detachNextRequest(); + detachNextRequest(); detachRootRequest(); - fType = kIOPMRequestTypeInvalid; - - if (fCompletionAction) - { - fCompletionAction(fCompletionTarget, fCompletionParam, fCompletionStatus); + if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree)) + { + // Call the completion on PM work loop context + fCompletionAction(fCompletionTarget, fCompletionParam); + fCompletionAction = 0; } - if (fTarget) - { - fTarget->release(); - fTarget = 0; - } + fRequestType = kIOPMRequestTypeInvalid; + + if (fTarget) + { + fTarget->release(); + fTarget = 0; + } } bool IOPMRequest::attachNextRequest( IOPMRequest * next ) @@ -7438,9 +8130,9 @@ bool IOPMRequest::attachNextRequest( IOPMRequest * next ) fRequestNext = next; fRequestNext->fWorkWaitCount++; #if LOG_REQUEST_ATTACH - kprintf("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n", - this, (uint32_t) fType, fRequestNext, - (uint32_t) fRequestNext->fType, + 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 @@ -7459,9 +8151,9 @@ bool IOPMRequest::detachNextRequest( void ) if (fRequestNext->fWorkWaitCount) fRequestNext->fWorkWaitCount--; #if LOG_REQUEST_ATTACH - kprintf("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n", - this, (uint32_t) fType, fRequestNext, - (uint32_t) fRequestNext->fType, + 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 @@ -7482,8 +8174,8 @@ bool IOPMRequest::attachRootRequest( IOPMRequest * root ) fRequestRoot = root; fRequestRoot->fFreeWaitCount++; #if LOG_REQUEST_ATTACH - kprintf("Attached root: %p [0x%x] -> %p [0x%x, %u] %s\n", - this, (uint32_t) fType, fRequestRoot, + 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()); @@ -7503,8 +8195,8 @@ bool IOPMRequest::detachRootRequest( void ) if (fRequestRoot->fFreeWaitCount) fRequestRoot->fFreeWaitCount--; #if LOG_REQUEST_ATTACH - kprintf("Detached root: %p [0x%x] -> %p [0x%x, %u] %s\n", - this, (uint32_t) fType, fRequestRoot, + 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()); @@ -7528,82 +8220,90 @@ OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource ); 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 = 0; + } + return me; } bool IOPMRequestQueue::init( IOService * inOwner, Action inAction ) { - if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) + if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) return false; - queue_init(&fQueue); - fLock = IOLockAlloc(); - return (fLock != 0); + queue_init(&fQueue); + fLock = IOLockAlloc(); + return (fLock != 0); } void IOPMRequestQueue::free( void ) { - if (fLock) - { - IOLockFree(fLock); - fLock = 0; - } - return IOEventSource::free(); + if (fLock) + { + IOLockFree(fLock); + fLock = 0; + } + return IOEventSource::free(); } void IOPMRequestQueue::queuePMRequest( IOPMRequest * request ) { - assert(request); - IOLockLock(fLock); - queue_enter(&fQueue, request, IOPMRequest *, 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; + IOPMRequest * next; - assert(requests && count); - IOLockLock(fLock); - while (count--) - { - next = *requests; - requests++; - queue_enter(&fQueue, next, IOPMRequest *, fCommandChain); - } - IOLockUnlock(fLock); - if (workLoop) signalWorkAvailable(); + 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; - bool more = false; + Action dqAction = (Action) action; + IOPMRequest * request; + IOService * target; + int dequeueCount = 0; + bool more = false; - IOLockLock( fLock ); + IOLockLock( fLock ); - while (!queue_empty(&fQueue)) - { - queue_remove_first( &fQueue, request, IOPMRequest *, fCommandChain ); - IOLockUnlock( fLock ); - target = request->getTarget(); - assert(target); - more |= (*dqAction)( target, request, this ); - 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; + IOLockUnlock( fLock ); + return more; } // MARK: - @@ -7612,110 +8312,143 @@ bool IOPMRequestQueue::checkForWork( void ) //********************************************************************************* // IOPMWorkQueue Class // -// Queue of IOServicePM objects with busy IOPMRequest(s). +// Queue of IOServicePM objects, each with a queue of IOPMRequest sharing the +// same target. //********************************************************************************* OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource ); IOPMWorkQueue * -IOPMWorkQueue::create( IOService * inOwner, Action work, Action retire ) +IOPMWorkQueue::create( IOService * inOwner, Action invoke, Action retire ) { - IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue); - if (me && !me->init(inOwner, work, retire)) - { - me->release(); - me = 0; - } - return me; + IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue); + if (me && !me->init(inOwner, invoke, retire)) + { + me->release(); + me = 0; + } + return me; } -bool IOPMWorkQueue::init( IOService * inOwner, Action work, Action retire ) +bool IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire ) { - if (!work || !retire || - !IOEventSource::init(inOwner, (IOEventSourceAction)0)) - return false; + if (!invoke || !retire || + !IOEventSource::init(inOwner, (IOEventSourceAction)0)) + return false; - queue_init(&fWorkQueue); + queue_init(&fWorkQueue); - fWorkAction = work; - fRetireAction = retire; + fInvokeAction = invoke; + fRetireAction = retire; fConsumerCount = fProducerCount = 0; - return true; + return true; } bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt ) { - bool more = false; - bool empty; + queue_head_t * requestQueue; + bool more = false; + bool empty; - assert( request ); + assert( request ); assert( pwrMgt ); - assert( onThread() ); + assert( onThread() ); assert( queue_next(&request->fCommandChain) == queue_prev(&request->fCommandChain) ); - gIOPMBusyCount++; + 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. - empty = queue_empty(&pwrMgt->RequestHead); - queue_enter(&pwrMgt->RequestHead, request, IOPMRequest *, fCommandChain); + requestQueue = &pwrMgt->RequestHead; + empty = queue_empty(requestQueue); + queue_enter(requestQueue, request, typeof(request), fCommandChain); if (empty) { - more = checkRequestQueue(&pwrMgt->RequestHead, &empty); + more = checkRequestQueue(requestQueue, &empty); if (!empty) { - // New Request is blocked, add IOServicePM to work queue. + // 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, IOServicePM *, WorkChain); + queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain); fQueueLength++; PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n", - fQueueLength, pwrMgt->Name, pwrMgt); + fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt)); } } return more; } -bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty ) +bool IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty ) { - IOPMRequest * request; - IOService * target; + IOPMRequest * request; + IOService * target; bool more = false; - bool done = false; + bool done = false; - assert(!queue_empty(queue)); + assert(!queue_empty(requestQueue)); do { - request = (IOPMRequest *) queue_first(queue); - if (request->isWorkBlocked()) - break; // cannot start, blocked on attached request + request = (typeof(request)) queue_first(requestQueue); + if (request->isWorkBlocked()) + break; // request dispatch blocked on attached request - target = request->getTarget(); - done = (*fWorkAction)( target, request, this ); - if (!done) - break; // work started, blocked on PM state machine + 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--; - assert(gIOPMBusyCount > 0); - if (gIOPMBusyCount) - gIOPMBusyCount--; + if (request == fQuiesceRequest) + { + fQuiesceRequest = 0; + } - queue_remove_first(queue, request, IOPMRequest *, fCommandChain); + queue_remove_first(requestQueue, request, typeof(request), fCommandChain); more |= (*fRetireAction)( target, request, this ); - done = queue_empty(queue); + done = queue_empty(requestQueue); } while (!done); *empty = done; if (more) { - // Retired request blocks another request, since the - // blocked request may reside in the work queue, we - // must bump the producer count to avoid work stall. + // Retired a request that may unblock a previously visited request + // that is still waiting on the work queue. Must trigger another + // queue check. fProducerCount++; } @@ -7724,17 +8457,17 @@ bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty ) bool IOPMWorkQueue::checkForWork( void ) { - IOServicePM * entry; - IOServicePM * next; - bool more = false; + IOServicePM * entry; + IOServicePM * next; + bool more = false; bool empty; #if WORK_QUEUE_STATS fStatCheckForWork++; #endif - // Each producer signal triggers a full iteration over - // all IOServicePM entries in the work queue. + // Iterate over all IOServicePM entries in the work queue, + // and check each entry's request queue. while (fConsumerCount != fProducerCount) { @@ -7743,38 +8476,38 @@ bool IOPMWorkQueue::checkForWork( void ) fConsumerCount = fProducerCount; -#if WORK_QUEUE_STATS +#if WORK_QUEUE_STATS if (queue_empty(&fWorkQueue)) { fStatQueueEmpty++; break; } fStatScanEntries++; - uint32_t cachedWorkCount = gIOPMWorkCount; + uint32_t cachedWorkCount = gIOPMWorkInvokeCount; #endif - entry = (IOServicePM *) queue_first(&fWorkQueue); + __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. - next = (IOServicePM *) queue_next(&entry->WorkChain); + __IGNORE_WCASTALIGN(next = (typeof(next)) queue_next(&entry->WorkChain)); - // if request queue is empty, remove IOServicePM from queue. + // 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, entry); - queue_remove(&fWorkQueue, entry, IOServicePM *, WorkChain); + fQueueLength, entry->Name, OBFUSCATE(entry)); + queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain); } entry = next; } #if WORK_QUEUE_STATS - if (cachedWorkCount == gIOPMWorkCount) + if (cachedWorkCount == gIOPMWorkInvokeCount) fStatNoWorkDone++; #endif } @@ -7785,7 +8518,7 @@ bool IOPMWorkQueue::checkForWork( void ) void IOPMWorkQueue::signalWorkAvailable( void ) { fProducerCount++; - IOEventSource::signalWorkAvailable(); + IOEventSource::signalWorkAvailable(); } void IOPMWorkQueue::incrementProducerCount( void ) @@ -7793,6 +8526,42 @@ void IOPMWorkQueue::incrementProducerCount( void ) fProducerCount++; } +void IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest ) +{ + IOServicePM * entry; + IOPMRequest * request; + + 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. + + if (request->isQuiesceBlocker()) + { + request->attachNextRequest(quiesceRequest); + } + } + } +} + +void IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest ) +{ + if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) && + (fQuiesceStartTime != 0)) + { + fInvokeAction = 0; + fQuiesceFinishTime = mach_absolute_time(); + } +} + // MARK: - // MARK: IOPMCompletionQueue @@ -7805,50 +8574,50 @@ 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 = 0; + } + return me; } bool IOPMCompletionQueue::init( IOService * inOwner, Action inAction ) { - if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) + 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 more; - assert(request); + assert(request); // unblock dependent request more = request->detachNextRequest(); - queue_enter(&fQueue, request, IOPMRequest *, fCommandChain); + queue_enter(&fQueue, request, typeof(request), fCommandChain); return more; } 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 = (IOPMRequest *) queue_first(&fQueue); + request = (typeof(request)) queue_first(&fQueue); while (!queue_end(&fQueue, (queue_entry_t) request)) { - next = (IOPMRequest *) queue_next(&request->fCommandChain); - if (!request->isFreeBlocked()) + next = (typeof(next)) queue_next(&request->fCommandChain); + if (!request->isFreeBlocked()) { - queue_remove(&fQueue, request, IOPMRequest *, fCommandChain); + queue_remove(&fQueue, request, typeof(request), fCommandChain); target = request->getTarget(); assert(target); more |= (*dqAction)( target, request, this ); @@ -7881,14 +8650,24 @@ setPMProperty( OSDictionary * dict, const char * key, uint64_t value ) } } -IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) +IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) const { - OSDictionary * dict; - bool ok = false; - int dictSize = 5; + OSDictionary * dict; + bool ok = false; + int powerClamp = -1; + int dictSize = 6; + + if (IdleTimerPeriod) + dictSize += 4; - 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) @@ -7901,9 +8680,10 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) else dict = OSDictionary::withCapacity(dictSize); - if (dict) - { + if (dict) + { setPMProperty(dict, "CurrentPowerState", CurrentPowerState); + setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags); if (NumberOfPowerStates) setPMProperty(dict, "MaxPowerState", NumberOfPowerStates-1); if (DesiredPowerState != CurrentPowerState) @@ -7912,39 +8692,41 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) setPMProperty(dict, "MachineState", MachineState); if (DeviceOverrideEnabled) dict->setObject("PowerOverrideOn", kOSBooleanTrue); + if (powerClamp >= 0) + setPMProperty(dict, "PowerClamp", powerClamp); - if (IdleTimerPeriod) - { + if (IdleTimerPeriod) + { AbsoluteTime now; AbsoluteTime delta; uint64_t nsecs; clock_get_uptime(&now); - // The idle timer period in milliseconds. - setPMProperty(dict, "IdleTimerPeriod", IdleTimerPeriod * 1000ULL); + // The idle timer period in milliseconds + setPMProperty(dict, "IdleTimerPeriod", NextIdleTimerPeriod * 1000ULL); - // The number of activity tickles recorded since device idle + // Number of tickles since the last idle timer expiration setPMProperty(dict, "ActivityTickles", ActivityTickleCount); if (AbsoluteTime_to_scalar(&DeviceActiveTimestamp)) { - // The number of milliseconds since the last activity tickle. + // 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 (AbsoluteTime_to_scalar(&IdleTimerStartTime)) + if (!IdleTimerStopped && AbsoluteTime_to_scalar(&IdleTimerStartTime)) { - // The number of milliseconds since the last device idle. + // Idle timer elapsed time in milliseconds delta = now; SUB_ABSOLUTETIME(&delta, &IdleTimerStartTime); absolutetime_to_nanoseconds(delta, &nsecs); - setPMProperty(dict, "TimeSinceDeviceIdle", NS_TO_MS(nsecs)); + setPMProperty(dict, "IdleTimerElapsedTime", NS_TO_MS(nsecs)); } - } + } #if WORK_QUEUE_STATS if (gIOPMRootNode == Owner) @@ -7966,73 +8748,75 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) 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 { IOReturn ret = kIOReturnNotReady; - if (gIOPMWorkLoop) - { - ret = gIOPMWorkLoop->runAction( + 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); } -PMEventDetails* PMEventDetails::eventDetails(uint32_t type, - const char *ownerName, - uintptr_t ownerUnique, - const char *interestName, - uint8_t oldState, - uint8_t newState, - uint32_t result, - uint32_t elapsedTimeUS) { - - PMEventDetails *myself; - myself = new PMEventDetails; - - if(myself) { - myself->eventType = type; - myself->ownerName = ownerName; - myself->ownerUnique = ownerUnique; - myself->interestName = interestName; - myself->oldState = oldState; - myself->newState = newState; - myself->result = result; - myself->elapsedTimeUS = elapsedTimeUS; - - myself->eventClassifier = kIOPMEventClassDriverEvent; - } - - return myself; -} - - -PMEventDetails* PMEventDetails::eventDetails(uint32_t type, - const char *uuid, - uint32_t reason, - uint32_t result) { - - PMEventDetails *myself; - myself = new PMEventDetails; - - if(myself) { - myself->eventType = type; - myself->uuid = uuid; - myself->reason = reason; - myself->result = result; - - myself->eventClassifier = kIOPMEventClassSystemEvent; - } - - return myself; +void IOServicePM::pmPrint( + uint32_t event, + uintptr_t param1, + uintptr_t param2 ) const +{ + gPlatform->PMLog(Name, event, param1, param2); +} + +void IOServicePM::pmTrace( + uint32_t event, + uintptr_t param1, + uintptr_t param2 ) const +{ + const char * who = Name; + uint64_t regId = Owner->getRegistryEntryID(); + uintptr_t name = 0; + + static const uint32_t sStartStopBitField[] = + { 0x00000000, 0x00000040 }; // Only Program Hardware so far + + // 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); + + 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); }