X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/89b3af67bb32e691275bf6fa803d1834b2284115..eee3565979933af707c711411001ba11fe406a3c:/iokit/Kernel/IOServicePM.cpp diff --git a/iokit/Kernel/IOServicePM.cpp b/iokit/Kernel/IOServicePM.cpp index 7993b7458..e7fbb0802 100644 --- a/iokit/Kernel/IOServicePM.cpp +++ b/iokit/Kernel/IOServicePM.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 1998-2016 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * @@ -27,376 +27,702 @@ */ #include - -#include #include #include #include #include #include -#include +#include #include +#include +#include +#include -#include +#include #include #include -#include #include #include +#include +#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); +static void tellAppClientApplier(OSObject * object, void * arg); + +static uint64_t computeTimeDeltaNS( const AbsoluteTime * start ) +{ + AbsoluteTime now; + uint64_t nsec; + + clock_get_uptime(&now); + SUB_ABSOLUTETIME(&now, start); + absolutetime_to_nanoseconds(now, &nsec); + return nsec; +} + +#if PM_VARS_SUPPORT +OSDefineMetaClassAndStructors(IOPMprot, OSObject) +#endif + +//****************************************************************************** +// Globals +//****************************************************************************** + +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) + type = gIOPMRequest->getType(); + return type; +} + +static IOPMRequestTag getPMRequestTag( void ) +{ + IOPMRequestTag tag = 0; + if (gIOPMRequest && + (gIOPMRequest->getType() == kIOPMRequestTypeRequestPowerStateOverride)) + { + tag = gIOPMRequest->fRequestTag; + } + return tag; +} -#define super IORegistryEntry +SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gCanSleepTimeout, 0, "Power Management Timeout"); -#define OUR_PMLog(t, a, b) \ - do { pm_vars->thePlatform->PMLog(pm_vars->ourName, t, a, b); } while(0) +//****************************************************************************** +// Macros +//****************************************************************************** -static void ack_timer_expired(thread_call_param_t); -static void settle_timer_expired(thread_call_param_t); -static void PM_idle_timer_expired(OSObject *, IOTimerEventSource *); -void tellAppWithResponse ( OSObject * object, void * context); -void tellClientWithResponse ( OSObject * object, void * context); -void tellClient ( OSObject * object, void * context); -IOReturn serializedAllowPowerChange ( OSObject *, void *, void *, void *, void *); -IOReturn serializedCancelPowerChange ( OSObject *, void *, void *, void *, void *); +#define PM_ERROR(x...) do { kprintf(x);IOLog(x); \ + } while (false) +#define PM_LOG(x...) do { kprintf(x); } while (false) -extern const IORegistryPlane * gIOPowerPlane; +#define PM_LOG1(x...) do { \ + if (kIOLogDebugPower & gIOKitDebug) \ + kprintf(x); } while (false) +#define PM_LOG2(x...) do { \ + if (kIOLogDebugPower & gIOKitDebug) \ + kprintf(x); } while (false) -// and there's 1000 nanoseconds in a microsecond: -#define ns_per_us 1000 +#if 0 +#define PM_LOG3(x...) do { kprintf(x); } while (false) +#else +#define PM_LOG3(x...) +#endif +#define RD_LOG(x...) do { \ + if ((kIOLogPMRootDomain & gIOKitDebug) && \ + (getPMRootDomain() == this)) { \ + kprintf("PMRD: " x); \ + }} while (false) +#define PM_ASSERT_IN_GATE(x) \ +do { \ + assert(gIOPMWorkLoop->inGate()); \ +} while(false) + +#define PM_LOCK() IOLockLock(fPMLock) +#define PM_UNLOCK() IOLockUnlock(fPMLock) +#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*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 { \ + if (pwrMgt) { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, DBG_FUNC_NONE, a, b); \ + } \ + } while(0) + +#define OUR_PMLogFuncStart(t, a, b) do { \ + if (pwrMgt) { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, DBG_FUNC_START, a, b); \ + } \ + } while(0) + +#define OUR_PMLogFuncEnd(t, a, b) do { \ + if (pwrMgt) { \ + if (gIOKitDebug & kIOLogPower) \ + pwrMgt->pmPrint(-t, a, b); \ + if (gIOKitTrace & kIOTracePowerMgmt) \ + pwrMgt->pmTrace(t, DBG_FUNC_END, a, b); \ + } \ + } while(0) + +#define NS_TO_MS(nsec) ((int)((nsec) / 1000000ULL)) +#define NS_TO_US(nsec) ((int)((nsec) / 1000ULL)) + +#define SUPPORT_IDLE_CANCEL 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 (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): +#define LOG_APP_RESPONSE_MSG_TRACER (3 * 1000ULL * 1000ULL * 1000ULL) -// The current change note is processed by a state machine. -// Inputs are acks from interested parties, ack from the controlling driver, -// ack timeouts, settle timeout, and powerStateDidChange from the parent. -// These are the states: enum { - kIOPM_OurChangeTellClientsPowerDown = 1, - kIOPM_OurChangeTellPriorityClientsPowerDown, - kIOPM_OurChangeNotifyInterestedDriversWillChange, - kIOPM_OurChangeSetPowerState, - kIOPM_OurChangeWaitForPowerSettle, - kIOPM_OurChangeNotifyInterestedDriversDidChange, - kIOPM_OurChangeFinish, - kIOPM_ParentDownTellPriorityClientsPowerDown_Immediate, - kIOPM_ParentDownNotifyInterestedDriversWillChange_Delayed, - kIOPM_ParentDownWaitForPowerSettleAndNotifyDidChange_Immediate, - kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed, - kIOPM_ParentDownSetPowerState_Delayed, - kIOPM_ParentDownWaitForPowerSettle_Delayed, - kIOPM_ParentDownAcknowledgeChange_Delayed, - kIOPM_ParentUpSetPowerState_Delayed, - kIOPM_ParentUpSetPowerState_Immediate, - kIOPM_ParentUpWaitForSettleTime_Delayed, - kIOPM_ParentUpNotifyInterestedDriversDidChange_Delayed, - kIOPM_ParentUpAcknowledgePowerChange_Delayed, - kIOPM_Finished + kReserveDomainPower = 1 }; -// values of outofbandparameter +#define MS_PUSH(n) \ + do { assert(kIOPM_BadMachineState == fSavedMachineState); \ + assert(kIOPM_BadMachineState != n); \ + fSavedMachineState = n; } while (false) + +#define MS_POP() \ + do { assert(kIOPM_BadMachineState != fSavedMachineState); \ + fMachineState = fSavedMachineState; \ + fSavedMachineState = kIOPM_BadMachineState; } while (false) + +#define PM_ACTION_0(a) \ + do { if (fPMActions.a) { \ + (fPMActions.a)(fPMActions.target, this, &fPMActions); } \ + } while (false) + +#define PM_ACTION_2(a, x, y) \ + do { if (fPMActions.a) { \ + (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y, \ + getPMRequestTag()); } \ + } while (false) + +#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, + IOPMInterestContext *context); + +static void logClientIDForNotification( + OSObject *object, + IOPMInterestContext *context, + const char *logString); + +//********************************************************************************* +// PM machine states +// +// Check kgmacros after modifying machine states. +//********************************************************************************* + enum { - kNotifyApps, - kNotifyPriority + kIOPM_Finished = 0, + + kIOPM_OurChangeTellClientsPowerDown = 1, + kIOPM_OurChangeTellUserPMPolicyPowerDown = 2, + kIOPM_OurChangeTellPriorityClientsPowerDown = 3, + kIOPM_OurChangeNotifyInterestedDriversWillChange = 4, + kIOPM_OurChangeSetPowerState = 5, + kIOPM_OurChangeWaitForPowerSettle = 6, + kIOPM_OurChangeNotifyInterestedDriversDidChange = 7, + kIOPM_OurChangeTellCapabilityDidChange = 8, + kIOPM_OurChangeFinish = 9, + + kIOPM_ParentChangeTellPriorityClientsPowerDown = 10, + kIOPM_ParentChangeNotifyInterestedDriversWillChange = 11, + kIOPM_ParentChangeSetPowerState = 12, + kIOPM_ParentChangeWaitForPowerSettle = 13, + kIOPM_ParentChangeNotifyInterestedDriversDidChange = 14, + kIOPM_ParentChangeTellCapabilityDidChange = 15, + kIOPM_ParentChangeAcknowledgePowerChange = 16, + + kIOPM_NotifyChildrenStart = 17, + kIOPM_NotifyChildrenOrdered = 18, + kIOPM_NotifyChildrenDelayed = 19, + kIOPM_SyncTellClientsPowerDown = 20, + kIOPM_SyncTellPriorityClientsPowerDown = 21, + kIOPM_SyncNotifyWillChange = 22, + kIOPM_SyncNotifyDidChange = 23, + kIOPM_SyncTellCapabilityDidChange = 24, + kIOPM_SyncFinish = 25, + kIOPM_TellCapabilityChangeDone = 26, + kIOPM_DriverThreadCallDone = 27, + + kIOPM_BadMachineState = 0xFFFFFFFF }; +//********************************************************************************* +// [public] PMinit +// +// Initialize power management. +//********************************************************************************* -// used for applyToInterested -struct context { - OSArray * responseFlags; - UInt16 serialNumber; - UInt16 counter; - UInt32 maxTimeRequested; - int msgType; - IOService * us; - IOLock * flags_lock; - unsigned long stateNumber; - IOPMPowerFlags stateFlags; -}; +void IOService::PMinit( void ) +{ + if ( !initialized ) + { + if ( !gIOPMInitialized ) + { + gPlatform = getPlatform(); + gIOPMWorkLoop = IOWorkLoop::workLoop(); + if (gIOPMWorkLoop) + { + gIOPMRequestQueue = IOPMRequestQueue::create( + this, OSMemberFunctionCast(IOPMRequestQueue::Action, + this, &IOService::actionPMRequestQueue)); + + gIOPMReplyQueue = IOPMRequestQueue::create( + this, OSMemberFunctionCast(IOPMRequestQueue::Action, + this, &IOService::actionPMReplyQueue)); + + gIOPMWorkQueue = IOPMWorkQueue::create(this, + OSMemberFunctionCast(IOPMWorkQueue::Action, this, + &IOService::actionPMWorkQueueInvoke), + OSMemberFunctionCast(IOPMWorkQueue::Action, this, + &IOService::actionPMWorkQueueRetire)); + + gIOPMCompletionQueue = IOPMCompletionQueue::create( + this, OSMemberFunctionCast(IOPMCompletionQueue::Action, + this, &IOService::actionPMCompletionQueue)); + + if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) != + kIOReturnSuccess) + { + gIOPMRequestQueue->release(); + gIOPMRequestQueue = 0; + } -// five minutes in microseconds -#define FIVE_MINUTES 5*60*1000000 -#define k30seconds 30*1000000 + if (gIOPMWorkLoop->addEventSource(gIOPMReplyQueue) != + kIOReturnSuccess) + { + gIOPMReplyQueue->release(); + gIOPMReplyQueue = 0; + } + + if (gIOPMWorkLoop->addEventSource(gIOPMWorkQueue) != + kIOReturnSuccess) + { + gIOPMWorkQueue->release(); + gIOPMWorkQueue = 0; + } + + // Must be added after the work queue, which pushes request + // to the completion queue without signaling the work loop. + if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) != + kIOReturnSuccess) + { + gIOPMCompletionQueue->release(); + gIOPMCompletionQueue = 0; + } + + gIOPMPowerClientDevice = + OSSymbol::withCStringNoCopy( "DevicePowerState" ); + + gIOPMPowerClientDriver = + OSSymbol::withCStringNoCopy( "DriverPowerState" ); + + gIOPMPowerClientChildProxy = + OSSymbol::withCStringNoCopy( "ChildProxyPowerState" ); + + gIOPMPowerClientChildren = + OSSymbol::withCStringNoCopy( "ChildrenPowerState" ); + + gIOPMPowerClientAdvisoryTickle = + OSSymbol::withCStringNoCopy( "AdvisoryTicklePowerState" ); + + gIOPMPowerClientRootDomain = + OSSymbol::withCStringNoCopy( "RootDomainPower" ); + + gIOSpinDumpKextName[0] = '\0'; + gIOSpinDumpDelayType[0] = '\0'; + } + + if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue) + gIOPMInitialized = true; + } + if (!gIOPMInitialized) + return; + + pwrMgt = new IOServicePM; + pwrMgt->init(); + setProperty(kPwrMgtKey, pwrMgt); + + queue_init(&pwrMgt->WorkChain); + queue_init(&pwrMgt->RequestHead); + queue_init(&pwrMgt->PMDriverCallQueue); + + fOwner = this; + fPMLock = IOLockAlloc(); + fInterestedDrivers = new IOPMinformeeList; + fInterestedDrivers->initialize(); + fDesiredPowerState = kPowerStateZero; + fDeviceDesire = kPowerStateZero; + fInitialPowerChange = true; + fInitialSetPowerState = true; + fPreviousRequestPowerFlags = 0; + fDeviceOverrideEnabled = false; + fMachineState = kIOPM_Finished; + fSavedMachineState = kIOPM_BadMachineState; + fIdleTimerMinPowerState = kPowerStateZero; + fActivityLock = IOLockAlloc(); + fStrictTreeOrder = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + fAdvisoryTicklePowerState = kInvalidTicklePowerState; + fControllingDriver = NULL; + fPowerStates = NULL; + fNumberOfPowerStates = 0; + fCurrentPowerState = kPowerStateZero; + fParentsCurrentPowerFlags = 0; + fMaxPowerState = kPowerStateZero; + fName = getName(); + fParentsKnowState = false; + fSerialNumber = 0; + fResponseArray = NULL; + fNotifyClientArray = NULL; + fCurrentPowerConsumption = kIOPMUnknown; + fOverrideMaxPowerState = kIOPMPowerStateMax; + + if (!gIOPMRootNode && (getParentEntry(gIOPowerPlane) == getRegistryRoot())) + { + gIOPMRootNode = this; + fParentsKnowState = true; + } + else if (getProperty(kIOPMResetPowerStateOnWakeKey) == kOSBooleanTrue) + { + fResetPowerStateOnWake = true; + } + + if (IS_ROOT_DOMAIN) + { + fWatchdogTimer = thread_call_allocate( + &IOService::watchdog_timer_expired, (thread_call_param_t)this); + } + + fAckTimer = thread_call_allocate( + &IOService::ack_timer_expired, (thread_call_param_t)this); + fSettleTimer = thread_call_allocate( + &settle_timer_expired, (thread_call_param_t)this); + fIdleTimer = thread_call_allocate( + &idle_timer_expired, (thread_call_param_t)this); + fDriverCallEntry = thread_call_allocate( + (thread_call_func_t) &IOService::pmDriverCallout, this); + assert(fDriverCallEntry); + if (kIOKextSpinDump & gIOKitDebug) + { + fSpinDumpTimer = thread_call_allocate( + &IOService::spindump_timer_expired, (thread_call_param_t)this); + } + + // Check for powerChangeDone override. + if (OSMemberFunctionCast(void (*)(void), + getResourceService(), &IOService::powerChangeDone) != + OSMemberFunctionCast(void (*)(void), + this, &IOService::powerChangeDone)) + { + fPCDFunctionOverride = true; + } + +#if PM_VARS_SUPPORT + IOPMprot * prot = new IOPMprot; + if (prot) + { + prot->init(); + prot->ourName = fName; + prot->thePlatform = gPlatform; + fPMVars = prot; + pm_vars = prot; + } +#else + pm_vars = (void *) (uintptr_t) true; +#endif -/* - 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 slightly differently. - -There is a queue of so-called change notifications, or change notes for short. Usually the queue is empty, and when - it isn't, usually there is one change note in it, but since it's possible to have more than one power state change pending - at one time, 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. - - 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. - - This is 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. - - This is 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 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, and - We will not take advantage of a change to a higher domain state, because we have no need of the higher power. - In such a case, 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. - - 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: - - 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. - - 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 "OurChangeSetPowerState". Otherwise, we start the ack timer and wait for the stragglers to acknowlege by calling - acknowledgePowerChange. We move on to state "OurChangeSetPowerState" when all the stragglers have acknowledged, - or when the ack timer expires on all those which didn't acknowledge. In "OurChangeSetPowerState" 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 "OurChangeWaitForPowerSettle". - 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 "OurChangeWaitForPowerSettle", 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 "OurChangeNotifyInterestedDriversDidChange". Otherwise, we - set the settle timer and wait. When it expires, we move on. In "OurChangeNotifyInterestedDriversDidChange" 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 "OurChangeFinish". 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 "OurChangeFinish", where we remove the used - change note from the head of the queue and start the next one if one exists. - - Parent-initiated changes are more complex in the state machine. First, power going up and power going down are handled - differently, so they have different paths throught the state machine. Second, we can acknowledge the parent's notification - in two different ways, so each of the parent paths is really two. - - When the parent calls our powerDomainWillChange method, notifying us that it will lower power in the domain, we decide - what state that will put our device in. Then we embark on the state machine path "IOPMParentDownSetPowerState_Immediate" - and "kIOPM_ParentDownWaitForPowerSettleAndNotifyDidChange_Immediate", in which we notify interested parties of the upcoming change, instruct our driver to make - the change, check for settle time, and notify interested parties of the completed change. If we get to the end of this path without - stalling due to an interested party which didn't acknowledge via return code, due to the controlling driver not able to change - state right away, or due to a non-zero settling time, then we return IOPMAckImplied to the parent, and we're done with the change. - If we do stall in any of those states, we return IOPMWillAckLater to the parent and enter the parallel path "kIOPM_ParentDownSetPowerState_Delayed" - "kIOPM_ParentDownWaitForPowerSettle_Delayed", and "kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed", where we continue with the same processing, except that at the end we - acknowledge the parent explicitly via acknowledgePowerChange, and we're done with the change. -Then when the parent calls us at powerStateDidChange we acknowledging via return code, because we have already made - the power change. In any case, when we are done we remove the used change note from the head of the queue and start on the next one. - - The case of the parent raising power in the domain is handled similarly in that there are parallel paths, one for no-stall - that ends in implicit acknowleging the parent, and one that has stalled at least once that ends in explicit acknowledging - the parent. This case is different, though in that our device changes state in the second half, after the parent calls - powerStateDidChange rather than before, as in the power-lowering case. - - When the parent calls our powerDomainWillChange method, notifying us that it will raise power in the domain, we acknowledge - via return code, because there's really nothing we can do until the power is actually raised in the domain. - When the parent calls us at powerStateDidChange, we start by notifying our interested parties. If they all acknowledge via return code, - we go on to" kIOPM_ParentUpSetPowerState_Immediate" to instruct the driver to raise its power level. After that, we check for any - necessary settling time in "IOPMParentUpWaitForSettleTime_Immediate", and we notify all interested parties that power has changed - in "IOPMParentUpNotifyInterestedDriversDidChange_Immediate". If none of these operations stall, we acknowledge the parent via return code, release - the change note, and start the next, if there is one. If one of them does stall, we enter the parallel path "kIOPM_ParentUpSetPowerState_Delayed", - "kIOPM_ParentUpWaitForSettleTime_Delayed", "kIOPM_ParentUpNotifyInterestedDriversDidChange_Delayed", and "kIOPM_ParentUpAcknowledgePowerChange_Delayed", which ends with - our explicit acknowledgement to the parent. - -*/ - - -const char priv_key[ ] = "Power Management private data"; -const char prot_key[ ] = "Power Management protected data"; - - -void IOService::PMinit ( void ) -{ - if ( ! initialized ) { - - // make space for our variables - pm_vars = new IOPMprot; - priv = new IOPMpriv; - pm_vars->init(); - priv->init(); - - - // add pm_vars & priv to the properties - setProperty(prot_key, (OSObject *) pm_vars); - setProperty(priv_key, (OSObject *) priv); - - // then initialize them - priv->owner = this; - pm_vars->theNumberOfPowerStates = 0; - priv->we_are_root = false; - pm_vars->theControllingDriver = NULL; - priv->our_lock = IOLockAlloc(); - priv->flags_lock = IOLockAlloc(); - priv->queue_lock = IOLockAlloc(); - pm_vars->childLock = IOLockAlloc(); - pm_vars->parentLock = IOLockAlloc(); - priv->interestedDrivers = new IOPMinformeeList; - priv->interestedDrivers->initialize(); - priv->changeList = new IOPMchangeNoteList; - priv->changeList->initialize(); - pm_vars->aggressiveness = 0; - for (unsigned int i = 0; i <= kMaxType; i++) - { - pm_vars->current_aggressiveness_values[i] = 0; - pm_vars->current_aggressiveness_valid[i] = false; - } - pm_vars->myCurrentState = 0; - priv->imminentState = 0; - priv->ourDesiredPowerState = 0; - pm_vars->parentsCurrentPowerFlags = 0; - pm_vars->maxCapability = 0; - priv->driverDesire = 0; - priv->deviceDesire = 0; - priv->initial_change = true; - priv->need_to_become_usable = false; - priv->previousRequest = 0; - priv->device_overrides = false; - priv->machine_state = kIOPM_Finished; - priv->timerEventSrc = NULL; - priv->clampTimerEventSrc = NULL; - pm_vars->PMworkloop = NULL; - priv->activityLock = NULL; - pm_vars->ourName = getName(); - pm_vars->thePlatform = getPlatform(); - pm_vars->parentsKnowState = false; - assert( pm_vars->thePlatform != 0 ); - priv->clampOn = false; - pm_vars->serialNumber = 0; - pm_vars->responseFlags = NULL; - pm_vars->doNotPowerDown = true; - pm_vars->PMcommandGate = NULL; - priv->ackTimer = thread_call_allocate( - (thread_call_func_t)ack_timer_expired, - (thread_call_param_t)this); - priv->settleTimer = thread_call_allocate( - (thread_call_func_t)settle_timer_expired, - (thread_call_param_t)this); - initialized = true; } } - //********************************************************************************* -// PMfree +// [private] PMfree // -// Free up the data created in PMinit, if it exists. +// Free the data created by PMinit. Only called from IOService::free(). //********************************************************************************* -void IOService::PMfree ( void ) + +void IOService::PMfree( void ) { - if ( priv ) { - if ( priv->clampTimerEventSrc != NULL ) { - getPMworkloop()->removeEventSource(priv->clampTimerEventSrc); - priv->clampTimerEventSrc->release(); - priv->clampTimerEventSrc = NULL; + initialized = false; + pm_vars = 0; + + if ( pwrMgt ) + { + assert(fMachineState == kIOPM_Finished); + assert(fInsertInterestSet == NULL); + assert(fRemoveInterestSet == NULL); + assert(fNotifyChildArray == NULL); + assert(queue_empty(&pwrMgt->RequestHead)); + assert(queue_empty(&fPMDriverCallQueue)); + + if (fWatchdogTimer) { + thread_call_cancel(fWatchdogTimer); + thread_call_free(fWatchdogTimer); + fWatchdogTimer = NULL; } - if ( priv->timerEventSrc != NULL ) { - pm_vars->PMworkloop->removeEventSource(priv->timerEventSrc); - priv->timerEventSrc->release(); - priv->timerEventSrc = NULL; + + if ( fSettleTimer ) { + thread_call_cancel(fSettleTimer); + thread_call_free(fSettleTimer); + fSettleTimer = NULL; } - if ( priv->settleTimer ) { - thread_call_cancel(priv->settleTimer); - thread_call_free(priv->settleTimer); - priv->settleTimer = NULL; + if ( fAckTimer ) { + thread_call_cancel(fAckTimer); + thread_call_free(fAckTimer); + fAckTimer = NULL; } - if ( priv->ackTimer ) { - thread_call_cancel(priv->ackTimer); - thread_call_free(priv->ackTimer); - priv->ackTimer = NULL; + if ( fIdleTimer ) { + thread_call_cancel(fIdleTimer); + thread_call_free(fIdleTimer); + fIdleTimer = NULL; } - if ( priv->our_lock ) { - IOLockFree(priv->our_lock); - priv->our_lock = NULL; + if ( fDriverCallEntry ) { + thread_call_free(fDriverCallEntry); + fDriverCallEntry = NULL; } - if ( priv->flags_lock ) { - IOLockFree(priv->flags_lock); - priv->flags_lock = NULL; + if ( fSpinDumpTimer ) { + thread_call_cancel(fSpinDumpTimer); + thread_call_free(fSpinDumpTimer); + fSpinDumpTimer = NULL; } - if ( priv->activityLock ) { - IOLockFree(priv->activityLock); - priv->activityLock = NULL; + if ( fPMLock ) { + IOLockFree(fPMLock); + fPMLock = NULL; } - priv->interestedDrivers->release(); - priv->changeList->release(); - // remove instance variables - priv->release(); - } - - if ( pm_vars ) { - if ( pm_vars->PMcommandGate ) { - if(pm_vars->PMworkloop) - pm_vars->PMworkloop->removeEventSource(pm_vars->PMcommandGate); - pm_vars->PMcommandGate->release(); - pm_vars->PMcommandGate = NULL; + if ( fActivityLock ) { + IOLockFree(fActivityLock); + fActivityLock = NULL; + } + if ( fInterestedDrivers ) { + fInterestedDrivers->release(); + fInterestedDrivers = NULL; + } + if (fDriverCallParamSlots && fDriverCallParamPtr) { + IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots); + fDriverCallParamPtr = 0; + fDriverCallParamSlots = 0; + } + if ( fResponseArray ) { + fResponseArray->release(); + fResponseArray = NULL; + } + if ( fNotifyClientArray ) { + fNotifyClientArray->release(); + fNotifyClientArray = NULL; } - if ( pm_vars->PMworkloop ) { - // The work loop object returned from getPMworkLoop() is - // never retained, therefore it should not be released. - // pm_vars->PMworkloop->release(); - pm_vars->PMworkloop = NULL; + if (fPowerStates && fNumberOfPowerStates) { + IODelete(fPowerStates, IOPMPSEntry, fNumberOfPowerStates); + fNumberOfPowerStates = 0; + fPowerStates = NULL; } - if ( pm_vars->responseFlags ) { - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; + if (fPowerClients) { + fPowerClients->release(); + fPowerClients = 0; } - // remove instance variables - pm_vars->release(); + +#if PM_VARS_SUPPORT + if (fPMVars) + { + fPMVars->release(); + fPMVars = 0; + } +#endif + + pwrMgt->release(); + pwrMgt = 0; } } +void IOService::PMDebug( uint32_t event, uintptr_t param1, uintptr_t param2 ) +{ + OUR_PMLog(event, param1, param2); +} //********************************************************************************* -// PMstop +// [public] joinPMtree +// +// A policy-maker calls its nub here when initializing, to be attached into +// the power management hierarchy. The default function is to call the +// platform expert, which knows how to do it. This method is overridden +// by a nub subclass which may either know how to do it, or may need to +// take other action. // -// Disconnect the node from its parents and children in the Power Plane. +// This may be the only "power management" method used in a nub, +// meaning it may not be initialized for power management. //********************************************************************************* -void IOService::PMstop ( void ) + +void IOService::joinPMtree( IOService * driver ) { - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - IOService * theChild; - IOService * theParent; + IOPlatformExpert * platform; - // remove the properties - removeProperty(prot_key); - removeProperty(priv_key); - - // detach parents - iter = getParentIterator(gIOPowerPlane); + platform = getPlatform(); + assert(platform != 0); + platform->PMRegisterDevice(this, driver); +} + +#ifndef __LP64__ +//********************************************************************************* +// [deprecated] youAreRoot +// +// Power Managment is informing us that we are the root power domain. +//********************************************************************************* + +IOReturn IOService::youAreRoot( void ) +{ + return IOPMNoErr; +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// [public] PMstop +// +// Immediately stop driver callouts. Schedule an async stop request to detach +// from power plane. +//********************************************************************************* + +void IOService::PMstop( void ) +{ + IOPMRequest * request; - if ( iter ) + if (!initialized) + return; + + PM_LOCK(); + + if (fLockedFlags.PMStop) + { + PM_LOG2("%s: PMstop() already stopped\n", fName); + PM_UNLOCK(); + return; + } + + // Inhibit future driver calls. + fLockedFlags.PMStop = true; + + // Wait for all prior driver calls to finish. + waitForPMDriverCall(); + + PM_UNLOCK(); + + // The rest of the work is performed async. + request = acquirePMRequest( this, kIOPMRequestTypePMStop ); + if (request) + { + PM_LOG2("%s: %p PMstop\n", getName(), OBFUSCATE(this)); + submitPMRequest( request ); + } +} + +//********************************************************************************* +// [private] handlePMstop +// +// Disconnect the node from all parents and children in the power plane. +//********************************************************************************* + +void IOService::handlePMstop( IOPMRequest * request ) +{ + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOService * theChild; + IOService * theParent; + + PM_ASSERT_IN_GATE(); + PM_LOG2("%s: %p %s start\n", getName(), OBFUSCATE(this), __FUNCTION__); + + // remove driver from prevent system sleep lists + getPMRootDomain()->updatePreventIdleSleepList(this, false); + getPMRootDomain()->updatePreventSystemSleepList(this, false); + + // remove the property + removeProperty(kPwrMgtKey); + + // detach parents + iter = getParentIterator(gIOPowerPlane); + if ( iter ) { - while ( (next = iter->getNextObject()) ) + while ( (next = iter->getNextObject()) ) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) { theParent = (IOService *)connection->copyParentEntry(gIOPowerPlane); - if ( theParent ) + if ( theParent ) { theParent->removePowerChild(connection); theParent->release(); @@ -406,33 +732,29 @@ void IOService::PMstop ( void ) iter->release(); } - // detach IOConnections - detachAbove( gIOPowerPlane ); - - if ( pm_vars ) - { - // no more power state changes - pm_vars->parentsKnowState = false; - } - - // detach children - iter = getChildIterator(gIOPowerPlane); + // detach IOConnections + detachAbove( gIOPowerPlane ); - if ( iter ) + // no more power state changes + fParentsKnowState = false; + + // detach children + iter = getChildIterator(gIOPowerPlane); + if ( iter ) { - while ( (next = iter->getNextObject()) ) + while ( (next = iter->getNextObject()) ) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) { theChild = ((IOService *)(connection->copyChildEntry(gIOPowerPlane))); - if ( theChild ) + if ( theChild ) { // detach nub from child - connection->detachFromChild(theChild,gIOPowerPlane); + connection->detachFromChild(theChild, gIOPowerPlane); theChild->release(); } // detach us from nub - detachFromChild(connection,gIOPowerPlane); + detachFromChild(connection, gIOPowerPlane); } } iter->release(); @@ -446,380 +768,559 @@ void IOService::PMstop ( void ) // the object will be holding an extra retain on itself, and cannot // be freed. - if ( priv && priv->interestedDrivers ) + if ( fInterestedDrivers ) { - IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; + IOPMinformee * item; - while (( informee = priv->interestedDrivers->firstInList() )) - deRegisterInterestedDriver( informee->whatObject ); + PM_LOCK(); + while ((item = list->firstInList())) + { + list->removeFromList(item->whatObject); + } + PM_UNLOCK(); } -} + // Clear idle period to prevent idleTimerExpired() from servicing + // idle timer expirations. + + fIdleTimerPeriod = 0; + if (fIdleTimer && thread_call_cancel(fIdleTimer)) + release(); + + PM_LOG2("%s: %p %s done\n", getName(), OBFUSCATE(this), __FUNCTION__); +} //********************************************************************************* -// joinPMtree -// -// A policy-maker calls its nub here when initializing, to be attached into -// the power management hierarchy. The default function is to call the -// platform expert, which knows how to do it. This method is overridden -// by a nub subclass which may either know how to do it, or may need -// to take other action. +// [public] addPowerChild // -// This may be the only "power management" method used in a nub, -// meaning it may not be initialized for power management. +// Power Management is informing us who our children are. //********************************************************************************* -void IOService::joinPMtree ( IOService * driver ) + +IOReturn IOService::addPowerChild( IOService * child ) { - IOPlatformExpert * thePlatform; + IOPowerConnection * connection = 0; + IOPMRequest * requests[3] = {0, 0, 0}; + OSIterator * iter; + bool ok = true; - thePlatform = getPlatform(); - assert(thePlatform != 0 ); - thePlatform->PMRegisterDevice(this,driver); -} + if (!child) + return kIOReturnBadArgument; + if (!initialized || !child->initialized) + return IOPMNotYetInitialized; -//********************************************************************************* -// youAreRoot -// -// Power Managment is informing us that we are the root power domain. -// The only difference between us and any other power domain is that -// we have no parent and therefore never call it. -//********************************************************************************* -IOReturn IOService::youAreRoot ( void ) -{ - priv-> we_are_root = true; - pm_vars->parentsKnowState = true; - attachToParent( getRegistryRoot(),gIOPowerPlane ); - - return IOPMNoErr; -} + OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 ); + do { + // Is this child already one of our children? -//********************************************************************************* -// setPowerParent -// -// Power Management is informing us who our parent is. -// If we have a controlling driver, find out, given our newly-informed -// power domain state, what state it would be in, and then tell it -// to assume that state. -//********************************************************************************* -IOReturn IOService::setPowerParent ( IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags currentState ) -{ - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - unsigned long tempDesire; + iter = child->getParentIterator( gIOPowerPlane ); + if ( iter ) + { + IORegistryEntry * entry; + OSObject * next; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSetParent,stateKnown,currentState); - - IOLockLock(pm_vars->parentLock); - - if ( stateKnown && ((pm_vars->PMworkloop == NULL) || (pm_vars->PMcommandGate == NULL)) ) - { - // we have a path to the root - // find out the workloop - getPMworkloop(); - if ( pm_vars->PMworkloop != NULL ) - { - if ( pm_vars->PMcommandGate == NULL ) - { - // and make our command gate - pm_vars->PMcommandGate = IOCommandGate::commandGate((OSObject *)this); - if ( pm_vars->PMcommandGate != NULL ) + while ((next = iter->getNextObject())) + { + if ((entry = OSDynamicCast(IORegistryEntry, next)) && + isChild(entry, gIOPowerPlane)) { - pm_vars->PMworkloop->addEventSource(pm_vars->PMcommandGate); + 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. + + connection = new IOPowerConnection; + if (!connection) + break; + + // 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[1] = acquirePMRequest( + /* target */ child, + /* type */ kIOPMRequestTypeAddPowerChild2 ); + + requests[2] = acquirePMRequest( + /* target */ this, + /* type */ kIOPMRequestTypeAddPowerChild3 ); + + if (!requests[0] || !requests[1] || !requests[2]) + break; + + requests[0]->attachNextRequest( requests[1] ); + requests[1]->attachNextRequest( requests[2] ); + + connection->init(); + connection->start(this); + connection->setAwaitingAck(false); + connection->setReadyFlag(false); + + attachToChild( connection, gIOPowerPlane ); + connection->attachToChild( child, gIOPowerPlane ); + + // connection needs to be released + requests[0]->fArg0 = connection; + requests[1]->fArg0 = connection; + requests[2]->fArg0 = connection; + + submitPMRequests( requests, 3 ); + return kIOReturnSuccess; } - - IOLockUnlock(pm_vars->parentLock); + while (false); - // set our connection data - theParent->setParentCurrentPowerFlags(currentState); - theParent->setParentKnowsState(stateKnown); + if (connection) connection->release(); + if (requests[0]) releasePMRequest(requests[0]); + if (requests[1]) releasePMRequest(requests[1]); + if (requests[2]) releasePMRequest(requests[2]); - // combine parent knowledge - pm_vars->parentsKnowState = true; - pm_vars->parentsCurrentPowerFlags = 0; - - iter = getParentIterator(gIOPowerPlane); + // Silent failure, to prevent platform drivers from adding the child + // to the root domain. + + return kIOReturnSuccess; +} + +//********************************************************************************* +// [private] addPowerChild1 +// +// Step 1/3 of adding a power child. Called on the power parent. +//********************************************************************************* + +void IOService::addPowerChild1( IOPMRequest * request ) +{ + IOPMPowerStateIndex tempDesire = kPowerStateZero; + + // Make us temporary usable before adding the child. - if ( iter ) + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 ); + + if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState) { - while ( (next = iter->getNextObject()) ) - { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) - { - pm_vars->parentsKnowState &= connection->parentKnowsState(); - pm_vars->parentsCurrentPowerFlags |= connection->parentCurrentPowerFlags(); - } - } - iter->release(); + tempDesire = fHighestPowerState; } - - if ( (pm_vars->theControllingDriver != NULL) && - (pm_vars->parentsKnowState) ) + + if ((tempDesire != kPowerStateZero) && + (IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire)))) { - pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentsCurrentPowerFlags); - // initially change into the state we are already in - tempDesire = priv->deviceDesire; - priv->deviceDesire = pm_vars->theControllingDriver->initialPowerStateForDomainState(pm_vars->parentsCurrentPowerFlags); - computeDesiredState(); - priv->previousRequest = 0xffffffff; - changeState(); - // put this back like before - priv->deviceDesire = tempDesire; + adjustPowerState(tempDesire); } - - return IOPMNoErr; } - //********************************************************************************* -// addPowerChild +// [private] addPowerChild2 // -// Power Management is informing us who our children are. +// Step 2/3 of adding a power child. Called on the joining child. +// Execution blocked behind addPowerChild1. //********************************************************************************* -IOReturn IOService::addPowerChild ( IOService * theChild ) + +void IOService::addPowerChild2( IOPMRequest * request ) { - IOPowerConnection *connection; - unsigned int i; + 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); - if ( ! initialized ) + if (!parent || !inPlane(gIOPowerPlane)) { - // we're not a power-managed IOService - return IOPMNotYetInitialized; + PM_LOG("%s: addPowerChild2 not in power plane\n", getName()); + return; } - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAddChild,0,0); + // Parent will be waiting for us to complete this stage. + // It is safe to directly access parent's vars. - // Put ourselves into a usable power state. - // We must be in an "on" power state, as our children must be able to access - // our hardware after joining the power plane. - temporaryMakeUsable(); - - // make a nub - connection = new IOPowerConnection; + knowsState = (parent->fPowerStates) && (parent->fParentsKnowState); + powerState = parent->fCurrentPowerState; - connection->init(); - connection->start(this); - connection->setAwaitingAck(false); - - // connect it up - attachToChild( connection,gIOPowerPlane ); - connection->attachToChild( theChild,gIOPowerPlane ); - connection->release(); - - // tell it the current state of the power domain - if ( (pm_vars->theControllingDriver == NULL) || - ! (inPlane(gIOPowerPlane)) || - ! (pm_vars->parentsKnowState) ) + if (knowsState) + powerFlags = parent->fPowerStates[powerState].outputPowerFlags; + else + powerFlags = 0; + + // Set our power parent. + + OUR_PMLog(kPMLogSetParent, knowsState, powerFlags); + + setParentInfo( powerFlags, connection, knowsState ); + + connection->setReadyFlag(true); + + if ( fControllingDriver && fParentsKnowState ) { - theChild->setPowerParent(connection,false,0); - if ( inPlane(gIOPowerPlane) ) - { - for (i = 0; i <= kMaxType; i++) { - if ( pm_vars->current_aggressiveness_valid[i] ) - { - theChild->setAggressiveness (i, pm_vars->current_aggressiveness_values[i]); - } - } - } - } else { - theChild->setPowerParent(connection,true,pm_vars->thePowerStates[pm_vars->myCurrentState].outputPowerCharacter); - for (i = 0; i <= kMaxType; i++) + fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags); + // initially change into the state we are already in + tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags); + fPreviousRequestPowerFlags = (IOPMPowerFlags)(-1); + adjustPowerState(tempDesire); + } + + getPMRootDomain()->tagPowerPlaneService(this, &fPMActions); +} + +//********************************************************************************* +// [private] addPowerChild3 +// +// Step 3/3 of adding a power child. Called on the parent. +// Execution blocked behind addPowerChild2. +//********************************************************************************* + +void IOService::addPowerChild3( IOPMRequest * request ) +{ + IOPowerConnection * connection = (IOPowerConnection *) request->fArg0; + IOService * child; + IOPMrootDomain * rootDomain = getPMRootDomain(); + + PM_ASSERT_IN_GATE(); + child = (IOService *) connection->getChildEntry(gIOPowerPlane); + + if (child && inPlane(gIOPowerPlane)) + { + if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder")) { - if ( pm_vars->current_aggressiveness_valid[i] ) - { - theChild->setAggressiveness (i, pm_vars->current_aggressiveness_values[i]); - } + PM_LOG1("%s: strict PM order enforced\n", getName()); + fStrictTreeOrder = true; } - // catch it up if change is in progress - add_child_to_active_change(connection); + + if (rootDomain) + rootDomain->joinAggressiveness( child ); } - - return IOPMNoErr; + else + { + PM_LOG("%s: addPowerChild3 not in power plane\n", getName()); + } + + connection->release(); } +#ifndef __LP64__ +//********************************************************************************* +// [deprecated] setPowerParent +// +// Power Management is informing us who our parent is. +// If we have a controlling driver, find out, given our newly-informed +// power domain state, what state it would be in, and then tell it +// to assume that state. +//********************************************************************************* + +IOReturn IOService::setPowerParent( + IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags ) +{ + return kIOReturnUnsupported; +} +#endif /* !__LP64__ */ -//****************************************************************************** -// removePowerChild +//********************************************************************************* +// [public] removePowerChild // -//****************************************************************************** -IOReturn IOService::removePowerChild ( IOPowerConnection * theNub ) +// Called on a parent whose child is being removed by PMstop(). +//********************************************************************************* + +IOReturn IOService::removePowerChild( IOPowerConnection * theNub ) { - IORegistryEntry *theChild; + IORegistryEntry * theChild; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRemoveChild,0,0); + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogRemoveChild, 0, 0 ); theNub->retain(); - + // detach nub from child - theChild = theNub->copyChildEntry(gIOPowerPlane); - if ( theChild ) + theChild = theNub->copyChildEntry(gIOPowerPlane); + if ( theChild ) { theNub->detachFromChild(theChild, gIOPowerPlane); theChild->release(); } // detach from the nub - detachFromChild(theNub,gIOPowerPlane); - - // are we awaiting an ack from this child? - if ( theNub->getAwaitingAck() ) + detachFromChild(theNub, gIOPowerPlane); + + // Are we awaiting an ack from this child? + if ( theNub->getAwaitingAck() ) { // yes, pretend we got one theNub->setAwaitingAck(false); - if ( acquire_lock() ) + if (fHeadNotePendingAcks != 0 ) { - if (priv->head_note_pendingAcks != 0 ) + // that's one fewer ack to worry about + fHeadNotePendingAcks--; + + // is that the last? + if ( fHeadNotePendingAcks == 0 ) { - // that's one fewer ack to worry about - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - // is that the last? - if ( priv->head_note_pendingAcks == 0 ) - { - // yes, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); - // and now we can continue our power change - all_acked(); - } else { - IOUnlock(priv->our_lock); - } - } else { - IOUnlock(priv->our_lock); + stop_ack_timer(); + + // This parent may have a request in the work queue that is + // blocked on fHeadNotePendingAcks=0. And removePowerChild() + // is called while executing the child's PMstop request so they + // can occur simultaneously. IOPMWorkQueue::checkForWork() must + // restart and check all request queues again. + + gIOPMWorkQueue->incrementProducerCount(); } } } theNub->release(); - // if not fully initialized - if ( (pm_vars->theControllingDriver == NULL) || - !(inPlane(gIOPowerPlane)) || - !(pm_vars->parentsKnowState) ) + // A child has gone away, re-scan children desires and clamp bits. + // The fPendingAdjustPowerRequest helps to reduce redundant parent work. + + if (!fAdjustPowerScheduled) { - // we can do no more - return IOPMNoErr; + IOPMRequest * request; + request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); + if (request) + { + submitPMRequest( request ); + fAdjustPowerScheduled = true; + } } - // Perhaps the departing child was holding up idle or system sleep - we - // need to re-evaluate our childrens' requests. - // Clear and re-calculate our kIOPMChildClamp and kIOPMChildClamp2 bits. - rebuildChildClampBits(); - - // Change state if we can now tolerate lower power - computeDesiredState(); - changeState(); - return IOPMNoErr; } - //********************************************************************************* -// registerPowerDriver +// [public] registerPowerDriver // // A driver has called us volunteering to control power to our device. -// If the power state array it provides is richer than the one we already -// know about (supplied by an earlier volunteer), then accept the offer. -// Notify all interested parties of our power state, which we now know. //********************************************************************************* -IOReturn IOService::registerPowerDriver ( IOService * controllingDriver, IOPMPowerState* powerStates, unsigned long numberOfStates ) +IOReturn IOService::registerPowerDriver( + IOService * powerDriver, + IOPMPowerState * powerStates, + unsigned long numberOfStates ) { - unsigned long i; - unsigned long tempDesire; + IOPMRequest * request; + IOPMPSEntry * powerStatesCopy = 0; + IOPMPowerStateIndex stateOrder; + IOReturn error = kIOReturnSuccess; + + if (!initialized) + return IOPMNotYetInitialized; + + if (!powerStates || (numberOfStates < 2)) + { + OUR_PMLog(kPMLogControllingDriverErr5, numberOfStates, 0); + return kIOReturnBadArgument; + } + + if (!powerDriver || !powerDriver->initialized) + { + OUR_PMLog(kPMLogControllingDriverErr4, 0, 0); + return kIOReturnBadArgument; + } - if ( (numberOfStates > pm_vars->theNumberOfPowerStates) - && (numberOfStates > 1) ) + if (powerStates[0].version > kIOPMPowerStateVersion2) { - if ( priv->changeList->currentChange() == -1 ) + 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++) { - if ( controllingDriver != NULL ) + powerStatesCopy[i].capabilityFlags = powerStates[i].capabilityFlags; + powerStatesCopy[i].outputPowerFlags = powerStates[i].outputPowerCharacter; + powerStatesCopy[i].inputPowerFlags = powerStates[i].inputPowerRequirement; + powerStatesCopy[i].staticPower = powerStates[i].staticPower; + powerStatesCopy[i].settleUpTime = powerStates[i].settleUpTime; + powerStatesCopy[i].settleDownTime = powerStates[i].settleDownTime; + if (powerStates[i].version >= kIOPMPowerStateVersion2) + stateOrder = powerStates[i].stateOrder; + else + stateOrder = i; + + if (stateOrder < numberOfStates) { - if ( numberOfStates <= IOPMMaxPowerStates ) - { - switch ( powerStates[0].version ) - { - case 1: - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriver, - (unsigned long)numberOfStates, (unsigned long)powerStates[0].version); - for ( i = 0; i < numberOfStates; i++ ) - { - pm_vars->thePowerStates[i] = powerStates[i]; - } - break; - case 2: - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriver, - (unsigned long) numberOfStates,(unsigned long) powerStates[0].version); - for ( i = 0; i < numberOfStates; i++ ) - { - pm_vars->thePowerStates[i].version = powerStates[i].version; - pm_vars->thePowerStates[i].capabilityFlags = powerStates[i].capabilityFlags; - pm_vars->thePowerStates[i].outputPowerCharacter = powerStates[i].outputPowerCharacter; - pm_vars->thePowerStates[i].inputPowerRequirement = powerStates[i].inputPowerRequirement; - pm_vars->thePowerStates[i].staticPower = powerStates[i].staticPower; - pm_vars->thePowerStates[i].unbudgetedPower = powerStates[i].unbudgetedPower; - pm_vars->thePowerStates[i].powerToAttain = powerStates[i].powerToAttain; - pm_vars->thePowerStates[i].timeToAttain = powerStates[i].timeToAttain; - pm_vars->thePowerStates[i].settleUpTime = powerStates[i].settleUpTime; - pm_vars->thePowerStates[i].timeToLower = powerStates[i].timeToLower; - pm_vars->thePowerStates[i].settleDownTime = powerStates[i].settleDownTime; - pm_vars->thePowerStates[i].powerDomainBudget = powerStates[i].powerDomainBudget; - } - break; - default: - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr1, - (unsigned long)powerStates[0].version,0); - return IOPMNoErr; - } + powerStatesCopy[i].stateOrder = stateOrder; + powerStatesCopy[stateOrder].stateOrderToIndex = i; + } + } - // make a mask of all the character bits we know about - pm_vars->myCharacterFlags = 0; - for ( i = 0; i < numberOfStates; i++ ) { - pm_vars->myCharacterFlags |= pm_vars->thePowerStates[i].outputPowerCharacter; - } - - pm_vars->theNumberOfPowerStates = numberOfStates; - pm_vars->theControllingDriver = controllingDriver; - if ( priv->interestedDrivers->findItem(controllingDriver) == NULL ) - { - // register it as interested, unless already done - registerInterestedDriver (controllingDriver ); - } - if ( priv->need_to_become_usable ) { - priv->need_to_become_usable = false; - priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1; - } + for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) + { + if (powerStatesCopy[i].stateOrderToIndex == kIOPMPowerStateMax) + { + // power state order missing + error = kIOReturnBadArgument; + break; + } + } + if (kIOReturnSuccess != error) + break; - if ( inPlane(gIOPowerPlane) && - (pm_vars->parentsKnowState) ) { - pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentsCurrentPowerFlags); - // initially change into the state we are already in - tempDesire = priv->deviceDesire; - priv->deviceDesire = pm_vars->theControllingDriver->initialPowerStateForDomainState(pm_vars->parentsCurrentPowerFlags); - computeDesiredState(); - changeState(); - // put this back like before - priv->deviceDesire = tempDesire; - } - } else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr2,(unsigned long)numberOfStates,0); + request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver ); + if (!request) + { + error = kIOReturnNoMemory; + break; + } + + powerDriver->retain(); + request->fArg0 = (void *) powerDriver; + request->fArg1 = (void *) powerStatesCopy; + request->fArg2 = (void *) numberOfStates; + + submitPMRequest( request ); + return kIOReturnSuccess; + } + while (false); + + if (powerStatesCopy) + IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates); + + return error; +} + +//********************************************************************************* +// [private] handleRegisterPowerDriver +//********************************************************************************* + +void IOService::handleRegisterPowerDriver( IOPMRequest * request ) +{ + IOService * powerDriver = (IOService *) request->fArg0; + IOPMPSEntry * powerStates = (IOPMPSEntry *) request->fArg1; + unsigned long numberOfStates = (unsigned long) request->fArg2; + unsigned long i, stateIndex; + unsigned long lowestPowerState; + IOService * root; + OSIterator * iter; + + PM_ASSERT_IN_GATE(); + assert(powerStates); + assert(powerDriver); + assert(numberOfStates > 1); + + if ( !fNumberOfPowerStates ) + { + OUR_PMLog(kPMLogControllingDriver, + (unsigned long) numberOfStates, + (unsigned long) kIOPMPowerStateVersion1); + + fPowerStates = powerStates; + fNumberOfPowerStates = numberOfStates; + fControllingDriver = powerDriver; + fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags; + + lowestPowerState = fPowerStates[0].stateOrderToIndex; + fHighestPowerState = fPowerStates[numberOfStates - 1].stateOrderToIndex; + + // OR'in all the output power flags + fMergedOutputPowerFlags = 0; + fDeviceUsablePowerState = lowestPowerState; + for ( i = 0; i < numberOfStates; i++ ) + { + fMergedOutputPowerFlags |= fPowerStates[i].outputPowerFlags; + + stateIndex = fPowerStates[i].stateOrderToIndex; + assert(stateIndex < numberOfStates); + if ((fDeviceUsablePowerState == lowestPowerState) && + (fPowerStates[stateIndex].capabilityFlags & IOPMDeviceUsable)) + { + // The minimum power state that the device is usable + fDeviceUsablePowerState = stateIndex; + } + } + + // Register powerDriver as interested, unless already done. + // We don't want to register the default implementation since + // it does nothing. One ramification of not always registering + // is the one fewer retain count held. + + root = getPlatform()->getProvider(); + assert(root); + if (!root || + ((OSMemberFunctionCast(void (*)(void), + root, &IOService::powerStateDidChangeTo)) != + ((OSMemberFunctionCast(void (*)(void), + this, &IOService::powerStateDidChangeTo)))) || + ((OSMemberFunctionCast(void (*)(void), + root, &IOService::powerStateWillChangeTo)) != + ((OSMemberFunctionCast(void (*)(void), + this, &IOService::powerStateWillChangeTo))))) + { + if (fInterestedDrivers->findItem(powerDriver) == NULL) + { + PM_LOCK(); + fInterestedDrivers->appendNewInformee(powerDriver); + PM_UNLOCK(); + } + } + + // Examine all existing power clients and perform limit check. + + if (fPowerClients && + (iter = OSCollectionIterator::withCollection(fPowerClients))) + { + const OSSymbol * client; + while ((client = (const OSSymbol *) iter->getNextObject())) + { + IOPMPowerStateIndex powerState = getPowerStateForClient(client); + if (powerState >= numberOfStates) + { + updatePowerClient(client, fHighestPowerState); } - } else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr4,0,0); } + iter->release(); + } + + if ( inPlane(gIOPowerPlane) && fParentsKnowState ) + { + IOPMPowerStateIndex tempDesire; + fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags); + // initially change into the state we are already in + tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags); + adjustPowerState(tempDesire); } } - else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr5,(unsigned long)numberOfStates,0); + else + { + OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0); + IODelete(powerStates, IOPMPSEntry, numberOfStates); } - return IOPMNoErr; + + powerDriver->release(); } //********************************************************************************* -// registerInterestedDriver +// [public] registerInterestedDriver // // Add the caller to our list of interested drivers and return our current // power state. If we don't have a power-controlling driver yet, we will @@ -827,72 +1328,146 @@ IOReturn IOService::registerPowerDriver ( IOService * controllingDriver, IOPMPow // out what the current power state of the device is. //********************************************************************************* -IOPMPowerFlags IOService::registerInterestedDriver ( IOService * theDriver ) +IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver ) { - IOPMinformee *newInformee; - IOPMPowerFlags futureCapability; + IOPMRequest * request; + bool signal; - if (theDriver == NULL ) { + if (!driver || !initialized || !fInterestedDrivers) return 0; - } - // make new driver node - newInformee = new IOPMinformee; - newInformee->initialize(theDriver); - // add it to list of drivers - priv->interestedDrivers->addToList(newInformee); + PM_LOCK(); + signal = (!fInsertInterestSet && !fRemoveInterestSet); + if (fInsertInterestSet == NULL) + fInsertInterestSet = OSSet::withCapacity(4); + if (fInsertInterestSet) + { + fInsertInterestSet->setObject(driver); + if (fRemoveInterestSet) + fRemoveInterestSet->removeObject(driver); + } + PM_UNLOCK(); - if ( (pm_vars->theControllingDriver == NULL) || - !(inPlane(gIOPowerPlane)) || - !(pm_vars->parentsKnowState) ) + if (signal) { - // can't tell it a state yet - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,IOPMNotPowerManaged,0); + request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged ); + if (request) + submitPMRequest( request ); + } + + // This return value cannot be trusted, but return a value + // for those clients that care. + + OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2); + return kIOPMDeviceUsable; +} + +//********************************************************************************* +// [public] deRegisterInterestedDriver +//********************************************************************************* + +IOReturn IOService::deRegisterInterestedDriver( IOService * driver ) +{ + IOPMinformee * item; + IOPMRequest * request; + bool signal; + + if (!driver) + return kIOReturnBadArgument; + if (!initialized || !fInterestedDrivers) return IOPMNotPowerManaged; + + PM_LOCK(); + if (fInsertInterestSet) + { + fInsertInterestSet->removeObject(driver); } - // can we notify new driver of a change in progress? - switch (priv->machine_state) { - case kIOPM_OurChangeSetPowerState: - case kIOPM_OurChangeFinish: - case kIOPM_ParentDownSetPowerState_Delayed: - case kIOPM_ParentDownAcknowledgeChange_Delayed: - case kIOPM_ParentUpSetPowerState_Delayed: - case kIOPM_ParentUpAcknowledgePowerChange_Delayed: - // yes, remember what we tell it - futureCapability = priv->head_note_capabilityFlags; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,(unsigned long)futureCapability,1); - // notify it - add_driver_to_active_change(newInformee); - // and return the same thing - return futureCapability; + item = fInterestedDrivers->findItem(driver); + if (!item) + { + PM_UNLOCK(); + return kIOReturnNotFound; } - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver, - (unsigned long) pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags,2); + signal = (!fRemoveInterestSet && !fInsertInterestSet); + if (fRemoveInterestSet == NULL) + fRemoveInterestSet = OSSet::withCapacity(4); + if (fRemoveInterestSet) + { + fRemoveInterestSet->setObject(driver); + if (item->active) + { + item->active = false; + waitForPMDriverCall( driver ); + } + } + PM_UNLOCK(); - // no, return current capability - return pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags; -} + if (signal) + { + request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged ); + if (request) + submitPMRequest( request ); + } + return IOPMNoErr; +} //********************************************************************************* -// deRegisterInterestedDriver +// [private] handleInterestChanged // +// Handle interest added or removed. //********************************************************************************* -IOReturn IOService::deRegisterInterestedDriver ( IOService * theDriver ) + +void IOService::handleInterestChanged( IOPMRequest * request ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRemoveDriver,0,0); + IOService * driver; + IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; - // remove the departing driver - priv->interestedDrivers->removeFromList(theDriver); + PM_LOCK(); - return IOPMNoErr; -} + if (fInsertInterestSet) + { + while ((driver = (IOService *) fInsertInterestSet->getAnyObject())) + { + if (list->findItem(driver) == NULL) + { + informee = list->appendNewInformee(driver); + } + fInsertInterestSet->removeObject(driver); + } + fInsertInterestSet->release(); + fInsertInterestSet = 0; + } + + if (fRemoveInterestSet) + { + while ((driver = (IOService *) fRemoveInterestSet->getAnyObject())) + { + informee = list->findItem(driver); + if (informee) + { + // Clean-up async interest acknowledgement + if (fHeadNotePendingAcks && informee->timer) + { + informee->timer = 0; + fHeadNotePendingAcks--; + } + list->removeFromList(driver); + } + fRemoveInterestSet->removeObject(driver); + } + fRemoveInterestSet->release(); + fRemoveInterestSet = 0; + } + PM_UNLOCK(); +} //********************************************************************************* -// acknowledgePowerChange +// [public] acknowledgePowerChange // // After we notified one of the interested drivers or a power-domain child // of an impending change in power, it has called to say it is now @@ -905,251 +1480,389 @@ IOReturn IOService::deRegisterInterestedDriver ( IOService * theDriver ) // of a "current change note".) //********************************************************************************* -IOReturn IOService::acknowledgePowerChange ( IOService * whichObject ) +IOReturn IOService::acknowledgePowerChange( IOService * whichObject ) +{ + IOPMRequest * request; + + if (!initialized) + return IOPMNotYetInitialized; + if (!whichObject) + return kIOReturnBadArgument; + + request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange ); + if (!request) + return kIOReturnNoMemory; + + whichObject->retain(); + request->fArg0 = whichObject; + + submitPMRequest( request ); + return IOPMNoErr; +} + +//********************************************************************************* +// [private] handleAcknowledgePowerChange +//********************************************************************************* + +bool IOService::handleAcknowledgePowerChange( IOPMRequest * request ) { - IOPMinformee *ackingObject; - unsigned long childPower = kIOPMUnknown; - IOService *theChild; + IOPMinformee * informee; + unsigned long childPower = kIOPMUnknown; + IOService * theChild; + IOService * whichObject; + bool all_acked = false; + + PM_ASSERT_IN_GATE(); + whichObject = (IOService *) request->fArg0; + assert(whichObject); // one of our interested drivers? - ackingObject = priv->interestedDrivers->findItem(whichObject); - if ( ackingObject == NULL ) + informee = fInterestedDrivers->findItem( whichObject ); + if ( informee == NULL ) { - if ( ! isChild(whichObject,gIOPowerPlane) ) + if ( !isChild(whichObject, gIOPowerPlane) ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr1,0,0); - //kprintf("errant driver: %s\n",whichObject->getName()); - // no, just return - return IOPMNoErr; + OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0); + goto no_err; } else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChildAcknowledge,priv->head_note_pendingAcks,0); + OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0); } } else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDriverAcknowledge,priv->head_note_pendingAcks,0); + OUR_PMLog(kPMLogDriverAcknowledge, fHeadNotePendingAcks, 0); } - - if (! acquire_lock() ) - { - return IOPMNoErr; - } - - if (priv->head_note_pendingAcks != 0 ) + + if ( fHeadNotePendingAcks != 0 ) { + assert(fPowerStates != NULL); + // yes, make sure we're expecting acks - if ( ackingObject != NULL ) + if ( informee != NULL ) { // it's an interested driver // make sure we're expecting this ack - if ( ackingObject->timer != 0 ) + if ( informee->timer != 0 ) { - // mark it acked - ackingObject->timer = 0; - // that's one fewer to worry about - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - // is that the last? - if ( priv->head_note_pendingAcks == 0 ) + + if (informee->timer > 0) { - // yes, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); - // and now we can continue - all_acked(); - return IOPMNoErr; + uint64_t nsec = computeTimeDeltaNS(&informee->startTime); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, informee->whatObject->getName(), + fDriverCallReason, NS_TO_MS(nsec), informee->whatObject->getRegistryEntryID(), + NULL, fHeadNotePowerState); + } } + + // mark it acked + informee->timer = 0; + // that's one fewer to worry about + fHeadNotePendingAcks--; } else { // this driver has already acked - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr2,0,0); - //kprintf("errant driver: %s\n",whichObject->getName()); + OUR_PMLog(kPMLogAcknowledgeErr2, 0, 0); } } else { // it's a child // make sure we're expecting this ack - if ( ((IOPowerConnection *)whichObject)->getAwaitingAck() ) + if ( ((IOPowerConnection *)whichObject)->getAwaitingAck() ) { // that's one fewer to worry about - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); + fHeadNotePendingAcks--; ((IOPowerConnection *)whichObject)->setAwaitingAck(false); theChild = (IOService *)whichObject->copyChildEntry(gIOPowerPlane); - if ( theChild ) + if ( theChild ) { childPower = theChild->currentPowerConsumption(); theChild->release(); } - if ( childPower == kIOPMUnknown ) + if ( childPower == kIOPMUnknown ) { - pm_vars->thePowerStates[priv->head_note_state].staticPower = kIOPMUnknown; + fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown; } else { - if ( pm_vars->thePowerStates[priv->head_note_state].staticPower != kIOPMUnknown ) + if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown) { - pm_vars->thePowerStates[priv->head_note_state].staticPower += childPower; + fHeadNotePowerArrayEntry->staticPower += childPower; } } - // is that the last? - if ( priv->head_note_pendingAcks == 0 ) { - // yes, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); - // and now we can continue - all_acked(); - return IOPMNoErr; - } } - } + } + + if ( fHeadNotePendingAcks == 0 ) { + // yes, stop the timer + stop_ack_timer(); + // and now we can continue + all_acked = true; + } } else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr3,0,0); // not expecting anybody to ack - //kprintf("errant driver: %s\n",whichObject->getName()); + OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack } - IOUnlock(priv->our_lock); - return IOPMNoErr; + +no_err: + if (whichObject) + whichObject->release(); + + return all_acked; } //********************************************************************************* -// acknowledgeSetPowerState +// [public] acknowledgeSetPowerState // // After we instructed our controlling driver to change power states, // it has called to say it has finished doing so. // We continue to process the power state change. //********************************************************************************* -IOReturn IOService::acknowledgeSetPowerState ( void ) +IOReturn IOService::acknowledgeSetPowerState( void ) { - if (!acquire_lock()) - return IOPMNoErr; + IOPMRequest * request; - IOReturn timer = priv->driver_timer; - if ( timer == -1 ) { - // driver is acking instead of using return code - OUR_PMLog(kPMLogDriverAcknowledgeSet, (UInt32) this, timer); - priv->driver_timer = 0; - } - else if ( timer > 0 ) { // are we expecting this? - // yes, stop the timer - stop_ack_timer(); - priv->driver_timer = 0; - OUR_PMLog(kPMLogDriverAcknowledgeSet, (UInt32) this, timer); - IOUnlock(priv->our_lock); - driver_acked(); - return IOPMNoErr; - } else { - // not expecting this - OUR_PMLog(kPMLogAcknowledgeErr4, (UInt32) this, 0); - } + if (!initialized) + return IOPMNotYetInitialized; - IOUnlock(priv->our_lock); - return IOPMNoErr; -} + request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState ); + if (!request) + return kIOReturnNoMemory; + submitPMRequest( request ); + return kIOReturnSuccess; +} //********************************************************************************* -// driver_acked -// -// Either the controlling driver has called acknowledgeSetPowerState -// or the acknowledgement timer has expired while waiting for that. -// We carry on processing the current change note. +// [private] adjustPowerState //********************************************************************************* -void IOService::driver_acked ( void ) +void IOService::adjustPowerState( uint32_t clamp ) { + PM_ASSERT_IN_GATE(); + computeDesiredState(clamp, false); + if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane)) + { + IOPMPowerChangeFlags changeFlags = kIOPMSelfInitiated; - switch (priv->machine_state) { - case kIOPM_OurChangeWaitForPowerSettle: - OurChangeWaitForPowerSettle(); - break; - case kIOPM_ParentDownWaitForPowerSettle_Delayed: - ParentDownWaitForPowerSettle_Delayed(); - break; - case kIOPM_ParentUpWaitForSettleTime_Delayed: - ParentUpWaitForSettleTime_Delayed(); - break; + // 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); } } - //********************************************************************************* -// powerDomainWillChangeTo -// -// Called by the power-hierarchy parent notifying of a new power state -// in the power domain. -// We enqueue a parent power-change to our queue of power changes. -// This may or may not cause us to change power, depending on what -// kind of change is occuring in the domain. +// [public] synchronizePowerTree //********************************************************************************* -IOReturn IOService::powerDomainWillChangeTo ( IOPMPowerFlags newPowerStateFlags, IOPowerConnection * whichParent ) +IOReturn IOService::synchronizePowerTree( + IOOptionBits options, + IOService * notifyRoot ) { - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - unsigned long newStateNumber; - IOPMPowerFlags combinedPowerFlags; + IOPMRequest * request_c = 0; + IOPMRequest * request_s; + + if (this != getPMRootDomain()) + return kIOReturnBadArgument; + if (!initialized) + return kIOPMNotYetInitialized; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogWillChange,(unsigned long)newPowerStateFlags,0); + OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0)); - if ( ! inPlane(gIOPowerPlane) ) + if (notifyRoot) { - // somebody goofed - return IOPMAckImplied; + IOPMRequest * nr; + + // Cancels don't need to be synchronized. + nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel); + if (nr) submitPMRequest(nr); + nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel); + if (nr) submitPMRequest(nr); } - IOLockLock(pm_vars->parentLock); - - if ( (pm_vars->PMworkloop == NULL) || (pm_vars->PMcommandGate == NULL) ) + request_s = acquirePMRequest( this, kIOPMRequestTypeSynchronizePowerTree ); + if (!request_s) + goto error_no_memory; + + if (options & kIOPMSyncCancelPowerDown) + request_c = acquirePMRequest( this, kIOPMRequestTypeIdleCancel ); + if (request_c) { - // we have a path to the root - getPMworkloop(); - // so find out the workloop - if ( pm_vars->PMworkloop != NULL ) - { - // and make our command gate - if ( pm_vars->PMcommandGate == NULL ) - { - pm_vars->PMcommandGate = IOCommandGate::commandGate((OSObject *)this); - if ( pm_vars->PMcommandGate != NULL ) - { - pm_vars->PMworkloop->addEventSource(pm_vars->PMcommandGate); - } - } - } + request_c->attachNextRequest( request_s ); + submitPMRequest(request_c); } - - IOLockUnlock(pm_vars->parentLock); - // combine parents' power states - // to determine our maximum state within the new power domain + 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); + return kIOReturnNoMemory; +} + +//********************************************************************************* +// [private] handleSynchronizePowerTree +//********************************************************************************* + +void IOService::handleSynchronizePowerTree( IOPMRequest * request ) +{ + PM_ASSERT_IN_GATE(); + if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) && + (fCurrentPowerState == fHighestPowerState)) + { + IOOptionBits options = (uintptr_t) request->fArg0; + + startPowerChange( + /* flags */ kIOPMSelfInitiated | kIOPMSynchronize | + (options & kIOPMSyncNoChildNotify), + /* power state */ fCurrentPowerState, + /* domain flags */ 0, + /* connection */ 0, + /* parent flags */ 0); + } +} + +#ifndef __LP64__ +//********************************************************************************* +// [deprecated] powerDomainWillChangeTo +// +// Called by the power-hierarchy parent notifying of a new power state +// in the power domain. +// We enqueue a parent power-change to our queue of power changes. +// This may or may not cause us to change power, depending on what +// kind of change is occuring in the domain. +//********************************************************************************* + +IOReturn IOService::powerDomainWillChangeTo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent ) +{ + assert(false); + return kIOReturnUnsupported; +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// [private] handlePowerDomainWillChangeTo +//********************************************************************************* + +void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request ) +{ + IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; + IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; + IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; + IOPMPowerChangeFlags myChangeFlags; + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOPMPowerStateIndex maxPowerState; + IOPMPowerFlags combinedPowerFlags; + bool savedParentsKnowState; + IOReturn result = IOPMAckImplied; + + PM_ASSERT_IN_GATE(); + OUR_PMLog(kPMLogWillChange, parentPowerFlags, 0); + + if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) + { + PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); + goto exit_no_ack; + } + + savedParentsKnowState = fParentsKnowState; + + // Combine parents' output power flags. + combinedPowerFlags = 0; - - iter = getParentIterator(gIOPowerPlane); - if ( iter ) + iter = getParentIterator(gIOPowerPlane); + if ( iter ) { - while ( (next = iter->getNextObject()) ) + while ( (next = iter->getNextObject()) ) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) { - if ( connection == whichParent ){ - combinedPowerFlags |= newPowerStateFlags; - } else { + if ( connection == whichParent ) + combinedPowerFlags |= parentPowerFlags; + else combinedPowerFlags |= connection->parentCurrentPowerFlags(); - } } } iter->release(); } - - if ( pm_vars->theControllingDriver == NULL ) + + // If our initial change has yet to occur, then defer the power change + // until after the power domain has completed its power transition. + + if ( fControllingDriver && !fInitialPowerChange ) { - // we can't take any more action - return IOPMAckImplied; + maxPowerState = fControllingDriver->maxCapabilityForDomainState( + combinedPowerFlags); + + if (parentChangeFlags & kIOPMDomainPowerDrop) + { + // fMaxPowerState set a limit on self-initiated power changes. + // Update it before a parent power drop. + fMaxPowerState = maxPowerState; + } + + // Use kIOPMSynchronize below instead of kIOPMRootBroadcastFlags + // to avoid propagating the root change flags if any service must + // change power state due to root's will-change notification. + // Root does not change power state for kIOPMSynchronize. + + myChangeFlags = kIOPMParentInitiated | kIOPMDomainWillChange | + (parentChangeFlags & kIOPMSynchronize); + + result = startPowerChange( + /* flags */ myChangeFlags, + /* power state */ maxPowerState, + /* domain flags */ combinedPowerFlags, + /* connection */ whichParent, + /* parent flags */ parentPowerFlags); + } + + // If parent is dropping power, immediately update the parent's + // capability flags. Any future merging of parent(s) combined + // power flags should account for this power drop. + + if (parentChangeFlags & kIOPMDomainPowerDrop) + { + setParentInfo(parentPowerFlags, whichParent, true); + } + + // Parent is expecting an ACK from us. If we did not embark on a state + // transition, i.e. startPowerChange() returned IOPMAckImplied. We are + // still required to issue an ACK to our parent. + + if (IOPMAckImplied == result) + { + IOService * parent; + parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane); + assert(parent); + if ( parent ) + { + parent->acknowledgePowerChange( whichParent ); + parent->release(); + } } - newStateNumber = pm_vars->theControllingDriver->maxCapabilityForDomainState(combinedPowerFlags); - // make the change - return enqueuePowerChange(IOPMParentInitiated | IOPMDomainWillChange, - newStateNumber,combinedPowerFlags,whichParent,newPowerStateFlags); -} +exit_no_ack: + // Drop the retain from notifyChild(). + if (whichParent) whichParent->release(); +} +#ifndef __LP64__ //********************************************************************************* -// powerDomainDidChangeTo +// [deprecated] powerDomainDidChangeTo // // Called by the power-hierarchy parent after the power state of the power domain // has settled at a new level. @@ -1158,261 +1871,387 @@ IOReturn IOService::powerDomainWillChangeTo ( IOPMPowerFlags newPowerStateFlags, // kind of change is occuring in the domain. //********************************************************************************* -IOReturn IOService::powerDomainDidChangeTo ( IOPMPowerFlags newPowerStateFlags, IOPowerConnection * whichParent ) +IOReturn IOService::powerDomainDidChangeTo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent ) { - unsigned long newStateNumber; + assert(false); + return kIOReturnUnsupported; +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// [private] handlePowerDomainDidChangeTo +//********************************************************************************* - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDidChange,newPowerStateFlags,0); +void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request ) +{ + IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0; + IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1; + IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2; + IOPMPowerChangeFlags myChangeFlags; + IOPMPowerStateIndex maxPowerState; + IOPMPowerStateIndex initialDesire = kPowerStateZero; + bool computeDesire = false; + bool desireChanged = false; + bool savedParentsKnowState; + IOReturn result = IOPMAckImplied; - setParentInfo(newPowerStateFlags,whichParent); + PM_ASSERT_IN_GATE(); + OUR_PMLog(kPMLogDidChange, parentPowerFlags, 0); - if ( pm_vars->theControllingDriver == NULL ) { - return IOPMAckImplied; + if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) + { + PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__); + goto exit_no_ack; } - newStateNumber = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentsCurrentPowerFlags); - // tell interested parties about it - return enqueuePowerChange(IOPMParentInitiated | IOPMDomainDidChange, - newStateNumber,pm_vars->parentsCurrentPowerFlags,whichParent,0); -} + savedParentsKnowState = fParentsKnowState; + + setParentInfo(parentPowerFlags, whichParent, true); + + if ( fControllingDriver ) + { + maxPowerState = fControllingDriver->maxCapabilityForDomainState( + fParentsCurrentPowerFlags); + + if ((parentChangeFlags & kIOPMDomainPowerDrop) == 0) + { + // fMaxPowerState set a limit on self-initiated power changes. + // Update it after a parent power rise. + fMaxPowerState = maxPowerState; + } + + if (fInitialPowerChange) + { + computeDesire = true; + initialDesire = fControllingDriver->initialPowerStateForDomainState( + fParentsCurrentPowerFlags); + } + else if (parentChangeFlags & kIOPMRootChangeUp) + { + if (fAdvisoryTickleUsed) + { + // On system wake, re-compute the desired power state since + // gIOPMAdvisoryTickleEnabled will change for a full wake, + // which is an input to computeDesiredState(). This is not + // necessary for a dark wake because powerChangeDone() will + // handle the dark to full wake case, but it does no harm. + + desireChanged = true; + } + + if (fResetPowerStateOnWake) + { + // Query the driver for the desired power state on system wake. + // Default implementation returns the lowest power state. + + IOPMPowerStateIndex wakePowerState = + fControllingDriver->initialPowerStateForDomainState( + kIOPMRootDomainState | kIOPMPowerOn ); + + // fDesiredPowerState was adjusted before going to sleep + // with fDeviceDesire at min. + + if (StateOrder(wakePowerState) > StateOrder(fDesiredPowerState)) + { + // Must schedule a power adjustment if we changed the + // device desire. That will update the desired domain + // power on the parent power connection and ping the + // power parent if necessary. + + updatePowerClient(gIOPMPowerClientDevice, wakePowerState); + desireChanged = true; + } + } + } + if (computeDesire || desireChanged) + computeDesiredState(initialDesire, false); + + // Absorb and propagate parent's broadcast flags + myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange | + (parentChangeFlags & kIOPMRootBroadcastFlags); + + result = startPowerChange( + /* flags */ myChangeFlags, + /* power state */ maxPowerState, + /* domain flags */ fParentsCurrentPowerFlags, + /* connection */ whichParent, + /* parent flags */ 0); + } + + // Parent is expecting an ACK from us. If we did not embark on a state + // transition, i.e. startPowerChange() returned IOPMAckImplied. We are + // still required to issue an ACK to our parent. + + if (IOPMAckImplied == result) + { + IOService * parent; + parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane); + assert(parent); + if ( parent ) + { + parent->acknowledgePowerChange( whichParent ); + parent->release(); + } + } + + // If the parent registers its power driver late, then this is the + // first opportunity to tell our parent about our desire. Or if the + // child's desire changed during a parent change notify. + + if (fControllingDriver && + ((!savedParentsKnowState && fParentsKnowState) || desireChanged)) + { + PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState %d\n", + getName(), fParentsKnowState); + requestDomainPower( fDesiredPowerState ); + } + +exit_no_ack: + // Drop the retain from notifyChild(). + if (whichParent) whichParent->release(); +} //********************************************************************************* -// setParentInfo +// [private] setParentInfo // // Set our connection data for one specific parent, and then combine all the parent // data together. //********************************************************************************* -void IOService::setParentInfo ( IOPMPowerFlags newPowerStateFlags, IOPowerConnection * whichParent ) +void IOService::setParentInfo( + IOPMPowerFlags newPowerFlags, + IOPowerConnection * whichParent, + bool knowsState ) { - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - + OSIterator * iter; + OSObject * next; + IOPowerConnection * conn; + + PM_ASSERT_IN_GATE(); + // set our connection data - whichParent->setParentCurrentPowerFlags(newPowerStateFlags); - whichParent->setParentKnowsState(true); + whichParent->setParentCurrentPowerFlags(newPowerFlags); + whichParent->setParentKnowsState(knowsState); - IOLockLock(pm_vars->parentLock); - // recompute our parent info - pm_vars->parentsCurrentPowerFlags = 0; - pm_vars->parentsKnowState = true; + fParentsCurrentPowerFlags = 0; + fParentsKnowState = true; iter = getParentIterator(gIOPowerPlane); - - if ( iter ) + if ( iter ) { - while ( (next = iter->getNextObject()) ) + while ( (next = iter->getNextObject()) ) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + if ( (conn = OSDynamicCast(IOPowerConnection, next)) ) { - pm_vars->parentsKnowState &= connection->parentKnowsState(); - pm_vars->parentsCurrentPowerFlags |= connection->parentCurrentPowerFlags(); + fParentsKnowState &= conn->parentKnowsState(); + fParentsCurrentPowerFlags |= conn->parentCurrentPowerFlags(); } } iter->release(); } - IOLockUnlock(pm_vars->parentLock); } -//********************************************************************************* -// rebuildChildClampBits -// -// The ChildClamp bits (kIOPMChildClamp & kIOPMChildClamp2) in our capabilityFlags -// indicate that one of our children (or grandchildren or great-grandchildren or ...) -// doesn't support idle or system sleep in its current state. Since we don't track the -// origin of each bit, every time any child changes state we have to clear these bits -// and rebuild them. -//********************************************************************************* +//****************************************************************************** +// [private] trackSystemSleepPreventers +//****************************************************************************** -void IOService::rebuildChildClampBits(void) +void IOService::trackSystemSleepPreventers( + IOPMPowerStateIndex oldPowerState, + IOPMPowerStateIndex newPowerState, + IOPMPowerChangeFlags changeFlags __unused ) { - unsigned long i; - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - - - // A child's desires has changed. We need to rebuild the child-clamp bits in our - // power state array. Start by clearing the bits in each power state. - - for ( i = 0; i < pm_vars->theNumberOfPowerStates; i++ ) - { - pm_vars->thePowerStates[i].capabilityFlags &= ~(kIOPMChildClamp | kIOPMChildClamp2); - } + IOPMPowerFlags oldCapability, newCapability; - // Now loop through the children. When we encounter the calling child, save - // the computed state as this child's desire. And while we're at it, set the ChildClamp bits - // in any of our states that some child has requested with clamp on. + oldCapability = fPowerStates[oldPowerState].capabilityFlags & + (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); + newCapability = fPowerStates[newPowerState].capabilityFlags & + (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); - iter = getChildIterator(gIOPowerPlane); + if (fHeadNoteChangeFlags & kIOPMInitialPowerChange) + oldCapability = 0; + if (oldCapability == newCapability) + return; - if ( iter ) + if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep) { - while ( (next = iter->getNextObject()) ) + bool enablePrevention = ((oldCapability & kIOPMPreventIdleSleep) == 0); + bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList( + this, enablePrevention); +#if SUPPORT_IDLE_CANCEL + if (idleCancelAllowed && enablePrevention) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + IOPMRequest * cancelRequest; + + cancelRequest = acquirePMRequest( getPMRootDomain(), kIOPMRequestTypeIdleCancel ); + if (cancelRequest) { - if ( connection->getPreventIdleSleepFlag() ) - pm_vars->thePowerStates[connection->getDesiredDomainState()].capabilityFlags |= kIOPMChildClamp; - if ( connection->getPreventSystemSleepFlag() ) - pm_vars->thePowerStates[connection->getDesiredDomainState()].capabilityFlags |= kIOPMChildClamp2; + submitPMRequest( cancelRequest ); } } - iter->release(); +#endif } + if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep) + { + getPMRootDomain()->updatePreventSystemSleepList(this, + ((oldCapability & kIOPMPreventSystemSleep) == 0)); + } } - //********************************************************************************* -// requestPowerDomainState +// [public] requestPowerDomainState // -// The kIOPMPreventIdleSleep and/or kIOPMPreventIdleSleep bits may be be set in the parameter. -// It is not considered part of the state specification. +// Called on a power parent when a child's power requirement changes. //********************************************************************************* -IOReturn IOService::requestPowerDomainState ( IOPMPowerFlags desiredState, IOPowerConnection * whichChild, unsigned long specification ) + +IOReturn IOService::requestPowerDomainState( + IOPMPowerFlags childRequestPowerFlags, + IOPowerConnection * childConnection, + unsigned long specification ) { - unsigned long i; - unsigned long computedState; - unsigned long theDesiredState = desiredState & ~(kIOPMPreventIdleSleep | kIOPMPreventSystemSleep); - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; + IOPMPowerStateIndex order, powerState; + IOPMPowerFlags outputPowerFlags; + IOService * child; + IOPMRequest * subRequest; + bool adjustPower = false; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRequestDomain, - (unsigned long)desiredState,(unsigned long)specification); + if (!initialized) + return IOPMNotYetInitialized; - if ( pm_vars->theControllingDriver == NULL) + if (gIOPMWorkLoop->onThread() == false) { - return IOPMNotYetInitialized; + PM_LOG("%s::requestPowerDomainState\n", getName()); + return kIOReturnSuccess; } - switch (specification) { - case IOPMLowestState: - i = 0; - while ( i < pm_vars->theNumberOfPowerStates ) - { - if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) - { - break; - } - i++; - } - if ( i >= pm_vars->theNumberOfPowerStates ) - { - return IOPMNoSuchState; - } - break; + OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification); - case IOPMNextLowerState: - i = pm_vars->myCurrentState - 1; - while ( (int) i >= 0 ) - { - if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) - { - break; - } - i--; - } - if ( (int) i < 0 ) - { - return IOPMNoSuchState; - } - break; + if (!isChild(childConnection, gIOPowerPlane)) + return kIOReturnNotAttached; - case IOPMHighestState: - i = pm_vars->theNumberOfPowerStates; - while ( (int) i >= 0 ) - { - i--; - if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) - { - break; - } - } - if ( (int) i < 0 ) - { - return IOPMNoSuchState; - } - break; + if (!fControllingDriver || !fNumberOfPowerStates) + return kIOReturnNotReady; + + child = (IOService *) childConnection->getChildEntry(gIOPowerPlane); + assert(child); - case IOPMNextHigherState: - i = pm_vars->myCurrentState + 1; - while ( i < pm_vars->theNumberOfPowerStates ) + // Remove flags from child request which we can't possibly supply + childRequestPowerFlags &= fMergedOutputPowerFlags; + + // Merge in the power flags contributed by this power parent + // at its current or impending power state. + + outputPowerFlags = fPowerStates[fCurrentPowerState].outputPowerFlags; + if (fMachineState != kIOPM_Finished) + { + if (IS_POWER_DROP && !IS_ROOT_DOMAIN) + { + // Use the lower power state when dropping power. + // Must be careful since a power drop can be cancelled + // from the following states: + // - kIOPM_OurChangeTellClientsPowerDown + // - kIOPM_OurChangeTellPriorityClientsPowerDown + // + // The child must not wait for this parent to raise power + // if the power drop was cancelled. The solution is to cancel + // the power drop if possible, then schedule an adjustment to + // re-evaluate the parent's power state. + // + // Root domain is excluded to avoid idle sleep issues. And allow + // root domain children to pop up when system is going to sleep. + + if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) || + (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)) { - if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) - { - break; - } - i++; + 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()); } - if ( i == pm_vars->theNumberOfPowerStates ) + else { - return IOPMNoSuchState; + // Beyond cancellation point, report the impending state. + outputPowerFlags = + fPowerStates[fHeadNotePowerState].outputPowerFlags; } + } + else if (IS_POWER_RISE) + { + // When raising power, must report the output power flags from + // child's perspective. A child power request may arrive while + // parent is transitioning upwards. If a request arrives after + // setParentInfo() has already recorded the output power flags + // for the next power state, then using the power supplied by + // fCurrentPowerState is incorrect, and might cause the child + // to wait when it should not. + + outputPowerFlags = childConnection->parentCurrentPowerFlags(); + } + } + child->fHeadNoteDomainTargetFlags |= outputPowerFlags; + + // Map child's requested power flags to one of our power state. + + for (order = 0; order < fNumberOfPowerStates; order++) + { + powerState = fPowerStates[order].stateOrderToIndex; + if ((fPowerStates[powerState].outputPowerFlags & childRequestPowerFlags) + == childRequestPowerFlags) break; + } + if (order >= fNumberOfPowerStates) + { + powerState = kPowerStateZero; + } - default: - return IOPMBadSpecification; + // Conditions that warrants a power adjustment on this parent. + // Adjust power will also propagate any changes to the child's + // prevent idle/sleep flags towards the root domain. + + if (!childConnection->childHasRequestedPower() || + (powerState != childConnection->getDesiredDomainState())) + adjustPower = true; + +#if ENABLE_DEBUG_LOGS + if (adjustPower) + { + PM_LOG("requestPowerDomainState[%s]: %s, init %d, %u->%u\n", + getName(), child->getName(), + !childConnection->childHasRequestedPower(), + (uint32_t) childConnection->getDesiredDomainState(), + (uint32_t) powerState); } +#endif - computedState = i; - - IOLockLock(pm_vars->childLock); + // Record the child's desires on the connection. + childConnection->setChildHasRequestedPower(); + childConnection->setDesiredDomainState( powerState ); - // Now loop through the children. When we encounter the calling child, save - // the computed state as this child's desire. - iter = getChildIterator(gIOPowerPlane); + // 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 ( iter ) + if (adjustPower && !fDeviceOverrideEnabled && + (!fAdjustPowerScheduled || gIOPMRequest->getRootRequest())) { - while ( (next = iter->getNextObject()) ) + subRequest = acquirePMRequest( + this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest ); + if (subRequest) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) - { - if ( connection == whichChild ) - { - connection->setDesiredDomainState(computedState); - connection->setPreventIdleSleepFlag(desiredState & kIOPMPreventIdleSleep); - connection->setPreventSystemSleepFlag(desiredState & kIOPMPreventSystemSleep); - connection->setChildHasRequestedPower(); - } - } + submitPMRequest( subRequest ); + fAdjustPowerScheduled = true; } - iter->release(); } - // Since a child's power requirements may have changed, clear and rebuild - // kIOPMChildClamp and kIOPMChildClamp2 (idle and system sleep clamps) - rebuildChildClampBits(); - - IOLockUnlock(pm_vars->childLock); - - // this may be different now - computeDesiredState(); - - if ( inPlane(gIOPowerPlane) && - (pm_vars->parentsKnowState) ) { - // change state if all children can now tolerate lower power - changeState(); - } - - // are we clamped on, waiting for this child? - if ( priv->clampOn ) { - // yes, remove the clamp - priv->clampOn = false; - changePowerStateToPriv(0); - } - - return IOPMNoErr; + return kIOReturnSuccess; } - //********************************************************************************* -// temporaryPowerClampOn +// [public] temporaryPowerClampOn // // A power domain wants to clamp its power on till it has children which // will thendetermine the power domain state. @@ -1420,16 +2259,13 @@ IOReturn IOService::requestPowerDomainState ( IOPMPowerFlags desiredState, IOPow // We enter the highest state until addPowerChild is called. //********************************************************************************* -IOReturn IOService::temporaryPowerClampOn ( void ) +IOReturn IOService::temporaryPowerClampOn( void ) { - priv->clampOn = true; - makeUsable(); - return IOPMNoErr; + return requestPowerState( gIOPMPowerClientChildProxy, kIOPMPowerStateMax ); } - //********************************************************************************* -// makeUsable +// [public] makeUsable // // Some client of our device is asking that we become usable. Although // this has not come from a subclassed device object, treat it exactly @@ -1440,3535 +2276,6583 @@ IOReturn IOService::temporaryPowerClampOn ( void ) // highest power state. //********************************************************************************* -IOReturn IOService::makeUsable ( void ) +IOReturn IOService::makeUsable( void ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogMakeUsable,0,0); - - if ( pm_vars->theControllingDriver == NULL ) - { - priv->need_to_become_usable = true; - return IOPMNoErr; - } - priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1; - computeDesiredState(); - if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) - { - return changeState(); - } - return IOPMNoErr; + OUR_PMLog(kPMLogMakeUsable, 0, 0); + return requestPowerState( gIOPMPowerClientDevice, kIOPMPowerStateMax ); } -//****************************************************************************** -// temporaryMakeUsable -// -// Private function, called by IOService::addPowerChild to ensure that the -// device is temporarily in a usable power state so that attached power -// children may properly initialize. -//****************************************************************************** +//********************************************************************************* +// [public] currentCapability +//********************************************************************************* -IOReturn IOService::temporaryMakeUsable ( void ) +IOPMPowerFlags IOService::currentCapability( void ) { - IOReturn ret = kIOReturnSuccess; - unsigned long tempDesire; - - pm_vars->thePlatform->PMLog( pm_vars->ourName, - PMlogMakeUsable, - PMlogMakeUsable, - priv->deviceDesire); + if (!initialized) + return IOPMNotPowerManaged; - if ( pm_vars->theControllingDriver == NULL ) - { - priv->need_to_become_usable = true; - return IOPMNoErr; - } - tempDesire = priv->deviceDesire; - priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1; - computeDesiredState(); - if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) - { - ret = changeState(); - } - priv->deviceDesire = tempDesire; - return ret; + return fCurrentCapabilityFlags; } - //********************************************************************************* -// currentCapability +// [public] changePowerStateTo // +// Called by our power-controlling driver to change power state. The new desired +// power state is computed and compared against the current power state. If those +// power states differ, then a power state change is initiated. //********************************************************************************* -IOPMPowerFlags IOService::currentCapability ( void ) +IOReturn IOService::changePowerStateTo( unsigned long ordinal ) { - if ( pm_vars->theControllingDriver == NULL ) - { - return 0; - } else { - return pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags; - } + OUR_PMLog(kPMLogChangeStateTo, ordinal, 0); + return requestPowerState( gIOPMPowerClientDriver, ordinal ); } - //********************************************************************************* -// changePowerStateTo +// [protected] changePowerStateToPriv // -// For some reason, our power-controlling driver has decided it needs to change -// power state. We enqueue the power change so that appropriate parties -// will be notified, and then we will instruct the driver to make the change. +// 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 +// power states differ, then a power state change is initiated. //********************************************************************************* -IOReturn IOService::changePowerStateTo ( unsigned long ordinal ) +IOReturn IOService::changePowerStateToPriv( unsigned long ordinal ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeStateTo,ordinal,0); - - if ( ordinal >= pm_vars->theNumberOfPowerStates ) - { - return IOPMParameterError; - } - priv->driverDesire = ordinal; - computeDesiredState(); - if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) - { - return changeState(); - } - - return IOPMNoErr; + OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0); + return requestPowerState( gIOPMPowerClientDevice, ordinal ); } //********************************************************************************* -// changePowerStateToPriv +// [public] changePowerStateWithOverrideTo // -// For some reason, a subclassed device object has decided it needs to change -// power state. We enqueue the power change so that appropriate parties -// will be notified, and then we will instruct the driver to make the change. +// 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 +// power states differ, then a power state change is initiated. +// Override enforced - Children and Driver desires are ignored. //********************************************************************************* -IOReturn IOService::changePowerStateToPriv ( unsigned long ordinal ) +IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal, + IOPMRequestTag tag ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeStateToPriv,ordinal,0); + IOPMRequest * request; - if ( pm_vars->theControllingDriver == NULL) - { - return IOPMNotYetInitialized; - } - if ( ordinal >= pm_vars->theNumberOfPowerStates ) - { - return IOPMParameterError; - } - priv->deviceDesire = ordinal; - computeDesiredState(); - if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) + if (!initialized) + return kIOPMNotYetInitialized; + + OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0); + + request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride ); + if (!request) + return kIOReturnNoMemory; + + gIOPMPowerClientDevice->retain(); + request->fRequestTag = tag; + request->fArg0 = (void *) ordinal; + request->fArg1 = (void *) gIOPMPowerClientDevice; + 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. + + if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates)) { - return changeState(); + fTempClampPowerState = StateMax(fTempClampPowerState, ordinal); + fTempClampCount++; + fOverrideMaxPowerState = ordinal; + request->fArg2 = (void *) (uintptr_t) true; } + 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 ); +} //********************************************************************************* -// computeDesiredState +// [public for PMRD] quiescePowerTree // +// For root domain to issue a request to quiesce the power tree. +// Supplied callback invoked upon completion. //********************************************************************************* -void IOService::computeDesiredState ( void ) +IOReturn IOService::quiescePowerTree( + void * target, IOPMCompletionAction action, void * param ) { - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - unsigned long newDesiredState = 0; + IOPMRequest * request; - // Compute the maximum of our children's desires, our controlling driver's desire, and the subclass device's desire. - if ( ! priv->device_overrides ) - { - iter = getChildIterator(gIOPowerPlane); + if (!initialized) + return kIOPMNotYetInitialized; + if (!target || !action) + return kIOReturnBadArgument; - if ( iter ) - { - while ( (next = iter->getNextObject()) ) - { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) - { - if ( connection->getDesiredDomainState() > newDesiredState ) - { - newDesiredState = connection->getDesiredDomainState(); - } - } - } - iter->release(); - } - - if ( priv->driverDesire > newDesiredState ) - { - newDesiredState = priv->driverDesire; - } - } + OUR_PMLog(kPMLogQuiescePowerTree, 0, 0); - if ( priv->deviceDesire > newDesiredState ) - { - newDesiredState = priv->deviceDesire; - } + // 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. - priv->ourDesiredPowerState = newDesiredState; -} + 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; +} //********************************************************************************* -// changeState -// -// A subclass object, our controlling driver, or a power domain child -// has asked for a different power state. Here we compute what new -// state we should enter and enqueue the change (or start it). +// [private] requestPowerState //********************************************************************************* -IOReturn IOService::changeState ( void ) +IOReturn IOService::requestPowerState( + const OSSymbol * client, + uint32_t state ) { - // if not fully initialized - if ( (pm_vars->theControllingDriver == NULL) || - !(inPlane(gIOPowerPlane)) || - !(pm_vars->parentsKnowState) ) + IOPMRequest * request; + + if (!client) + return kIOReturnBadArgument; + if (!initialized) + return kIOPMNotYetInitialized; + + request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState ); + if (!request) + return kIOReturnNoMemory; + + client->retain(); + request->fArg0 = (void *)(uintptr_t) state; + request->fArg1 = (void *) client; + request->fArg2 = 0; +#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. + + if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates)) { - // we can do no more - return IOPMNoErr; + fTempClampPowerState = StateMax(fTempClampPowerState, state); + fTempClampCount++; + request->fArg2 = (void *) (uintptr_t) true; } - - return enqueuePowerChange(IOPMWeInitiated,priv->ourDesiredPowerState,0,0,0); -} + submitPMRequest( request ); + return IOPMNoErr; +} //********************************************************************************* -// currentPowerConsumption -// +// [private] handleRequestPowerState //********************************************************************************* -unsigned long IOService::currentPowerConsumption ( void ) +void IOService::handleRequestPowerState( IOPMRequest * request ) { - if ( pm_vars->theControllingDriver == NULL ) - { - return kIOPMUnknown; - } - if ( pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags & kIOPMStaticPowerValid ) + const OSSymbol * client = (const OSSymbol *) request->fArg1; + uint32_t state = (uint32_t)(uintptr_t) request->fArg0; + + PM_ASSERT_IN_GATE(); + if (request->fArg2) { - return pm_vars->thePowerStates[pm_vars->myCurrentState].staticPower; + assert(fTempClampCount != 0); + if (fTempClampCount) fTempClampCount--; + if (!fTempClampCount) fTempClampPowerState = kPowerStateZero; } - return kIOPMUnknown; + + if (fNumberOfPowerStates && (state >= fNumberOfPowerStates)) + state = fHighestPowerState; + + // The power suppression due to changePowerStateWithOverrideTo() expires + // upon the next "device" power request - changePowerStateToPriv(). + + if ((getPMRequestType() != kIOPMRequestTypeRequestPowerStateOverride) && + (client == gIOPMPowerClientDevice)) + fOverrideMaxPowerState = kIOPMPowerStateMax; + + if ((state == kPowerStateZero) && + (client != gIOPMPowerClientDevice) && + (client != gIOPMPowerClientDriver) && + (client != gIOPMPowerClientChildProxy)) + removePowerClient(client); + else + updatePowerClient(client, state); + + adjustPowerState(); + client->release(); } //********************************************************************************* -// activityTickle -// -// The activity tickle with parameter kIOPMSubclassPolicyis not handled -// here and should have been intercepted by the subclass. -// The tickle with parameter kIOPMSuperclassPolicy1 causes the activity -// flag to be set, and the device state checked. If the device has been -// powered down, it is powered up again. +// [private] Helper functions to update/remove power clients. //********************************************************************************* -bool IOService::activityTickle ( unsigned long type, unsigned long stateNumber ) +void IOService::updatePowerClient( const OSSymbol * client, uint32_t powerState ) { - IOPMrootDomain *pmRootDomain; - AbsoluteTime uptime; + IOPMPowerStateIndex oldPowerState = kPowerStateZero; - if ( type == kIOPMSuperclassPolicy1 ) + if (!fPowerClients) + fPowerClients = OSDictionary::withCapacity(4); + if (fPowerClients && client) { - if ( pm_vars->theControllingDriver == NULL ) - { - return true; - } - - if( priv->activityLock == NULL ) + OSNumber * num = (OSNumber *) fPowerClients->getObject(client); + if (num) { - priv->activityLock = IOLockAlloc(); + oldPowerState = num->unsigned32BitValue(); + num->setValue(powerState); } - - IOTakeLock(priv->activityLock); - priv->device_active = true; - - clock_get_uptime(&uptime); - priv->device_active_timestamp = uptime; - - if ( pm_vars->myCurrentState >= stateNumber) + else { - IOUnlock(priv->activityLock); - return true; + num = OSNumber::withNumber(powerState, 32); + if (num) + { + fPowerClients->setObject(client, num); + num->release(); + } } - IOUnlock(priv->activityLock); - - // Transfer execution to the PM workloop - if( (pmRootDomain = getPMRootDomain()) ) - pmRootDomain->unIdleDevice(this, stateNumber); - return false; + PM_ACTION_3(actionUpdatePowerClient, client, oldPowerState, powerState); } - return true; } -//********************************************************************************* -// getPMworkloop -// -// A child is calling to get a pointer to the Power Management workloop. -// We got it or get it from one of our parents. -//********************************************************************************* +void IOService::removePowerClient( const OSSymbol * client ) +{ + if (fPowerClients && client) + fPowerClients->removeObject(client); +} -IOWorkLoop * IOService::getPMworkloop ( void ) +uint32_t IOService::getPowerStateForClient( const OSSymbol * client ) { - IOService *nub; - IOService *parent; + uint32_t powerState = kPowerStateZero; - if ( ! inPlane(gIOPowerPlane) ) - { - return NULL; - } - // we have no workloop yet - if ( pm_vars->PMworkloop == NULL ) + if (fPowerClients && client) { - nub = (IOService *)copyParentEntry(gIOPowerPlane); - if ( nub ) - { - parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); - nub->release(); - // ask one of our parents for the workloop - if ( parent ) - { - pm_vars->PMworkloop = parent->getPMworkloop(); - parent->release(); - } - } + OSNumber * num = (OSNumber *) fPowerClients->getObject(client); + if (num) powerState = num->unsigned32BitValue(); } - return pm_vars->PMworkloop; + return powerState; } - //********************************************************************************* -// setIdleTimerPeriod -// -// A subclass policy-maker is going to use our standard idleness -// detection service. Make a command queue and an idle timer and -// connect them to the power management workloop. Finally, -// start the timer. +// [protected] powerOverrideOnPriv //********************************************************************************* -IOReturn IOService::setIdleTimerPeriod ( unsigned long period ) +IOReturn IOService::powerOverrideOnPriv( void ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMsetIdleTimerPeriod,period, 0); + IOPMRequest * request; - priv->idle_timer_period = period; + if (!initialized) + return IOPMNotYetInitialized; - if ( period > 0 ) + if (gIOPMWorkLoop->inGate()) { - if ( getPMworkloop() == NULL ) - { - return kIOReturnError; - } - - // make the timer event - if ( priv->timerEventSrc == NULL ) - { - priv->timerEventSrc = IOTimerEventSource::timerEventSource(this, - PM_idle_timer_expired); - if ((!priv->timerEventSrc) || - (pm_vars->PMworkloop->addEventSource(priv->timerEventSrc) != kIOReturnSuccess) ) - { - return kIOReturnError; - } - } + fDeviceOverrideEnabled = true; + return IOPMNoErr; + } - if ( priv->activityLock == NULL ) - { - priv->activityLock = IOLockAlloc(); - } + request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv ); + if (!request) + return kIOReturnNoMemory; - start_PM_idle_timer(); - } + submitPMRequest( request ); return IOPMNoErr; } -//****************************************************************************** -// nextIdleTimeout -// -// Returns how many "seconds from now" the device should idle into its -// next lowest power state. -//****************************************************************************** -SInt32 IOService::nextIdleTimeout( - AbsoluteTime currentTime, - AbsoluteTime lastActivity, - unsigned int powerState) -{ - AbsoluteTime delta; - UInt64 delta_ns; - SInt32 delta_secs; - SInt32 delay_secs; - - // Calculate time difference using funky macro from clock.h. - delta = currentTime; - SUB_ABSOLUTETIME(&delta, &lastActivity); - - // Figure it in seconds. - absolutetime_to_nanoseconds(delta, &delta_ns); - delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC); - - // Be paranoid about delta somehow exceeding timer period. - if (delta_secs < (int) priv->idle_timer_period ) - delay_secs = (int) priv->idle_timer_period - delta_secs; - else - delay_secs = (int) priv->idle_timer_period; - - return (SInt32)delay_secs; -} +//********************************************************************************* +// [protected] powerOverrideOffPriv +//********************************************************************************* -//****************************************************************************** -// start_PM_idle_timer -// -// The parameter is a pointer to us. Use it to call our timeout method. -//****************************************************************************** -void IOService::start_PM_idle_timer ( void ) +IOReturn IOService::powerOverrideOffPriv( void ) { - static const int maxTimeout = 100000; - static const int minTimeout = 1; - AbsoluteTime uptime; - SInt32 idle_in = 0; - - IOLockLock(priv->activityLock); + IOPMRequest * request; - clock_get_uptime(&uptime); - - // Subclasses may modify idle sleep algorithm - idle_in = nextIdleTimeout(uptime, - priv->device_active_timestamp, - pm_vars->myCurrentState); + if (!initialized) + return IOPMNotYetInitialized; - // Check for out-of range responses - if(idle_in > maxTimeout) + if (gIOPMWorkLoop->inGate()) { - // use standard implementation - idle_in = IOService::nextIdleTimeout(uptime, - priv->device_active_timestamp, - pm_vars->myCurrentState); - } else if(idle_in < minTimeout) { - // fire immediately - idle_in = 0; + fDeviceOverrideEnabled = false; + return IOPMNoErr; } - priv->timerEventSrc->setTimeout(idle_in, NSEC_PER_SEC); + request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv ); + if (!request) + return kIOReturnNoMemory; - IOLockUnlock(priv->activityLock); - return; + submitPMRequest( request ); + return IOPMNoErr; } - //********************************************************************************* -// PM_idle_timer_expired -// -// The parameter is a pointer to us. Use it to call our timeout method. +// [private] handlePowerOverrideChanged //********************************************************************************* -void PM_idle_timer_expired(OSObject * ourSelves, IOTimerEventSource *) +void IOService::handlePowerOverrideChanged( IOPMRequest * request ) { - ((IOService *)ourSelves)->PM_idle_timer_expiration(); -} + PM_ASSERT_IN_GATE(); + if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv) + { + OUR_PMLog(kPMLogOverrideOn, 0, 0); + fDeviceOverrideEnabled = true; + } + else + { + OUR_PMLog(kPMLogOverrideOff, 0, 0); + fDeviceOverrideEnabled = false; + } + adjustPowerState(); +} //********************************************************************************* -// PM_idle_timer_expiration -// -// The idle timer has expired. If there has been activity since the last -// expiration, just restart the timer and return. If there has not been -// activity, switch to the next lower power state and restart the timer. +// [private] computeDesiredState //********************************************************************************* -void IOService::PM_idle_timer_expiration ( void ) +void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly ) { - if ( ! initialized ) + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + uint32_t desiredState = kPowerStateZero; + uint32_t newPowerState = kPowerStateZero; + bool hasChildren = false; + + // Desired power state is always 0 without a controlling driver. + + if (!fNumberOfPowerStates) { - // we're unloading + fDesiredPowerState = kPowerStateZero; return; } - if ( priv->idle_timer_period > 0 ) + // Examine the children's desired power state. + + iter = getChildIterator(gIOPowerPlane); + if (iter) { - IOTakeLock(priv->activityLock); - if ( priv->device_active ) - { - priv->device_active = false; - IOUnlock(priv->activityLock); - start_PM_idle_timer(); - return; - } - if ( pm_vars->myCurrentState > 0 ) + while ((next = iter->getNextObject())) { - - unsigned long newState = pm_vars->myCurrentState - 1; - - IOUnlock(priv->activityLock); - changePowerStateToPriv(newState); - if ( newState >= priv->ourDesiredPowerState ) - start_PM_idle_timer(); - return; + if ((connection = OSDynamicCast(IOPowerConnection, next))) + { + if (connection->getReadyFlag() == false) + { + PM_LOG3("[%s] %s: connection not ready\n", + getName(), __FUNCTION__); + continue; + } + if (connection->childHasRequestedPower()) + hasChildren = true; + desiredState = StateMax(connection->getDesiredDomainState(), desiredState); + } } - IOUnlock(priv->activityLock); - start_PM_idle_timer(); + iter->release(); } -} + if (hasChildren) + updatePowerClient(gIOPMPowerClientChildren, desiredState); + else + removePowerClient(gIOPMPowerClientChildren); + // Iterate through all power clients to determine the min power state. -// ********************************************************************************** -// command_received -// -// We are un-idling a device due to its activity tickle. This routine runs on the -// PM workloop, and is initiated by IOService::activityTickle. -// We process all activityTickle state requests on the list. -// ********************************************************************************** -void IOService::command_received ( void *statePtr , void *, void * , void * ) -{ - unsigned long stateNumber; + iter = OSCollectionIterator::withCollection(fPowerClients); + if (iter) + { + const OSSymbol * client; + while ((client = (const OSSymbol *) iter->getNextObject())) + { + // Ignore child and driver when override is in effect. + if ((fDeviceOverrideEnabled || + (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)) && + ((client == gIOPMPowerClientChildren) || + (client == gIOPMPowerClientDriver))) + continue; + + // Ignore child proxy when children are present. + if (hasChildren && (client == gIOPMPowerClientChildProxy)) + continue; + + // Advisory tickles are irrelevant unless system is in full wake + if (client == gIOPMPowerClientAdvisoryTickle && + !gIOPMAdvisoryTickleEnabled) + continue; + + desiredState = getPowerStateForClient(client); + assert(desiredState < fNumberOfPowerStates); + PM_LOG1(" %u %s\n", + desiredState, client->getCStringNoCopy()); + + newPowerState = StateMax(newPowerState, desiredState); + + if (client == gIOPMPowerClientDevice) + fDeviceDesire = desiredState; + } + iter->release(); + } - stateNumber = (unsigned long)statePtr; + // Factor in the temporary power desires. - // If not initialized, we're unloading - if ( ! initialized ) return; + newPowerState = StateMax(newPowerState, localClamp); + newPowerState = StateMax(newPowerState, fTempClampPowerState); - if ( (pm_vars->myCurrentState < stateNumber) && - (priv->imminentState < stateNumber) ) - { - changePowerStateToPriv(stateNumber); + // Limit check against max power override. - // After we raise our state, re-schedule the idle timer. - if(priv->timerEventSrc) - start_PM_idle_timer(); - } -} + newPowerState = StateMin(newPowerState, fOverrideMaxPowerState); + // Limit check against number of power states. -//********************************************************************************* -// setAggressiveness -// -// Pass on the input parameters to all power domain children. All those which are -// power domains will pass it on to their children, etc. -//********************************************************************************* + if (newPowerState >= fNumberOfPowerStates) + newPowerState = fHighestPowerState; -IOReturn IOService::setAggressiveness ( unsigned long type, unsigned long newLevel ) -{ - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - IOService *child; + fDesiredPowerState = newPowerState; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSetAggressiveness,type, newLevel); + PM_LOG1(" temp %u, clamp %u, current %u, new %u\n", + (uint32_t) localClamp, (uint32_t) fTempClampPowerState, + (uint32_t) fCurrentPowerState, newPowerState); - if ( type <= kMaxType ) + if (!computeOnly) { - pm_vars->current_aggressiveness_values[type] = newLevel; - pm_vars->current_aggressiveness_valid[type] = true; - } + // Restart idle timer if possible when device desire has increased. + // Or if an advisory desire exists. - iter = getChildIterator(gIOPowerPlane); + if (fIdleTimerPeriod && fIdleTimerStopped) + { + restartIdleTimer(); + } - if ( iter ) - { - while ( (next = iter->getNextObject()) ) + // 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)) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) - { - child = ((IOService *)(connection->copyChildEntry(gIOPowerPlane))); - if ( child ) - { - child->setAggressiveness(type, newLevel); - child->release(); - } - } + IOLockLock(fActivityLock); + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); } - iter->release(); } - - return IOPMNoErr; } //********************************************************************************* -// getAggressiveness +// [public] currentPowerConsumption // -// Called by the user client. //********************************************************************************* -IOReturn IOService::getAggressiveness ( unsigned long type, unsigned long * currentLevel ) +unsigned long IOService::currentPowerConsumption( void ) { - if ( type > kMaxType ) - return kIOReturnBadArgument; + if (!initialized) + return kIOPMUnknown; - if ( !pm_vars->current_aggressiveness_valid[type] ) - return kIOReturnInvalid; - - *currentLevel = pm_vars->current_aggressiveness_values[type]; - - return kIOReturnSuccess; + return fCurrentPowerConsumption; } //********************************************************************************* -// systemWake -// -// Pass this to all power domain children. All those which are -// power domains will pass it on to their children, etc. +// [deprecated] getPMworkloop //********************************************************************************* -IOReturn IOService::systemWake ( void ) +#ifndef __LP64__ +IOWorkLoop * IOService::getPMworkloop( void ) { - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - IOService *theChild; + return gIOPMWorkLoop; +} +#endif - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSystemWake,0, 0); +#if NOT_YET - iter = getChildIterator(gIOPowerPlane); +//********************************************************************************* +// Power Parent/Children Applier +//********************************************************************************* + +static void +applyToPowerChildren( + IOService * service, + IOServiceApplierFunction applier, + void * context, + IOOptionBits options ) +{ + PM_ASSERT_IN_GATE(); - if ( iter ) + IORegistryEntry * entry; + IORegistryIterator * iter; + IOPowerConnection * connection; + IOService * child; + + iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, options); + if (iter) { - while ( (next = iter->getNextObject()) ) + while ((entry = iter->getNextObject())) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + // Get child of IOPowerConnection objects + if ((connection = OSDynamicCast(IOPowerConnection, entry))) { - theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane); - if ( theChild ) + child = (IOService *) connection->copyChildEntry(gIOPowerPlane); + if (child) { - theChild->systemWake(); - theChild->release(); + (*applier)(child, context); + child->release(); } } } iter->release(); } - - if ( pm_vars->theControllingDriver != NULL ) - { - if ( pm_vars->theControllingDriver->didYouWakeSystem() ) - { - makeUsable(); - } - } - - return IOPMNoErr; } - -//********************************************************************************* -// temperatureCriticalForZone -// -//********************************************************************************* - -IOReturn IOService::temperatureCriticalForZone ( IOService * whichZone ) +static void +applyToPowerParent( + IOService * service, + IOServiceApplierFunction applier, + void * context, + IOOptionBits options ) { - IOService *theParent; - IOService *theNub; - - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCriticalTemp,0,0); + PM_ASSERT_IN_GATE(); - if ( inPlane(gIOPowerPlane) && !(priv->we_are_root) ) + IORegistryEntry * entry; + IORegistryIterator * iter; + IOPowerConnection * connection; + IOService * parent; + + iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, + options | kIORegistryIterateParents); + if (iter) { - theNub = (IOService *)copyParentEntry(gIOPowerPlane); - if ( theNub ) + while ((entry = iter->getNextObject())) { - theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane); - theNub->release(); - if ( theParent ) + // Get child of IOPowerConnection objects + if ((connection = OSDynamicCast(IOPowerConnection, entry))) { - theParent->temperatureCriticalForZone(whichZone); - theParent->release(); + parent = (IOService *) connection->copyParentEntry(gIOPowerPlane); + if (parent) + { + (*applier)(parent, context); + parent->release(); + } } } + iter->release(); } - return IOPMNoErr; } +#endif /* NOT_YET */ -//********************************************************************************* -// powerOverrideOnPriv -// -//********************************************************************************* - +// MARK: - +// MARK: Activity Tickle & Idle Timer -IOReturn IOService::powerOverrideOnPriv ( void ) +void IOService::setAdvisoryTickleEnable( bool enable ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogOverrideOn,0,0); - - // turn on the override - priv->device_overrides = true; - computeDesiredState(); - - // change state if that changed something - return changeState(); + gIOPMAdvisoryTickleEnabled = enable; } - //********************************************************************************* -// powerOverrideOffPriv +// [public] activityTickle // +// The tickle with parameter kIOPMSuperclassPolicy1 causes the activity +// flag to be set, and the device state checked. If the device has been +// powered down, it is powered up again. +// The tickle with parameter kIOPMSubclassPolicy is ignored here and +// should be intercepted by a subclass. //********************************************************************************* -IOReturn IOService::powerOverrideOffPriv ( void ) + +bool IOService::activityTickle( unsigned long type, unsigned long stateNumber ) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogOverrideOff,0,0); + IOPMRequest * request; + bool noPowerChange = true; + uint32_t tickleFlags; - // turn off the override - priv->device_overrides = false; - computeDesiredState(); - if( priv->clampOn) + if (!initialized) + return true; // no power change + + if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber)) { - return makeUsable(); - } else { - // change state if that changed something - return changeState(); - } -} + IOLockLock(fActivityLock); + // Record device activity for the idle timer handler. -//********************************************************************************* -// enqueuePowerChange -// -// Allocate a new state change notification, initialize it with fields from the -// caller, and add it to the tail of the list of pending power changes. -// -// If it is early enough in the list, and almost all the time it is the only one in -// the list, start the power change. -// -// In rare instances, this change will preempt the previous change in the list. -// If the previous change is un-actioned in any way (because we are still -// processing an even earlier power change), and if both the previous change -// in the list and this change are initiated by us (not the parent), then we -// needn't perform the previous change, so we collapse the list a little. -//********************************************************************************* + fDeviceWasActive = true; + fActivityTickleCount++; + clock_get_uptime(&fDeviceActiveTimestamp); -IOReturn IOService::enqueuePowerChange ( - unsigned long flags, - unsigned long whatStateOrdinal, - unsigned long domainState, - IOPowerConnection * whichParent, - unsigned long singleParentState ) -{ - long newNote; - long previousNote; + PM_ACTION_0(actionActivityTickle); - // Create and initialize the new change note + // Record the last tickle power state. + // This helps to filter out redundant tickles as + // this function may be called from the data path. - IOLockLock(priv->queue_lock); - newNote = priv->changeList->createChangeNote(); - if ( newNote == -1 ) { - // uh-oh, our list is full - IOLockUnlock(priv->queue_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogEnqueueErr,0,0); - return IOPMAckImplied; - } + if ((fActivityTicklePowerState == kInvalidTicklePowerState) + || StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber)) + { + fActivityTicklePowerState = stateNumber; + noPowerChange = false; - priv->changeList->changeNote[newNote].newStateNumber = whatStateOrdinal; - priv->changeList->changeNote[newNote].outputPowerCharacter = pm_vars->thePowerStates[whatStateOrdinal].outputPowerCharacter; - priv->changeList->changeNote[newNote].inputPowerRequirement = pm_vars->thePowerStates[whatStateOrdinal].inputPowerRequirement; - priv->changeList->changeNote[newNote].capabilityFlags = pm_vars->thePowerStates[whatStateOrdinal].capabilityFlags; - priv->changeList->changeNote[newNote].flags = flags; - priv->changeList->changeNote[newNote].parent = NULL; - if (flags & IOPMParentInitiated ) - { - priv->changeList->changeNote[newNote].domainState = domainState; - priv->changeList->changeNote[newNote].parent = whichParent; - whichParent->retain(); - priv->changeList->changeNote[newNote].singleParentState = singleParentState; - } + 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); + } + } - previousNote = priv->changeList->previousChangeNote(newNote); + IOLockUnlock(fActivityLock); + } - if ( previousNote == -1 ) + else if ((type == kIOPMActivityTickleTypeAdvisory) && + ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero)) { + IOLockLock(fActivityLock); - // Queue is empty, we can start this change. + fAdvisoryTickled = true; - if (flags & IOPMWeInitiated ) + if (fAdvisoryTicklePowerState != stateNumber) { - IOLockUnlock(priv->queue_lock); - start_our_change(newNote); - return 0; - } else { - IOLockUnlock(priv->queue_lock); - return start_parent_change(newNote); + 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); + } } - } - // The queue is not empty. Try to collapse this new change and the previous one in queue into one change. - // This is possible only if both changes are initiated by us, and neither has been started yet. - // Do this more than once if possible. + IOLockUnlock(fActivityLock); + } - // (A change is started iff it is at the head of the queue) + // Returns false if the activityTickle might cause a transition to a + // higher powered state, true otherwise. - while ( (previousNote != priv->head_note) && (previousNote != -1) && - (priv->changeList->changeNote[newNote].flags & priv->changeList->changeNote[previousNote].flags & IOPMWeInitiated) ) - { - priv->changeList->changeNote[previousNote].outputPowerCharacter = priv->changeList->changeNote[newNote].outputPowerCharacter; - priv->changeList->changeNote[previousNote].inputPowerRequirement = priv->changeList->changeNote[newNote].inputPowerRequirement; - priv->changeList->changeNote[previousNote].capabilityFlags =priv-> changeList->changeNote[newNote].capabilityFlags; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCollapseQueue,priv->changeList->changeNote[newNote].newStateNumber, - priv->changeList->changeNote[previousNote].newStateNumber); - priv->changeList->changeNote[previousNote].newStateNumber = priv->changeList->changeNote[newNote].newStateNumber; - priv->changeList->releaseTailChangeNote(); - newNote = previousNote; - previousNote = priv->changeList->previousChangeNote(newNote); - } - IOLockUnlock(priv->queue_lock); - // in any case, we can't start yet - return IOPMWillAckLater; + return noPowerChange; } //********************************************************************************* -// notifyAll -// -// Notify all interested parties either that a change is impending or that the -// previously-notified change is done and power has settled. -// The parameter identifies whether this is the -// pre-change notification or the post-change notification. -// +// [private] handleActivityTickle //********************************************************************************* -IOReturn IOService::notifyAll ( bool is_prechange ) +void IOService::handleActivityTickle( IOPMRequest * request ) { - IOPMinformee * nextObject; - OSIterator * iter; - OSObject * next; - IOPowerConnection * connection; - - // To prevent acknowledgePowerChange from finishing the change note and - // removing it from the queue if - // some driver calls it, we inflate the number of pending acks so it - // cannot become zero. We'll fix it later. - - if(!acquire_lock()) return IOPMAckImplied; + 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; - OSAddAtomic(1, (SInt32*)&priv->head_note_pendingAcks); - - // OK, we will go through the lists of interested drivers and - // power domain children and notify each one of this change. - - nextObject = priv->interestedDrivers->firstInList(); - while ( nextObject != NULL ) { + 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. - OSAddAtomic(1, (SInt32*)&priv->head_note_pendingAcks); + return; + } - IOUnlock(priv->our_lock); + if (tickleFlags & kTickleTypeActivity) + { + IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire); + uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop - inform(nextObject, is_prechange); - - if(!acquire_lock()) + if (tickleFlags & kTickleTypePowerRise) { - goto exit; + if ((StateOrder(ticklePowerState) > deviceDesireOrder) && + (ticklePowerState < fNumberOfPowerStates)) + { + fIdleTimerMinPowerState = ticklePowerState; + updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); + adjustPower = true; + } + } + else if ((deviceDesireOrder > StateOrder(fIdleTimerMinPowerState)) && + (idleTimerGeneration == fIdleTimerGeneration)) + { + // Power drop due to idle timer expiration. + // Do not allow idle timer to reduce power below tickle power. + // This prevents the idle timer from decreasing the device desire + // to zero and cancelling the effect of a pre-sleep tickle when + // system wakes up to doze state, while the device is unable to + // raise its power state to satisfy the tickle. + + deviceDesireOrder--; + if (deviceDesireOrder < fNumberOfPowerStates) + { + ticklePowerState = fPowerStates[deviceDesireOrder].stateOrderToIndex; + updatePowerClient(gIOPMPowerClientDevice, ticklePowerState); + adjustPower = true; + } } - - nextObject = priv->interestedDrivers->nextInList(nextObject); - } - - // did they all ack? - if ( priv->head_note_pendingAcks > 1 ) { - // no - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); - start_ack_timer(); } - // either way - IOUnlock(priv->our_lock); - - // notify children - iter = getChildIterator(gIOPowerPlane); - // summing their power consumption - pm_vars->thePowerStates[priv->head_note_state].staticPower = 0; - - if ( iter && acquire_lock()) + else // advisory tickle { - while ( (next = iter->getNextObject()) ) + if (tickleFlags & kTickleTypePowerRise) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) + if ((ticklePowerState == fDeviceUsablePowerState) && + (ticklePowerState < fNumberOfPowerStates)) { - OSAddAtomic(1, (SInt32*)&priv->head_note_pendingAcks); - - IOUnlock(priv->our_lock); - - notifyChild(connection, is_prechange); - - if(!acquire_lock()) - { - goto exit; - } + updatePowerClient(gIOPMPowerClientAdvisoryTickle, ticklePowerState); + fHasAdvisoryDesire = true; + fAdvisoryTickleUsed = true; + adjustPower = true; + } + else + { + IOLockLock(fActivityLock); + fAdvisoryTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); } } - iter->release(); - IOUnlock(priv->our_lock); + else if (fHasAdvisoryDesire) + { + removePowerClient(gIOPMPowerClientAdvisoryTickle); + fHasAdvisoryDesire = false; + adjustPower = true; + } } - if (! acquire_lock() ) { - return IOPMNoErr; + if (adjustPower) + { + adjustPowerState(); } - // now make this real - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); +} - // is it all acked? - if (priv->head_note_pendingAcks == 0 ) { - // yes, all acked - IOUnlock(priv->our_lock); - // return ack to parent - return IOPMAckImplied; - } +//****************************************************************************** +// [public] setIdleTimerPeriod +// +// A subclass policy-maker is using our standard idleness detection service. +// Start the idle timer. Period is in seconds. +//****************************************************************************** - // not all acked - IOUnlock(priv->our_lock); +IOReturn IOService::setIdleTimerPeriod( unsigned long period ) +{ + if (!initialized) + return IOPMNotYetInitialized; -exit: // unable to acquire_lock exit case + OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod); - return IOPMWillAckLater; -} + IOPMRequest * request = + acquirePMRequest( this, kIOPMRequestTypeSetIdleTimerPeriod ); + if (!request) + return kIOReturnNoMemory; + request->fArg0 = (void *) period; + submitPMRequest( request ); -//********************************************************************************* -// notifyChild -// -// Notify a power domain child of an upcoming power change. -// -// If the object acknowledges the current change, we return TRUE. -//********************************************************************************* + return kIOReturnSuccess; +} -bool IOService::notifyChild ( IOPowerConnection * theNub, bool is_prechange ) +IOReturn IOService::setIgnoreIdleTimer( bool ignore ) { - IOReturn k = IOPMAckImplied; - unsigned long childPower; - IOService *theChild; - - theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane)); - if(!theChild) - { - // The child has been detached since we grabbed the child iterator. - // Decrement pending_acks, already incremented in notifyAll, - // to account for this unexpected departure. + if (!initialized) + return IOPMNotYetInitialized; - if( acquire_lock() ) - { - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - IOUnlock(priv->our_lock); - } - return true; - } - - // Unless the child handles the notification immediately and returns - // kIOPMAckImplied, we'll be awaiting their acknowledgement later. - theNub->setAwaitingAck(true); - - if ( is_prechange ) - { - k = theChild->powerDomainWillChangeTo(priv->head_note_outputFlags,theNub); - } else { - k = theChild->powerDomainDidChangeTo(priv->head_note_outputFlags,theNub); - } - - // did the return code ack? - if ( k == IOPMAckImplied ) - { - // yes - if( acquire_lock() ) - { - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - IOUnlock(priv->our_lock); - } - - theNub->setAwaitingAck(false); - childPower = theChild->currentPowerConsumption(); - if ( childPower == kIOPMUnknown ) - { - pm_vars->thePowerStates[priv->head_note_state].staticPower = kIOPMUnknown; - } else { - if ( pm_vars->thePowerStates[priv->head_note_state].staticPower != kIOPMUnknown ) - { - pm_vars->thePowerStates[priv->head_note_state].staticPower += childPower; - } - } - theChild->release(); - return true; - } - theChild->release(); - return false; -} + OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0); + IOPMRequest * request = + acquirePMRequest( this, kIOPMRequestTypeIgnoreIdleTimer ); + if (!request) + return kIOReturnNoMemory; -//********************************************************************************* -// inform -// -// Notify an interested driver of an upcoming power change. + request->fArg0 = (void *) ignore; + submitPMRequest( request ); + + return kIOReturnSuccess; +} + +//****************************************************************************** +// [public] nextIdleTimeout // -// If the object acknowledges the current change, we return TRUE. -//********************************************************************************* +// Returns how many "seconds from now" the device should idle into its +// next lowest power state. +//****************************************************************************** -bool IOService::inform ( IOPMinformee * nextObject, bool is_prechange ) +SInt32 IOService::nextIdleTimeout( + AbsoluteTime currentTime, + AbsoluteTime lastActivity, + unsigned int powerState) { - IOReturn k = IOPMAckImplied; + AbsoluteTime delta; + UInt64 delta_ns; + SInt32 delta_secs; + SInt32 delay_secs; - // initialize this - nextObject->timer = -1; - - if ( is_prechange ) - { - pm_vars->thePlatform->PMLog (pm_vars->ourName,PMlogInformDriverPreChange, - (unsigned long)priv->head_note_capabilityFlags,(unsigned long)priv->head_note_state); - k = nextObject->whatObject->powerStateWillChangeTo( priv->head_note_capabilityFlags,priv->head_note_state,this); - } else { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInformDriverPostChange, - (unsigned long)priv->head_note_capabilityFlags,(unsigned long)priv->head_note_state); - k = nextObject->whatObject->powerStateDidChangeTo(priv->head_note_capabilityFlags,priv->head_note_state,this); - } - - // did it ack behind our back? - if ( nextObject->timer == 0 ) - { - // yes - return true; - } - - if ( (k ==IOPMAckImplied) // no, did the return code ack? - || (k < 0) ) // somebody goofed - { - // yes - nextObject->timer = 0; + // Calculate time difference using funky macro from clock.h. + delta = currentTime; + SUB_ABSOLUTETIME(&delta, &lastActivity); - if( acquire_lock() ) - { - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - IOUnlock(priv->our_lock); - } - return true; - } - - // no, it's a timer - nextObject->timer = (k / (ACK_TIMER_PERIOD / ns_per_us)) + 1; + // Figure it in seconds. + absolutetime_to_nanoseconds(delta, &delta_ns); + delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC); - return false; -} + // Be paranoid about delta somehow exceeding timer period. + if (delta_secs < (int) fIdleTimerPeriod) + delay_secs = (int) fIdleTimerPeriod - delta_secs; + else + delay_secs = (int) fIdleTimerPeriod; + return (SInt32)delay_secs; +} //********************************************************************************* -// OurChangeTellClientsPowerDown -// -// All registered applications and kernel clients have positively acknowledged our -// intention of lowering power. Here we notify them all that we will definitely -// lower the power. If we don't have to wait for any of them to acknowledge, we -// carry on by notifying interested drivers. Otherwise, we do wait. +// [public] start_PM_idle_timer //********************************************************************************* -void IOService::OurChangeTellClientsPowerDown ( void ) +void IOService::start_PM_idle_timer( void ) { - // next state - priv->machine_state = kIOPM_OurChangeTellPriorityClientsPowerDown; - - // are we waiting for responses? - if ( tellChangeDown1(priv->head_note_state) ) + static const int maxTimeout = 100000; + static const int minTimeout = 1; + AbsoluteTime uptime, deadline; + SInt32 idle_in = 0; + boolean_t pending; + + if (!initialized || !fIdleTimerPeriod) + return; + + IOLockLock(fActivityLock); + + clock_get_uptime(&uptime); + + // Subclasses may modify idle sleep algorithm + idle_in = nextIdleTimeout(uptime, fDeviceActiveTimestamp, fCurrentPowerState); + + // Check for out-of range responses + if (idle_in > maxTimeout) { - // no, notify priority clients - OurChangeTellPriorityClientsPowerDown(); + // use standard implementation + idle_in = IOService::nextIdleTimeout(uptime, + fDeviceActiveTimestamp, + fCurrentPowerState); + } else if (idle_in < minTimeout) { + idle_in = fIdleTimerPeriod; } - // If we are waiting for responses, execution will resume via - // allowCancelCommon() or ack timeout -} + IOLockUnlock(fActivityLock); + + fNextIdleTimerPeriod = idle_in; + fIdleTimerStartTime = uptime; + + retain(); + clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline); + ADD_ABSOLUTETIME(&deadline, &uptime); + pending = thread_call_enter_delayed(fIdleTimer, deadline); + if (pending) release(); +} //********************************************************************************* -// OurChangeTellPriorityClientsPowerDown -// -// All registered applications and kernel clients have positively acknowledged our -// intention of lowering power. Here we notify "priority" clients that we are -// lowering power. If we don't have to wait for any of them to acknowledge, we -// carry on by notifying interested drivers. Otherwise, we do wait. +// [private] restartIdleTimer //********************************************************************************* -void IOService::OurChangeTellPriorityClientsPowerDown ( void ) +void IOService::restartIdleTimer( void ) { - // next state - priv->machine_state = kIOPM_OurChangeNotifyInterestedDriversWillChange; - // are we waiting for responses? - if ( tellChangeDown2(priv->head_note_state) ) + if (fDeviceDesire != kPowerStateZero) { - // no, notify interested drivers - return OurChangeNotifyInterestedDriversWillChange(); + fIdleTimerStopped = false; + fActivityTickleCount = 0; + start_PM_idle_timer(); + } + else if (fHasAdvisoryDesire) + { + fIdleTimerStopped = false; + start_PM_idle_timer(); + } + else + { + fIdleTimerStopped = true; } - // If we are waiting for responses, execution will resume via - // allowCancelCommon() or ack timeout } - //********************************************************************************* -// OurChangeNotifyInterestedDriversWillChange -// -// All registered applications and kernel clients have acknowledged our notification -// that we are lowering power. Here we notify interested drivers. If we don't have -// to wait for any of them to acknowledge, we instruct our power driver to make the change. -// Otherwise, we do wait. +// idle_timer_expired //********************************************************************************* -void IOService::OurChangeNotifyInterestedDriversWillChange ( void ) +static void +idle_timer_expired( + thread_call_param_t arg0, thread_call_param_t arg1 ) { - // no, in case they don't all ack - priv->machine_state = kIOPM_OurChangeSetPowerState; - if ( notifyAll(true) == IOPMAckImplied ) - { - // not waiting for responses - OurChangeSetPowerState(); - } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout -} + IOService * me = (IOService *) arg0; + if (gIOPMWorkLoop) + gIOPMWorkLoop->runAction( + OSMemberFunctionCast(IOWorkLoop::Action, me, + &IOService::idleTimerExpired), + me); + + me->release(); +} //********************************************************************************* -// OurChangeSetPowerState +// [private] idleTimerExpired // -// All interested drivers have acknowledged our pre-change notification of a power -// change we initiated. Here we instruct our controlling driver to make -// the change to the hardware. If it does so, we continue processing -// (waiting for settle and notifying interested parties post-change.) -// If it doesn't, we have to wait for it to acknowledge and then continue. +// The idle timer has expired. If there has been activity since the last +// expiration, just restart the timer and return. If there has not been +// activity, switch to the next lower power state and restart the timer. //********************************************************************************* -void IOService::OurChangeSetPowerState ( void ) +void IOService::idleTimerExpired( void ) { - priv->machine_state = kIOPM_OurChangeWaitForPowerSettle; + IOPMRequest * request; + bool restartTimer = true; + uint32_t tickleFlags; - IOLockLock(priv->our_lock); + if ( !initialized || !fIdleTimerPeriod || fIdleTimerStopped || + fLockedFlags.PMStop ) + return; + + fIdleTimerStartTime = 0; + + IOLockLock(fActivityLock); + + // Check for device activity (tickles) over last timer period. - if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) + if (fDeviceWasActive) { - // it's done, carry on - IOLockUnlock(priv->our_lock); - OurChangeWaitForPowerSettle(); - } else { - // it's not, wait for it - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); - start_ack_timer(); - IOLockUnlock(priv->our_lock); - // execution will resume via ack_timer_ticked() + // Device was active - do not drop power, restart timer. + fDeviceWasActive = false; } -} + else if (!fIdleTimerIgnored) + { + // No device activity - drop power state by one level. + // Decrement the cached tickle power state when possible. + // This value may be kInvalidTicklePowerState before activityTickle() + // is called, but the power drop request must be issued regardless. + if ((fActivityTicklePowerState != kInvalidTicklePowerState) && + (fActivityTicklePowerState != kPowerStateZero)) + fActivityTicklePowerState--; -//********************************************************************************* -// OurChangeWaitForPowerSettle -// -// Our controlling driver has changed power state on the hardware -// during a power change we initiated. Here we see if we need to wait -// for power to settle before continuing. If not, we continue processing -// (notifying interested parties post-change). If so, we wait and -// continue later. -//********************************************************************************* + 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 ); -void IOService::OurChangeWaitForPowerSettle ( void ) -{ - priv->settle_time = compute_settle_time(); - if ( priv->settle_time == 0 ) + // Do not restart timer until after the tickle request has been + // processed. + + restartTimer = false; + } + } + + if (fAdvisoryTickled) { - OurChangeNotifyInterestedDriversDidChange(); - } else { - priv->machine_state = kIOPM_OurChangeNotifyInterestedDriversDidChange; - startSettleTimer(priv->settle_time); + fAdvisoryTickled = false; } -} + else if (fHasAdvisoryDesire) + { + // Want new tickles to turn into pm request after we drop the lock + fAdvisoryTicklePowerState = kInvalidTicklePowerState; + tickleFlags = kTickleTypeAdvisory | kTickleTypePowerDrop; + request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle ); + if (request) + { + request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration; + request->fArg1 = (void *)(uintptr_t) tickleFlags; + request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration; + submitPMRequest( request ); -//********************************************************************************* -// OurChangeNotifyInterestedDriversDidChange -// -// Power has settled on a power change we initiated. Here we notify -// all our interested parties post-change. If they all acknowledge, we're -// done with this change note, and we can start on the next one. -// Otherwise we have to wait for acknowledgements and finish up later. -//********************************************************************************* + // Do not restart timer until after the tickle request has been + // processed. -void IOService::OurChangeNotifyInterestedDriversDidChange ( void ) -{ - // in case they don't all ack - priv->machine_state = kIOPM_OurChangeFinish; - if ( notifyAll(false) == IOPMAckImplied ) - { - // not waiting for responses - OurChangeFinish(); + restartTimer = false; + } } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout -} + IOLockUnlock(fActivityLock); + if (restartTimer) + start_PM_idle_timer(); +} + +#ifndef __LP64__ //********************************************************************************* -// OurChangeFinish -// -// Power has settled on a power change we initiated, and -// all our interested parties have acknowledged. We're -// done with this change note, and we can start on the next one. +// [deprecated] PM_idle_timer_expiration //********************************************************************************* -void IOService::OurChangeFinish ( void ) +void IOService::PM_idle_timer_expiration( void ) { - all_done(); } - //********************************************************************************* -// ParentDownTellPriorityClientsPowerDown_Immediate -// -// All applications and kernel clients have been notified of a power lowering -// initiated by the parent and we didn't have to wait for any responses. Here -// we notify any priority clients. If they all ack, we continue with the power change. -// If at least one doesn't, we have to wait for it to acknowledge and then continue. +// [deprecated] command_received //********************************************************************************* -IOReturn IOService::ParentDownTellPriorityClientsPowerDown_Immediate ( void ) +void IOService::command_received( void *statePtr , void *, void * , void * ) { - // in case they don't all ack - priv->machine_state = kIOPM_ParentDownNotifyInterestedDriversWillChange_Delayed; - // are we waiting for responses? - if ( tellChangeDown2(priv->head_note_state) ) - { - // no, notify interested drivers - return ParentDownNotifyInterestedDriversWillChange_Immediate(); - } - // If we are waiting for responses, execution will resume via - // allowCancelCommon() or ack timeout - return IOPMWillAckLater; } - +#endif /* !__LP64__ */ //********************************************************************************* -// ParentDownTellPriorityClientsPowerDown_Immediate2 +// [public] setAggressiveness // -// All priority kernel clients have been notified of a power lowering -// initiated by the parent and we didn't have to wait for any responses. Here -// we notify any interested drivers and power domain children. If they all ack, -// we continue with the power change. -// If at least one doesn't, we have to wait for it to acknowledge and then continue. +// Pass on the input parameters to all power domain children. All those which are +// power domains will pass it on to their children, etc. //********************************************************************************* -IOReturn IOService::ParentDownNotifyInterestedDriversWillChange_Immediate ( void ) +IOReturn IOService::setAggressiveness( unsigned long type, unsigned long newLevel ) { - // in case they don't all ack - priv->machine_state = kIOPM_ParentDownSetPowerState_Delayed; - if ( notifyAll(true) == IOPMAckImplied ) - { - // they did - return ParentDownSetPowerState_Immediate(); - } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout - return IOPMWillAckLater; + return kIOReturnSuccess; } - //********************************************************************************* -// ParentDownTellPriorityClientsPowerDown_Immediate4 +// [public] getAggressiveness // -// All applications and kernel clients have been notified of a power lowering -// initiated by the parent and we had to wait for responses. Here -// we notify any priority clients. If they all ack, we continue with the power change. -// If at least one doesn't, we have to wait for it to acknowledge and then continue. +// Called by the user client. //********************************************************************************* -void IOService::ParentDownTellPriorityClientsPowerDown_Delayed ( void ) +IOReturn IOService::getAggressiveness( unsigned long type, unsigned long * currentLevel ) { - // in case they don't all ack - priv->machine_state = kIOPM_ParentDownNotifyInterestedDriversWillChange_Delayed; + IOPMrootDomain * rootDomain = getPMRootDomain(); - // are we waiting for responses? - if ( tellChangeDown2(priv->head_note_state) ) - { - // no, notify interested drivers - ParentDownNotifyInterestedDriversWillChange_Delayed(); - } - // If we are waiting for responses, execution will resume via - // allowCancelCommon() or ack timeout -} + if (!rootDomain) + return kIOReturnNotReady; + return rootDomain->getAggressiveness( type, currentLevel ); +} //********************************************************************************* -// ParentDownTellPriorityClientsPowerDown_Immediate5 +// [public] getPowerState // -// All applications and kernel clients have been notified of a power lowering -// initiated by the parent and we had to wait for their responses. Here we notify -// any interested drivers and power domain children. If they all ack, we continue -// with the power change. -// If at least one doesn't, we have to wait for it to acknowledge and then continue. //********************************************************************************* -void IOService::ParentDownNotifyInterestedDriversWillChange_Delayed ( void ) +UInt32 IOService::getPowerState( void ) { - // in case they don't all ack - priv->machine_state = kIOPM_ParentDownSetPowerState_Delayed; - if ( notifyAll(true) == IOPMAckImplied ) - { - // they did - ParentDownSetPowerState_Delayed(); - } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout -} + if (!initialized) + return kPowerStateZero; + return fCurrentPowerState; +} +#ifndef __LP64__ //********************************************************************************* -// ParentDownSetPowerState_Immediate +// [deprecated] systemWake // -// All parties have acknowledged our pre-change notification of a power -// lowering initiated by the parent. Here we instruct our controlling driver -// to put the hardware in the state it needs to be in when the domain is -// lowered. If it does so, we continue processing -// (waiting for settle and acknowledging the parent.) -// If it doesn't, we have to wait for it to acknowledge and then continue. +// Pass this to all power domain children. All those which are +// power domains will pass it on to their children, etc. //********************************************************************************* -IOReturn IOService::ParentDownSetPowerState_Immediate ( void ) +IOReturn IOService::systemWake( void ) { - priv->machine_state = kIOPM_ParentDownWaitForPowerSettle_Delayed; + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + IOService * theChild; + + iter = getChildIterator(gIOPowerPlane); + if ( iter ) + { + while ( (next = iter->getNextObject()) ) + { + if ( (connection = OSDynamicCast(IOPowerConnection, next)) ) + { + if (connection->getReadyFlag() == false) + { + PM_LOG3("[%s] %s: connection not ready\n", + getName(), __FUNCTION__); + continue; + } - IOLockLock(priv->our_lock); + theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane); + if ( theChild ) + { + theChild->systemWake(); + theChild->release(); + } + } + } + iter->release(); + } - if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) + if ( fControllingDriver != NULL ) { - // it's done, carry on - IOLockUnlock(priv->our_lock); - return ParentDownWaitForPowerSettleAndNotifyDidChange_Immediate(); + if ( fControllingDriver->didYouWakeSystem() ) + { + makeUsable(); + } } - // it's not, wait for it - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); - start_ack_timer(); - IOLockUnlock(priv->our_lock); - return IOPMWillAckLater; -} + return IOPMNoErr; +} //********************************************************************************* -// ParentDownSetPowerState_Delayed -// -// We had to wait for it, but all parties have acknowledged our pre-change -// notification of a power lowering initiated by the parent. -// Here we instruct our controlling driver -// to put the hardware in the state it needs to be in when the domain is -// lowered. If it does so, we continue processing -// (waiting for settle and acknowledging the parent.) -// If it doesn't, we have to wait for it to acknowledge and then continue. +// [deprecated] temperatureCriticalForZone //********************************************************************************* -void IOService::ParentDownSetPowerState_Delayed ( void ) +IOReturn IOService::temperatureCriticalForZone( IOService * whichZone ) { - priv-> machine_state = kIOPM_ParentDownWaitForPowerSettle_Delayed; + IOService * theParent; + IOService * theNub; - IOLockLock(priv->our_lock); + OUR_PMLog(kPMLogCriticalTemp, 0, 0); - if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) + if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT ) { - // it's done, carry on - IOLockUnlock(priv->our_lock); - ParentDownWaitForPowerSettle_Delayed(); - } else { - // it's not, wait for it - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); - start_ack_timer(); - IOLockUnlock(priv->our_lock); + theNub = (IOService *)copyParentEntry(gIOPowerPlane); + if ( theNub ) + { + theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane); + theNub->release(); + if ( theParent ) + { + theParent->temperatureCriticalForZone(whichZone); + theParent->release(); + } + } } + return IOPMNoErr; } +#endif /* !__LP64__ */ +// MARK: - +// MARK: Power Change (Common) //********************************************************************************* -// ParentDownWaitForPowerSettleAndNotifyDidChange_Immediate +// [private] startPowerChange // -// Our controlling driver has changed power state on the hardware -// during a power change initiated by our parent. Here we see if we need -// to wait for power to settle before continuing. If not, we continue -// processing (acknowledging our preparedness to the parent). -// If so, we wait and continue later. +// All power state changes starts here. //********************************************************************************* -IOReturn IOService::ParentDownWaitForPowerSettleAndNotifyDidChange_Immediate ( void ) +IOReturn IOService::startPowerChange( + IOPMPowerChangeFlags changeFlags, + IOPMPowerStateIndex powerState, + IOPMPowerFlags domainFlags, + IOPowerConnection * parentConnection, + IOPMPowerFlags parentFlags ) { - IOService * nub; - - priv->settle_time = compute_settle_time(); - if ( priv->settle_time == 0 ) - { - // store current state in case they don't all ack - priv->machine_state = kIOPM_ParentDownAcknowledgeChange_Delayed; - if ( notifyAll(false) == IOPMAckImplied ) - { - // not waiting for responses - nub = priv->head_note_parent; - nub->retain(); - all_done(); - nub->release(); - return IOPMAckImplied; - } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout - return IOPMWillAckLater; - } else { - // let settle time elapse, then notify interest drivers of our power state change in ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed - priv->machine_state = kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed; - startSettleTimer(priv->settle_time); - return IOPMWillAckLater; - } -} + PM_ASSERT_IN_GATE(); + assert( fMachineState == kIOPM_Finished ); + assert( powerState < fNumberOfPowerStates ); + if (powerState >= fNumberOfPowerStates) + return IOPMAckImplied; -//********************************************************************************* -// ParentDownWaitForPowerSettle_Delayed -// -// Our controlling driver has changed power state on the hardware -// during a power change initiated by our parent. We have had to wait -// for acknowledgement from interested parties, or we have had to wait -// for the controlling driver to change the state. Here we see if we need -// to wait for power to settle before continuing. If not, we continue -// processing (acknowledging our preparedness to the parent). -// If so, we wait and continue later. -//********************************************************************************* + fIsPreChange = true; + PM_ACTION_2(actionPowerChangeOverride, &powerState, &changeFlags); -void IOService::ParentDownWaitForPowerSettle_Delayed ( void ) -{ - priv->settle_time = compute_settle_time(); - if ( priv->settle_time == 0 ) + if (changeFlags & kIOPMExpireIdleTimer) { - ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed(); - } else { - priv->machine_state = kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed; - startSettleTimer(priv->settle_time); - } -} - - -//********************************************************************************* -// ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed -// -// Power has settled on a power change initiated by our parent. Here we -// notify interested parties. -//********************************************************************************* + // 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); -void IOService::ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed ( void ) -{ - IORegistryEntry *nub; - IOService *parent; + // Invalidate tickle cache so the next tickle will issue a request + IOLockLock(fActivityLock); + fDeviceWasActive = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); - // in case they don't all ack - priv->machine_state = kIOPM_ParentDownAcknowledgeChange_Delayed; - if ( notifyAll(false) == IOPMAckImplied ) { - nub = priv->head_note_parent; - nub->retain(); - all_done(); - parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); - if ( parent ) { - parent->acknowledgePowerChange((IOService *)nub); - parent->release(); + fIdleTimerMinPowerState = kPowerStateZero; } - nub->release(); } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout in ParentDownAcknowledgeChange_Delayed. - // Notice the duplication of code just above and in ParentDownAcknowledgeChange_Delayed. -} + // Root domain's override handler may cancel the power change by + // setting the kIOPMNotDone flag. -//********************************************************************************* -// ParentDownAcknowledgeChange_Delayed -// -// We had to wait for it, but all parties have acknowledged our post-change -// notification of a power lowering initiated by the parent. -// Here we acknowledge the parent. -// We are done with this change note, and we can start on the next one. -//********************************************************************************* + if (changeFlags & kIOPMNotDone) + return IOPMAckImplied; -void IOService::ParentDownAcknowledgeChange_Delayed ( void ) -{ - IORegistryEntry *nub; - IOService *parent; - - nub = priv->head_note_parent; - nub->retain(); - all_done(); - parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); - if ( parent ) + // Forks to either Driver or Parent initiated power change paths. + + fHeadNoteChangeFlags = changeFlags; + fHeadNotePowerState = powerState; + fHeadNotePowerArrayEntry = &fPowerStates[ powerState ]; + fHeadNoteParentConnection = NULL; + + if (changeFlags & kIOPMSelfInitiated) { - parent->acknowledgePowerChange((IOService *)nub); - parent->release(); + if (changeFlags & kIOPMSynchronize) + OurSyncStart(); + else + OurChangeStart(); + return 0; + } + else + { + assert(changeFlags & kIOPMParentInitiated); + fHeadNoteDomainFlags = domainFlags; + fHeadNoteParentFlags = parentFlags; + fHeadNoteParentConnection = parentConnection; + return ParentChangeStart(); } - nub->release(); } - //********************************************************************************* -// ParentUpSetPowerState_Delayed -// -// Our parent has informed us via powerStateDidChange that it has -// raised the power in our power domain, and we have had to wait -// for some interested party to acknowledge our notification. -// Here we instruct our controlling -// driver to program the hardware to take advantage of the higher domain -// power. If it does so, we continue processing -// (waiting for settle and notifying interested parties post-change.) -// If it doesn't, we have to wait for it to acknowledge and then continue. +// [private] notifyInterestedDrivers //********************************************************************************* -void IOService::ParentUpSetPowerState_Delayed ( void ) +bool IOService::notifyInterestedDrivers( void ) { - priv->machine_state = kIOPM_ParentUpWaitForSettleTime_Delayed; - - IOLockLock(priv->our_lock); - - if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) - { - // it did it, carry on - IOLockUnlock(priv->our_lock); - ParentUpWaitForSettleTime_Delayed(); - } else { - // it didn't, wait for it - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); - start_ack_timer(); - IOLockUnlock(priv->our_lock); - } -} + IOPMinformee * informee; + IOPMinformeeList * list = fInterestedDrivers; + DriverCallParam * param; + IOItemCount count; + IOItemCount skipCnt = 0; + PM_ASSERT_IN_GATE(); + assert( fDriverCallParamCount == 0 ); + assert( fHeadNotePendingAcks == 0 ); -//********************************************************************************* -// ParentUpSetPowerState_Immediate -// -// Our parent has informed us via powerStateDidChange that it has -// raised the power in our power domain. Here we instruct our controlling -// driver to program the hardware to take advantage of the higher domain -// power. If it does so, we continue processing -// (waiting for settle and notifying interested parties post-change.) -// If it doesn't, we have to wait for it to acknowledge and then continue. -//********************************************************************************* + fHeadNotePendingAcks = 0; -IOReturn IOService::ParentUpSetPowerState_Immediate ( void ) -{ - priv->machine_state = kIOPM_ParentUpWaitForSettleTime_Delayed; + count = list->numberOfItems(); + if (!count) + goto done; // no interested drivers - IOLockLock(priv->our_lock); + // Allocate an array of interested drivers and their return values + // for the callout thread. Everything else is still "owned" by the + // PM work loop, which can run to process acknowledgePowerChange() + // responses. - if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) + param = (DriverCallParam *) fDriverCallParamPtr; + if (count > fDriverCallParamSlots) { - // it did it, carry on - IOLockUnlock(priv->our_lock); - return ParentUpWaitForSettleTime_Immediate(); - } - else { - // it didn't, wait for it - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); - start_ack_timer(); - IOLockUnlock(priv->our_lock); - return IOPMWillAckLater; - } -} + if (fDriverCallParamSlots) + { + assert(fDriverCallParamPtr); + IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots); + fDriverCallParamPtr = 0; + fDriverCallParamSlots = 0; + } + param = IONew(DriverCallParam, count); + if (!param) + goto done; // no memory -//********************************************************************************* -// ParentUpWaitForSettleTime_Immediate -// -// Our controlling driver has changed power state on the hardware -// during a power raise initiated by the parent. Here we see if we need to wait -// for power to settle before continuing. If not, we continue processing -// (notifying interested parties post-change). If so, we wait and -// continue later. -//********************************************************************************* + fDriverCallParamPtr = (void *) param; + fDriverCallParamSlots = count; + } -IOReturn IOService::ParentUpWaitForSettleTime_Immediate ( void ) -{ - priv->settle_time = compute_settle_time(); - if ( priv->settle_time == 0 ) + informee = list->firstInList(); + assert(informee); + for (IOItemCount i = 0; i < count; i++) { - return ParentUpNotifyInterestedDriversDidChange_Immediate(); - } else { - priv->machine_state = kIOPM_ParentUpNotifyInterestedDriversDidChange_Delayed; - startSettleTimer(priv->settle_time); - return IOPMWillAckLater; + if (fInitialSetPowerState || (fHeadNoteChangeFlags & kIOPMInitialPowerChange)) { + // Skip notifying self, if 'kIOPMInitialDeviceState' is set and + // this is the initial power state change + if ((this == informee->whatObject) && + (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState)) { + skipCnt++; + continue; + } + } + informee->timer = -1; + param[i].Target = informee; + informee->retain(); + informee = list->nextInList( informee ); } -} + count -= skipCnt; + if (!count) { + goto done; + } + fDriverCallParamCount = count; + fHeadNotePendingAcks = count; + + // Block state machine and wait for callout completion. + assert(!fDriverCallBusy); + fDriverCallBusy = true; + thread_call_enter( fDriverCallEntry ); + return true; + +done: + // Return false if there are no interested drivers or could not schedule + // callout thread due to error. + return false; +} //********************************************************************************* -// ParentUpWaitForSettleTime_Delayed -// -// Our controlling driver has changed power state on the hardware -// during a power raise initiated by the parent, but we had to wait for it. -// Here we see if we need to wait for power to settle before continuing. -// If not, we continue processing (notifying interested parties post-change). -// If so, we wait and continue later. +// [private] notifyInterestedDriversDone //********************************************************************************* -void IOService::ParentUpWaitForSettleTime_Delayed ( void ) +void IOService::notifyInterestedDriversDone( void ) { - priv->settle_time = compute_settle_time(); - if ( priv->settle_time == 0 ) + IOPMinformee * informee; + IOItemCount count; + DriverCallParam * param; + IOReturn result; + + PM_ASSERT_IN_GATE(); + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); + + param = (DriverCallParam *) fDriverCallParamPtr; + count = fDriverCallParamCount; + + if (param && count) { - ParentUpNotifyInterestedDriversDidChange_Delayed(); - } else { - priv->machine_state = kIOPM_ParentUpNotifyInterestedDriversDidChange_Delayed; - startSettleTimer(priv->settle_time); - } -} + for (IOItemCount i = 0; i < count; i++, param++) + { + informee = (IOPMinformee *) param->Target; + result = param->Result; + if ((result == IOPMAckImplied) || (result < 0)) + { + // Interested driver return IOPMAckImplied. + // If informee timer is zero, it must have de-registered + // interest during the thread callout. That also drops + // the pending ack count. -//********************************************************************************* -// ParentUpNotifyInterestedDriversDidChange_Immediate -// -// No power settling was required on a power raise initiated by the parent. -// Here we notify all our interested parties post-change. If they all acknowledge, -// we're done with this change note, and we can start on the next one. -// Otherwise we have to wait for acknowledgements and finish up later. -//********************************************************************************* + if (fHeadNotePendingAcks && informee->timer) + fHeadNotePendingAcks--; -IOReturn IOService::ParentUpNotifyInterestedDriversDidChange_Immediate ( void ) -{ - IOService * nub; - - // in case they don't all ack - priv->machine_state = kIOPM_ParentUpAcknowledgePowerChange_Delayed; - if ( notifyAll(false) == IOPMAckImplied ) - { - nub = priv->head_note_parent; - nub->retain(); - all_done(); - nub->release(); - return IOPMAckImplied; + informee->timer = 0; + } + else if (informee->timer) + { + assert(informee->timer == -1); + + // Driver has not acked, and has returned a positive result. + // Enforce a minimum permissible timeout value. + // Make the min value large enough so timeout is less likely + // to occur if a driver misinterpreted that the return value + // should be in microsecond units. And make it large enough + // to be noticeable if a driver neglects to ack. + + if (result < kMinAckTimeoutTicks) + result = kMinAckTimeoutTicks; + + informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; + } + // else, child has already acked or driver has removed interest, + // and head_note_pendingAcks decremented. + // informee may have been removed from the interested drivers list, + // thus the informee must be retained across the callout. + + informee->release(); + } + + fDriverCallParamCount = 0; + + if ( fHeadNotePendingAcks ) + { + OUR_PMLog(kPMLogStartAckTimer, 0, 0); + start_ack_timer(); + } } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout in ParentUpAcknowledgePowerChange_Delayed. - return IOPMWillAckLater; -} + MS_POP(); // pop the machine state passed to notifyAll() -//********************************************************************************* -// ParentUpNotifyInterestedDriversDidChange_Delayed -// -// Power has settled on a power raise initiated by the parent. -// Here we notify all our interested parties post-change. If they all acknowledge, -// we're done with this change note, and we can start on the next one. -// Otherwise we have to wait for acknowledgements and finish up later. -//********************************************************************************* + // If interest acks are outstanding, block the state machine until + // fHeadNotePendingAcks drops to zero before notifying root domain. + // Otherwise notify root domain directly. -void IOService::ParentUpNotifyInterestedDriversDidChange_Delayed ( void ) -{ - // in case they don't all ack - priv->machine_state = kIOPM_ParentUpAcknowledgePowerChange_Delayed; - if ( notifyAll(false) == IOPMAckImplied ) + if (!fHeadNotePendingAcks) + { + notifyRootDomain(); + } + else { - ParentUpAcknowledgePowerChange_Delayed(); + MS_PUSH(fMachineState); + fMachineState = kIOPM_NotifyChildrenStart; } - // If we are waiting for responses, execution will resume via - // all_acked() or ack timeout in ParentUpAcknowledgePowerChange_Delayed. } - //********************************************************************************* -// ParentUpAcknowledgePowerChange_Delayed -// -// All parties have acknowledged our post-change notification of a power -// raising initiated by the parent. Here we acknowledge the parent. -// We are done with this change note, and we can start on the next one. +// [private] notifyRootDomain //********************************************************************************* -void IOService::ParentUpAcknowledgePowerChange_Delayed ( void ) +void IOService::notifyRootDomain( void ) { - IORegistryEntry *nub; - IOService *parent; - - nub = priv->head_note_parent; - nub->retain(); - all_done(); - parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); - if ( parent ) + assert( fDriverCallBusy == false ); + + // Only for root domain in the will-change phase + if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState)) { - parent->acknowledgePowerChange((IOService *)nub); - parent->release(); + notifyChildren(); + return; } - nub->release(); + + 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(); +} //********************************************************************************* -// all_done -// -// A power change is complete, and the used post-change note is at -// the head of the queue. Remove it and set myCurrentState to the result -// of the change. Start up the next change in queue. +// [private] notifyChildren //********************************************************************************* -void IOService::all_done ( void ) +void IOService::notifyChildren( void ) { - unsigned long previous_state; - IORegistryEntry *nub; - IOService *parent; - - priv->machine_state = kIOPM_Finished; + OSIterator * iter; + OSObject * next; + IOPowerConnection * connection; + OSArray * children = 0; + IOPMrootDomain * rootDomain; + bool delayNotify = false; - // our power change - if ( priv->head_note_flags & IOPMWeInitiated ) + if ((fHeadNotePowerState != fCurrentPowerState) && + (IS_POWER_DROP == fIsPreChange) && + ((rootDomain = getPMRootDomain()) == this)) + { + rootDomain->tracePoint( IS_POWER_DROP ? + kIOPMTracePointSleepPowerPlaneDrivers : + kIOPMTracePointWakePowerPlaneDrivers ); + } + + if (fStrictTreeOrder) + children = OSArray::withCapacity(8); + + // Sum child power consumption in notifyChild() + fHeadNotePowerArrayEntry->staticPower = 0; + + iter = getChildIterator(gIOPowerPlane); + if ( iter ) { - // could our driver switch to the new state? - if ( !( priv->head_note_flags & IOPMNotDone) ) + while ((next = iter->getNextObject())) { - // yes, did power raise? - if ( pm_vars->myCurrentState < priv->head_note_state ) + if ((connection = OSDynamicCast(IOPowerConnection, next))) { - // yes, inform clients and apps - tellChangeUp (priv->head_note_state); - } else { - // no, if this lowers our - if ( ! priv->we_are_root ) + if (connection->getReadyFlag() == false) { - // power requirements, tell the parent - ask_parent(priv->head_note_state); + PM_LOG3("[%s] %s: connection not ready\n", + getName(), __FUNCTION__); + continue; } + + // Mechanism to postpone the did-change notification to + // certain power children to order those children last. + // Cannot be used together with strict tree ordering. + + if (!fIsPreChange && + connection->delayChildNotification && + getPMRootDomain()->shouldDelayChildNotification(this)) + { + if (!children) + { + children = OSArray::withCapacity(8); + if (children) + delayNotify = true; + } + if (delayNotify) + { + children->setObject( connection ); + continue; + } + } + + if (!delayNotify && children) + children->setObject( connection ); + else + notifyChild( connection ); } - previous_state = pm_vars->myCurrentState; - // either way - pm_vars->myCurrentState = priv->head_note_state; - priv->imminentState = pm_vars->myCurrentState; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeDone,(unsigned long)pm_vars->myCurrentState,0); - // inform subclass policy-maker - powerChangeDone(previous_state); } + iter->release(); } - // parent's power change - if ( priv->head_note_flags & IOPMParentInitiated) + if (children && (children->getCount() == 0)) { - if ( ((priv->head_note_flags & IOPMDomainWillChange) && (pm_vars->myCurrentState >= priv->head_note_state)) || - ((priv->head_note_flags & IOPMDomainDidChange) && (pm_vars->myCurrentState < priv->head_note_state)) ) + children->release(); + children = 0; + } + if (children) + { + assert(fNotifyChildArray == 0); + fNotifyChildArray = children; + MS_PUSH(fMachineState); + + if (delayNotify) { - // did power raise? - if ( pm_vars->myCurrentState < priv->head_note_state ) - { - // yes, inform clients and apps - tellChangeUp (priv->head_note_state); - } - // either way - previous_state = pm_vars->myCurrentState; - pm_vars->myCurrentState = priv->head_note_state; - priv->imminentState = pm_vars->myCurrentState; - pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(priv->head_note_domainState); + // 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. - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeDone,(unsigned long)pm_vars->myCurrentState,0); - // inform subclass policy-maker - powerChangeDone(previous_state); + fMachineState = kIOPM_NotifyChildrenOrdered; } } +} - IOLockLock(priv->queue_lock); - // we're done with this - priv->changeList->releaseHeadChangeNote(); - - // start next one in queue - priv->head_note = priv->changeList->currentChange(); - if ( priv->head_note != -1 ) +//********************************************************************************* +// [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; - IOLockUnlock(priv->queue_lock); - if (priv->changeList->changeNote[priv->head_note].flags & IOPMWeInitiated ) - { - start_our_change(priv->head_note); - } else { - nub = priv->changeList->changeNote[priv->head_note].parent; - if (nub) nub->retain(); // might be released by start_parent_change() - if ( start_parent_change(priv->head_note) == IOPMAckImplied ) - { - parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); - if ( parent ) - { - parent->acknowledgePowerChange((IOService *)nub); - parent->release(); - } - } - if (nub) nub->release(); - } - } else { - IOLockUnlock(priv->queue_lock); + MS_POP(); // pushed by notifyChildren() } } +//********************************************************************************* +// [private] notifyChildrenDelayed +//********************************************************************************* + +void IOService::notifyChildrenDelayed( void ) +{ + IOPowerConnection * connection; + + PM_ASSERT_IN_GATE(); + assert(fNotifyChildArray); + assert(fMachineState == kIOPM_NotifyChildrenDelayed); + + // Wait after all non-delayed children and interested drivers have ack'ed, + // then notify all delayed children. If notify delay is canceled, child + // acks may be outstanding with PM blocked on fHeadNotePendingAcks != 0. + // But the handling for either case is identical. + for (int i = 0; ; i++) + { + connection = (IOPowerConnection *) fNotifyChildArray->getObject(i); + if (!connection) + break; + + notifyChild( connection ); + } + + PM_LOG2("%s: notified delayed children\n", getName()); + fNotifyChildArray->release(); + fNotifyChildArray = 0; + + MS_POP(); // pushed by notifyChildren() +} //********************************************************************************* -// all_acked -// -// A driver or child has acknowledged our notification of an upcoming power -// change, and this acknowledgement is the last one pending -// before we change power or after changing power. -// +// [private] notifyAll //********************************************************************************* +IOReturn IOService::notifyAll( uint32_t nextMS ) +{ + // Save the machine state to be restored by notifyInterestedDriversDone() + + PM_ASSERT_IN_GATE(); + MS_PUSH(nextMS); + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = fIsPreChange ? + kDriverCallInformPreChange : kDriverCallInformPostChange; + if (!notifyInterestedDrivers()) + notifyInterestedDriversDone(); -void IOService::all_acked( void ) -{ - switch (priv->machine_state) { - case kIOPM_OurChangeSetPowerState: - OurChangeSetPowerState(); - break; - case kIOPM_OurChangeFinish: - OurChangeFinish(); - break; - case kIOPM_ParentDownSetPowerState_Delayed: - ParentDownSetPowerState_Delayed(); - break; - case kIOPM_ParentDownAcknowledgeChange_Delayed: - ParentDownAcknowledgeChange_Delayed(); - break; - case kIOPM_ParentUpSetPowerState_Delayed: - ParentUpSetPowerState_Delayed(); - break; - case kIOPM_ParentUpAcknowledgePowerChange_Delayed: - ParentUpAcknowledgePowerChange_Delayed(); - break; - } + return IOPMWillAckLater; } //********************************************************************************* -// settleTimerExpired +// [private, static] pmDriverCallout // -// Power has settled after our last change. Notify interested parties that -// there is a new power state. +// Thread call context //********************************************************************************* -void IOService::settleTimerExpired ( void ) +IOReturn IOService::actionDriverCalloutDone( + OSObject * target, + void * arg0, void * arg1, + void * arg2, void * arg3 ) { - if ( ! initialized ) - { - // we're unloading - return; - } + IOServicePM * pwrMgt = (IOServicePM *) arg0; + + assert( fDriverCallBusy ); + fDriverCallBusy = false; + + assert(gIOPMWorkQueue); + gIOPMWorkQueue->signalWorkAvailable(); + + return kIOReturnSuccess; +} - switch (priv->machine_state) { - case kIOPM_OurChangeNotifyInterestedDriversDidChange: - OurChangeNotifyInterestedDriversDidChange(); +void IOService::pmDriverCallout( IOService * from ) +{ + assert(from); + switch (from->fDriverCallReason) + { + case kDriverCallSetPowerState: + from->driverSetPowerState(); break; - case kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed: - ParentDownNotifyDidChangeAndAcknowledgeChange_Delayed(); + + case kDriverCallInformPreChange: + case kDriverCallInformPostChange: + from->driverInformPowerChange(); break; - case kIOPM_ParentUpNotifyInterestedDriversDidChange_Delayed: - ParentUpNotifyInterestedDriversDidChange_Delayed(); + + case kRootDomainInformPreChange: + getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState); break; + + default: + panic("IOService::pmDriverCallout bad machine state %x", + from->fDriverCallReason); } -} + gIOPMWorkLoop->runAction(actionDriverCalloutDone, + /* target */ from, + /* arg0 */ (void *) from->pwrMgt ); +} //********************************************************************************* -// compute_settle_time +// [private] driverSetPowerState // -// Compute the power-settling delay in microseconds for the -// change from myCurrentState to head_note_state. +// Thread call context //********************************************************************************* -unsigned long IOService::compute_settle_time ( void ) +void IOService::driverSetPowerState( void ) { - unsigned long totalTime; - unsigned long i; - - // compute total time to attain the new state - totalTime = 0; - i = pm_vars->myCurrentState; - - // we're lowering power - if ( priv->head_note_state < pm_vars->myCurrentState ) - { - while ( i > priv->head_note_state ) + IOPMPowerStateIndex powerState; + DriverCallParam * param; + IOPMDriverCallEntry callEntry; + AbsoluteTime end; + IOReturn result; + uint32_t oldPowerState = getPowerState(); + + assert( fDriverCallBusy ); + assert( fDriverCallParamPtr ); + assert( fDriverCallParamCount == 1 ); + + param = (DriverCallParam *) fDriverCallParamPtr; + powerState = fHeadNotePowerState; + + if (assertPMDriverCall(&callEntry)) + { + OUR_PMLogFuncStart(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_PMLogFuncEnd(kPMLogProgramHardware, (uintptr_t) this, (UInt32) result); + + deassertPMDriverCall(&callEntry); + + // Record the most recent max power state residency timings. + // Use with DeviceActiveTimestamp to diagnose tickle issues. + if (powerState == fHighestPowerState) + fMaxPowerStateEntryTime = end; + else if (oldPowerState == fHighestPowerState) + fMaxPowerStateExitTime = end; + + if (result < 0) { - totalTime += pm_vars->thePowerStates[i].settleDownTime; - i--; + PM_LOG("%s::setPowerState(%p, %lu -> %lu) returned 0x%x\n", + fName, OBFUSCATE(this), fCurrentPowerState, powerState, result); } - } - // we're raising power - if ( priv->head_note_state > pm_vars->myCurrentState ) - { - while ( i < priv->head_note_state ) + + if ((result == IOPMAckImplied) || (result < 0)) { - totalTime += pm_vars->thePowerStates[i+1].settleUpTime; - i++; + uint64_t nsec; + + SUB_ABSOLUTETIME(&end, &fDriverCallStartTime); + absolutetime_to_nanoseconds(end, &nsec); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, + fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(), + NULL, powerState); + } } + } + else + result = kIOPMAckImplied; - return totalTime; + param->Result = result; } - //********************************************************************************* -// startSettleTimer +// [private] driverInformPowerChange // -// Enter with a power-settling delay in microseconds and start a nano-second -// timer for that delay. +// Thread call context //********************************************************************************* -IOReturn IOService::startSettleTimer ( unsigned long delay ) +void IOService::driverInformPowerChange( void ) { - AbsoluteTime deadline; - - clock_interval_to_deadline(delay, kMicrosecondScale, &deadline); + IOPMinformee * informee; + IOService * driver; + DriverCallParam * param; + IOPMDriverCallEntry callEntry; + IOPMPowerFlags powerFlags; + IOPMPowerStateIndex powerState; + AbsoluteTime end; + IOReturn result; + IOItemCount count; - thread_call_enter_delayed(priv->settleTimer, deadline); + assert( fDriverCallBusy ); + assert( fDriverCallParamPtr ); + assert( fDriverCallParamCount ); - return IOPMNoErr; + param = (DriverCallParam *) fDriverCallParamPtr; + count = fDriverCallParamCount; + + powerFlags = fHeadNotePowerArrayEntry->capabilityFlags; + powerState = fHeadNotePowerState; + + for (IOItemCount i = 0; i < count; i++) + { + informee = (IOPMinformee *) param->Target; + driver = informee->whatObject; + + if (assertPMDriverCall(&callEntry, 0, informee)) + { + if (fDriverCallReason == kDriverCallInformPreChange) + { + OUR_PMLogFuncStart(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_PMLogFuncEnd(kPMLogInformDriverPreChange, (uintptr_t) this, result); + } + else + { + OUR_PMLogFuncStart(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_PMLogFuncEnd(kPMLogInformDriverPostChange, (uintptr_t) this, result); + } + + deassertPMDriverCall(&callEntry); + + + if ((result == IOPMAckImplied) || (result < 0)) + { + uint64_t nsec; + + SUB_ABSOLUTETIME(&end, &informee->startTime); + absolutetime_to_nanoseconds(end, &nsec); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, driver->getName(), + fDriverCallReason, NS_TO_MS(nsec), driver->getRegistryEntryID(), + NULL, powerState); + } + } + + } + else + result = kIOPMAckImplied; + + param->Result = result; + param++; + } } //********************************************************************************* -// ack_timer_ticked +// [private] notifyChild // -// The acknowledgement timeout periodic timer has ticked. -// If we are awaiting acks for a power change notification, -// we decrement the timer word of each interested driver which hasn't acked. -// If a timer word becomes zero, we pretend the driver aknowledged. -// If we are waiting for the controlling driver to change the power -// state of the hardware, we decrement its timer word, and if it becomes -// zero, we pretend the driver acknowledged. +// Notify a power domain child of an upcoming power change. +// If the object acknowledges the current change, we return TRUE. //********************************************************************************* -void IOService::ack_timer_ticked ( void ) +bool IOService::notifyChild( IOPowerConnection * theNub ) { - IOPMinformee * nextObject; - - if ( ! initialized ) + IOReturn ret = IOPMAckImplied; + unsigned long childPower; + IOService * theChild; + IOPMRequest * childRequest; + IOPMPowerChangeFlags requestArg2; + int requestType; + + PM_ASSERT_IN_GATE(); + theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane)); + if (!theChild) { - // we're unloading - return; + return true; } - if (! acquire_lock() ) - { - return; - } - - switch (priv->machine_state) { - case kIOPM_OurChangeWaitForPowerSettle: - case kIOPM_ParentDownWaitForPowerSettle_Delayed: - case kIOPM_ParentUpWaitForSettleTime_Delayed: - // are we waiting for our driver to make its change? - if ( priv->driver_timer != 0 ) { - // yes, tick once - priv->driver_timer -= 1; - // it's tardy, we'll go on without it - if ( priv->driver_timer == 0 ) - { - IOUnlock(priv->our_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCtrlDriverTardy,0,0); - driver_acked(); - } else { - // still waiting, set timer again - start_ack_timer(); - IOUnlock(priv->our_lock); - } - } - else { - IOUnlock(priv->our_lock); - } - break; + // Unless the child handles the notification immediately and returns + // kIOPMAckImplied, we'll be awaiting their acknowledgement later. + fHeadNotePendingAcks++; + theNub->setAwaitingAck(true); - case kIOPM_OurChangeSetPowerState: - case kIOPM_OurChangeFinish: - case kIOPM_ParentDownSetPowerState_Delayed: - case kIOPM_ParentDownAcknowledgeChange_Delayed: - case kIOPM_ParentUpSetPowerState_Delayed: - case kIOPM_ParentUpAcknowledgePowerChange_Delayed: - // are we waiting for interested parties to acknowledge? - if (priv->head_note_pendingAcks != 0 ) - { - // yes, go through the list of interested drivers - nextObject = priv->interestedDrivers->firstInList(); - // and check each one - while ( nextObject != NULL ) - { - if ( nextObject->timer > 0 ) - { - nextObject->timer -= 1; - // this one should have acked by now - if ( nextObject->timer == 0 ) - { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogIntDriverTardy,0,0); - //kprintf("interested driver tardy: %s\n",nextObject->whatObject->getName()); - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - } - } - nextObject = priv->interestedDrivers->nextInList(nextObject); - } + requestArg2 = fHeadNoteChangeFlags; + if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) + requestArg2 |= kIOPMDomainPowerDrop; - // is that the last? - if ( priv->head_note_pendingAcks == 0 ) - { - IOUnlock(priv->our_lock); - // yes, we can continue - all_acked(); - } else { - // no, set timer again - start_ack_timer(); - IOUnlock(priv->our_lock); - } - } else { - IOUnlock(priv->our_lock); - } - break; + requestType = fIsPreChange ? + kIOPMRequestTypePowerDomainWillChange : + kIOPMRequestTypePowerDomainDidChange; - // apps didn't respond to parent-down notification - case kIOPM_ParentDownTellPriorityClientsPowerDown_Immediate: - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - if (pm_vars->responseFlags) - { - // get rid of this stuff - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - } - IOLockUnlock(priv->flags_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,5); - // carry on with the change - ParentDownTellPriorityClientsPowerDown_Delayed(); - break; - - case kIOPM_ParentDownNotifyInterestedDriversWillChange_Delayed: - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - if (pm_vars->responseFlags) - { - // get rid of this stuff - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - } - IOLockUnlock(priv->flags_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,1); - // carry on with the change - ParentDownNotifyInterestedDriversWillChange_Delayed(); - break; - - case kIOPM_OurChangeTellClientsPowerDown: - // apps didn't respond to our power-down request - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - if (pm_vars->responseFlags) - { - // get rid of this stuff - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - } - IOLockUnlock(priv->flags_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,2); - // rescind the request - tellNoChangeDown(priv->head_note_state); - // mark the change note un-actioned - priv->head_note_flags |= IOPMNotDone; - // and we're done - all_done(); - break; - - case kIOPM_OurChangeTellPriorityClientsPowerDown: - // clients didn't respond to our power-down note - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - if (pm_vars->responseFlags) - { - // get rid of this stuff - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - } - IOLockUnlock(priv->flags_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,4); - // carry on with the change - OurChangeTellPriorityClientsPowerDown(); - break; - - case kIOPM_OurChangeNotifyInterestedDriversWillChange: - // apps didn't respond to our power-down notification - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - if (pm_vars->responseFlags) - { - // get rid of this stuff - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - } - IOLockUnlock(priv->flags_lock); - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,3); - // carry on with the change - OurChangeNotifyInterestedDriversWillChange(); - break; - - default: - // not waiting for acks - IOUnlock(priv->our_lock); - break; + childRequest = acquirePMRequest( theChild, requestType ); + if (childRequest) + { + theNub->retain(); + childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags; + childRequest->fArg1 = (void *) theNub; + childRequest->fArg2 = (void *)(uintptr_t) requestArg2; + theChild->submitPMRequest( childRequest ); + ret = IOPMWillAckLater; + } + else + { + ret = IOPMAckImplied; + fHeadNotePendingAcks--; + theNub->setAwaitingAck(false); + childPower = theChild->currentPowerConsumption(); + if ( childPower == kIOPMUnknown ) + { + fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown; + } else { + if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown ) + fHeadNotePowerArrayEntry->staticPower += childPower; + } } -} + theChild->release(); + return (IOPMAckImplied == ret); +} //********************************************************************************* -// start_ack_timer -// +// [private] notifyControllingDriver //********************************************************************************* -void IOService::start_ack_timer ( void ) +bool IOService::notifyControllingDriver( void ) { - AbsoluteTime deadline; - - clock_interval_to_deadline(ACK_TIMER_PERIOD, kNanosecondScale, &deadline); - - thread_call_enter_delayed(priv->ackTimer, deadline); -} + DriverCallParam * param; + PM_ASSERT_IN_GATE(); + assert( fDriverCallParamCount == 0 ); + assert( fControllingDriver ); -//********************************************************************************* -// stop_ack_timer -// -//********************************************************************************* + if (fInitialSetPowerState) + { + fInitialSetPowerState = false; + fHeadNoteChangeFlags |= kIOPMInitialPowerChange; -void IOService::stop_ack_timer ( void ) -{ - thread_call_cancel(priv->ackTimer); -} + // Driver specified flag to skip the inital setPowerState() + if (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState) + { + return false; + } + } + param = (DriverCallParam *) fDriverCallParamPtr; + if (!param) + { + param = IONew(DriverCallParam, 1); + if (!param) + return false; // no memory -//********************************************************************************* -// c-language timer expiration functions -// -//********************************************************************************* + fDriverCallParamPtr = (void *) param; + fDriverCallParamSlots = 1; + } -static void ack_timer_expired ( thread_call_param_t us) -{ - ((IOService *)us)->ack_timer_ticked(); -} + param->Target = fControllingDriver; + fDriverCallParamCount = 1; + fDriverTimer = -1; + // Block state machine and wait for callout completion. + assert(!fDriverCallBusy); + fDriverCallBusy = true; + thread_call_enter( fDriverCallEntry ); -static void settle_timer_expired ( thread_call_param_t us) -{ - ((IOService *)us)->settleTimerExpired(); + return true; } - //********************************************************************************* -// add_child_to_active_change -// -// A child has just registered with us. If there is -// currently a change in progress, get the new party involved: if we -// have notified all parties and are waiting for acks, notify the new -// party. +// [private] notifyControllingDriverDone //********************************************************************************* -IOReturn IOService::add_child_to_active_change ( IOPowerConnection * newObject ) +void IOService::notifyControllingDriverDone( void ) { - if (! acquire_lock() ) - { - return IOPMNoErr; - } + DriverCallParam * param; + IOReturn result; + + PM_ASSERT_IN_GATE(); + param = (DriverCallParam *) fDriverCallParamPtr; + + assert( fDriverCallBusy == false ); + assert( fMachineState == kIOPM_DriverThreadCallDone ); - switch (priv->machine_state) + if (param && fDriverCallParamCount) { - case kIOPM_OurChangeSetPowerState: - case kIOPM_ParentDownSetPowerState_Delayed: - case kIOPM_ParentUpSetPowerState_Delayed: - // one for this child and one to prevent - OSAddAtomic(2, (SInt32*)&priv->head_note_pendingAcks); - // incoming acks from changing our state - IOUnlock(priv->our_lock); - notifyChild(newObject, true); - if (! acquire_lock() ) - { - // put it back - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - return IOPMNoErr; - } - // are we still waiting for acks? - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - if ( priv->head_note_pendingAcks == 0 ) - { - // no, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); - - // and now we can continue - all_acked(); - return IOPMNoErr; - } - break; - case kIOPM_OurChangeFinish: - case kIOPM_ParentDownAcknowledgeChange_Delayed: - case kIOPM_ParentUpAcknowledgePowerChange_Delayed: - // one for this child and one to prevent - OSAddAtomic(2, (SInt32*)&priv->head_note_pendingAcks); - // incoming acks from changing our state - IOUnlock(priv->our_lock); - notifyChild(newObject, false); - if (! acquire_lock() ) - { - // put it back - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - return IOPMNoErr; - } - // are we still waiting for acks? - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - if ( priv->head_note_pendingAcks == 0 ) - { - // no, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); + assert(fDriverCallParamCount == 1); - // and now we can continue - all_acked(); - return IOPMNoErr; - } - break; - } - IOUnlock(priv->our_lock); - return IOPMNoErr; -} + // the return value from setPowerState() + result = param->Result; + if ((result == IOPMAckImplied) || (result < 0)) + { + fDriverTimer = 0; + } + else if (fDriverTimer) + { + assert(fDriverTimer == -1); -//********************************************************************************* -// add_driver_to_active_change -// -// An interested driver has just registered with us. If there is -// currently a change in progress, get the new party involved: if we -// have notified all parties and are waiting for acks, notify the new -// party. -//********************************************************************************* + // Driver has not acked, and has returned a positive result. + // Enforce a minimum permissible timeout value. + // Make the min value large enough so timeout is less likely + // to occur if a driver misinterpreted that the return value + // should be in microsecond units. And make it large enough + // to be noticeable if a driver neglects to ack. -IOReturn IOService::add_driver_to_active_change ( IOPMinformee * newObject ) -{ - if (! acquire_lock() ) - { - return IOPMNoErr; - } + if (result < kMinAckTimeoutTicks) + result = kMinAckTimeoutTicks; - switch (priv->machine_state) { - case kIOPM_OurChangeSetPowerState: - case kIOPM_ParentDownSetPowerState_Delayed: - case kIOPM_ParentUpSetPowerState_Delayed: - // one for this driver and one to prevent - OSAddAtomic(2, (SInt32*)&priv->head_note_pendingAcks); - // incoming acks from changing our state - IOUnlock(priv->our_lock); - // inform the driver - inform(newObject, true); - if (! acquire_lock() ) - { - // put it back - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - return IOPMNoErr; - } - // are we still waiting for acks? - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - if ( priv->head_note_pendingAcks == 0 ) - { - // no, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); + fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1; + } + // else, child has already acked and driver_timer reset to 0. - // and now we can continue - all_acked(); - return IOPMNoErr; - } - break; - case kIOPM_OurChangeFinish: - case kIOPM_ParentDownAcknowledgeChange_Delayed: - case kIOPM_ParentUpAcknowledgePowerChange_Delayed: - // one for this driver and one to prevent - OSAddAtomic(2, (SInt32*)&priv->head_note_pendingAcks); - // incoming acks from changing our state - IOUnlock(priv->our_lock); - // inform the driver - inform(newObject, false); - if (! acquire_lock() ) { - // put it back - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - return IOPMNoErr; - } - // are we still waiting for acks? - OSAddAtomic(-1, (SInt32*)&priv->head_note_pendingAcks); - if ( priv->head_note_pendingAcks == 0 ) { - // no, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); + fDriverCallParamCount = 0; - // and now we can continue - all_acked(); - return IOPMNoErr; - } - break; + if ( fDriverTimer ) + { + OUR_PMLog(kPMLogStartAckTimer, 0, 0); + start_ack_timer(); + } } - IOUnlock(priv->our_lock); - return IOPMNoErr; -} + MS_POP(); // pushed by OurChangeSetPowerState() + fIsPreChange = false; +} //********************************************************************************* -// start_parent_change -// -// Here we begin the processing of a change note initiated by our parent -// which is at the head of the queue. +// [private] all_done // -// It is possible for the change to be processed to completion and removed from the queue. -// There are several possible interruptions to the processing, though, and they are: -// we may have to wait for interested parties to acknowledge our pre-change notification, -// we may have to wait for our controlling driver to change the hardware power state, -// there may be a settling time after changing the hardware power state, -// we may have to wait for interested parties to acknowledge our post-change notification, -// we may have to wait for the acknowledgement timer expiration to substitute for the -// acknowledgement from a failing driver. +// A power change is done. //********************************************************************************* -IOReturn IOService::start_parent_change ( unsigned long queue_head ) +void IOService::all_done( void ) { - priv->head_note = queue_head; - priv->head_note_flags = priv-> changeList->changeNote[priv->head_note].flags; - priv->head_note_state = priv->changeList->changeNote[priv->head_note].newStateNumber; - priv->imminentState = priv->head_note_state; - priv->head_note_outputFlags = priv->changeList->changeNote[priv->head_note].outputPowerCharacter; - priv->head_note_domainState = priv->changeList->changeNote[priv->head_note].domainState; - priv->head_note_parent = priv->changeList->changeNote[priv->head_note].parent; - priv->head_note_capabilityFlags = priv->changeList->changeNote[priv->head_note].capabilityFlags; + IOPMPowerStateIndex prevPowerState; + const IOPMPSEntry * powerStatePtr; + IOPMDriverCallEntry callEntry; + uint32_t prevMachineState = fMachineState; + bool actionCalled = false; + uint64_t ts; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartParentChange, - (unsigned long)priv->head_note_state,(unsigned long)pm_vars->myCurrentState); + fMachineState = kIOPM_Finished; - // if we need something and haven't told the parent, do so - ask_parent( priv->ourDesiredPowerState); - - // power domain is lowering - if ( priv->head_note_state < pm_vars->myCurrentState ) + if ((fHeadNoteChangeFlags & kIOPMSynchronize) && + ((prevMachineState == kIOPM_Finished) || + (prevMachineState == kIOPM_SyncFinish))) { - setParentInfo(priv->changeList->changeNote[priv->head_note].singleParentState,priv->head_note_parent); - priv->initial_change = false; - // tell apps and kernel clients - priv->machine_state = kIOPM_ParentDownTellPriorityClientsPowerDown_Immediate; + // Sync operation and no power change occurred. + // Do not inform driver and clients about this request completion, + // except for the originator (root domain). + + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); - // are we waiting for responses? - if ( tellChangeDown1(priv->head_note_state) ) + if (getPMRequestType() == kIOPMRequestTypeSynchronizePowerTree) { - // no, notify priority clients - return ParentDownTellPriorityClientsPowerDown_Immediate(); + powerChangeDone(fCurrentPowerState); } - // yes - return IOPMWillAckLater; - } - - // parent is raising power, we may or may not - if ( priv->head_note_state > pm_vars->myCurrentState ) - { - if ( priv->ourDesiredPowerState > pm_vars->myCurrentState ) + else if (fAdvisoryTickleUsed) { - if ( priv->ourDesiredPowerState < priv->head_note_state ) + // 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)) { - // we do, but not all the way - priv->head_note_state = priv->ourDesiredPowerState; - priv->imminentState = priv->head_note_state; - priv->head_note_outputFlags = pm_vars->thePowerStates[priv->head_note_state].outputPowerCharacter; - priv->head_note_capabilityFlags = pm_vars->thePowerStates[priv->head_note_state].capabilityFlags; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAmendParentChange,(unsigned long)priv->head_note_state,0); - } - } else { - // we don't - priv->head_note_state = pm_vars->myCurrentState; - priv->imminentState = priv->head_note_state; - priv->head_note_outputFlags = pm_vars->thePowerStates[priv->head_note_state].outputPowerCharacter; - priv->head_note_capabilityFlags = pm_vars->thePowerStates[priv->head_note_state].capabilityFlags; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAmendParentChange,(unsigned long)priv->head_note_state,0); + IOPMRequest * request; + request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState ); + if (request) + { + submitPMRequest( request ); + fAdjustPowerScheduled = true; + } + } } - } - if ( (priv->head_note_state > pm_vars->myCurrentState) && - (priv->head_note_flags & IOPMDomainDidChange) ) - { - // changing up - priv->initial_change = false; - priv->machine_state = kIOPM_ParentUpSetPowerState_Delayed; - if ( notifyAll(true) == IOPMAckImplied ) { - return ParentUpSetPowerState_Immediate(); - } - // they didn't all ack - return IOPMWillAckLater; + return; } - all_done(); - // a null change or power will go up - return IOPMAckImplied; -} + // our power change + if (fHeadNoteChangeFlags & kIOPMSelfInitiated) + { + // power state changed + if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) + { + trackSystemSleepPreventers( + fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); + // we changed, tell our parent + requestDomainPower(fHeadNotePowerState); -//********************************************************************************* -// start_our_change -// -// Here we begin the processing of a change note initiated by us -// which is at the head of the queue. -// -// It is possible for the change to be processed to completion and removed from the queue. -// There are several possible interruptions to the processing, though, and they are: -// we may have to wait for interested parties to acknowledge our pre-change notification, -// changes initiated by the parent will wait in the middle for powerStateDidChange, -// we may have to wait for our controlling driver to change the hardware power state, -// there may be a settling time after changing the hardware power state, -// we may have to wait for interested parties to acknowledge our post-change notification, -// we may have to wait for the acknowledgement timer expiration to substitute for the -// acknowledgement from a failing driver. -//********************************************************************************* + // yes, did power raise? + if ( StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState) ) + { + // yes, inform clients and apps + tellChangeUp (fHeadNotePowerState); + } + prevPowerState = fCurrentPowerState; + // either way + fCurrentPowerState = fHeadNotePowerState; + PM_LOCK(); + if (fReportBuf) { + ts = mach_absolute_time(); + STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); + } + PM_UNLOCK(); +#if PM_VARS_SUPPORT + fPMVars->myCurrentState = fCurrentPowerState; +#endif + OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); + actionCalled = true; -void IOService::start_our_change ( unsigned long queue_head ) -{ - priv->head_note = queue_head; - priv->head_note_flags = priv->changeList->changeNote[priv->head_note].flags; - priv->head_note_state = priv->changeList->changeNote[priv->head_note].newStateNumber; - priv->imminentState = priv->head_note_state; - priv->head_note_outputFlags = priv->changeList->changeNote[priv->head_note].outputPowerCharacter; - priv->head_note_capabilityFlags = priv->changeList->changeNote[priv->head_note].capabilityFlags; + powerStatePtr = &fPowerStates[fCurrentPowerState]; + fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; + if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) + fCurrentPowerConsumption = powerStatePtr->staticPower; - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartDeviceChange, - (unsigned long)priv->head_note_state,(unsigned long)pm_vars->myCurrentState); + if (fHeadNoteChangeFlags & kIOPMRootChangeDown) + { + // Bump tickle generation count once the entire tree is down + gIOPMTickleGeneration++; + } - // can our driver switch to the new state? - if ( priv->head_note_capabilityFlags & IOPMNotAttainable ) - { - // no, ask the parent to do it then - if ( ! priv->we_are_root ) - { - ask_parent(priv->head_note_state); + // inform subclass policy-maker + if (fPCDFunctionOverride && fParentsKnowState && + assertPMDriverCall(&callEntry, kIOPMADC_NoInactiveCheck)) + { + powerChangeDone(prevPowerState); + deassertPMDriverCall(&callEntry); + } } - // mark the change note un-actioned - priv-> head_note_flags |= IOPMNotDone; - // and we're done - all_done(); - return; - } - - // is there enough power in the domain? - if ( (pm_vars->maxCapability < priv->head_note_state) && (! priv->we_are_root) ) - { - // no, ask the parent to raise it - if ( ! priv->we_are_root ) + else if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) { - ask_parent(priv->head_note_state); + // changePowerStateWithOverrideTo() was cancelled + fOverrideMaxPowerState = kIOPMPowerStateMax; } - // no, mark the change note un-actioned - priv->head_note_flags |= IOPMNotDone; - // and we're done - // till the parent raises power - all_done(); - return; } - if ( ! priv->initial_change ) + // parent-initiated power change + if (fHeadNoteChangeFlags & kIOPMParentInitiated) { - if ( priv->head_note_state == pm_vars->myCurrentState ) + if (fHeadNoteChangeFlags & kIOPMRootChangeDown) + ParentChangeRootChangeDown(); + + // power state changed + if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) { - // we initiated a null change; forget it - all_done(); - return; - } - } - priv->initial_change = false; + trackSystemSleepPreventers( + fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags); - // dropping power? - if ( priv->head_note_state < pm_vars->myCurrentState ) - { - // yes, in case we have to wait for acks - priv->machine_state = kIOPM_OurChangeTellClientsPowerDown; - pm_vars->doNotPowerDown = false; + // did power raise? + if ( StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState) ) + { + // yes, inform clients and apps + tellChangeUp (fHeadNotePowerState); + } + // either way + prevPowerState = fCurrentPowerState; + fCurrentPowerState = fHeadNotePowerState; + PM_LOCK(); + if (fReportBuf) { + ts = mach_absolute_time(); + STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); + } + PM_UNLOCK(); +#if PM_VARS_SUPPORT + fPMVars->myCurrentState = fCurrentPowerState; +#endif - // ask apps and kernel clients if we can drop power - pm_vars->outofbandparameter = kNotifyApps; - if ( askChangeDown(priv->head_note_state) ) - { - // don't have to wait, did any clients veto? - if ( pm_vars->doNotPowerDown ) + OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState); + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); + actionCalled = true; + + powerStatePtr = &fPowerStates[fCurrentPowerState]; + fCurrentCapabilityFlags = powerStatePtr->capabilityFlags; + if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) + fCurrentPowerConsumption = powerStatePtr->staticPower; + + // inform subclass policy-maker + if (fPCDFunctionOverride && fParentsKnowState && + assertPMDriverCall(&callEntry, kIOPMADC_NoInactiveCheck)) { - // yes, rescind the warning - tellNoChangeDown(priv->head_note_state); - // mark the change note un-actioned - priv-> head_note_flags |= IOPMNotDone; - // and we're done - all_done(); - } else { - // no, tell'em we're dropping power - OurChangeTellClientsPowerDown(); + powerChangeDone(prevPowerState); + deassertPMDriverCall(&callEntry); } } - } else { - // we are raising power - if ( ! priv->we_are_root ) - { - // if this changes our power requirement, tell the parent - ask_parent(priv->head_note_state); - } - // in case they don't all ack - priv->machine_state = kIOPM_OurChangeSetPowerState; + } - // notify interested drivers and children - if ( notifyAll(true) == IOPMAckImplied ) - { - OurChangeSetPowerState(); - } + // When power rises enough to satisfy the tickle's desire for more power, + // the condition preventing idle-timer from dropping power is removed. + + if (StateOrder(fCurrentPowerState) >= StateOrder(fIdleTimerMinPowerState)) + { + fIdleTimerMinPowerState = kPowerStateZero; + } + + if (!actionCalled) + { + PM_ACTION_2(actionPowerChangeDone, + fHeadNotePowerState, fHeadNoteChangeFlags); } } +// MARK: - +// MARK: Power Change Initiated by Driver //********************************************************************************* -// ask_parent +// [private] OurChangeStart // -// Call the power domain parent to ask for a higher power state in the domain -// or to suggest a lower power state. +// Begin the processing of a power change initiated by us. //********************************************************************************* -IOReturn IOService::ask_parent ( unsigned long requestedState ) +void IOService::OurChangeStart( void ) { - OSIterator *iter; - OSObject *next; - IOPowerConnection *connection; - IOService *parent; - unsigned long ourRequest = pm_vars->thePowerStates[requestedState].inputPowerRequirement; + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState ); - if ( pm_vars->thePowerStates[requestedState].capabilityFlags & (kIOPMChildClamp | kIOPMPreventIdleSleep) ) - { - ourRequest |= kIOPMPreventIdleSleep; - } - if ( pm_vars->thePowerStates[requestedState].capabilityFlags & (kIOPMChildClamp2 | kIOPMPreventSystemSleep) ) + // fMaxPowerState is our maximum possible power state based on the current + // power state of our parents. If we are trying to raise power beyond the + // maximum, send an async request for more power to all parents. + + if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState))) { - ourRequest |= kIOPMPreventSystemSleep; - } - - // is this a new desire? - if ( priv->previousRequest == ourRequest ) - { - // no, the parent knows already, just return - return IOPMNoErr; + fHeadNoteChangeFlags |= kIOPMNotDone; + requestDomainPower(fHeadNotePowerState); + OurChangeFinish(); + return; } - if ( priv->we_are_root ) + // Redundant power changes skips to the end of the state machine. + + if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState)) { - return IOPMNoErr; + OurChangeFinish(); + return; } - priv->previousRequest = ourRequest; + fInitialPowerChange = false; - iter = getParentIterator(gIOPowerPlane); + // Change started, but may not complete... + // Can be canceled (power drop) or deferred (power rise). - if ( iter ) + PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); + + // Two separate paths, depending if power is being raised or lowered. + // Lowering power is subject to approval by clients of this service. + + if (IS_POWER_DROP) + { + fDoNotPowerDown = false; + + // Ask for persmission to drop power state + fMachineState = kIOPM_OurChangeTellClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + askChangeDown(fHeadNotePowerState); + } + else { - while ( (next = iter->getNextObject()) ) + // This service is raising power and parents are able to support the + // new power state. However a parent may have already committed to + // drop power, which might force this object to temporarily drop power. + // This results in "oscillations" before the state machines converge + // to a steady state. + // + // To prevent this, a child must make a power reservation against all + // parents before raising power. If the reservation fails, indicating + // that the child will be unable to sustain the higher power state, + // then the child will signal the parent to adjust power, and the child + // will defer its power change. + + IOReturn ret; + + // Reserve parent power necessary to achieve fHeadNotePowerState. + ret = requestDomainPower( fHeadNotePowerState, kReserveDomainPower ); + if (ret != kIOReturnSuccess) { - if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) - { - parent = (IOService *)connection->copyParentEntry(gIOPowerPlane); - if ( parent ) { - if ( parent->requestPowerDomainState(ourRequest,connection,IOPMLowestState)!= IOPMNoErr ) - { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRequestDenied, - (unsigned long)priv->previousRequest,0); - } - parent->release(); - } - } + // Reservation failed, defer power rise. + fHeadNoteChangeFlags |= kIOPMNotDone; + OurChangeFinish(); + return; } - iter->release(); - } - return IOPMNoErr; + OurChangeTellCapabilityWillChange(); + } } - //********************************************************************************* -// instruct_driver +// [private] requestDomainPowerApplier // -// Call the controlling driver and have it change the power state of the -// hardware. If it returns IOPMAckImplied, the change is complete, and -// we return IOPMAckImplied. Otherwise, it will ack when the change -// is done; we return IOPMWillAckLater. +// Call requestPowerDomainState() on all power parents. //********************************************************************************* -IOReturn IOService::instruct_driver ( unsigned long newState ) -{ - IOReturn delay; - // can our driver switch to the desired state? - if ( pm_vars->thePowerStates[newState].capabilityFlags & IOPMNotAttainable ) - { - // no, so don't try - return IOPMAckImplied; - } +struct IOPMRequestDomainPowerContext { + IOService * child; // the requesting child + IOPMPowerFlags requestPowerFlags; // power flags requested by child +}; - priv->driver_timer = -1; +static void +requestDomainPowerApplier( + IORegistryEntry * entry, + void * inContext ) +{ + IOPowerConnection * connection; + IOService * parent; + IOPMRequestDomainPowerContext * context; - // yes, instruct it - IOLockUnlock(priv->our_lock); - OUR_PMLog( kPMLogProgramHardware, (UInt32) this, newState); - delay = pm_vars->theControllingDriver->setPowerState( newState,this ); - OUR_PMLog((UInt32) -kPMLogProgramHardware, (UInt32) this, (UInt32) delay); - IOLockLock(priv->our_lock); + if ((connection = OSDynamicCast(IOPowerConnection, entry)) == 0) + return; + parent = (IOService *) connection->copyParentEntry(gIOPowerPlane); + if (!parent) + return; - // it finished - if ( delay == IOPMAckImplied ) + assert(inContext); + context = (IOPMRequestDomainPowerContext *) inContext; + + if (connection->parentKnowsState() && connection->getReadyFlag()) { - priv->driver_timer = 0; - return IOPMAckImplied; + parent->requestPowerDomainState( + context->requestPowerFlags, + connection, + IOPMLowestState); } - // it acked behind our back - if ( priv->driver_timer == 0 ) + parent->release(); +} + +//********************************************************************************* +// [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( + IOPMPowerStateIndex ourPowerState, + IOOptionBits options ) +{ + IOPMPowerFlags requestPowerFlags; + IOPMPowerStateIndex maxPowerState; + IOPMRequestDomainPowerContext context; + + PM_ASSERT_IN_GATE(); + assert(ourPowerState < fNumberOfPowerStates); + if (ourPowerState >= fNumberOfPowerStates) + return kIOReturnBadArgument; + if (IS_PM_ROOT) + return kIOReturnSuccess; + + // Fetch our input power flags for the requested power state. + // Parent request is stated in terms of required power flags. + + requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags; + + // Disregard the "previous request" for power reservation. + + if (((options & kReserveDomainPower) == 0) && + (fPreviousRequestPowerFlags == requestPowerFlags)) { - return IOPMAckImplied; + // skip if domain already knows our requirements + goto done; } + fPreviousRequestPowerFlags = requestPowerFlags; + + // The results will be collected by fHeadNoteDomainTargetFlags + context.child = this; + context.requestPowerFlags = requestPowerFlags; + fHeadNoteDomainTargetFlags = 0; + applyToParents(requestDomainPowerApplier, &context, gIOPowerPlane); - // somebody goofed - if ( delay < 0 ) + if (options & kReserveDomainPower) { - return IOPMAckImplied; + maxPowerState = fControllingDriver->maxCapabilityForDomainState( + fHeadNoteDomainTargetFlags ); + + if (StateOrder(maxPowerState) < StateOrder(ourPowerState)) + { + PM_LOG1("%s: power desired %u:0x%x got %u:0x%x\n", + getName(), + (uint32_t) ourPowerState, (uint32_t) requestPowerFlags, + (uint32_t) maxPowerState, (uint32_t) fHeadNoteDomainTargetFlags); + return kIOReturnNoPower; + } } - - // it didn't finish - priv->driver_timer = (delay / ( ACK_TIMER_PERIOD / ns_per_us )) + 1; - return IOPMWillAckLater; -} +done: + return kIOReturnSuccess; +} //********************************************************************************* -// acquire_lock -// -// We are acquiring the lock we use to protect our queue head from -// simutaneous access by a thread which calls acknowledgePowerStateChange -// or acknowledgeSetPowerState and the ack timer expiration thread. -// Return TRUE if we acquire the lock, and the queue head didn't change -// while we were acquiring the lock (and maybe blocked). -// If there is no queue head, or it changes while we are blocked, -// return FALSE with the lock unlocked. +// [private] OurSyncStart //********************************************************************************* -bool IOService::acquire_lock ( void ) +void IOService::OurSyncStart( void ) { - long current_change_note; + PM_ASSERT_IN_GATE(); + + if (fInitialPowerChange) + return; - current_change_note = priv->head_note; - if ( current_change_note == -1 ) { - return FALSE; + PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); + + if (fHeadNoteChangeFlags & kIOPMNotDone) + { + OurChangeFinish(); + return; } - IOTakeLock(priv->our_lock); - if ( current_change_note == priv->head_note ) + if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown) { - return TRUE; - } else { - // we blocked and something changed radically - // so there's nothing to do any more - IOUnlock(priv->our_lock); - return FALSE; + fDoNotPowerDown = false; + + // Ask for permission to drop power state + fMachineState = kIOPM_SyncTellClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + askChangeDown(fHeadNotePowerState); + } + else + { + // Only inform capability app and clients. + tellSystemCapabilityChange( kIOPM_SyncNotifyWillChange ); } } - //********************************************************************************* -// askChangeDown -// -// Ask registered applications and kernel clients if we can change to a lower -// power state. -// -// Subclass can override this to send a different message type. Parameter is -// the destination state number. +// [private] OurChangeTellClientsPowerDown // -// Return true if we don't have to wait for acknowledgements +// 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. //********************************************************************************* -bool IOService::askChangeDown ( unsigned long stateNum ) +void IOService::OurChangeTellClientsPowerDown( void ) { - return tellClientsWithResponse(kIOMessageCanDevicePowerOff); + if(!IS_ROOT_DOMAIN) + fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown; + else + { + fMachineState = kIOPM_OurChangeTellUserPMPolicyPowerDown; + } + tellChangeDown1(fHeadNotePowerState); } - //********************************************************************************* -// tellChangeDown1 +// [private] OurChangeTellUserPMPolicyPowerDown // -// Notify registered applications and kernel clients that we are definitely -// dropping power. +// 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 // -// Return true if we don't have to wait for acknowledgements +// All applications and kernel clients have acknowledged our intention to drop +// power. Here we notify "priority" clients that we are lowering power. //********************************************************************************* -bool IOService::tellChangeDown1 ( unsigned long stateNum ) +void IOService::OurChangeTellPriorityClientsPowerDown( void ) { - pm_vars->outofbandparameter = kNotifyApps; - return tellChangeDown(stateNum); + fMachineState = kIOPM_OurChangeNotifyInterestedDriversWillChange; + tellChangeDown2(fHeadNotePowerState); } +//********************************************************************************* +// [private] OurChangeTellCapabilityWillChange +// +// Extra stage for root domain to notify apps and drivers about the +// system capability change when raising power state. +//********************************************************************************* + +void IOService::OurChangeTellCapabilityWillChange( void ) +{ + if (!IS_ROOT_DOMAIN) + return OurChangeNotifyInterestedDriversWillChange(); + + tellSystemCapabilityChange( kIOPM_OurChangeNotifyInterestedDriversWillChange ); +} //********************************************************************************* -// tellChangeDown2 +// [private] OurChangeNotifyInterestedDriversWillChange // -// Notify priority clients that we are definitely dropping power. +// All applications and kernel clients have acknowledged our power state change. +// Here we notify interested drivers pre-change. +//********************************************************************************* + +void IOService::OurChangeNotifyInterestedDriversWillChange( void ) +{ + IOPMrootDomain * rootDomain; + if ((rootDomain = getPMRootDomain()) == this) + { + if (IS_POWER_DROP) + { + rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests ); + } + else + rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests ); + } + + notifyAll( kIOPM_OurChangeSetPowerState ); +} + +//********************************************************************************* +// [private] OurChangeSetPowerState // -// Return true if we don't have to wait for acknowledgements +// Instruct our controlling driver to program the hardware for the power state +// change. Wait for async completions. //********************************************************************************* -bool IOService::tellChangeDown2 ( unsigned long stateNum ) +void IOService::OurChangeSetPowerState( void ) { - pm_vars->outofbandparameter = kNotifyPriority; - return tellChangeDown(stateNum); + MS_PUSH( kIOPM_OurChangeWaitForPowerSettle ); + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = kDriverCallSetPowerState; + + if (notifyControllingDriver() == false) + notifyControllingDriverDone(); } +//********************************************************************************* +// [private] OurChangeWaitForPowerSettle +// +// Our controlling driver has completed the power state change we initiated. +// Wait for the driver specified settle time to expire. +//********************************************************************************* + +void IOService::OurChangeWaitForPowerSettle( void ) +{ + fMachineState = kIOPM_OurChangeNotifyInterestedDriversDidChange; + startSettleTimer(); +} //********************************************************************************* -// tellChangeDown +// [private] OurChangeNotifyInterestedDriversDidChange // -// Notify registered applications and kernel clients that we are definitely -// dropping power. +// Power has settled on a power change we initiated. Here we notify +// all our interested drivers post-change. +//********************************************************************************* + +void IOService::OurChangeNotifyInterestedDriversDidChange( void ) +{ + IOPMrootDomain * rootDomain; + if ((rootDomain = getPMRootDomain()) == this) + { + rootDomain->tracePoint( IS_POWER_DROP ? + kIOPMTracePointSleepDidChangeInterests : + kIOPMTracePointWakeDidChangeInterests ); + } + + notifyAll( kIOPM_OurChangeTellCapabilityDidChange ); +} + +//********************************************************************************* +// [private] OurChangeTellCapabilityDidChange // -// Subclass can override this to send a different message type. Parameter is -// the destination state number. +// For root domain to notify capability power-change. +//********************************************************************************* + +void IOService::OurChangeTellCapabilityDidChange( void ) +{ + if (!IS_ROOT_DOMAIN) + return OurChangeFinish(); + + getPMRootDomain()->tracePoint( IS_POWER_DROP ? + kIOPMTracePointSleepCapabilityClients : + kIOPMTracePointWakeCapabilityClients ); + + tellSystemCapabilityChange( kIOPM_OurChangeFinish ); +} + +//********************************************************************************* +// [private] OurChangeFinish // -// Return true if we don't have to wait for acknowledgements +// Done with this self-induced power state change. //********************************************************************************* -bool IOService::tellChangeDown ( unsigned long stateNum ) +void IOService::OurChangeFinish( void ) { - return tellClientsWithResponse(kIOMessageDeviceWillPowerOff); + all_done(); } +// MARK: - +// MARK: Power Change Initiated by Parent //********************************************************************************* -// tellClientsWithResponse -// -// Notify registered applications and kernel clients that we are definitely -// dropping power. +// [private] ParentChangeStart // -// Return true if we don't have to wait for acknowledgements +// Here we begin the processing of a power change initiated by our parent. //********************************************************************************* -bool IOService::tellClientsWithResponse ( int messageType ) +IOReturn IOService::ParentChangeStart( void ) { - struct context theContext; - AbsoluteTime deadline; - OSBoolean *aBool; + PM_ASSERT_IN_GATE(); + OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState ); - pm_vars->responseFlags = OSArray::withCapacity( 1 ); - pm_vars->serialNumber += 1; - - theContext.responseFlags = pm_vars->responseFlags; - theContext.serialNumber = pm_vars->serialNumber; - theContext.flags_lock = priv->flags_lock; - theContext.counter = 1; - theContext.msgType = messageType; - theContext.us = this; - theContext.maxTimeRequested = 0; - theContext.stateNumber = priv->head_note_state; - theContext.stateFlags = priv->head_note_capabilityFlags; - - IOLockLock(priv->flags_lock); - - // position zero is false to - // prevent allowCancelCommon from succeeding - aBool = OSBoolean::withBoolean(false); - theContext.responseFlags->setObject(0,aBool); - aBool->release(); - IOLockUnlock(priv->flags_lock); - - switch ( pm_vars->outofbandparameter ) { - case kNotifyApps: - applyToInterested(gIOAppPowerStateInterest,tellAppWithResponse,(void *)&theContext); - applyToInterested(gIOGeneralInterest,tellClientWithResponse,(void *)&theContext); - break; - case kNotifyPriority: - applyToInterested(gIOPriorityPowerStateInterest,tellClientWithResponse,(void *)&theContext); - break; + // Root power domain has transitioned to its max power state + if ((fHeadNoteChangeFlags & (kIOPMDomainDidChange | kIOPMRootChangeUp)) == + (kIOPMDomainDidChange | kIOPMRootChangeUp)) + { + // Restart the idle timer stopped by ParentChangeRootChangeDown() + if (fIdleTimerPeriod && fIdleTimerStopped) + { + restartIdleTimer(); + } } - if (! acquire_lock() ) + // Power domain is forcing us to lower power + if ( StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState) ) { - return true; + PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags); + + // Tell apps and kernel clients + fInitialPowerChange = false; + fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown; + tellChangeDown1(fHeadNotePowerState); + return IOPMWillAckLater; } - IOLockLock(priv->flags_lock); - // now fix position zero - aBool = OSBoolean::withBoolean(true); - theContext.responseFlags->replaceObject(0,aBool); - aBool->release(); - IOLockUnlock(priv->flags_lock); - - // do we have to wait for somebody? - if ( ! checkForDone() ) + + // Power domain is allowing us to raise power up to fHeadNotePowerState + if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) ) { - // yes, start the ackTimer - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,theContext.maxTimeRequested,0); - clock_interval_to_deadline(theContext.maxTimeRequested / 1000, kMillisecondScale, &deadline); - - thread_call_enter_delayed(priv->ackTimer, deadline); - - IOUnlock(priv->our_lock); - return false; + if ( StateOrder(fDesiredPowerState) > StateOrder(fCurrentPowerState) ) + { + if ( StateOrder(fDesiredPowerState) < StateOrder(fHeadNotePowerState) ) + { + // We power up, but not all the way + fHeadNotePowerState = fDesiredPowerState; + fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState]; + OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); + } + } else { + // We don't need to change + fHeadNotePowerState = fCurrentPowerState; + fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState]; + OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0); + } } - - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - - // everybody responded - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - IOLockUnlock(priv->flags_lock); - - return true; -} + if ( fHeadNoteChangeFlags & kIOPMDomainDidChange ) + { + if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) ) + { + PM_ACTION_2(actionPowerChangeStart, + fHeadNotePowerState, &fHeadNoteChangeFlags); -//********************************************************************************* -// tellAppWithResponse + // Parent did change up - start our change up + fInitialPowerChange = false; + ParentChangeTellCapabilityWillChange(); + return IOPMWillAckLater; + } + else if (fHeadNoteChangeFlags & kIOPMRootBroadcastFlags) + { + // No need to change power state, but broadcast change + // to our children. + fMachineState = kIOPM_SyncNotifyDidChange; + fDriverCallReason = kDriverCallInformPreChange; + fHeadNoteChangeFlags |= kIOPMNotDone; + notifyChildren(); + return IOPMWillAckLater; + } + } + + // No power state change necessary + fHeadNoteChangeFlags |= kIOPMNotDone; + + all_done(); + return IOPMAckImplied; +} + +//****************************************************************************** +// [private] ParentChangeRootChangeDown // -// We send a message to an application, and we expect a response, so we compute a -// cookie we can identify the response with. -//********************************************************************************* -void tellAppWithResponse ( OSObject * object, void * context) -{ - struct context *theContext = (struct context *)context; - OSBoolean *aBool; - IOPMprot *pm_vars = theContext->us->pm_vars; +// 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. +//****************************************************************************** - if( OSDynamicCast( IOService, object) ) +void IOService::ParentChangeRootChangeDown( void ) +{ + // Always stop the idle timer before root power down + if (fIdleTimerPeriod && !fIdleTimerStopped) { - // Automatically 'ack' in kernel clients - IOLockLock(theContext->flags_lock); - aBool = OSBoolean::withBoolean(true); - theContext->responseFlags->setObject(theContext->counter,aBool); - aBool->release(); - IOLockUnlock(theContext->flags_lock); + fIdleTimerStopped = true; + if (fIdleTimer && thread_call_cancel(fIdleTimer)) + release(); + } - const char *who = ((IOService *) object)->getName(); - pm_vars->thePlatform->PMLog(who, - kPMLogClientAcknowledge, theContext->msgType, * (UInt32 *) object); - } else { - UInt32 refcon = ((theContext->serialNumber & 0xFFFF)<<16) - + (theContext->counter & 0xFFFF); - IOLockLock(theContext->flags_lock); - aBool = OSBoolean::withBoolean(false); - theContext->responseFlags->setObject(theContext->counter,aBool); - aBool->release(); - IOLockUnlock(theContext->flags_lock); + 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. - OUR_PMLog(kPMLogAppNotify, theContext->msgType, refcon); - theContext->us->messageClient(theContext->msgType,object,(void *)refcon); - if ( theContext->maxTimeRequested < k30seconds ) + if (fDeviceDesire != kPowerStateZero) { - theContext->maxTimeRequested = k30seconds; + updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero); + computeDesiredState(kPowerStateZero, true); + requestDomainPower( fDesiredPowerState ); + PM_LOG1("%s: tickle desire removed\n", fName); } - } - theContext->counter += 1; -} -//********************************************************************************* -// tellClientWithResponse -// -// We send a message to an in-kernel client, and we expect a response, so we compute a -// cookie we can identify the response with. -// If it doesn't understand the notification (it is not power-management savvy) -// we won't wait for it to prepare for sleep. If it tells us via a return code -// in the passed struct that it is currently ready, we won't wait for it to prepare. -// If it tells us via the return code in the struct that it does need time, we will chill. -//********************************************************************************* -void tellClientWithResponse ( OSObject * object, void * context) -{ - struct context *theContext = (struct context *)context; - IOPowerStateChangeNotification notify; - UInt32 refcon; - IOReturn retCode; - OSBoolean *aBool; - OSObject *theFlag; - - refcon = ((theContext->serialNumber & 0xFFFF)<<16) + (theContext->counter & 0xFFFF); - IOLockLock(theContext->flags_lock); - aBool = OSBoolean::withBoolean(false); - theContext->responseFlags->setObject(theContext->counter,aBool); - aBool->release(); - IOLockUnlock(theContext->flags_lock); - - IOPMprot *pm_vars = theContext->us->pm_vars; - if (gIOKitDebug & kIOLogPower) { - OUR_PMLog(kPMLogClientNotify, refcon, (UInt32) theContext->msgType); - if (OSDynamicCast(IOService, object)) { - const char *who = ((IOService *) object)->getName(); - pm_vars->thePlatform->PMLog(who, - kPMLogClientNotify, * (UInt32 *) object, (UInt32) object); - } else if (OSDynamicCast(_IOServiceInterestNotifier, object)) { - _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; - OUR_PMLog(kPMLogClientNotify, (UInt32) n->handler, 0); - } - } - - notify.powerRef = (void *)refcon; - notify.returnValue = 0; - notify.stateNumber = theContext->stateNumber; - notify.stateFlags = theContext->stateFlags; - retCode = theContext->us->messageClient(theContext->msgType,object,(void *)¬ify); - if ( retCode == kIOReturnSuccess ) + // Invalidate tickle cache so the next tickle will issue a request + IOLockLock(fActivityLock); + fDeviceWasActive = false; + fActivityTicklePowerState = kInvalidTicklePowerState; + IOLockUnlock(fActivityLock); + + fIdleTimerMinPowerState = kPowerStateZero; + } + else if (fAdvisoryTickleUsed) { - if ( notify.returnValue == 0 ) + // 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)) { - // client doesn't want time to respond - IOLockLock(theContext->flags_lock); - aBool = OSBoolean::withBoolean(true); - // so set its flag true - theContext->responseFlags->replaceObject(theContext->counter,aBool); - aBool->release(); - IOLockUnlock(theContext->flags_lock); - OUR_PMLog(kPMLogClientAcknowledge, refcon, (UInt32) object); - } else { - IOLockLock(theContext->flags_lock); - - // it does want time, and it hasn't responded yet - theFlag = theContext->responseFlags->getObject(theContext->counter); - if ( theFlag != 0 ) + IOLockLock(fActivityLock); + + if (!fDeviceWasActive) + { + // No tickles since the last idle timer expiration. + // Safe to drop the device desire to zero. + dropTickleDesire = true; + } + else { - if ( ((OSBoolean *)theFlag)->isFalse() ) + // 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) { - // so note its time requirement - if ( theContext->maxTimeRequested < notify.returnValue ) - { - theContext->maxTimeRequested = notify.returnValue; - } + dropTickleDesire = true; } } - IOLockUnlock(theContext->flags_lock); + + 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); } - } else { - OUR_PMLog(kPMLogClientAcknowledge, refcon, 0); - // not a client of ours - IOLockLock(theContext->flags_lock); - // so we won't be waiting for response - aBool = OSBoolean::withBoolean(true); - theContext->responseFlags->replaceObject(theContext->counter,aBool); - aBool->release(); - IOLockUnlock(theContext->flags_lock); } - theContext->counter += 1; } - //********************************************************************************* -// tellNoChangeDown -// -// Notify registered applications and kernel clients that we are not -// dropping power. +// [private] ParentChangeTellPriorityClientsPowerDown // -// Subclass can override this to send a different message type. Parameter is -// the aborted destination state number. +// All applications and kernel clients have acknowledged our intention to drop +// power. Here we notify "priority" clients that we are lowering power. //********************************************************************************* -void IOService::tellNoChangeDown ( unsigned long ) +void IOService::ParentChangeTellPriorityClientsPowerDown( void ) { - return tellClients(kIOMessageDeviceWillNotPowerOff); + fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange; + tellChangeDown2(fHeadNotePowerState); } - //********************************************************************************* -// tellChangeUp -// -// Notify registered applications and kernel clients that we are raising power. +// [private] ParentChangeTellCapabilityWillChange // -// Subclass can override this to send a different message type. Parameter is -// the aborted destination state number. +// All (legacy) applications and kernel clients have acknowledged, extra stage for +// root domain to notify apps and drivers about the system capability change. //********************************************************************************* -void IOService::tellChangeUp ( unsigned long ) +void IOService::ParentChangeTellCapabilityWillChange( void ) { - return tellClients(kIOMessageDeviceHasPoweredOn); -} + if (!IS_ROOT_DOMAIN) + return ParentChangeNotifyInterestedDriversWillChange(); + tellSystemCapabilityChange( kIOPM_ParentChangeNotifyInterestedDriversWillChange ); +} //********************************************************************************* -// tellClients +// [private] ParentChangeNotifyInterestedDriversWillChange // -// Notify registered applications and kernel clients of something. +// All applications and kernel clients have acknowledged our power state change. +// Here we notify interested drivers pre-change. //********************************************************************************* -void IOService::tellClients ( int messageType ) +void IOService::ParentChangeNotifyInterestedDriversWillChange( void ) { - struct context theContext; + notifyAll( kIOPM_ParentChangeSetPowerState ); +} + +//********************************************************************************* +// [private] ParentChangeSetPowerState +// +// Instruct our controlling driver to program the hardware for the power state +// change. Wait for async completions. +//********************************************************************************* - theContext.msgType = messageType; - theContext.us = this; - theContext.stateNumber = priv->head_note_state; - theContext.stateFlags = priv->head_note_capabilityFlags; +void IOService::ParentChangeSetPowerState( void ) +{ + MS_PUSH( kIOPM_ParentChangeWaitForPowerSettle ); + fMachineState = kIOPM_DriverThreadCallDone; + fDriverCallReason = kDriverCallSetPowerState; - applyToInterested(gIOAppPowerStateInterest,tellClient,(void *)&theContext); - applyToInterested(gIOGeneralInterest,tellClient,(void *)&theContext); + if (notifyControllingDriver() == false) + notifyControllingDriverDone(); } - //********************************************************************************* -// tellClient +// [private] ParentChangeWaitForPowerSettle // -// Notify a registered application or kernel client of something. +// Our controlling driver has completed the power state change initiated by our +// parent. Wait for the driver specified settle time to expire. //********************************************************************************* -void tellClient ( OSObject * object, void * context) + +void IOService::ParentChangeWaitForPowerSettle( void ) { - struct context *theContext = (struct context *)context; - IOPowerStateChangeNotification notify; + fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange; + startSettleTimer(); +} - notify.powerRef = (void *) 0; - notify.returnValue = 0; - notify.stateNumber = theContext->stateNumber; - notify.stateFlags = theContext->stateFlags; +//********************************************************************************* +// [private] ParentChangeNotifyInterestedDriversDidChange +// +// Power has settled on a power change initiated by our parent. Here we notify +// all our interested drivers post-change. +//********************************************************************************* - theContext->us->messageClient(theContext->msgType,object, ¬ify); +void IOService::ParentChangeNotifyInterestedDriversDidChange( void ) +{ + notifyAll( kIOPM_ParentChangeTellCapabilityDidChange ); } +//********************************************************************************* +// [private] ParentChangeTellCapabilityDidChange +// +// For root domain to notify capability power-change. +//********************************************************************************* + +void IOService::ParentChangeTellCapabilityDidChange( void ) +{ + if (!IS_ROOT_DOMAIN) + return ParentChangeAcknowledgePowerChange(); + + tellSystemCapabilityChange( kIOPM_ParentChangeAcknowledgePowerChange ); +} -// ********************************************************************************** -// checkForDone +//********************************************************************************* +// [private] ParentAcknowledgePowerChange // -// ********************************************************************************** -bool IOService::checkForDone ( void ) +// Acknowledge our power parent that our power change is done. +//********************************************************************************* + +void IOService::ParentChangeAcknowledgePowerChange( void ) { - int i = 0; - OSObject *theFlag; + IORegistryEntry * nub; + IOService * parent; - IOLockLock(priv->flags_lock); - if ( pm_vars->responseFlags == NULL ) - { - IOLockUnlock(priv->flags_lock); - return true; - } - - for ( i = 0; ; i++ ) + nub = fHeadNoteParentConnection; + nub->retain(); + all_done(); + parent = (IOService *)nub->copyParentEntry(gIOPowerPlane); + if ( parent ) { - theFlag = pm_vars->responseFlags->getObject(i); - if ( theFlag == NULL ) - { - break; - } - if ( ((OSBoolean *)theFlag)->isFalse() ) - { - IOLockUnlock(priv->flags_lock); - return false; - } + parent->acknowledgePowerChange((IOService *)nub); + parent->release(); } - IOLockUnlock(priv->flags_lock); - return true; + nub->release(); } +// MARK: - +// MARK: Ack and Settle timers -// ********************************************************************************** -// responseValid +//********************************************************************************* +// [private] settleTimerExpired // -// ********************************************************************************** -bool IOService::responseValid ( unsigned long x ) -{ - UInt16 serialComponent; - UInt16 ordinalComponent; - OSObject * theFlag; - unsigned long refcon = (unsigned long)x; - OSBoolean * aBool; - - serialComponent = (refcon>>16) & 0xFFFF; - ordinalComponent = refcon & 0xFFFF; +// Power has settled after our last change. Notify interested parties that +// there is a new power state. +//********************************************************************************* + +void IOService::settleTimerExpired( void ) +{ + fSettleTimeUS = 0; + gIOPMWorkQueue->signalWorkAvailable(); +} + +//********************************************************************************* +// settle_timer_expired +// +// Holds a retain while the settle timer callout is in flight. +//********************************************************************************* + +static void +settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 ) +{ + IOService * me = (IOService *) arg0; + + if (gIOPMWorkLoop && gIOPMWorkQueue) + { + gIOPMWorkLoop->runAction( + OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired), + me); + } + me->release(); +} + +//********************************************************************************* +// [private] startSettleTimer +// +// Calculate a power-settling delay in microseconds and start a timer. +//********************************************************************************* + +void IOService::startSettleTimer( void ) +{ +#if NOT_USEFUL + // This function is broken and serves no useful purpose since it never + // updates fSettleTimeUS to a non-zero value to stall the state machine, + // yet it starts a delay timer. It appears no driver relies on a delay + // from settleUpTime and settleDownTime in the power state table. + + AbsoluteTime deadline; + IOPMPowerStateIndex stateIndex; + IOPMPowerStateIndex currentOrder, newOrder, i; + uint32_t settleTime = 0; + boolean_t pending; + + PM_ASSERT_IN_GATE(); + + currentOrder = StateOrder(fCurrentPowerState); + newOrder = StateOrder(fHeadNotePowerState); + + i = currentOrder; + + // lowering power + if ( newOrder < currentOrder ) + { + while ( i > newOrder ) + { + stateIndex = fPowerStates[i].stateOrderToIndex; + settleTime += (uint32_t) fPowerStates[stateIndex].settleDownTime; + i--; + } + } + + // raising power + if ( newOrder > currentOrder ) + { + while ( i < newOrder ) + { + stateIndex = fPowerStates[i+1].stateOrderToIndex; + settleTime += (uint32_t) fPowerStates[stateIndex].settleUpTime; + i++; + } + } + + if (settleTime) + { + retain(); + clock_interval_to_deadline(settleTime, kMicrosecondScale, &deadline); + pending = thread_call_enter_delayed(fSettleTimer, deadline); + if (pending) release(); + } +#endif +} + +//********************************************************************************* +// [private] ackTimerTick +// +// The acknowledgement timeout periodic timer has ticked. +// If we are awaiting acks for a power change notification, +// we decrement the timer word of each interested driver which hasn't acked. +// If a timer word becomes zero, we pretend the driver aknowledged. +// If we are waiting for the controlling driver to change the power +// state of the hardware, we decrement its timer word, and if it becomes +// zero, we pretend the driver acknowledged. +// +// Returns true if the timer tick made it possible to advance to the next +// machine state, false otherwise. +//********************************************************************************* + +#ifndef __LP64__ +void IOService::ack_timer_ticked ( void ) +{ + assert(false); +} +#endif /* !__LP64__ */ + +bool IOService::ackTimerTick( void ) +{ + IOPMinformee * nextObject; + bool done = false; + + PM_ASSERT_IN_GATE(); + switch (fMachineState) { + case kIOPM_OurChangeWaitForPowerSettle: + case kIOPM_ParentChangeWaitForPowerSettle: + // are we waiting for controlling driver to acknowledge? + if ( fDriverTimer > 0 ) + { + // yes, decrement timer tick + fDriverTimer--; + if ( fDriverTimer == 0 ) + { + // controlling driver is tardy + uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime); + OUR_PMLog(kPMLogCtrlDriverTardy, 0, 0); + setProperty(kIOPMTardyAckSPSKey, kOSBooleanTrue); + PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n", + fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); + + if (gIOKitDebug & kIOLogDebugPower) + { + panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms", + fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec)); + } + else + { + // Unblock state machine and pretend driver has acked. + done = true; + } + } else { + // still waiting, set timer again + start_ack_timer(); + } + } + break; + + case kIOPM_NotifyChildrenStart: + // are we waiting for interested parties to acknowledge? + if ( fHeadNotePendingAcks != 0 ) + { + // yes, go through the list of interested drivers + nextObject = fInterestedDrivers->firstInList(); + // and check each one + while ( nextObject != NULL ) + { + if ( nextObject->timer > 0 ) + { + nextObject->timer--; + // this one should have acked by now + if ( nextObject->timer == 0 ) + { + uint64_t nsec = computeTimeDeltaNS(&nextObject->startTime); + OUR_PMLog(kPMLogIntDriverTardy, 0, 0); + nextObject->whatObject->setProperty(kIOPMTardyAckPSCKey, kOSBooleanTrue); + PM_ERROR("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) timed out after %d ms\n", + nextObject->whatObject->getName(), + (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did", + OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState, + NS_TO_MS(nsec)); + + // Pretend driver has acked. + fHeadNotePendingAcks--; + } + } + nextObject = fInterestedDrivers->nextInList(nextObject); + } + + // is that the last? + if ( fHeadNotePendingAcks == 0 ) + { + // yes, we can continue + done = true; + } else { + // no, set timer again + start_ack_timer(); + } + } + break; + + // TODO: aggreggate this + case kIOPM_OurChangeTellClientsPowerDown: + case kIOPM_OurChangeTellUserPMPolicyPowerDown: + case kIOPM_OurChangeTellPriorityClientsPowerDown: + case kIOPM_OurChangeNotifyInterestedDriversWillChange: + case kIOPM_ParentChangeTellPriorityClientsPowerDown: + case kIOPM_ParentChangeNotifyInterestedDriversWillChange: + case kIOPM_SyncTellClientsPowerDown: + case kIOPM_SyncTellPriorityClientsPowerDown: + case kIOPM_SyncNotifyWillChange: + case kIOPM_TellCapabilityChangeDone: + // apps didn't respond in time + cleanClientResponses(true); + OUR_PMLog(kPMLogClientTardy, 0, 1); + // tardy equates to approval + done = true; + break; + + default: + PM_LOG1("%s: unexpected ack timer tick (state = %d)\n", + getName(), fMachineState); + break; + } + return done; +} + +//********************************************************************************* +// [private] start_watchdog_timer +//********************************************************************************* +void IOService::start_watchdog_timer( void ) +{ + AbsoluteTime deadline; + boolean_t pending; + static int timeout = -1; + + if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) + return; + + if (thread_call_isactive(fWatchdogTimer)) return; + if (timeout == -1) { + PE_parse_boot_argn("swd_timeout", &timeout, sizeof(timeout)); + } + if (timeout < 60) { + timeout = WATCHDOG_TIMER_PERIOD; + } + + 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 ; +} + + +IOWorkLoop * IOService::getIOPMWorkloop( void ) +{ + return gIOPMWorkLoop; +} + + + +//********************************************************************************* +// [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 ) +{ + boolean_t pending; + + pending = thread_call_cancel(fAckTimer); + if (pending) release(); + + start_watchdog_timer(); +} + +//********************************************************************************* +// [static] actionAckTimerExpired +// +// Inside PM work loop's gate. +//********************************************************************************* + +IOReturn +IOService::actionAckTimerExpired( + OSObject * target, + void * arg0, void * arg1, + void * arg2, void * arg3 ) +{ + 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 = me->ackTimerTick(); + if (done && gIOPMWorkQueue) + { + gIOPMWorkQueue->signalWorkAvailable(); + me->start_watchdog_timer(); + } + + return kIOReturnSuccess; +} + +//********************************************************************************* +// ack_timer_expired +// +// Thread call function. Holds a retain while the callout is in flight. +//********************************************************************************* + +void +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; + + if (gIOPMWorkLoop) + { + gIOPMWorkLoop->runAction(&actionSpinDumpTimerExpired, me); + } + me->release(); +} + +// MARK: - +// MARK: Client Messaging + +//********************************************************************************* +// [private] tellSystemCapabilityChange +//********************************************************************************* + +void IOService::tellSystemCapabilityChange( uint32_t nextMS ) +{ + MS_PUSH( nextMS ); + fMachineState = kIOPM_TellCapabilityChangeDone; + fOutOfBandMessage = kIOMessageSystemCapabilityChange; + + if (fIsPreChange) + { + // Notify app first on pre-change. + fOutOfBandParameter = kNotifyCapabilityChangeApps; + } + else + { + // Notify kernel clients first on post-change. + fOutOfBandParameter = kNotifyCapabilityChangePriority; + } + + tellClientsWithResponse( fOutOfBandMessage ); +} + +//********************************************************************************* +// [public] askChangeDown +// +// Ask registered applications and kernel clients if we can change to a lower +// power state. +// +// Subclass can override this to send a different message type. Parameter is +// the destination state number. +// +// Return true if we don't have to wait for acknowledgements +//********************************************************************************* + +bool IOService::askChangeDown( unsigned long stateNum ) +{ + return tellClientsWithResponse( kIOMessageCanDevicePowerOff ); +} + +//********************************************************************************* +// [private] tellChangeDown1 +// +// Notify registered applications and kernel clients that we are definitely +// dropping power. +// +// Return true if we don't have to wait for acknowledgements +//********************************************************************************* + +bool IOService::tellChangeDown1( unsigned long stateNum ) +{ + fOutOfBandParameter = kNotifyApps; + return tellChangeDown(stateNum); +} + +//********************************************************************************* +// [private] tellChangeDown2 +// +// Notify priority clients that we are definitely dropping power. +// +// Return true if we don't have to wait for acknowledgements +//********************************************************************************* + +bool IOService::tellChangeDown2( unsigned long stateNum ) +{ + fOutOfBandParameter = kNotifyPriority; + return tellChangeDown(stateNum); +} + +//********************************************************************************* +// [public] tellChangeDown +// +// Notify registered applications and kernel clients that we are definitely +// dropping power. +// +// Subclass can override this to send a different message type. Parameter is +// the destination state number. +// +// Return true if we don't have to wait for acknowledgements +//********************************************************************************* + +bool IOService::tellChangeDown( unsigned long stateNum ) +{ + return tellClientsWithResponse( kIOMessageDeviceWillPowerOff ); +} + +//********************************************************************************* +// cleanClientResponses +// +//********************************************************************************* + +static void logAppTimeouts( OSObject * object, void * arg ) +{ + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * flag; + unsigned int clientIndex; + int pid = 0; + char name[128]; + + if (OSDynamicCast(_IOServiceInterestNotifier, object)) + { + // Discover the 'counter' value or index assigned to this client + // when it was notified, by searching for the array index of the + // client in an array holding the cached interested clients. + + clientIndex = context->notifyClients->getNextIndexOfObject(object, 0); + + if ((clientIndex != (unsigned int) -1) && + (flag = context->responseArray->getObject(clientIndex)) && + (flag != kOSBooleanTrue)) + { + OSNumber *clientID = copyClientIDForNotification(object, context); + + name[0] = '\0'; + if (clientID) { + pid = clientID->unsigned32BitValue(); + proc_name(pid, name, sizeof(name)); + clientID->release(); + } + + PM_ERROR(context->errorLog, pid, name); + + // TODO: record message type if possible + IOService::getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsApplicationResponseTimedOut, + name, 0, (30*1000), pid, object); + + } + } +} + +void IOService::cleanClientResponses( bool logErrors ) +{ + if (logErrors && fResponseArray) + { + switch ( fOutOfBandParameter ) { + case kNotifyApps: + case kNotifyCapabilityChangeApps: + if (fNotifyClientArray) + { + IOPMInterestContext context; + + context.responseArray = fResponseArray; + context.notifyClients = fNotifyClientArray; + context.serialNumber = fSerialNumber; + context.messageType = kIOMessageCopyClientID; + context.notifyType = kNotifyApps; + context.isPreChange = fIsPreChange; + context.enableTracing = false; + context.us = this; + context.maxTimeRequested = 0; + context.stateNumber = fHeadNotePowerState; + context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; + context.changeFlags = fHeadNoteChangeFlags; + context.errorLog = "PM notification timeout (pid %d, %s)\n"; + + applyToInterested(gIOAppPowerStateInterest, logAppTimeouts, (void *) &context); + } + break; + + default: + // kNotifyPriority, kNotifyCapabilityChangePriority + // TODO: identify the priority client that has not acked + PM_ERROR("PM priority notification timeout\n"); + if (gIOKitDebug & kIOLogDebugPower) + { + panic("PM priority notification timeout"); + } + break; + } + } + + if (fResponseArray) + { + fResponseArray->release(); + fResponseArray = NULL; + } + if (fNotifyClientArray) + { + fNotifyClientArray->release(); + fNotifyClientArray = NULL; + } +} + +//********************************************************************************* +// [protected] tellClientsWithResponse +// +// Notify registered applications and kernel clients that we are definitely +// dropping power. +// +// Return true if we don't have to wait for acknowledgements +//********************************************************************************* + +bool IOService::tellClientsWithResponse( int messageType ) +{ + IOPMInterestContext context; + bool isRootDomain = IS_ROOT_DOMAIN; + uint32_t maxTimeOut = kMaxTimeRequested; + + PM_ASSERT_IN_GATE(); + assert( fResponseArray == NULL ); + assert( fNotifyClientArray == NULL ); + + if(messageType == (int)kIOPMMessageLastCallBeforeSleep) + RD_LOG("tellClientsWithResponse( kIOPMMessageLastCallBeforeSleep, %d )\n", + fOutOfBandParameter); + else + RD_LOG("tellClientsWithResponse( %s, %d )\n", + getIOMessageString(messageType), fOutOfBandParameter); + + fResponseArray = OSArray::withCapacity( 1 ); + if (!fResponseArray) + goto exit; + + fResponseArray->setCapacityIncrement(8); + if (++fSerialNumber == 0) + fSerialNumber++; + + context.responseArray = fResponseArray; + context.notifyClients = 0; + context.serialNumber = fSerialNumber; + context.messageType = messageType; + context.notifyType = fOutOfBandParameter; + context.isPreChange = fIsPreChange; + context.enableTracing = false; + context.us = this; + context.maxTimeRequested = 0; + context.stateNumber = fHeadNotePowerState; + context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; + context.changeFlags = fHeadNoteChangeFlags; + context.messageFilter = (isRootDomain) ? + OSMemberFunctionCast( + IOPMMessageFilter, + this, + &IOPMrootDomain::systemMessageFilter) : 0; + + switch ( fOutOfBandParameter ) { + case kNotifyApps: + applyToInterested( gIOAppPowerStateInterest, + pmTellAppWithResponse, (void *) &context ); + + if (isRootDomain && + (fMachineState != kIOPM_OurChangeTellClientsPowerDown) && + (fMachineState != kIOPM_SyncTellClientsPowerDown) && + (context.messageType != kIOPMMessageLastCallBeforeSleep)) + { + // Notify capability app for tellChangeDown1() + // but not for askChangeDown(). + context.notifyType = kNotifyCapabilityChangeApps; + context.messageType = kIOMessageSystemCapabilityChange; + applyToInterested( gIOAppPowerStateInterest, + pmTellCapabilityAppWithResponse, (void *) &context ); + context.notifyType = fOutOfBandParameter; + context.messageType = messageType; + } + if(context.messageType == kIOMessageCanSystemSleep) + { + maxTimeOut = kCanSleepMaxTimeReq; + if(gCanSleepTimeout) + { + maxTimeOut = (gCanSleepTimeout*us_per_s); + } + } + context.maxTimeRequested = maxTimeOut; + applyToInterested( gIOGeneralInterest, + pmTellClientWithResponse, (void *) &context ); + + fNotifyClientArray = context.notifyClients; + break; + + case kNotifyPriority: + context.enableTracing = isRootDomain; + applyToInterested( gIOPriorityPowerStateInterest, + pmTellClientWithResponse, (void *) &context ); + + if (isRootDomain) + { + // Notify capability clients for tellChangeDown2(). + context.notifyType = kNotifyCapabilityChangePriority; + context.messageType = kIOMessageSystemCapabilityChange; + applyToInterested( gIOPriorityPowerStateInterest, + pmTellCapabilityClientWithResponse, (void *) &context ); + } + break; + + case kNotifyCapabilityChangeApps: + applyToInterested( gIOAppPowerStateInterest, + pmTellCapabilityAppWithResponse, (void *) &context ); + fNotifyClientArray = context.notifyClients; + if(context.messageType == kIOMessageCanSystemSleep) + { + maxTimeOut = kCanSleepMaxTimeReq; + if(gCanSleepTimeout) + { + maxTimeOut = (gCanSleepTimeout*us_per_s); + } + } + context.maxTimeRequested = maxTimeOut; + break; + + case kNotifyCapabilityChangePriority: + context.enableTracing = isRootDomain; + applyToInterested( gIOPriorityPowerStateInterest, + pmTellCapabilityClientWithResponse, (void *) &context ); + break; + } + + // do we have to wait for somebody? + if ( !checkForDone() ) + { + OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0); + if (context.enableTracing) { + getPMRootDomain()->traceDetail(context.messageType, 0, context.maxTimeRequested / 1000); + } + start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale ); + return false; + } + +exit: + // everybody responded + if (fResponseArray) + { + fResponseArray->release(); + fResponseArray = NULL; + } + if (fNotifyClientArray) + { + fNotifyClientArray->release(); + fNotifyClientArray = NULL; + } + + return true; +} + +//********************************************************************************* +// [static private] pmTellAppWithResponse +// +// We send a message to an application, and we expect a response, so we compute a +// cookie we can identify the response with. +//********************************************************************************* + +void IOService::pmTellAppWithResponse( OSObject * object, void * arg ) +{ + IOPMInterestContext * context = (IOPMInterestContext *) arg; + IOServicePM * pwrMgt = context->us->pwrMgt; + uint32_t msgIndex, msgRef, msgType; + OSNumber *clientID = NULL; + proc_t proc = NULL; + boolean_t proc_suspended = FALSE; + OSObject * waitForReply = kOSBooleanTrue; +#if LOG_APP_RESPONSE_TIMES + AbsoluteTime now; +#endif + + if (!OSDynamicCast(_IOServiceInterestNotifier, object)) + return; + + if (context->us == getPMRootDomain()) + { + if ((clientID = copyClientIDForNotification(object, context))) + { + uint32_t clientPID = clientID->unsigned32BitValue(); + clientID->release(); + proc = proc_find(clientPID); + + if (proc) + { + proc_suspended = get_task_pidsuspended((task_t) proc->task); + proc_rele(proc); + + if (proc_suspended) + { + logClientIDForNotification(object, context, "PMTellAppWithResponse - Suspended"); + return; + } + } + } + } + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, 0, &waitForReply)) + { + if (kIOLogDebugPower & gIOKitDebug) + { + logClientIDForNotification(object, context, "DROP App"); + } + return; + } + + // Create client array (for tracking purposes) only if the service + // has app clients. Usually only root domain does. + if (0 == context->notifyClients) + context->notifyClients = OSArray::withCapacity( 32 ); + + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + OUR_PMLog(kPMLogAppNotify, msgType, msgRef); + if (kIOLogDebugPower & gIOKitDebug) + { + logClientIDForNotification(object, context, "MESG App"); + } + + if (waitForReply == kOSBooleanTrue) + { + + OSNumber * num; + clock_get_uptime(&now); + num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8); + if (num) + { + context->responseArray->setObject(msgIndex, num); + num->release(); + } + else { + context->responseArray->setObject(msgIndex, kOSBooleanFalse); + } + } + else + { + context->responseArray->setObject(msgIndex, kOSBooleanTrue); + if (kIOLogDebugPower & gIOKitDebug) + { + logClientIDForNotification(object, context, "App response ignored"); + } + } + + if (context->notifyClients) + context->notifyClients->setObject(msgIndex, object); + + context->us->messageClient(msgType, object, (void *)(uintptr_t) msgRef); +} + +//********************************************************************************* +// [static private] pmTellClientWithResponse +// +// We send a message to an in-kernel client, and we expect a response, +// so we compute a cookie we can identify the response with. +//********************************************************************************* + +void IOService::pmTellClientWithResponse( OSObject * object, void * arg ) +{ + IOPowerStateChangeNotification notify; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * replied = kOSBooleanTrue; + _IOServiceInterestNotifier * notifier; + uint32_t msgIndex, msgRef, msgType; + IOReturn retCode; + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, 0, 0)) + { + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) + { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } + return; + } + + notifier = OSDynamicCast(_IOServiceInterestNotifier, object); + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + IOServicePM * pwrMgt = context->us->pwrMgt; + if (gIOKitDebug & kIOLogPower) { + OUR_PMLog(kPMLogClientNotify, msgRef, msgType); + if (OSDynamicCast(IOService, object)) { + const char *who = ((IOService *) object)->getName(); + gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0); + } + else if (notifier) { + OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); + } + } + if ((kIOLogDebugPower & gIOKitDebug) && notifier) + { + PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(msgType), + OBFUSCATE(object), OBFUSCATE(notifier->handler)); + } + + notify.powerRef = (void *)(uintptr_t) msgRef; + notify.returnValue = 0; + notify.stateNumber = context->stateNumber; + notify.stateFlags = context->stateFlags; + + if (context->enableTracing && (notifier != 0)) + { + getPMRootDomain()->traceDetail(msgType, msgIndex, (uintptr_t) notifier->handler); + } + + retCode = context->us->messageClient(msgType, object, (void *) ¬ify, sizeof(notify)); + + if (kIOReturnSuccess == retCode) + { + if (0 == notify.returnValue) { + OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); + } else { + replied = kOSBooleanFalse; + if ( notify.returnValue > context->maxTimeRequested ) + { + if (notify.returnValue > kPriorityClientMaxWait) + { + context->maxTimeRequested = kPriorityClientMaxWait; + PM_ERROR("%s: client %p returned %llu for %s\n", + context->us->getName(), + notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), + (uint64_t) notify.returnValue, + getIOMessageString(msgType)); + } + else + context->maxTimeRequested = notify.returnValue; + } + } + } else { + // not a client of ours + // so we won't be waiting for response + OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); + } + + context->responseArray->setObject(msgIndex, replied); +} + +//********************************************************************************* +// [static private] pmTellCapabilityAppWithResponse +//********************************************************************************* + +void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg ) +{ + IOPMSystemCapabilityChangeParameters msgArg; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * replied = kOSBooleanTrue; + IOServicePM * pwrMgt = context->us->pwrMgt; + uint32_t msgIndex, msgRef, msgType; +#if LOG_APP_RESPONSE_TIMES + AbsoluteTime now; +#endif + + if (!OSDynamicCast(_IOServiceInterestNotifier, object)) + return; + + memset(&msgArg, 0, sizeof(msgArg)); + if (context->messageFilter && + !context->messageFilter(context->us, object, context, &msgArg, &replied)) + { + return; + } + + // Create client array (for tracking purposes) only if the service + // has app clients. Usually only root domain does. + if (0 == context->notifyClients) + context->notifyClients = OSArray::withCapacity( 32 ); + + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + OUR_PMLog(kPMLogAppNotify, msgType, msgRef); + if (kIOLogDebugPower & gIOKitDebug) + { + // Log client pid/name and client array index. + OSNumber * clientID = NULL; + OSString * clientIDString = NULL;; + context->us->messageClient(kIOMessageCopyClientID, object, &clientID); + if (clientID) { + clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue()); + } + + PM_LOG("%s MESG App(%u) %s, wait %u, %s\n", + context->us->getName(), + msgIndex, getIOMessageString(msgType), + (replied != kOSBooleanTrue), + clientIDString ? clientIDString->getCStringNoCopy() : ""); + if (clientID) clientID->release(); + if (clientIDString) clientIDString->release(); + } + + msgArg.notifyRef = msgRef; + msgArg.maxWaitForReply = 0; + + if (replied == kOSBooleanTrue) + { + msgArg.notifyRef = 0; + context->responseArray->setObject(msgIndex, kOSBooleanTrue); + if (context->notifyClients) + context->notifyClients->setObject(msgIndex, kOSBooleanTrue); + } + else + { + + OSNumber * num; + clock_get_uptime(&now); + num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8); + if (num) + { + context->responseArray->setObject(msgIndex, num); + num->release(); + } + else { + context->responseArray->setObject(msgIndex, kOSBooleanFalse); + } + + if (context->notifyClients) + context->notifyClients->setObject(msgIndex, object); + } + + context->us->messageClient(msgType, object, (void *) &msgArg, sizeof(msgArg)); +} + +//********************************************************************************* +// [static private] pmTellCapabilityClientWithResponse +//********************************************************************************* + +void IOService::pmTellCapabilityClientWithResponse( + OSObject * object, void * arg ) +{ + IOPMSystemCapabilityChangeParameters msgArg; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSObject * replied = kOSBooleanTrue; + _IOServiceInterestNotifier * notifier; + uint32_t msgIndex, msgRef, msgType; + IOReturn retCode; + + memset(&msgArg, 0, sizeof(msgArg)); + if (context->messageFilter && + !context->messageFilter(context->us, object, context, &msgArg, 0)) + { + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) + { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } + return; + } + + notifier = OSDynamicCast(_IOServiceInterestNotifier, object); + msgType = context->messageType; + msgIndex = context->responseArray->getCount(); + msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF); + + IOServicePM * pwrMgt = context->us->pwrMgt; + if (gIOKitDebug & kIOLogPower) { + OUR_PMLog(kPMLogClientNotify, msgRef, msgType); + if (OSDynamicCast(IOService, object)) { + const char *who = ((IOService *) object)->getName(); + gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0); + } + else if (notifier) { + OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0); + } + } + if ((kIOLogDebugPower & gIOKitDebug) && notifier) + { + PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", + context->us->getName(), + getIOMessageString(msgType), + OBFUSCATE(object), OBFUSCATE(notifier->handler)); + } + + msgArg.notifyRef = msgRef; + msgArg.maxWaitForReply = 0; + + if (context->enableTracing && (notifier != 0)) + { + getPMRootDomain()->traceDetail(msgType, msgIndex, (uintptr_t) notifier->handler); + } + + retCode = context->us->messageClient( + msgType, object, (void *) &msgArg, sizeof(msgArg)); + + if ( kIOReturnSuccess == retCode ) + { + if ( 0 == msgArg.maxWaitForReply ) + { + // client doesn't want time to respond + OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object); + } + else + { + replied = kOSBooleanFalse; + if ( msgArg.maxWaitForReply > context->maxTimeRequested ) + { + if (msgArg.maxWaitForReply > kCapabilityClientMaxWait) + { + context->maxTimeRequested = kCapabilityClientMaxWait; + PM_ERROR("%s: client %p returned %u for %s\n", + context->us->getName(), + notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object), + msgArg.maxWaitForReply, + getIOMessageString(msgType)); + } + else + context->maxTimeRequested = msgArg.maxWaitForReply; + } + } + } + else + { + // not a client of ours + // so we won't be waiting for response + OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0); + } + + context->responseArray->setObject(msgIndex, replied); +} + +//********************************************************************************* +// [public] tellNoChangeDown +// +// Notify registered applications and kernel clients that we are not +// dropping power. +// +// Subclass can override this to send a different message type. Parameter is +// the aborted destination state number. +//********************************************************************************* + +void IOService::tellNoChangeDown( unsigned long ) +{ + return tellClients( kIOMessageDeviceWillNotPowerOff ); +} + +//********************************************************************************* +// [public] tellChangeUp +// +// Notify registered applications and kernel clients that we are raising power. +// +// Subclass can override this to send a different message type. Parameter is +// the aborted destination state number. +//********************************************************************************* + +void IOService::tellChangeUp( unsigned long ) +{ + return tellClients( kIOMessageDeviceHasPoweredOn ); +} + +//********************************************************************************* +// [protected] tellClients +// +// Notify registered applications and kernel clients of something. +//********************************************************************************* + +void IOService::tellClients( int messageType ) +{ + IOPMInterestContext context; + + RD_LOG("tellClients( %s )\n", getIOMessageString(messageType)); + + memset(&context, 0, sizeof(context)); + context.messageType = messageType; + context.isPreChange = fIsPreChange; + context.us = this; + context.stateNumber = fHeadNotePowerState; + context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags; + context.changeFlags = fHeadNoteChangeFlags; + context.messageFilter = (IS_ROOT_DOMAIN) ? + OSMemberFunctionCast( + IOPMMessageFilter, + this, + &IOPMrootDomain::systemMessageFilter) : 0; + + context.notifyType = kNotifyPriority; + applyToInterested( gIOPriorityPowerStateInterest, + tellKernelClientApplier, (void *) &context ); + + context.notifyType = kNotifyApps; + applyToInterested( gIOAppPowerStateInterest, + tellAppClientApplier, (void *) &context ); + + applyToInterested( gIOGeneralInterest, + tellKernelClientApplier, (void *) &context ); +} + +//********************************************************************************* +// [private] tellKernelClientApplier +// +// Message a kernel client. +//********************************************************************************* + +static void tellKernelClientApplier( OSObject * object, void * arg ) +{ + IOPowerStateChangeNotification notify; + IOPMInterestContext * context = (IOPMInterestContext *) arg; + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, 0, 0)) + { + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) + { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s DROP Client %s, notifier %p, handler %p\n", + context->us->getName(), + IOService::getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } + return; + } + + notify.powerRef = (void *) 0; + notify.returnValue = 0; + notify.stateNumber = context->stateNumber; + notify.stateFlags = context->stateFlags; + + context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify)); + + if ((kIOLogDebugPower & gIOKitDebug) && + (OSDynamicCast(_IOServiceInterestNotifier, object))) + { + _IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object; + PM_LOG("%s MESG Client %s, notifier %p, handler %p\n", + context->us->getName(), + IOService::getIOMessageString(context->messageType), + OBFUSCATE(object), OBFUSCATE(n->handler)); + } +} + +static OSNumber * copyClientIDForNotification( + OSObject *object, + IOPMInterestContext *context) +{ + OSNumber *clientID = NULL; + context->us->messageClient(kIOMessageCopyClientID, object, &clientID); + return clientID; +} + +static void logClientIDForNotification( + OSObject *object, + IOPMInterestContext *context, + const char *logString) +{ + OSString *logClientID = NULL; + OSNumber *clientID = copyClientIDForNotification(object, context); + + 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) + logClientID->release(); + } + + if (clientID) + clientID->release(); + + return; +} + +static void tellAppClientApplier( OSObject * object, void * arg ) +{ + IOPMInterestContext * context = (IOPMInterestContext *) arg; + OSNumber * clientID = NULL; + proc_t proc = NULL; + boolean_t proc_suspended = FALSE; + + if (context->us == IOService::getPMRootDomain()) + { + if ((clientID = copyClientIDForNotification(object, context))) + { + uint32_t clientPID = clientID->unsigned32BitValue(); + clientID->release(); + proc = proc_find(clientPID); + + if (proc) + { + proc_suspended = get_task_pidsuspended((task_t) proc->task); + proc_rele(proc); + + if (proc_suspended) + { + logClientIDForNotification(object, context, "tellAppClientApplier - Suspended"); + return; + } + } + } + } + + if (context->messageFilter && + !context->messageFilter(context->us, object, context, 0, 0)) + { + if (kIOLogDebugPower & gIOKitDebug) + { + logClientIDForNotification(object, context, "DROP App"); + } + return; + } + + if (kIOLogDebugPower & gIOKitDebug) + { + logClientIDForNotification(object, context, "MESG App"); + } + + context->us->messageClient(context->messageType, object, 0); +} + +//********************************************************************************* +// [private] checkForDone +//********************************************************************************* + +bool IOService::checkForDone( void ) +{ + int i = 0; + OSObject * theFlag; + + if (fResponseArray == NULL) { + return true; + } + + for (i = 0; ; i++) { + theFlag = fResponseArray->getObject(i); + + if (NULL == theFlag) { + break; + } + + if (kOSBooleanTrue != theFlag) { + return false; + } + } + return true; +} + +//********************************************************************************* +// [public] responseValid +//********************************************************************************* + +bool IOService::responseValid( uint32_t refcon, int pid ) +{ + UInt16 serialComponent; + UInt16 ordinalComponent; + OSObject * theFlag; + OSObject *object = 0; + + serialComponent = (refcon >> 16) & 0xFFFF; + ordinalComponent = (refcon & 0xFFFF); + + if ( serialComponent != fSerialNumber ) + { + return false; + } + + if ( fResponseArray == NULL ) + { + return false; + } + + theFlag = fResponseArray->getObject(ordinalComponent); + + if ( theFlag == 0 ) + { + return false; + } + + if (fNotifyClientArray) + object = fNotifyClientArray->getObject(ordinalComponent); + + OSNumber * num; + if ((num = OSDynamicCast(OSNumber, theFlag))) + { + + AbsoluteTime now; + AbsoluteTime start; + uint64_t nsec; + char name[128]; + + name[0] = '\0'; + proc_name(pid, name, sizeof(name)); + clock_get_uptime(&now); + AbsoluteTime_to_scalar(&start) = num->unsigned64BitValue(); + SUB_ABSOLUTETIME(&now, &start); + absolutetime_to_nanoseconds(now, &nsec); + + if (kIOLogDebugPower & gIOKitDebug) + { + PM_LOG("Ack(%u) %u ms\n", + (uint32_t) ordinalComponent, + NS_TO_MS(nsec)); + } + + // > 100 ms + if (nsec > LOG_APP_RESPONSE_TIMES) + { + IOLog("PM response took %d ms (%d, %s)\n", NS_TO_MS(nsec), + pid, name); + } + + if (nsec > LOG_APP_RESPONSE_MSG_TRACER) + { + // TODO: populate the messageType argument + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsApplicationResponseSlow, + name, 0, NS_TO_MS(nsec), pid, object); + } + else + { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsApplicationResponsePrompt, + name, 0, NS_TO_MS(nsec), pid, object); + } + + + theFlag = kOSBooleanFalse; + } + else if (object) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsApplicationResponsePrompt, + 0, 0, 0, pid, object); + + } + + if ( kOSBooleanFalse == theFlag ) + { + fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue); + } + + return true; +} + +//********************************************************************************* +// [public] allowPowerChange +// +// Our power state is about to lower, and we have notified applications +// and kernel clients, and one of them has acknowledged. If this is the last to do +// so, and all acknowledgements are positive, we continue with the power change. +//********************************************************************************* + +IOReturn IOService::allowPowerChange( unsigned long refcon ) +{ + IOPMRequest * request; + + if ( !initialized ) + { + // we're unloading + return kIOReturnSuccess; + } + + request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange ); + if (!request) + return kIOReturnNoMemory; + + request->fArg0 = (void *) refcon; + request->fArg1 = (void *)(uintptr_t) proc_selfpid(); + request->fArg2 = (void *) 0; + submitPMRequest( request ); + + return kIOReturnSuccess; +} + +#ifndef __LP64__ +IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon ) +{ + // [deprecated] public + return kIOReturnUnsupported; +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// [public] cancelPowerChange +// +// Our power state is about to lower, and we have notified applications +// and kernel clients, and one of them has vetoed the change. If this is the last +// client to respond, we abandon the power change. +//********************************************************************************* + +IOReturn IOService::cancelPowerChange( unsigned long refcon ) +{ + IOPMRequest * request; + char name[128]; + pid_t pid = proc_selfpid(); + + if ( !initialized ) + { + // we're unloading + return kIOReturnSuccess; + } + + name[0] = '\0'; + proc_name(pid, name, sizeof(name)); + PM_ERROR("PM notification cancel (pid %d, %s)\n", pid, name); + + request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange ); + if (!request) + { + return kIOReturnNoMemory; + } + + request->fArg0 = (void *) refcon; + request->fArg1 = (void *)(uintptr_t) proc_selfpid(); + request->fArg2 = (void *) OSString::withCString(name); + submitPMRequest( request ); + + return kIOReturnSuccess; +} + +#ifndef __LP64__ +IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon ) +{ + // [deprecated] public + return kIOReturnUnsupported; +} + +//********************************************************************************* +// PM_Clamp_Timer_Expired +// +// called when clamp timer expires...set power state to 0. +//********************************************************************************* + +void IOService::PM_Clamp_Timer_Expired( void ) +{ +} + +//********************************************************************************* +// clampPowerOn +// +// Set to highest available power state for a minimum of duration milliseconds +//********************************************************************************* + +void IOService::clampPowerOn( unsigned long duration ) +{ +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// configurePowerStateReport +// +// Configures the IOStateReport for kPMPowerStateChannel +//********************************************************************************* +IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action, void *result ) +{ + + IOReturn rc = kIOReturnSuccess; + size_t reportSize; + unsigned long i; + uint64_t ts; + + if (!pwrMgt) + return kIOReturnUnsupported; + + if (!fNumberOfPowerStates) + return kIOReturnSuccess; // For drivers which are in power plane, but haven't called registerPowerDriver() + PM_LOCK(); + + switch (action) + { + case kIOReportEnable: + if (fReportBuf) + { + fReportClientCnt++; + break; + } + reportSize = STATEREPORT_BUFSIZE(fNumberOfPowerStates); + fReportBuf = IOMalloc(reportSize); + if (!fReportBuf) { + rc = kIOReturnNoMemory; + break; + } + memset(fReportBuf, 0, reportSize); + + STATEREPORT_INIT(fNumberOfPowerStates, fReportBuf, reportSize, + getRegistryEntryID(), kPMPowerStatesChID, kIOReportCategoryPower); + + for (i = 0; i < fNumberOfPowerStates; i++) { + unsigned bits = 0; + + if (fPowerStates[i].capabilityFlags & kIOPMPowerOn) + bits |= kPMReportPowerOn; + if (fPowerStates[i].capabilityFlags & kIOPMDeviceUsable) + bits |= kPMReportDeviceUsable; + if (fPowerStates[i].capabilityFlags & kIOPMLowPower) + bits |= kPMReportLowPower; + + STATEREPORT_SETSTATEID(fReportBuf, i, ((bits & 0xff) << 8) | + ((StateOrder(fMaxPowerState) & 0xf) << 4) | (StateOrder(i) & 0xf)); + } + ts = mach_absolute_time(); + STATEREPORT_SETSTATE(fReportBuf, fCurrentPowerState, ts); + break; + + case kIOReportDisable: + if (fReportClientCnt == 0) { + rc = kIOReturnBadArgument; + break; + } + if (fReportClientCnt == 1) + { + IOFree(fReportBuf, STATEREPORT_BUFSIZE(fNumberOfPowerStates)); + fReportBuf = NULL; + } + fReportClientCnt--; + break; + + case kIOReportGetDimensions: + if (fReportBuf) + STATEREPORT_UPDATERES(fReportBuf, kIOReportGetDimensions, result); + break; + } + + PM_UNLOCK(); + + return rc; +} + +//********************************************************************************* +// updatePowerStateReport +// +// Updates the IOStateReport for kPMPowerStateChannel +//********************************************************************************* +IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, void *result, void *destination ) +{ + uint32_t size2cpy; + void *data2cpy; + uint64_t ts; + IOReturn rc = kIOReturnSuccess; + IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination); + + + if (!pwrMgt) + return kIOReturnUnsupported; + if (!fNumberOfPowerStates) + return kIOReturnSuccess; + + if ( !result || !dest ) return kIOReturnBadArgument; + PM_LOCK(); + + switch (action) { + case kIOReportCopyChannelData: + if ( !fReportBuf ) { + rc = kIOReturnNotOpen; + break; + } + + ts = mach_absolute_time(); + STATEREPORT_UPDATEPREP(fReportBuf, ts, data2cpy, size2cpy); + if (size2cpy > (dest->getCapacity() - dest->getLength()) ) { + rc = kIOReturnOverrun; + break; + } + + STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result); + dest->appendBytes(data2cpy, size2cpy); + break; + + 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); + break; + + default: + break; + + } + + 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-- ) + { + stateIndex = fPowerStates[order].stateOrderToIndex; + + if ( (flags & fPowerStates[stateIndex].inputPowerFlags) == + fPowerStates[stateIndex].inputPowerFlags ) + { + return stateIndex; + } + } + 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__ +//********************************************************************************* +// [deprecated] didYouWakeSystem +// +// Does nothing here. This should be implemented in a subclass driver. +//********************************************************************************* + +bool IOService::didYouWakeSystem( void ) +{ + return false; +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// [public] powerStateWillChangeTo +// +// Does nothing here. This should be implemented in a subclass driver. +//********************************************************************************* + +IOReturn IOService::powerStateWillChangeTo( IOPMPowerFlags, unsigned long, IOService * ) +{ + return kIOPMAckImplied; +} + +//********************************************************************************* +// [public] powerStateDidChangeTo +// +// Does nothing here. This should be implemented in a subclass driver. +//********************************************************************************* + +IOReturn IOService::powerStateDidChangeTo( IOPMPowerFlags, unsigned long, IOService * ) +{ + return kIOPMAckImplied; +} + +//********************************************************************************* +// [protected] powerChangeDone +// +// Called from PM work loop thread. +// Does nothing here. This should be implemented in a subclass policy-maker. +//********************************************************************************* + +void IOService::powerChangeDone( unsigned long ) +{ +} + +#ifndef __LP64__ +//********************************************************************************* +// [deprecated] newTemperature +// +// Does nothing here. This should be implemented in a subclass driver. +//********************************************************************************* + +IOReturn IOService::newTemperature( long currentTemp, IOService * whichZone ) +{ + return IOPMNoErr; +} +#endif /* !__LP64__ */ + +//********************************************************************************* +// [public] systemWillShutdown +// +// System shutdown and restart notification. +//********************************************************************************* + +void IOService::systemWillShutdown( IOOptionBits specifier ) +{ + IOPMrootDomain * rootDomain = IOService::getPMRootDomain(); + if (rootDomain) + rootDomain->acknowledgeSystemWillShutdown( this ); +} + +// MARK: - +// MARK: PM State Machine + +//********************************************************************************* +// [private static] acquirePMRequest +//********************************************************************************* + +IOPMRequest * +IOService::acquirePMRequest( IOService * target, IOOptionBits requestType, + IOPMRequest * active ) +{ + IOPMRequest * request; + + assert(target); + + request = IOPMRequest::create(); + if (request) + { + request->init( target, requestType ); + if (active) + { + IOPMRequest * root = active->getRootRequest(); + if (root) request->attachRootRequest(root); + } + } + else + { + PM_ERROR("%s: No memory for PM request type 0x%x\n", + target->getName(), (uint32_t) requestType); + } + return request; +} + +//********************************************************************************* +// [private static] releasePMRequest +//********************************************************************************* + +void IOService::releasePMRequest( IOPMRequest * request ) +{ + if (request) + { + request->reset(); + request->release(); + } +} + +//********************************************************************************* +// [private static] submitPMRequest +//********************************************************************************* + +void IOService::submitPMRequest( IOPMRequest * request ) +{ + assert( request ); + assert( gIOPMReplyQueue ); + assert( gIOPMRequestQueue ); + + PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n", + (long)request->getType(), OBFUSCATE(request), + OBFUSCATE(request->getTarget()), request->getTarget()->getName(), + OBFUSCATE(request->fArg0), + OBFUSCATE(request->fArg1), OBFUSCATE(request->fArg2)); + + if (request->isReplyType()) + gIOPMReplyQueue->queuePMRequest( request ); + else + gIOPMRequestQueue->queuePMRequest( request ); +} + +void IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count ) +{ + assert( requests ); + assert( count > 0 ); + assert( gIOPMRequestQueue ); + + for (IOItemCount i = 0; i < count; i++) + { + IOPMRequest * req = requests[i]; + PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n", + (long)req->getType(), OBFUSCATE(req), + OBFUSCATE(req->getTarget()), req->getTarget()->getName(), + OBFUSCATE(req->fArg0), + OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2)); + } + + gIOPMRequestQueue->queuePMRequestChain( requests, count ); +} + +//********************************************************************************* +// [private] actionPMRequestQueue +// +// IOPMRequestQueue::checkForWork() passing a new request to the request target. +//********************************************************************************* + +bool IOService::actionPMRequestQueue( + IOPMRequest * request, + IOPMRequestQueue * queue ) +{ + bool more; + + if (initialized) + { + // Work queue will immediately execute the request if the per-service + // request queue is empty. Note pwrMgt is the target's IOServicePM. + + more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt); + } + else + { + // Calling PM without PMinit() is not allowed, fail the request. + // Need to signal more when completing attached requests. + + PM_LOG("%s: PM not initialized\n", getName()); + PM_LOG1("[- %02x] %p [%p %s] !initialized\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName()); + + more = gIOPMCompletionQueue->queuePMRequest(request); + if (more) gIOPMWorkQueue->incrementProducerCount(); + } + + return more; +} + +//********************************************************************************* +// [private] actionPMCompletionQueue +// +// IOPMCompletionQueue::checkForWork() passing a completed request to the +// request target. +//********************************************************************************* + +bool IOService::actionPMCompletionQueue( + IOPMRequest * request, + IOPMCompletionQueue * queue ) +{ + bool more = (request->getNextRequest() != 0); + IOPMRequest * root = request->getRootRequest(); + + if (root && (root != request)) + more = true; + if (more) + gIOPMWorkQueue->incrementProducerCount(); + + releasePMRequest( request ); + return more; +} + +//********************************************************************************* +// [private] actionPMWorkQueueRetire +// +// IOPMWorkQueue::checkForWork() passing a retired request to the request target. +//********************************************************************************* + +bool IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * queue ) +{ + assert(request && queue); + + PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), + fMachineState, gIOPMBusyRequestCount); + + // Catch requests created by idleTimerExpired() + if (request->getType() == kIOPMRequestTypeActivityTickle) + { + uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1; + + if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod) + { + restartIdleTimer(); + } + else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise)) + { + // Invalidate any idle power drop that got queued while + // processing this request. + fIdleTimerGeneration++; + } + } - if ( serialComponent != pm_vars->serialNumber ) + // When the completed request is linked, tell work queue there is + // more work pending. + + return (gIOPMCompletionQueue->queuePMRequest( request )); +} + +//********************************************************************************* +// [private] isPMBlocked +// +// Check if machine state transition is blocked. +//********************************************************************************* + +bool IOService::isPMBlocked( IOPMRequest * request, int count ) +{ + int reason = 0; + + do { + if (kIOPM_Finished == fMachineState) + break; + + if (kIOPM_DriverThreadCallDone == fMachineState) + { + // 5 = kDriverCallInformPreChange + // 6 = kDriverCallInformPostChange + // 7 = kDriverCallSetPowerState + // 8 = kRootDomainInformPreChange + if (fDriverCallBusy) + reason = 5 + fDriverCallReason; + break; + } + + // Waiting on driver's setPowerState() timeout. + if (fDriverTimer) + { + reason = 1; break; + } + + // 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 settle timer expiration. + if (fSettleTimeUS) + { + reason = 4; break; + } + } while (false); + + fWaitReason = reason; + + if (reason) + { + if (count) + { + PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), + fMachineState, reason); + } + + return true; + } + + return false; +} + +//********************************************************************************* +// [private] actionPMWorkQueueInvoke +// +// IOPMWorkQueue::checkForWork() passing a request to the +// request target for execution. +//********************************************************************************* + +bool IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue ) +{ + bool done = false; + int loop = 0; + + assert(request && queue); + + while (isPMBlocked(request, loop++) == false) + { + PM_LOG1("[W %02x] %p [%p %s] state %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), fMachineState); + + gIOPMRequest = request; + gIOPMWorkInvokeCount++; + + // Every PM machine states must be handled in one of the cases below. + + switch ( fMachineState ) + { + case kIOPM_Finished: + start_watchdog_timer(); + + executePMRequest( request ); + break; + + case kIOPM_OurChangeTellClientsPowerDown: + // Root domain might self cancel due to assertions. + if (IS_ROOT_DOMAIN) + { + bool cancel = (bool) fDoNotPowerDown; + getPMRootDomain()->askChangeDownDone( + &fHeadNoteChangeFlags, &cancel); + fDoNotPowerDown = cancel; + } + + // askChangeDown() done, was it vetoed? + if (!fDoNotPowerDown) + { + // no, we can continue + OurChangeTellClientsPowerDown(); + } + else + { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); + if (IS_ROOT_DOMAIN) { + // RootDomain already sent "WillSleep" to its clients + tellChangeUp(fCurrentPowerState); + } + else { + tellNoChangeDown(fHeadNotePowerState); + } + // mark the change note un-actioned + fHeadNoteChangeFlags |= kIOPMNotDone; + // and we're done + OurChangeFinish(); + } + break; + + case kIOPM_OurChangeTellUserPMPolicyPowerDown: + // PMRD: tellChangeDown/kNotifyApps done, was it cancelled? + if (fDoNotPowerDown) + { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); + if (IS_ROOT_DOMAIN) { + // RootDomain already sent "WillSleep" to its clients + tellChangeUp(fCurrentPowerState); + } + else { + tellNoChangeDown(fHeadNotePowerState); + } + // mark the change note un-actioned + fHeadNoteChangeFlags |= kIOPMNotDone; + // and we're done + OurChangeFinish(); + } + else + OurChangeTellUserPMPolicyPowerDown(); + break; + + case kIOPM_OurChangeTellPriorityClientsPowerDown: + // PMRD: LastCallBeforeSleep notify done + // Non-PMRD: tellChangeDown/kNotifyApps done + if (fDoNotPowerDown) + { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState); + // no, tell clients we're back in the old state + tellChangeUp(fCurrentPowerState); + // mark the change note un-actioned + fHeadNoteChangeFlags |= kIOPMNotDone; + // and we're done + OurChangeFinish(); + } + else + { + // yes, we can continue + OurChangeTellPriorityClientsPowerDown(); + } + break; + + case kIOPM_OurChangeNotifyInterestedDriversWillChange: + OurChangeNotifyInterestedDriversWillChange(); + break; + + case kIOPM_OurChangeSetPowerState: + OurChangeSetPowerState(); + break; + + case kIOPM_OurChangeWaitForPowerSettle: + OurChangeWaitForPowerSettle(); + break; + + case kIOPM_OurChangeNotifyInterestedDriversDidChange: + OurChangeNotifyInterestedDriversDidChange(); + break; + + case kIOPM_OurChangeTellCapabilityDidChange: + OurChangeTellCapabilityDidChange(); + break; + + case kIOPM_OurChangeFinish: + OurChangeFinish(); + break; + + case kIOPM_ParentChangeTellPriorityClientsPowerDown: + ParentChangeTellPriorityClientsPowerDown(); + break; + + case kIOPM_ParentChangeNotifyInterestedDriversWillChange: + ParentChangeNotifyInterestedDriversWillChange(); + break; + + case kIOPM_ParentChangeSetPowerState: + ParentChangeSetPowerState(); + break; + + case kIOPM_ParentChangeWaitForPowerSettle: + ParentChangeWaitForPowerSettle(); + break; + + case kIOPM_ParentChangeNotifyInterestedDriversDidChange: + ParentChangeNotifyInterestedDriversDidChange(); + break; + + case kIOPM_ParentChangeTellCapabilityDidChange: + ParentChangeTellCapabilityDidChange(); + break; + + case kIOPM_ParentChangeAcknowledgePowerChange: + ParentChangeAcknowledgePowerChange(); + break; + + case kIOPM_DriverThreadCallDone: + switch (fDriverCallReason) + { + case kDriverCallInformPreChange: + case kDriverCallInformPostChange: + notifyInterestedDriversDone(); + break; + case kDriverCallSetPowerState: + notifyControllingDriverDone(); + break; + case kRootDomainInformPreChange: + notifyRootDomainDone(); + break; + default: + panic("%s: bad call reason %x", + getName(), fDriverCallReason); + } + break; + + case kIOPM_NotifyChildrenOrdered: + notifyChildrenOrdered(); + break; + + case kIOPM_NotifyChildrenDelayed: + notifyChildrenDelayed(); + break; + + case kIOPM_NotifyChildrenStart: + // pop notifyAll() state saved by notifyInterestedDriversDone() + MS_POP(); + notifyRootDomain(); + break; + + case kIOPM_SyncTellClientsPowerDown: + // Root domain might self cancel due to assertions. + if (IS_ROOT_DOMAIN) + { + bool cancel = (bool) fDoNotPowerDown; + getPMRootDomain()->askChangeDownDone( + &fHeadNoteChangeFlags, &cancel); + fDoNotPowerDown = cancel; + } + if (!fDoNotPowerDown) + { + fMachineState = kIOPM_SyncTellPriorityClientsPowerDown; + fOutOfBandParameter = kNotifyApps; + tellChangeDown(fHeadNotePowerState); + } + else + { + // Cancelled by IOPMrootDomain::askChangeDownDone() or + // askChangeDown/kNotifyApps + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState); + tellNoChangeDown(fHeadNotePowerState); + fHeadNoteChangeFlags |= kIOPMNotDone; + OurChangeFinish(); + } + break; + + case kIOPM_SyncTellPriorityClientsPowerDown: + // PMRD: tellChangeDown/kNotifyApps done, was it cancelled? + if (!fDoNotPowerDown) + { + fMachineState = kIOPM_SyncNotifyWillChange; + fOutOfBandParameter = kNotifyPriority; + tellChangeDown(fHeadNotePowerState); + } + else + { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState); + tellChangeUp(fCurrentPowerState); + fHeadNoteChangeFlags |= kIOPMNotDone; + OurChangeFinish(); + } + break; + + case kIOPM_SyncNotifyWillChange: + if (kIOPMSyncNoChildNotify & fHeadNoteChangeFlags) + { + fMachineState = kIOPM_SyncFinish; + continue; + } + fMachineState = kIOPM_SyncNotifyDidChange; + fDriverCallReason = kDriverCallInformPreChange; + notifyChildren(); + break; + + case kIOPM_SyncNotifyDidChange: + fIsPreChange = false; + + if (fHeadNoteChangeFlags & kIOPMParentInitiated) + { + fMachineState = kIOPM_SyncFinish; + } + else + { + assert(IS_ROOT_DOMAIN); + fMachineState = kIOPM_SyncTellCapabilityDidChange; + } + + fDriverCallReason = kDriverCallInformPostChange; + notifyChildren(); + break; + + case kIOPM_SyncTellCapabilityDidChange: + tellSystemCapabilityChange( kIOPM_SyncFinish ); + break; + + case kIOPM_SyncFinish: + if (fHeadNoteChangeFlags & kIOPMParentInitiated) + ParentChangeAcknowledgePowerChange(); + else + OurChangeFinish(); + break; + + case kIOPM_TellCapabilityChangeDone: + if (fIsPreChange) + { + if (fOutOfBandParameter == kNotifyCapabilityChangePriority) + { + MS_POP(); // tellSystemCapabilityChange() + continue; + } + fOutOfBandParameter = kNotifyCapabilityChangePriority; + } + else + { + if (fOutOfBandParameter == kNotifyCapabilityChangeApps) + { + MS_POP(); // tellSystemCapabilityChange() + continue; + } + fOutOfBandParameter = kNotifyCapabilityChangeApps; + } + tellClientsWithResponse( fOutOfBandMessage ); + break; + + default: + panic("PMWorkQueueInvoke: unknown machine state %x", + fMachineState); + } + + gIOPMRequest = 0; + + if (fMachineState == kIOPM_Finished) + { + stop_watchdog_timer(); + done = true; + break; + } + } + + return done; +} + +//********************************************************************************* +// [private] executePMRequest +//********************************************************************************* + +void IOService::executePMRequest( IOPMRequest * request ) +{ + assert( kIOPM_Finished == fMachineState ); + + switch (request->getType()) { - return false; + case kIOPMRequestTypePMStop: + handlePMstop( request ); + break; + + case kIOPMRequestTypeAddPowerChild1: + addPowerChild1( request ); + break; + + case kIOPMRequestTypeAddPowerChild2: + addPowerChild2( request ); + break; + + case kIOPMRequestTypeAddPowerChild3: + addPowerChild3( request ); + break; + + case kIOPMRequestTypeRegisterPowerDriver: + handleRegisterPowerDriver( request ); + break; + + case kIOPMRequestTypeAdjustPowerState: + fAdjustPowerScheduled = false; + adjustPowerState(); + break; + + case kIOPMRequestTypePowerDomainWillChange: + handlePowerDomainWillChangeTo( request ); + break; + + case kIOPMRequestTypePowerDomainDidChange: + handlePowerDomainDidChangeTo( request ); + break; + + case kIOPMRequestTypeRequestPowerState: + case kIOPMRequestTypeRequestPowerStateOverride: + handleRequestPowerState( request ); + break; + + case kIOPMRequestTypePowerOverrideOnPriv: + case kIOPMRequestTypePowerOverrideOffPriv: + handlePowerOverrideChanged( request ); + break; + + case kIOPMRequestTypeActivityTickle: + handleActivityTickle( request ); + break; + + case kIOPMRequestTypeSynchronizePowerTree: + handleSynchronizePowerTree( request ); + break; + + case kIOPMRequestTypeSetIdleTimerPeriod: + { + fIdleTimerPeriod = (uintptr_t) request->fArg0; + fNextIdleTimerPeriod = fIdleTimerPeriod; + if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0)) + restartIdleTimer(); + } + break; + + case kIOPMRequestTypeIgnoreIdleTimer: + fIdleTimerIgnored = request->fArg0 ? 1 : 0; + break; + + case kIOPMRequestTypeQuiescePowerTree: + gIOPMWorkQueue->finishQuiesceRequest(request); + break; + + default: + panic("executePMRequest: unknown request type %x", request->getType()); } - - IOLockLock(priv->flags_lock); - if ( pm_vars->responseFlags == NULL ) +} + +//********************************************************************************* +// [private] actionPMReplyQueue +// +// IOPMRequestQueue::checkForWork() passing a reply-type request to the +// request target. +//********************************************************************************* + +bool IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue ) +{ + bool more = false; + + assert( request && queue ); + assert( request->isReplyType() ); + + PM_LOG1("[A %02x] %p [%p %s] state %d\n", + request->getType(), OBFUSCATE(request), + OBFUSCATE(this), getName(), fMachineState); + + switch ( request->getType() ) { - IOLockUnlock(priv->flags_lock); + case kIOPMRequestTypeAllowPowerChange: + case kIOPMRequestTypeCancelPowerChange: + // Check if we are expecting this response. + if (responseValid((uint32_t)(uintptr_t) request->fArg0, + (int)(uintptr_t) request->fArg1)) + { + if (kIOPMRequestTypeCancelPowerChange == request->getType()) + { + // Clients are not allowed to cancel when kIOPMSkipAskPowerDown + // flag is set. Only root domain will set this flag. + // However, there is one exception to this rule. User-space PM + // policy may choose to cancel sleep even after all clients have + // been notified that we will lower power. + + if ((fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) + || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) + || ((fHeadNoteChangeFlags & kIOPMSkipAskPowerDown) == 0)) + { + fDoNotPowerDown = true; + + OSString * name = (OSString *) request->fArg2; + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsApplicationResponseCancel, + name ? name->getCStringNoCopy() : "", 0, + 0, (int)(uintptr_t) request->fArg1, 0); + } + } + + if (checkForDone()) + { + stop_ack_timer(); + cleanClientResponses(false); + more = true; + } + } + // OSString containing app name in Arg2 must be released. + if (request->getType() == kIOPMRequestTypeCancelPowerChange) + { + OSObject * obj = (OSObject *) request->fArg2; + if (obj) obj->release(); + } + break; + + case kIOPMRequestTypeAckPowerChange: + more = handleAcknowledgePowerChange( request ); + break; + + case kIOPMRequestTypeAckSetPowerState: + if (fDriverTimer == -1) + { + // driver acked while setPowerState() call is in-flight. + // take this ack, return value from setPowerState() is irrelevant. + OUR_PMLog(kPMLogDriverAcknowledgeSet, + (uintptr_t) this, fDriverTimer); + fDriverTimer = 0; + } + else if (fDriverTimer > 0) + { + // expected ack, stop the timer + stop_ack_timer(); + + + uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime); + if (nsec > LOG_SETPOWER_TIMES) { + getPMRootDomain()->pmStatsRecordApplicationResponse( + gIOPMStatsDriverPSChangeSlow, + fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(), + NULL, fHeadNotePowerState); + } + + OUR_PMLog(kPMLogDriverAcknowledgeSet, (uintptr_t) this, fDriverTimer); + fDriverTimer = 0; + more = true; + } + else + { + // unexpected ack + OUR_PMLog(kPMLogAcknowledgeErr4, (uintptr_t) this, 0); + } + break; + + case kIOPMRequestTypeInterestChanged: + handleInterestChanged( request ); + more = true; + break; + + case kIOPMRequestTypeIdleCancel: + if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) + || (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) + || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) + || (fMachineState == kIOPM_SyncTellClientsPowerDown) + || (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown)) + { + OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState); + PM_LOG2("%s: cancel from machine state %d\n", + getName(), fMachineState); + fDoNotPowerDown = true; + // Stop waiting for app replys. + if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) || + (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) || + (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown) || + (fMachineState == kIOPM_SyncTellClientsPowerDown) ) + cleanClientResponses(false); + more = true; + } + break; + + case kIOPMRequestTypeChildNotifyDelayCancel: + if (fMachineState == kIOPM_NotifyChildrenDelayed) + { + PM_LOG2("%s: delay notify cancelled\n", getName()); + notifyChildrenDelayed(); + } + break; + + default: + panic("PMReplyQueue: unknown reply type %x", request->getType()); + } + + more |= gIOPMCompletionQueue->queuePMRequest(request); + if (more) + gIOPMWorkQueue->incrementProducerCount(); + + return more; +} + +//********************************************************************************* +// [private] assertPMDriverCall / deassertPMDriverCall +//********************************************************************************* + +bool IOService::assertPMDriverCall( + IOPMDriverCallEntry * entry, + IOOptionBits options, + IOPMinformee * inform ) +{ + IOService * target = 0; + bool ok = false; + + if (!initialized) return false; + + PM_LOCK(); + + if (fLockedFlags.PMStop) + { + goto fail; } - - theFlag = pm_vars->responseFlags->getObject(ordinalComponent); - - if ( theFlag == 0 ) + + if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive()) + { + goto fail; + } + + if (inform) + { + if (!inform->active) + { + goto fail; + } + target = inform->whatObject; + if (target->isInactive()) + { + goto fail; + } + } + + entry->thread = current_thread(); + entry->target = target; + queue_enter(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link); + ok = true; + +fail: + PM_UNLOCK(); + + return ok; +} + +void IOService::deassertPMDriverCall( IOPMDriverCallEntry * entry ) +{ + bool wakeup = false; + + PM_LOCK(); + + assert( !queue_empty(&fPMDriverCallQueue) ); + queue_remove(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link); + if (fLockedFlags.PMDriverCallWait) + { + wakeup = true; + } + + PM_UNLOCK(); + + if (wakeup) + PM_LOCK_WAKEUP(&fPMDriverCallQueue); +} + +void IOService::waitForPMDriverCall( IOService * target ) +{ + const IOPMDriverCallEntry * entry; + thread_t thread = current_thread(); + AbsoluteTime deadline; + int waitResult; + bool log = true; + bool wait; + + do { + wait = false; + queue_iterate(&fPMDriverCallQueue, entry, const IOPMDriverCallEntry *, link) + { + // Target of interested driver call + if (target && (target != entry->target)) + continue; + + if (entry->thread == thread) + { + if (log) + { + PM_LOG("%s: %s(%s) on PM thread\n", + fName, __FUNCTION__, target ? target->getName() : ""); + OSReportWithBacktrace("%s: %s(%s) on PM thread\n", + fName, __FUNCTION__, target ? target->getName() : ""); + log = false; + } + continue; + } + + wait = true; + break; + } + + if (wait) + { + fLockedFlags.PMDriverCallWait = true; + clock_interval_to_deadline(15, kSecondScale, &deadline); + waitResult = PM_LOCK_SLEEP(&fPMDriverCallQueue, deadline); + fLockedFlags.PMDriverCallWait = false; + if (THREAD_TIMED_OUT == waitResult) + { + PM_ERROR("%s: waitForPMDriverCall timeout\n", fName); + wait = false; + } + } + } while (wait); +} + +//********************************************************************************* +// [private] Debug helpers +//********************************************************************************* + +const char * IOService::getIOMessageString( uint32_t msg ) +{ +#define MSG_ENTRY(x) {(int) x, #x} + + static const IONamedValue msgNames[] = { + MSG_ENTRY( kIOMessageCanDevicePowerOff ), + MSG_ENTRY( kIOMessageDeviceWillPowerOff ), + MSG_ENTRY( kIOMessageDeviceWillNotPowerOff ), + MSG_ENTRY( kIOMessageDeviceHasPoweredOn ), + MSG_ENTRY( kIOMessageCanSystemPowerOff ), + MSG_ENTRY( kIOMessageSystemWillPowerOff ), + MSG_ENTRY( kIOMessageSystemWillNotPowerOff ), + MSG_ENTRY( kIOMessageCanSystemSleep ), + MSG_ENTRY( kIOMessageSystemWillSleep ), + MSG_ENTRY( kIOMessageSystemWillNotSleep ), + MSG_ENTRY( kIOMessageSystemHasPoweredOn ), + MSG_ENTRY( kIOMessageSystemWillRestart ), + MSG_ENTRY( kIOMessageSystemWillPowerOn ), + MSG_ENTRY( kIOMessageSystemCapabilityChange ), + MSG_ENTRY( kIOPMMessageLastCallBeforeSleep ) + }; + + return IOFindNameForValue(msg, msgNames); +} + + +// MARK: - +// MARK: IOPMRequest + +//********************************************************************************* +// IOPMRequest Class +// +// Requests from PM clients, and also used for inter-object messaging within PM. +//********************************************************************************* + +OSDefineMetaClassAndStructors( IOPMRequest, IOCommand ); + +IOPMRequest * IOPMRequest::create( void ) +{ + IOPMRequest * me = OSTypeAlloc(IOPMRequest); + if (me && !me->init(0, kIOPMRequestTypeInvalid)) { - IOLockUnlock(priv->flags_lock); + me->release(); + me = 0; + } + return me; +} + +bool IOPMRequest::init( IOService * target, IOOptionBits type ) +{ + if (!IOCommand::init()) return false; + + fRequestType = type; + fTarget = target; + + if (fTarget) + fTarget->retain(); + + // Root node and root domain requests does not prevent the power tree from + // becoming quiescent. + + fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) && + (fTarget != IOService::getPMRootDomain())); + + return true; +} + +void IOPMRequest::reset( void ) +{ + assert( fWorkWaitCount == 0 ); + assert( fFreeWaitCount == 0 ); + + detachNextRequest(); + detachRootRequest(); + + if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree)) + { + // Call the completion on PM work loop context + fCompletionAction(fCompletionTarget, fCompletionParam); + fCompletionAction = 0; } - - if ( ((OSBoolean *)theFlag)->isFalse() ) + + fRequestType = kIOPMRequestTypeInvalid; + + if (fTarget) { - aBool = OSBoolean::withBoolean(true); - pm_vars->responseFlags->replaceObject(ordinalComponent,aBool); - aBool->release(); + fTarget->release(); + fTarget = 0; } - - IOLockUnlock(priv->flags_lock); - return true; } - -// ********************************************************************************** -// allowPowerChange -// -// Our power state is about to lower, and we have notified applications -// and kernel clients, and one of them has acknowledged. If this is the last to do -// so, and all acknowledgements are positive, we continue with the power change. -// -// We serialize this processing with timer expiration with a command gate on the -// power management workloop, which the timer expiration is command gated to as well. -// ********************************************************************************** -IOReturn IOService::allowPowerChange ( unsigned long refcon ) +bool IOPMRequest::attachNextRequest( IOPMRequest * next ) { - if ( ! initialized ) - { - // we're unloading - return kIOReturnSuccess; + bool ok = false; + + if (!fRequestNext) + { + // Postpone the execution of the next request after + // this request. + fRequestNext = next; + fRequestNext->fWorkWaitCount++; +#if LOG_REQUEST_ATTACH + PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext), + fRequestNext->fRequestType, + (uint32_t) fRequestNext->fWorkWaitCount, + fTarget->getName()); +#endif + ok = true; } - - return pm_vars->PMcommandGate->runAction(serializedAllowPowerChange,(void *)refcon); + return ok; } - - -IOReturn serializedAllowPowerChange ( OSObject *owner, void * refcon, void *, void *, void *) + +bool IOPMRequest::detachNextRequest( void ) { - return ((IOService *)owner)->serializedAllowPowerChange2((unsigned long)refcon); + bool ok = false; + + if (fRequestNext) + { + assert(fRequestNext->fWorkWaitCount); + if (fRequestNext->fWorkWaitCount) + fRequestNext->fWorkWaitCount--; +#if LOG_REQUEST_ATTACH + PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext), + fRequestNext->fRequestType, + (uint32_t) fRequestNext->fWorkWaitCount, + fTarget->getName()); +#endif + fRequestNext = 0; + ok = true; + } + return ok; } -IOReturn IOService::serializedAllowPowerChange2 ( unsigned long refcon ) +bool IOPMRequest::attachRootRequest( IOPMRequest * root ) { - // response valid? - if ( ! responseValid(refcon) ) - { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr5,refcon,0); - // no, just return - return kIOReturnSuccess; + bool ok = false; + + if (!fRequestRoot) + { + // Delay the completion of the root request after + // this request. + fRequestRoot = root; + fRequestRoot->fFreeWaitCount++; +#if LOG_REQUEST_ATTACH + PM_LOG("Attached root: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot), + (uint32_t) fRequestRoot->fType, + (uint32_t) fRequestRoot->fFreeWaitCount, + fTarget->getName()); +#endif + ok = true; } - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientAcknowledge,refcon,0); + return ok; +} - return allowCancelCommon(); +bool IOPMRequest::detachRootRequest( void ) +{ + bool ok = false; + + if (fRequestRoot) + { + assert(fRequestRoot->fFreeWaitCount); + if (fRequestRoot->fFreeWaitCount) + fRequestRoot->fFreeWaitCount--; +#if LOG_REQUEST_ATTACH + PM_LOG("Detached root: %p [0x%x] -> %p [0x%x, %u] %s\n", + OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot), + (uint32_t) fRequestRoot->fType, + (uint32_t) fRequestRoot->fFreeWaitCount, + fTarget->getName()); +#endif + fRequestRoot = 0; + ok = true; + } + return ok; } +// MARK: - +// MARK: IOPMRequestQueue -// ********************************************************************************** -// cancelPowerChange -// -// Our power state is about to lower, and we have notified applications -// and kernel clients, and one of them has vetoed the change. If this is the last -// client to respond, we abandon the power change. +//********************************************************************************* +// IOPMRequestQueue Class // -// We serialize this processing with timer expiration with a command gate on the -// power management workloop, which the timer expiration is command gated to as well. -// ********************************************************************************** -IOReturn IOService::cancelPowerChange ( unsigned long refcon ) +// Global queues. Queues are created once and never released. +//********************************************************************************* + +OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource ); + +IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction ) { - if ( ! initialized ) + IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue); + if (me && !me->init(inOwner, inAction)) { - // we're unloading - return kIOReturnSuccess; + me->release(); + me = 0; } - - return pm_vars->PMcommandGate->runAction(serializedCancelPowerChange,(void *)refcon); + return me; } - - -IOReturn serializedCancelPowerChange ( OSObject *owner, void * refcon, void *, void *, void *) + +bool IOPMRequestQueue::init( IOService * inOwner, Action inAction ) { - return ((IOService *)owner)->serializedCancelPowerChange2((unsigned long)refcon); + if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) + return false; + + queue_init(&fQueue); + fLock = IOLockAlloc(); + return (fLock != 0); } -IOReturn IOService::serializedCancelPowerChange2 ( unsigned long refcon ) +void IOPMRequestQueue::free( void ) { - // response valid? - if ( ! responseValid(refcon) ) + if (fLock) { - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr5,refcon,0); - // no, just return - return kIOReturnSuccess; + IOLockFree(fLock); + fLock = 0; } - pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientCancel,refcon,0); - - pm_vars->doNotPowerDown = true; - - return allowCancelCommon(); + return IOEventSource::free(); } +void IOPMRequestQueue::queuePMRequest( IOPMRequest * request ) +{ + assert(request); + IOLockLock(fLock); + queue_enter(&fQueue, request, typeof(request), fCommandChain); + IOLockUnlock(fLock); + if (workLoop) signalWorkAvailable(); +} -// ********************************************************************************** -// allowCancelCommon -// -// ********************************************************************************** -IOReturn IOService::allowCancelCommon ( void ) +void +IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count ) { - if (! acquire_lock() ) + IOPMRequest * next; + + assert(requests && count); + IOLockLock(fLock); + while (count--) { - return kIOReturnSuccess; + next = *requests; + requests++; + queue_enter(&fQueue, next, typeof(next), fCommandChain); } + IOLockUnlock(fLock); + if (workLoop) signalWorkAvailable(); +} + +bool IOPMRequestQueue::checkForWork( void ) +{ + Action dqAction = (Action) action; + IOPMRequest * request; + IOService * target; + int dequeueCount = 0; + bool more = false; - // is this the last response? - if ( checkForDone() ) + IOLockLock( fLock ); + + while (!queue_empty(&fQueue)) { - // yes, stop the timer - stop_ack_timer(); - IOUnlock(priv->our_lock); - IOLockLock(priv->flags_lock); - if ( pm_vars->responseFlags ) + if (dequeueCount++ >= kMaxDequeueCount) { - pm_vars->responseFlags->release(); - pm_vars->responseFlags = NULL; - } - IOLockUnlock(priv->flags_lock); - switch (priv->machine_state) { - case kIOPM_OurChangeTellClientsPowerDown: - // our change, was it vetoed? - if ( ! pm_vars->doNotPowerDown ) - { - // no, we can continue - OurChangeTellClientsPowerDown(); - } else { - // yes, rescind the warning - tellNoChangeDown(priv->head_note_state); - // mark the change note un-actioned - priv->head_note_flags |= IOPMNotDone; - - // and we're done - all_done(); - } - break; - case kIOPM_OurChangeTellPriorityClientsPowerDown: - OurChangeTellPriorityClientsPowerDown(); - break; - case kIOPM_OurChangeNotifyInterestedDriversWillChange: - // our change, continue - OurChangeNotifyInterestedDriversWillChange(); - break; - case kIOPM_ParentDownTellPriorityClientsPowerDown_Immediate: - // parent change, continue - ParentDownTellPriorityClientsPowerDown_Delayed(); - break; - case kIOPM_ParentDownNotifyInterestedDriversWillChange_Delayed: - // parent change, continue - ParentDownNotifyInterestedDriversWillChange_Delayed(); - break; + // Allow other queues a chance to work + more = true; + break; } - } else { - // not done yet - IOUnlock(priv->our_lock); + + queue_remove_first(&fQueue, request, typeof(request), fCommandChain); + IOLockUnlock(fLock); + target = request->getTarget(); + assert(target); + more |= (*dqAction)( target, request, this ); + IOLockLock( fLock ); } - return kIOReturnSuccess; + IOLockUnlock( fLock ); + return more; } +// MARK: - +// MARK: IOPMWorkQueue -#if 0 //********************************************************************************* -// c_PM_clamp_Timer_Expired (C Func) +// IOPMWorkQueue Class // -// Called when our clamp timer expires...we will call the object method. +// Queue of IOServicePM objects, each with a queue of IOPMRequest sharing the +// same target. //********************************************************************************* -static void c_PM_Clamp_Timer_Expired (OSObject * client, IOTimerEventSource *) +OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource ); + +IOPMWorkQueue * +IOPMWorkQueue::create( IOService * inOwner, Action invoke, Action retire ) { - if (client) - ((IOService *)client)->PM_Clamp_Timer_Expired (); + IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue); + if (me && !me->init(inOwner, invoke, retire)) + { + me->release(); + me = 0; + } + return me; } -#endif +bool IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire ) +{ + if (!invoke || !retire || + !IOEventSource::init(inOwner, (IOEventSourceAction)0)) + return false; -//********************************************************************************* -// PM_Clamp_Timer_Expired -// -// called when clamp timer expires...set power state to 0. -//********************************************************************************* + queue_init(&fWorkQueue); + + fInvokeAction = invoke; + fRetireAction = retire; + fConsumerCount = fProducerCount = 0; -void IOService::PM_Clamp_Timer_Expired (void) + return true; +} + +bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt ) { -#if 0 - if ( ! initialized ) + queue_head_t * requestQueue; + bool more = false; + bool empty; + + assert( request ); + assert( pwrMgt ); + assert( onThread() ); + assert( queue_next(&request->fCommandChain) == + queue_prev(&request->fCommandChain) ); + + gIOPMBusyRequestCount++; + + if (request->isQuiesceType()) { - // we're unloading - return; + 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); } - changePowerStateToPriv (0); -#endif -} + // 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. -//****************************************************************************** -// clampPowerOn -// -// Set to highest available power state for a minimum of duration milliseconds -//****************************************************************************** + requestQueue = &pwrMgt->RequestHead; + empty = queue_empty(requestQueue); + queue_enter(requestQueue, request, typeof(request), fCommandChain); + if (empty) + { + more = checkRequestQueue(requestQueue, &empty); + if (!empty) + { + // Request just added is blocked, add its target IOServicePM + // to the work queue. + assert( queue_next(&pwrMgt->WorkChain) == + queue_prev(&pwrMgt->WorkChain) ); + + queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain); + fQueueLength++; + PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n", + fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt)); + } + } -#define kFiveMinutesInNanoSeconds (300 * NSEC_PER_SEC) + return more; +} -void IOService::clampPowerOn (unsigned long duration) +bool IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty ) { -#if 0 - changePowerStateToPriv (pm_vars->theNumberOfPowerStates-1); + IOPMRequest * request; + IOService * target; + bool more = false; + bool done = false; + + assert(!queue_empty(requestQueue)); + do { + request = (typeof(request)) queue_first(requestQueue); + if (request->isWorkBlocked()) + break; // request dispatch blocked on attached request + + target = request->getTarget(); + if (fInvokeAction) + { + done = (*fInvokeAction)( target, request, this ); + } + else + { + PM_LOG("PM request 0x%x dropped\n", request->getType()); + done = true; + } + if (!done) + break; // PM state machine blocked - if ( priv->clampTimerEventSrc == NULL ) { - priv->clampTimerEventSrc = IOTimerEventSource::timerEventSource(this, - c_PM_Clamp_Timer_Expired); + assert(gIOPMBusyRequestCount > 0); + if (gIOPMBusyRequestCount) + gIOPMBusyRequestCount--; + + if (request == fQuiesceRequest) + { + fQuiesceRequest = 0; + } - IOWorkLoop * workLoop = getPMworkloop (); + queue_remove_first(requestQueue, request, typeof(request), fCommandChain); + more |= (*fRetireAction)( target, request, this ); + done = queue_empty(requestQueue); + } while (!done); - if ( !priv->clampTimerEventSrc || !workLoop || - ( workLoop->addEventSource( priv->clampTimerEventSrc) != kIOReturnSuccess) ) { + *empty = done; + if (more) + { + // Retired a request that may unblock a previously visited request + // that is still waiting on the work queue. Must trigger another + // queue check. + fProducerCount++; } - } - priv->clampTimerEventSrc->setTimeout(300*USEC_PER_SEC, USEC_PER_SEC); -#endif + return more; } -//********************************************************************************* -// setPowerState -// -// Does nothing here. This should be implemented in a subclass driver. -//********************************************************************************* - -IOReturn IOService::setPowerState ( unsigned long powerStateOrdinal, IOService* whatDevice ) +bool IOPMWorkQueue::checkForWork( void ) { - return IOPMNoErr; -} + IOServicePM * entry; + IOServicePM * next; + bool more = false; + bool empty; +#if WORK_QUEUE_STATS + fStatCheckForWork++; +#endif -//********************************************************************************* -// 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. -//********************************************************************************* + // Iterate over all IOServicePM entries in the work queue, + // and check each entry's request queue. -unsigned long IOService::maxCapabilityForDomainState ( IOPMPowerFlags domainState ) -{ - int i; + while (fConsumerCount != fProducerCount) + { + PM_LOG3("IOPMWorkQueue: checkForWork %u %u\n", + fProducerCount, fConsumerCount); - if (pm_vars->theNumberOfPowerStates == 0 ) - { - return 0; - } - for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) - { - if ( (domainState & pm_vars->thePowerStates[i].inputPowerRequirement) == pm_vars->thePowerStates[i].inputPowerRequirement ) - { - return i; - } - } - return 0; -} + fConsumerCount = fProducerCount; +#if WORK_QUEUE_STATS + if (queue_empty(&fWorkQueue)) + { + fStatQueueEmpty++; + break; + } + fStatScanEntries++; + uint32_t cachedWorkCount = gIOPMWorkInvokeCount; +#endif -//********************************************************************************* -// 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. -//********************************************************************************* + __IGNORE_WCASTALIGN(entry = (typeof(entry)) queue_first(&fWorkQueue)); + while (!queue_end(&fWorkQueue, (queue_entry_t) entry)) + { + more |= checkRequestQueue(&entry->RequestHead, &empty); -unsigned long IOService::initialPowerStateForDomainState ( IOPMPowerFlags domainState ) -{ - int i; + // Get next entry, points to head if current entry is last. + __IGNORE_WCASTALIGN(next = (typeof(next)) queue_next(&entry->WorkChain)); - if (pm_vars->theNumberOfPowerStates == 0 ) - { - return 0; - } - for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) - { - if ( (domainState & pm_vars->thePowerStates[i].inputPowerRequirement) == pm_vars->thePowerStates[i].inputPowerRequirement ) - { - return i; + // if request queue is empty, remove IOServicePM from work queue. + if (empty) + { + assert(fQueueLength); + if (fQueueLength) fQueueLength--; + PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n", + fQueueLength, entry->Name, OBFUSCATE(entry)); + queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain); + } + entry = next; } + +#if WORK_QUEUE_STATS + if (cachedWorkCount == gIOPMWorkInvokeCount) + fStatNoWorkDone++; +#endif } - return 0; + + return more; } +void IOPMWorkQueue::signalWorkAvailable( void ) +{ + fProducerCount++; + IOEventSource::signalWorkAvailable(); +} -//********************************************************************************* -// powerStateForDomainState -// -// 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. -//********************************************************************************* +void IOPMWorkQueue::incrementProducerCount( void ) +{ + fProducerCount++; +} -unsigned long IOService::powerStateForDomainState ( IOPMPowerFlags domainState ) +void IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest ) { - int i; + IOServicePM * entry; + IOPMRequest * request; - if (pm_vars->theNumberOfPowerStates == 0 ) + if (queue_empty(&fWorkQueue)) { - return 0; + return; } - for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) + + queue_iterate(&fWorkQueue, entry, typeof(entry), WorkChain) { - if ( (domainState & pm_vars->thePowerStates[i].inputPowerRequirement) == pm_vars->thePowerStates[i].inputPowerRequirement ) + queue_iterate(&entry->RequestHead, request, typeof(request), fCommandChain) { - return i; + // 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); + } } } - return 0; } - -//********************************************************************************* -// didYouWakeSystem -// -// Does nothing here. This should be implemented in a subclass driver. -//********************************************************************************* - -bool IOService::didYouWakeSystem ( void ) +void IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest ) { - return false; + if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) && + (fQuiesceStartTime != 0)) + { + fInvokeAction = 0; + fQuiesceFinishTime = mach_absolute_time(); + } } +// MARK: - +// MARK: IOPMCompletionQueue //********************************************************************************* -// powerStateWillChangeTo -// -// Does nothing here. This should be implemented in a subclass driver. +// IOPMCompletionQueue Class //********************************************************************************* -IOReturn IOService::powerStateWillChangeTo ( IOPMPowerFlags, unsigned long, IOService*) +OSDefineMetaClassAndStructors( IOPMCompletionQueue, IOEventSource ); + +IOPMCompletionQueue * +IOPMCompletionQueue::create( IOService * inOwner, Action inAction ) { - return 0; + 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)) + return false; -//********************************************************************************* -// powerStateDidChangeTo -// -// Does nothing here. This should be implemented in a subclass driver. -//********************************************************************************* + queue_init(&fQueue); + return true; +} -IOReturn IOService::powerStateDidChangeTo ( IOPMPowerFlags, unsigned long, IOService*) +bool IOPMCompletionQueue::queuePMRequest( IOPMRequest * request ) { - return 0; + bool more; + + assert(request); + // unblock dependent request + more = request->detachNextRequest(); + 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; -//********************************************************************************* -// powerChangeDone -// -// Does nothing here. This should be implemented in a subclass policy-maker. -//********************************************************************************* + request = (typeof(request)) queue_first(&fQueue); + while (!queue_end(&fQueue, (queue_entry_t) request)) + { + next = (typeof(next)) queue_next(&request->fCommandChain); + if (!request->isFreeBlocked()) + { + queue_remove(&fQueue, request, typeof(request), fCommandChain); + target = request->getTarget(); + assert(target); + more |= (*dqAction)( target, request, this ); + } + request = next; + } -void IOService::powerChangeDone ( unsigned long ) -{ + return more; } +// MARK: - +// MARK: IOServicePM + +OSDefineMetaClassAndStructors(IOServicePM, OSObject) //********************************************************************************* -// newTemperature +// serialize // -// Does nothing here. This should be implemented in a subclass driver. +// Serialize IOServicePM for debugging. //********************************************************************************* -IOReturn IOService::newTemperature ( long currentTemp, IOService * whichZone ) - +static void +setPMProperty( OSDictionary * dict, const char * key, uint64_t value ) { - return IOPMNoErr; + OSNumber * num = OSNumber::withNumber(value, sizeof(value) * 8); + if (num) + { + dict->setObject(key, num); + num->release(); + } } +IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) const +{ + OSDictionary * dict; + bool ok = false; + int powerClamp = -1; + int dictSize = 6; -#undef super -#define super OSObject + if (IdleTimerPeriod) + dictSize += 4; -OSDefineMetaClassAndStructors(IOPMprot, OSObject) -//********************************************************************************* -// serialize -// -// Serialize protected instance variables for debug output. -//********************************************************************************* -bool IOPMprot::serialize(OSSerialize *s) const -{ - OSString * theOSString; - char * buffer; - char * ptr; - int buf_size; - int i; - bool rtn_code; + if (PMActions.parameter & kPMActionsFlagLimitPower) + { + dictSize += 1; + powerClamp = 0; + if (PMActions.parameter & + (kPMActionsFlagIsDisplayWrangler | kPMActionsFlagIsGraphicsDevice)) + powerClamp++; + } - // estimate how many bytes we need to present all power states - buf_size = 150 // beginning and end of string - + (275 * (int)theNumberOfPowerStates) // size per state - + 100; // extra room just for kicks +#if WORK_QUEUE_STATS + if (gIOPMRootNode == ControllingDriver) + dictSize += 4; +#endif - buffer = ptr = IONew(char, buf_size); - if(!buffer) - return false; + if (PowerClients) + dict = OSDictionary::withDictionary( + PowerClients, PowerClients->getCount() + dictSize); + else + dict = OSDictionary::withCapacity(dictSize); + + if (dict) + { + setPMProperty(dict, "CurrentPowerState", CurrentPowerState); + setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags); + if (NumberOfPowerStates) + setPMProperty(dict, "MaxPowerState", NumberOfPowerStates-1); + if (DesiredPowerState != CurrentPowerState) + setPMProperty(dict, "DesiredPowerState", DesiredPowerState); + if (kIOPM_Finished != MachineState) + setPMProperty(dict, "MachineState", MachineState); + if (DeviceOverrideEnabled) + dict->setObject("PowerOverrideOn", kOSBooleanTrue); + if (powerClamp >= 0) + setPMProperty(dict, "PowerClamp", powerClamp); + + if (IdleTimerPeriod) + { + AbsoluteTime now; + AbsoluteTime delta; + uint64_t nsecs; - ptr += sprintf(ptr,"{ theNumberOfPowerStates = %d, ",(unsigned int)theNumberOfPowerStates); + clock_get_uptime(&now); - if ( theNumberOfPowerStates != 0 ) { - ptr += sprintf(ptr,"version %d, ",(unsigned int)thePowerStates[0].version); - } + // The idle timer period in milliseconds + setPMProperty(dict, "IdleTimerPeriod", NextIdleTimerPeriod * 1000ULL); - if ( theNumberOfPowerStates != 0 ) { - for ( i = 0; i < (int)theNumberOfPowerStates; i++ ) { - ptr += sprintf(ptr, "power state %d = { ",i); - ptr += sprintf(ptr,"capabilityFlags %08x, ",(unsigned int)thePowerStates[i].capabilityFlags); - ptr += sprintf(ptr,"outputPowerCharacter %08x, ",(unsigned int)thePowerStates[i].outputPowerCharacter); - ptr += sprintf(ptr,"inputPowerRequirement %08x, ",(unsigned int)thePowerStates[i].inputPowerRequirement); - ptr += sprintf(ptr,"staticPower %d, ",(unsigned int)thePowerStates[i].staticPower); - ptr += sprintf(ptr,"unbudgetedPower %d, ",(unsigned int)thePowerStates[i].unbudgetedPower); - ptr += sprintf(ptr,"powerToAttain %d, ",(unsigned int)thePowerStates[i].powerToAttain); - ptr += sprintf(ptr,"timeToAttain %d, ",(unsigned int)thePowerStates[i].timeToAttain); - ptr += sprintf(ptr,"settleUpTime %d, ",(unsigned int)thePowerStates[i].settleUpTime); - ptr += sprintf(ptr,"timeToLower %d, ",(unsigned int)thePowerStates[i].timeToLower); - ptr += sprintf(ptr,"settleDownTime %d, ",(unsigned int)thePowerStates[i].settleDownTime); - ptr += sprintf(ptr,"powerDomainBudget %d }, ",(unsigned int)thePowerStates[i].powerDomainBudget); - } - } + // Number of tickles since the last idle timer expiration + setPMProperty(dict, "ActivityTickles", ActivityTickleCount); - ptr += sprintf(ptr,"aggressiveness = %d, ",(unsigned int)aggressiveness); - ptr += sprintf(ptr,"myCurrentState = %d, ",(unsigned int)myCurrentState); - ptr += sprintf(ptr,"parentsCurrentPowerFlags = %08x, ",(unsigned int)parentsCurrentPowerFlags); - ptr += sprintf(ptr,"maxCapability = %d }",(unsigned int)maxCapability); + if (AbsoluteTime_to_scalar(&DeviceActiveTimestamp)) + { + // Milliseconds since the last activity tickle + delta = now; + SUB_ABSOLUTETIME(&delta, &DeviceActiveTimestamp); + absolutetime_to_nanoseconds(delta, &nsecs); + setPMProperty(dict, "TimeSinceLastTickle", NS_TO_MS(nsecs)); + } - theOSString = OSString::withCString(buffer); - rtn_code = theOSString->serialize(s); - theOSString->release(); - IODelete(buffer, char, buf_size); + if (!IdleTimerStopped && AbsoluteTime_to_scalar(&IdleTimerStartTime)) + { + // Idle timer elapsed time in milliseconds + delta = now; + SUB_ABSOLUTETIME(&delta, &IdleTimerStartTime); + absolutetime_to_nanoseconds(delta, &nsecs); + setPMProperty(dict, "IdleTimerElapsedTime", NS_TO_MS(nsecs)); + } + } - return rtn_code; -} +#if WORK_QUEUE_STATS + if (gIOPMRootNode == Owner) + { + setPMProperty(dict, "WQ-CheckForWork", + gIOPMWorkQueue->fStatCheckForWork); + setPMProperty(dict, "WQ-ScanEntries", + gIOPMWorkQueue->fStatScanEntries); + setPMProperty(dict, "WQ-QueueEmpty", + gIOPMWorkQueue->fStatQueueEmpty); + setPMProperty(dict, "WQ-NoWorkDone", + gIOPMWorkQueue->fStatNoWorkDone); + } +#endif + if (HasAdvisoryDesire && !gIOPMAdvisoryTickleEnabled) + { + // Don't report advisory tickle when it has no influence + dict->removeObject(gIOPMPowerClientAdvisoryTickle); + } -#undef super -#define super OSObject + ok = dict->serialize(s); + dict->release(); + } -OSDefineMetaClassAndStructors(IOPMpriv, OSObject) -//********************************************************************************* -// serialize -// -// Serialize private instance variables for debug output. -//********************************************************************************* -bool IOPMpriv::serialize(OSSerialize *s) const -{ - OSString * theOSString; - bool rtn_code; - char * buffer; - char * ptr; - IOPMinformee * nextObject; + return (ok ? kIOReturnSuccess : kIOReturnNoMemory); +} - buffer = ptr = IONew(char, 2000); - if(!buffer) - return false; +bool IOServicePM::serialize( OSSerialize * s ) const +{ + IOReturn ret = kIOReturnNotReady; - ptr += sprintf(ptr,"{ this object = %08x",(unsigned int)owner); - if ( we_are_root ) { - ptr += sprintf(ptr," (root)"); + 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); } - ptr += sprintf(ptr,", "); - - nextObject = interestedDrivers->firstInList(); // display interested drivers - while ( nextObject != NULL ) { - ptr += sprintf(ptr,"interested driver = %08x, ",(unsigned int)nextObject->whatObject); - nextObject = interestedDrivers->nextInList(nextObject); + else if (gIOPMWorkLoop) + { + ret = gIOPMWorkLoop->runAction( + OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize), + (OSObject *) this, (void *) s); } - if ( machine_state != kIOPM_Finished ) { - ptr += sprintf(ptr,"machine_state = %d, ",(unsigned int)machine_state); - ptr += sprintf(ptr,"driver_timer = %d, ",(unsigned int)driver_timer); - ptr += sprintf(ptr,"settle_time = %d, ",(unsigned int)settle_time); - ptr += sprintf(ptr,"head_note_flags = %08x, ",(unsigned int)head_note_flags); - ptr += sprintf(ptr,"head_note_state = %d, ",(unsigned int)head_note_state); - ptr += sprintf(ptr,"head_note_outputFlags = %08x, ",(unsigned int)head_note_outputFlags); - ptr += sprintf(ptr,"head_note_domainState = %08x, ",(unsigned int)head_note_domainState); - ptr += sprintf(ptr,"head_note_capabilityFlags = %08x, ",(unsigned int)head_note_capabilityFlags); - ptr += sprintf(ptr,"head_note_pendingAcks = %d, ",(unsigned int)head_note_pendingAcks); - } + return (kIOReturnSuccess == ret); +} - if ( device_overrides ) { - ptr += sprintf(ptr,"device overrides, "); - } - ptr += sprintf(ptr,"driverDesire = %d, ",(unsigned int)driverDesire); - ptr += sprintf(ptr,"deviceDesire = %d, ",(unsigned int)deviceDesire); - ptr += sprintf(ptr,"ourDesiredPowerState = %d, ",(unsigned int)ourDesiredPowerState); - ptr += sprintf(ptr,"previousRequest = %d }",(unsigned int)previousRequest); +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, + uint32_t eventFunc, + uintptr_t param1, + uintptr_t param2 ) const +{ + uintptr_t nameAsArg = 0; + + assert(event < KDBG_CODE_MAX); + assert((eventFunc & ~KDBG_FUNC_MASK) == 0); - theOSString = OSString::withCString(buffer); - rtn_code = theOSString->serialize(s); - theOSString->release(); - IODelete(buffer, char, 2000); + // Copy the first characters of the name into an uintptr_t. + // NULL termination is not required. + strncpy((char*)&nameAsArg, Name, sizeof(nameAsArg)); - return rtn_code; + IOTimeStampConstant(IODBG_POWER(event) | eventFunc, nameAsArg, (uintptr_t)Owner->getRegistryEntryID(), (uintptr_t)(OBFUSCATE(param1)), (uintptr_t)(OBFUSCATE(param2))); }