* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
-//#undef IOASSERT
-//#define IOASSERT 1
-
#include <IOKit/assert.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOLib.h>
#include <sys/proc.h>
#include <sys/proc_internal.h>
+#include <sys/sysctl.h>
#include <libkern/OSDebug.h>
#include <kern/thread.h>
OSDefineMetaClassAndStructors(IOPMprot, OSObject)
#endif
-// Container class for recording system power events
-OSDefineMetaClassAndStructors( PMEventDetails, OSObject );
-
//******************************************************************************
// Globals
//******************************************************************************
static bool gIOPMInitialized = false;
-static uint32_t gIOPMBusyCount = 0;
-static uint32_t gIOPMWorkCount = 0;
+static 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 * gIOPMFreeQueue = 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;
static const OSSymbol * gIOPMPowerClientAdvisoryTickle = 0;
static bool gIOPMAdvisoryTickleEnabled = true;
static thread_t gIOPMWatchDogThread = NULL;
+uint32_t gCanSleepTimeout = 0;
static uint32_t getPMRequestType( void )
{
uint32_t type = kIOPMRequestTypeInvalid;
- if (gIOPMRequest)
+ if (gIOPMRequest)
type = gIOPMRequest->getType();
return type;
}
return tag;
}
+SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gCanSleepTimeout, 0, "Power Management Timeout");
+
//******************************************************************************
// Macros
//******************************************************************************
-#define OBFUSCATE(x) ((void *)(VM_KERNEL_ADDRPERM(x)))
-
#define PM_ERROR(x...) do { kprintf(x);IOLog(x); \
- IOService::getPMRootDomain()->sleepWakeDebugLog(x); \
} while (false)
#define PM_LOG(x...) do { kprintf(x); } while (false)
if ((kIOLogPMRootDomain & gIOKitDebug) && \
(getPMRootDomain() == this)) { \
kprintf("PMRD: " x); \
- getPMRootDomain()->sleepWakeDebugLog(x); \
}} while (false)
#define PM_ASSERT_IN_GATE(x) \
do { \
#define PM_LOCK_SLEEP(event, dl) IOLockSleepDeadline(fPMLock, event, dl, THREAD_UNINT)
#define PM_LOCK_WAKEUP(event) IOLockWakeup(fPMLock, event, false)
+#define us_per_s 1000000
#define ns_per_us 1000
-#define k30Seconds (30*1000000)
+#define k30Seconds (30*us_per_s)
+#define k5Seconds ( 5*us_per_s)
+#define kCanSleepMaxTimeReq k30Seconds
+#define kMaxTimeRequested k30Seconds
#define kMinAckTimeoutTicks (10*1000000)
#define kIOPMTardyAckSPSKey "IOPMTardyAckSetPowerState"
#define kIOPMTardyAckPSCKey "IOPMTardyAckPowerStateChange"
#define 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):
} while (false)
static OSNumber * copyClientIDForNotification(
- OSObject *object,
+ OSObject *object,
IOPMInterestContext *context);
static void logClientIDForNotification(
OSObject *object,
- IOPMInterestContext *context,
+ IOPMInterestContext *context,
const char *logString);
//*********************************************************************************
void IOService::PMinit( void )
{
if ( !initialized )
- {
- if ( !gIOPMInitialized )
- {
+ {
+ if ( !gIOPMInitialized )
+ {
gPlatform = getPlatform();
gIOPMWorkLoop = IOWorkLoop::workLoop();
if (gIOPMWorkLoop)
{
gIOPMRequestQueue = IOPMRequestQueue::create(
this, OSMemberFunctionCast(IOPMRequestQueue::Action,
- this, &IOService::servicePMRequestQueue));
+ this, &IOService::actionPMRequestQueue));
gIOPMReplyQueue = IOPMRequestQueue::create(
this, OSMemberFunctionCast(IOPMRequestQueue::Action,
- this, &IOService::servicePMReplyQueue));
+ this, &IOService::actionPMReplyQueue));
- gIOPMWorkQueue = IOPMWorkQueue::create(
- this,
+ gIOPMWorkQueue = IOPMWorkQueue::create(this,
OSMemberFunctionCast(IOPMWorkQueue::Action, this,
- &IOService::servicePMRequest),
+ &IOService::actionPMWorkQueueInvoke),
OSMemberFunctionCast(IOPMWorkQueue::Action, this,
- &IOService::retirePMRequest));
+ &IOService::actionPMWorkQueueRetire));
- gIOPMFreeQueue = IOPMCompletionQueue::create(
+ gIOPMCompletionQueue = IOPMCompletionQueue::create(
this, OSMemberFunctionCast(IOPMCompletionQueue::Action,
- this, &IOService::servicePMFreeQueue));
+ this, &IOService::actionPMCompletionQueue));
if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) !=
kIOReturnSuccess)
gIOPMWorkQueue = 0;
}
- if (gIOPMWorkLoop->addEventSource(gIOPMFreeQueue) !=
+ // Must be added after the work queue, which pushes request
+ // to the completion queue without signaling the work loop.
+ if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) !=
kIOReturnSuccess)
{
- gIOPMFreeQueue->release();
- gIOPMFreeQueue = 0;
+ gIOPMCompletionQueue->release();
+ gIOPMCompletionQueue = 0;
}
gIOPMPowerClientDevice =
gIOPMPowerClientRootDomain =
OSSymbol::withCStringNoCopy( "RootDomainPower" );
+
+ gIOSpinDumpKextName[0] = '\0';
+ gIOSpinDumpDelayType[0] = '\0';
}
- if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMFreeQueue)
+ if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue)
gIOPMInitialized = true;
}
if (!gIOPMInitialized)
}
fAckTimer = thread_call_allocate(
- &IOService::ack_timer_expired, (thread_call_param_t)this);
+ &IOService::ack_timer_expired, (thread_call_param_t)this);
fSettleTimer = thread_call_allocate(
- &settle_timer_expired, (thread_call_param_t)this);
+ &settle_timer_expired, (thread_call_param_t)this);
fIdleTimer = thread_call_allocate(
&idle_timer_expired, (thread_call_param_t)this);
fDriverCallEntry = thread_call_allocate(
- (thread_call_func_t) &IOService::pmDriverCallout, this);
+ (thread_call_func_t) &IOService::pmDriverCallout, this);
assert(fDriverCallEntry);
+ if (kIOKextSpinDump & gIOKitDebug)
+ {
+ fSpinDumpTimer = thread_call_allocate(
+ &IOService::spindump_timer_expired, (thread_call_param_t)this);
+ }
// Check for powerChangeDone override.
if (OSMemberFunctionCast(void (*)(void),
- getResourceService(), &IOService::powerChangeDone) !=
- OSMemberFunctionCast(void (*)(void),
- this, &IOService::powerChangeDone))
+ getResourceService(), &IOService::powerChangeDone) !=
+ OSMemberFunctionCast(void (*)(void),
+ this, &IOService::powerChangeDone))
{
fPCDFunctionOverride = true;
}
prot->thePlatform = gPlatform;
fPMVars = prot;
pm_vars = prot;
- }
+ }
#else
pm_vars = (void *) (uintptr_t) true;
#endif
thread_call_free(fDriverCallEntry);
fDriverCallEntry = NULL;
}
+ if ( fSpinDumpTimer ) {
+ thread_call_cancel(fSpinDumpTimer);
+ thread_call_free(fSpinDumpTimer);
+ fSpinDumpTimer = NULL;
+ }
if ( fPMLock ) {
IOLockFree(fPMLock);
fPMLock = NULL;
void IOService::handlePMstop( IOPMRequest * request )
{
OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- IOService * theChild;
- IOService * theParent;
+ OSObject * next;
+ IOPowerConnection * connection;
+ IOService * theChild;
+ IOService * theParent;
- PM_ASSERT_IN_GATE();
- PM_LOG2("%s: %p %s start\n", getName(), OBFUSCATE(this), __FUNCTION__);
+ PM_ASSERT_IN_GATE();
+ PM_LOG2("%s: %p %s start\n", getName(), OBFUSCATE(this), __FUNCTION__);
// remove driver from prevent system sleep lists
getPMRootDomain()->updatePreventIdleSleepList(this, false);
getPMRootDomain()->updatePreventSystemSleepList(this, false);
// remove the property
- removeProperty(kPwrMgtKey);
+ removeProperty(kPwrMgtKey);
// detach parents
iter = getParentIterator(gIOPowerPlane);
// detach IOConnections
detachAbove( gIOPowerPlane );
-
+
// no more power state changes
fParentsKnowState = false;
if ( fInterestedDrivers )
{
- IOPMinformeeList * list = fInterestedDrivers;
- IOPMinformee * item;
+ IOPMinformeeList * list = fInterestedDrivers;
+ IOPMinformee * item;
PM_LOCK();
while ((item = list->firstInList()))
IOReturn IOService::addPowerChild( IOService * child )
{
- IOPowerConnection * connection = 0;
- IOPMRequest * requests[3] = {0, 0, 0};
- OSIterator * iter;
- bool ok = true;
+ IOPowerConnection * connection = 0;
+ IOPMRequest * requests[3] = {0, 0, 0};
+ OSIterator * iter;
+ bool ok = true;
- if (!child)
- return kIOReturnBadArgument;
+ if (!child)
+ return kIOReturnBadArgument;
if (!initialized || !child->initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 );
- do {
- // Is this child already one of our children?
+ do {
+ // Is this child already one of our children?
+
+ iter = child->getParentIterator( gIOPowerPlane );
+ if ( iter )
+ {
+ IORegistryEntry * entry;
+ OSObject * next;
- iter = child->getParentIterator( gIOPowerPlane );
- if ( iter )
- {
- IORegistryEntry * entry;
- OSObject * next;
-
- while ((next = iter->getNextObject()))
- {
- if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
- isChild(entry, gIOPowerPlane))
- {
- ok = false;
- break;
- }
- }
- iter->release();
- }
- if (!ok)
- {
- PM_LOG("%s: %s (%p) is already a child\n",
- getName(), child->getName(), OBFUSCATE(child));
- break;
- }
+ while ((next = iter->getNextObject()))
+ {
+ if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
+ isChild(entry, gIOPowerPlane))
+ {
+ ok = false;
+ break;
+ }
+ }
+ iter->release();
+ }
+ if (!ok)
+ {
+ PM_LOG("%s: %s (%p) is already a child\n",
+ getName(), child->getName(), OBFUSCATE(child));
+ break;
+ }
- // Add the child to the power plane immediately, but the
- // joining connection is marked as not ready.
- // We want the child to appear in the power plane before
- // returning to the caller, but don't want the caller to
- // block on the PM work loop.
+ // Add the child to the power plane immediately, but the
+ // joining connection is marked as not ready.
+ // We want the child to appear in the power plane before
+ // returning to the caller, but don't want the caller to
+ // block on the PM work loop.
- connection = new IOPowerConnection;
- if (!connection)
- break;
+ connection = new IOPowerConnection;
+ if (!connection)
+ break;
- // Create a chain of PM requests to perform the bottom-half
- // work from the PM work loop.
+ // Create a chain of PM requests to perform the bottom-half
+ // work from the PM work loop.
- requests[0] = acquirePMRequest(
- /* target */ this,
- /* type */ kIOPMRequestTypeAddPowerChild1 );
+ requests[0] = acquirePMRequest(
+ /* target */ this,
+ /* type */ kIOPMRequestTypeAddPowerChild1 );
- requests[1] = acquirePMRequest(
- /* target */ child,
- /* type */ kIOPMRequestTypeAddPowerChild2 );
+ requests[1] = acquirePMRequest(
+ /* target */ child,
+ /* type */ kIOPMRequestTypeAddPowerChild2 );
- requests[2] = acquirePMRequest(
- /* target */ this,
- /* type */ kIOPMRequestTypeAddPowerChild3 );
+ requests[2] = acquirePMRequest(
+ /* target */ this,
+ /* type */ kIOPMRequestTypeAddPowerChild3 );
- if (!requests[0] || !requests[1] || !requests[2])
- break;
+ if (!requests[0] || !requests[1] || !requests[2])
+ break;
- requests[0]->attachNextRequest( requests[1] );
- requests[1]->attachNextRequest( requests[2] );
+ requests[0]->attachNextRequest( requests[1] );
+ requests[1]->attachNextRequest( requests[2] );
- connection->init();
- connection->start(this);
- connection->setAwaitingAck(false);
- connection->setReadyFlag(false);
+ connection->init();
+ connection->start(this);
+ connection->setAwaitingAck(false);
+ connection->setReadyFlag(false);
- attachToChild( connection, gIOPowerPlane );
- connection->attachToChild( child, gIOPowerPlane );
+ attachToChild( connection, gIOPowerPlane );
+ connection->attachToChild( child, gIOPowerPlane );
- // connection needs to be released
- requests[0]->fArg0 = connection;
- requests[1]->fArg0 = connection;
- requests[2]->fArg0 = connection;
+ // connection needs to be released
+ requests[0]->fArg0 = connection;
+ requests[1]->fArg0 = connection;
+ requests[2]->fArg0 = connection;
- submitPMRequest( requests, 3 );
- return kIOReturnSuccess;
- }
- while (false);
+ submitPMRequests( requests, 3 );
+ return kIOReturnSuccess;
+ }
+ while (false);
- if (connection) connection->release();
- if (requests[0]) releasePMRequest(requests[0]);
- if (requests[1]) releasePMRequest(requests[1]);
- if (requests[2]) releasePMRequest(requests[2]);
+ if (connection) connection->release();
+ if (requests[0]) releasePMRequest(requests[0]);
+ if (requests[1]) releasePMRequest(requests[1]);
+ if (requests[2]) releasePMRequest(requests[2]);
- // Silent failure, to prevent platform drivers from adding the child
- // to the root domain.
+ // Silent failure, to prevent platform drivers from adding the child
+ // to the root domain.
- return kIOReturnSuccess;
+ return kIOReturnSuccess;
}
//*********************************************************************************
void IOService::addPowerChild1( IOPMRequest * request )
{
- IOPMPowerStateIndex tempDesire = kPowerStateZero;
+ IOPMPowerStateIndex tempDesire = kPowerStateZero;
- // Make us temporary usable before adding the child.
+ // Make us temporary usable before adding the child.
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 );
- if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState)
- {
- tempDesire = fHighestPowerState;
- }
+ if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState)
+ {
+ tempDesire = fHighestPowerState;
+ }
- if ((tempDesire != kPowerStateZero) &&
+ if ((tempDesire != kPowerStateZero) &&
(IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire))))
- {
- adjustPowerState(tempDesire);
- }
+ {
+ adjustPowerState(tempDesire);
+ }
}
//*********************************************************************************
void IOService::addPowerChild2( IOPMRequest * request )
{
- IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
- IOService * parent;
- IOPMPowerFlags powerFlags;
- bool knowsState;
- unsigned long powerState;
- unsigned long tempDesire;
+ IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
+ IOService * parent;
+ IOPMPowerFlags powerFlags;
+ bool knowsState;
+ unsigned long powerState;
+ unsigned long tempDesire;
- PM_ASSERT_IN_GATE();
- parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
+ PM_ASSERT_IN_GATE();
+ parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
- if (!parent || !inPlane(gIOPowerPlane))
- {
- PM_LOG("%s: addPowerChild2 not in power plane\n", getName());
- return;
- }
+ if (!parent || !inPlane(gIOPowerPlane))
+ {
+ PM_LOG("%s: addPowerChild2 not in power plane\n", getName());
+ return;
+ }
- // Parent will be waiting for us to complete this stage.
- // It is safe to directly access parent's vars.
+ // Parent will be waiting for us to complete this stage.
+ // It is safe to directly access parent's vars.
- knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
- powerState = parent->fCurrentPowerState;
+ knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
+ powerState = parent->fCurrentPowerState;
- if (knowsState)
- powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
- else
- powerFlags = 0;
+ if (knowsState)
+ powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
+ else
+ powerFlags = 0;
- // Set our power parent.
+ // Set our power parent.
OUR_PMLog(kPMLogSetParent, knowsState, powerFlags);
- setParentInfo( powerFlags, connection, knowsState );
+ setParentInfo( powerFlags, connection, knowsState );
- connection->setReadyFlag(true);
+ connection->setReadyFlag(true);
if ( fControllingDriver && fParentsKnowState )
{
void IOService::addPowerChild3( IOPMRequest * request )
{
- IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
- IOService * child;
+ IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
+ IOService * child;
IOPMrootDomain * rootDomain = getPMRootDomain();
- PM_ASSERT_IN_GATE();
- child = (IOService *) connection->getChildEntry(gIOPowerPlane);
+ PM_ASSERT_IN_GATE();
+ child = (IOService *) connection->getChildEntry(gIOPowerPlane);
- if (child && inPlane(gIOPowerPlane))
- {
- if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder"))
- {
- PM_LOG1("%s: strict PM order enforced\n", getName());
- fStrictTreeOrder = true;
- }
+ if (child && inPlane(gIOPowerPlane))
+ {
+ if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder"))
+ {
+ PM_LOG1("%s: strict PM order enforced\n", getName());
+ fStrictTreeOrder = true;
+ }
if (rootDomain)
rootDomain->joinAggressiveness( child );
- }
- else
- {
- PM_LOG("%s: addPowerChild3 not in power plane\n", getName());
- }
+ }
+ else
+ {
+ PM_LOG("%s: addPowerChild3 not in power plane\n", getName());
+ }
- connection->release();
+ connection->release();
}
#ifndef __LP64__
//*********************************************************************************
IOReturn IOService::setPowerParent(
- IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
+ IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
{
- return kIOReturnUnsupported;
+ return kIOReturnUnsupported;
}
#endif /* !__LP64__ */
IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
{
- IORegistryEntry * theChild;
+ IORegistryEntry * theChild;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogRemoveChild, 0, 0 );
theNub->retain();
// detach nub from child
- theChild = theNub->copyChildEntry(gIOPowerPlane);
+ theChild = theNub->copyChildEntry(gIOPowerPlane);
if ( theChild )
{
theNub->detachFromChild(theChild, gIOPowerPlane);
// Are we awaiting an ack from this child?
if ( theNub->getAwaitingAck() )
- {
- // yes, pretend we got one
- theNub->setAwaitingAck(false);
- if (fHeadNotePendingAcks != 0 )
- {
- // that's one fewer ack to worry about
- fHeadNotePendingAcks--;
-
- // is that the last?
- if ( fHeadNotePendingAcks == 0 )
- {
- stop_ack_timer();
-
- // Request unblocked, work queue
- // should re-scan all busy requests.
- gIOPMWorkQueue->incrementProducerCount();
- }
- }
- }
+ {
+ // yes, pretend we got one
+ theNub->setAwaitingAck(false);
+ if (fHeadNotePendingAcks != 0 )
+ {
+ // that's one fewer ack to worry about
+ fHeadNotePendingAcks--;
- theNub->release();
+ // is that the last?
+ if ( fHeadNotePendingAcks == 0 )
+ {
+ stop_ack_timer();
- // A child has gone away, re-scan children desires and clamp bits.
- // The fPendingAdjustPowerRequest helps to reduce redundant parent work.
+ // This parent may have a request in the work queue that is
+ // blocked on fHeadNotePendingAcks=0. And removePowerChild()
+ // is called while executing the child's PMstop request so they
+ // can occur simultaneously. IOPMWorkQueue::checkForWork() must
+ // restart and check all request queues again.
- if (!fAdjustPowerScheduled)
- {
- IOPMRequest * request;
- request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
- if (request)
- {
- submitPMRequest( request );
- fAdjustPowerScheduled = true;
- }
- }
+ gIOPMWorkQueue->incrementProducerCount();
+ }
+ }
+ }
+
+ theNub->release();
+
+ // A child has gone away, re-scan children desires and clamp bits.
+ // The fPendingAdjustPowerRequest helps to reduce redundant parent work.
+
+ if (!fAdjustPowerScheduled)
+ {
+ IOPMRequest * request;
+ request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
+ if (request)
+ {
+ submitPMRequest( request );
+ fAdjustPowerScheduled = true;
+ }
+ }
return IOPMNoErr;
}
//*********************************************************************************
IOReturn IOService::registerPowerDriver(
- IOService * powerDriver,
- IOPMPowerState * powerStates,
- unsigned long numberOfStates )
+ IOService * powerDriver,
+ IOPMPowerState * powerStates,
+ unsigned long numberOfStates )
{
- IOPMRequest * request;
- IOPMPSEntry * powerStatesCopy = 0;
+ IOPMRequest * request;
+ IOPMPSEntry * powerStatesCopy = 0;
IOPMPowerStateIndex stateOrder;
IOReturn error = kIOReturnSuccess;
if (!initialized)
- return IOPMNotYetInitialized;
-
- if (!powerStates || (numberOfStates < 2))
- {
- OUR_PMLog(kPMLogControllingDriverErr5, numberOfStates, 0);
- return kIOReturnBadArgument;
- }
-
- if (!powerDriver || !powerDriver->initialized)
- {
- OUR_PMLog(kPMLogControllingDriverErr4, 0, 0);
- return kIOReturnBadArgument;
- }
-
- if (powerStates[0].version > kIOPMPowerStateVersion2)
- {
- OUR_PMLog(kPMLogControllingDriverErr1, powerStates[0].version, 0);
- return kIOReturnBadArgument;
- }
-
- do {
- // Make a copy of the supplied power state array.
- powerStatesCopy = IONew(IOPMPSEntry, numberOfStates);
- if (!powerStatesCopy)
+ return IOPMNotYetInitialized;
+
+ if (!powerStates || (numberOfStates < 2))
+ {
+ OUR_PMLog(kPMLogControllingDriverErr5, numberOfStates, 0);
+ return kIOReturnBadArgument;
+ }
+
+ if (!powerDriver || !powerDriver->initialized)
+ {
+ OUR_PMLog(kPMLogControllingDriverErr4, 0, 0);
+ return kIOReturnBadArgument;
+ }
+
+ if (powerStates[0].version > kIOPMPowerStateVersion2)
+ {
+ OUR_PMLog(kPMLogControllingDriverErr1, powerStates[0].version, 0);
+ return kIOReturnBadArgument;
+ }
+
+ do {
+ // Make a copy of the supplied power state array.
+ powerStatesCopy = IONew(IOPMPSEntry, numberOfStates);
+ if (!powerStatesCopy)
{
error = kIOReturnNoMemory;
- break;
+ break;
}
// Initialize to bogus values
if (kIOReturnSuccess != error)
break;
- request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver );
- if (!request)
+ request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver );
+ if (!request)
{
error = kIOReturnNoMemory;
- break;
+ break;
}
- powerDriver->retain();
- request->fArg0 = (void *) powerDriver;
- request->fArg1 = (void *) powerStatesCopy;
- request->fArg2 = (void *) numberOfStates;
+ powerDriver->retain();
+ request->fArg0 = (void *) powerDriver;
+ request->fArg1 = (void *) powerStatesCopy;
+ request->fArg2 = (void *) numberOfStates;
- submitPMRequest( request );
+ submitPMRequest( request );
return kIOReturnSuccess;
- }
- while (false);
+ }
+ while (false);
- if (powerStatesCopy)
- IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates);
+ if (powerStatesCopy)
+ IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates);
- return error;
+ return error;
}
//*********************************************************************************
void IOService::handleRegisterPowerDriver( IOPMRequest * request )
{
- IOService * powerDriver = (IOService *) request->fArg0;
- IOPMPSEntry * powerStates = (IOPMPSEntry *) request->fArg1;
- unsigned long numberOfStates = (unsigned long) request->fArg2;
+ 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;
+ IOService * root;
+ OSIterator * iter;
- PM_ASSERT_IN_GATE();
- assert(powerStates);
- assert(powerDriver);
- assert(numberOfStates > 1);
+ PM_ASSERT_IN_GATE();
+ assert(powerStates);
+ assert(powerDriver);
+ assert(numberOfStates > 1);
if ( !fNumberOfPowerStates )
{
- OUR_PMLog(kPMLogControllingDriver,
- (unsigned long) numberOfStates,
- (unsigned long) kIOPMPowerStateVersion1);
+ OUR_PMLog(kPMLogControllingDriver,
+ (unsigned long) numberOfStates,
+ (unsigned long) kIOPMPowerStateVersion1);
fPowerStates = powerStates;
- fNumberOfPowerStates = numberOfStates;
- fControllingDriver = powerDriver;
+ fNumberOfPowerStates = numberOfStates;
+ fControllingDriver = powerDriver;
fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags;
lowestPowerState = fPowerStates[0].stateOrderToIndex;
fHighestPowerState = fPowerStates[numberOfStates - 1].stateOrderToIndex;
- // OR'in all the output power flags
- fMergedOutputPowerFlags = 0;
+ // OR'in all the output power flags
+ fMergedOutputPowerFlags = 0;
fDeviceUsablePowerState = lowestPowerState;
- for ( i = 0; i < numberOfStates; i++ )
+ for ( i = 0; i < numberOfStates; i++ )
{
- fMergedOutputPowerFlags |= fPowerStates[i].outputPowerFlags;
+ fMergedOutputPowerFlags |= fPowerStates[i].outputPowerFlags;
stateIndex = fPowerStates[i].stateOrderToIndex;
assert(stateIndex < numberOfStates);
// 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();
- }
- }
+ }
+
+ // Register powerDriver as interested, unless already done.
+ // We don't want to register the default implementation since
+ // it does nothing. One ramification of not always registering
+ // is the one fewer retain count held.
+
+ root = getPlatform()->getProvider();
+ assert(root);
+ if (!root ||
+ ((OSMemberFunctionCast(void (*)(void),
+ root, &IOService::powerStateDidChangeTo)) !=
+ ((OSMemberFunctionCast(void (*)(void),
+ this, &IOService::powerStateDidChangeTo)))) ||
+ ((OSMemberFunctionCast(void (*)(void),
+ root, &IOService::powerStateWillChangeTo)) !=
+ ((OSMemberFunctionCast(void (*)(void),
+ this, &IOService::powerStateWillChangeTo)))))
+ {
+ if (fInterestedDrivers->findItem(powerDriver) == NULL)
+ {
+ PM_LOCK();
+ fInterestedDrivers->appendNewInformee(powerDriver);
+ PM_UNLOCK();
+ }
+ }
- // Examine all existing power clients and perform limit check.
+ // Examine all existing power clients and perform limit check.
if (fPowerClients &&
(iter = OSCollectionIterator::withCollection(fPowerClients)))
iter->release();
}
- if ( inPlane(gIOPowerPlane) && fParentsKnowState )
- {
- IOPMPowerStateIndex tempDesire;
- fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags);
- // initially change into the state we are already in
- tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags);
- adjustPowerState(tempDesire);
- }
- }
- else
- {
- OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0);
+ if ( inPlane(gIOPowerPlane) && fParentsKnowState )
+ {
+ IOPMPowerStateIndex tempDesire;
+ fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags);
+ // initially change into the state we are already in
+ tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags);
+ adjustPowerState(tempDesire);
+ }
+ }
+ else
+ {
+ OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0);
IODelete(powerStates, IOPMPSEntry, numberOfStates);
- }
+ }
- powerDriver->release();
+ powerDriver->release();
}
//*********************************************************************************
IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
{
- IOPMRequest * request;
- bool signal;
+ IOPMRequest * request;
+ bool signal;
if (!driver || !initialized || !fInterestedDrivers)
return 0;
// for those clients that care.
OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2);
- return kIOPMDeviceUsable;
+ return kIOPMDeviceUsable;
}
//*********************************************************************************
IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
{
- IOPMinformeeList * list;
- IOPMinformee * item;
+ IOPMinformee * item;
IOPMRequest * request;
bool signal;
return IOPMNotPowerManaged;
PM_LOCK();
+ if (fInsertInterestSet)
+ {
+ fInsertInterestSet->removeObject(driver);
+ }
+
+ item = fInterestedDrivers->findItem(driver);
+ if (!item)
+ {
+ PM_UNLOCK();
+ return kIOReturnNotFound;
+ }
+
signal = (!fRemoveInterestSet && !fInsertInterestSet);
if (fRemoveInterestSet == NULL)
fRemoveInterestSet = OSSet::withCapacity(4);
if (fRemoveInterestSet)
{
fRemoveInterestSet->setObject(driver);
- if (fInsertInterestSet)
- fInsertInterestSet->removeObject(driver);
-
- list = fInterestedDrivers;
- item = list->findItem(driver);
- if (item && item->active)
+ if (item->active)
{
item->active = false;
waitForPMDriverCall( driver );
void IOService::handleInterestChanged( IOPMRequest * request )
{
- IOService * driver;
- IOPMinformee * informee;
- IOPMinformeeList * list = fInterestedDrivers;
+ IOService * driver;
+ IOPMinformee * informee;
+ IOPMinformeeList * list = fInterestedDrivers;
PM_LOCK();
IOReturn IOService::acknowledgePowerChange( IOService * whichObject )
{
- IOPMRequest * request;
+ IOPMRequest * request;
if (!initialized)
- return IOPMNotYetInitialized;
- if (!whichObject)
- return kIOReturnBadArgument;
+ return IOPMNotYetInitialized;
+ if (!whichObject)
+ return kIOReturnBadArgument;
- request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange );
- if (!request)
- return kIOReturnNoMemory;
+ request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange );
+ if (!request)
+ return kIOReturnNoMemory;
- whichObject->retain();
- request->fArg0 = whichObject;
+ whichObject->retain();
+ request->fArg0 = whichObject;
- submitPMRequest( request );
+ submitPMRequest( request );
return IOPMNoErr;
}
bool IOService::handleAcknowledgePowerChange( IOPMRequest * request )
{
- IOPMinformee * informee;
- unsigned long childPower = kIOPMUnknown;
- IOService * theChild;
- IOService * whichObject;
- bool all_acked = false;
+ IOPMinformee * informee;
+ unsigned long childPower = kIOPMUnknown;
+ IOService * theChild;
+ IOService * whichObject;
+ bool all_acked = false;
- PM_ASSERT_IN_GATE();
- whichObject = (IOService *) request->fArg0;
- assert(whichObject);
+ PM_ASSERT_IN_GATE();
+ whichObject = (IOService *) request->fArg0;
+ assert(whichObject);
// one of our interested drivers?
- informee = fInterestedDrivers->findItem( whichObject );
+ informee = fInterestedDrivers->findItem( whichObject );
if ( informee == NULL )
{
if ( !isChild(whichObject, gIOPowerPlane) )
{
- OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0);
- goto no_err;
+ OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0);
+ goto no_err;
} else {
OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0);
}
if (informee->timer > 0)
{
uint64_t nsec = computeTimeDeltaNS(&informee->startTime);
- if (nsec > LOG_SETPOWER_TIMES)
- PM_LOG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) async took %d ms\n",
- informee->whatObject->getName(),
- (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
- OBFUSCATE(informee->whatObject),
- fName, fCurrentPowerState, fHeadNotePowerState, NS_TO_US(nsec));
-
- uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange)
- ? kIOPMEventTypePSWillChangeTo
- : kIOPMEventTypePSDidChangeTo;
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- logType,
- fName,
- (uintptr_t)this,
- informee->whatObject->getName(),
- 0, 0, 0,
- NS_TO_MS(nsec));
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
+ if (nsec > LOG_SETPOWER_TIMES) {
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsDriverPSChangeSlow, informee->whatObject->getName(),
+ fDriverCallReason, NS_TO_MS(nsec), 0, NULL, fHeadNotePowerState);
+ }
}
#endif
// mark it acked
}
}
}
- }
+ }
- if ( fHeadNotePendingAcks == 0 ) {
- // yes, stop the timer
- stop_ack_timer();
- // and now we can continue
- all_acked = true;
- }
+ if ( fHeadNotePendingAcks == 0 ) {
+ // yes, stop the timer
+ stop_ack_timer();
+ // and now we can continue
+ all_acked = true;
+ }
} else {
- OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack
+ OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack
}
no_err:
- if (whichObject)
- whichObject->release();
+ if (whichObject)
+ whichObject->release();
return all_acked;
}
IOReturn IOService::acknowledgeSetPowerState( void )
{
- IOPMRequest * request;
+ IOPMRequest * request;
if (!initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
- request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState );
- if (!request)
- return kIOReturnNoMemory;
+ request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState );
+ if (!request)
+ return kIOReturnNoMemory;
- submitPMRequest( request );
- return kIOReturnSuccess;
+ submitPMRequest( request );
+ return kIOReturnSuccess;
}
//*********************************************************************************
void IOService::adjustPowerState( uint32_t clamp )
{
- PM_ASSERT_IN_GATE();
- computeDesiredState(clamp, false);
- if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane))
- {
+ PM_ASSERT_IN_GATE();
+ computeDesiredState(clamp, false);
+ if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane))
+ {
IOPMPowerChangeFlags changeFlags = kIOPMSelfInitiated;
// Indicate that children desires must be ignored, and do not ask
if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)
changeFlags |= (kIOPMIgnoreChildren | kIOPMSkipAskPowerDown);
- startPowerChange(
- /* flags */ changeFlags,
- /* power state */ fDesiredPowerState,
- /* domain flags */ 0,
- /* connection */ 0,
- /* parent flags */ 0);
- }
+ startPowerChange(
+ /* flags */ changeFlags,
+ /* power state */ fDesiredPowerState,
+ /* domain flags */ 0,
+ /* connection */ 0,
+ /* parent flags */ 0);
+ }
}
//*********************************************************************************
IOOptionBits options,
IOService * notifyRoot )
{
- IOPMRequest * request_c = 0;
+ IOPMRequest * request_c = 0;
IOPMRequest * request_s;
if (this != getPMRootDomain())
return kIOReturnBadArgument;
- if (!initialized)
- return kIOPMNotYetInitialized;
+ if (!initialized)
+ return kIOPMNotYetInitialized;
OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0));
// Cancels don't need to be synchronized.
nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel);
- if (nr) submitPMRequest(nr);
+ if (nr) submitPMRequest(nr);
nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel);
if (nr) submitPMRequest(nr);
}
request_c->attachNextRequest( request_s );
submitPMRequest(request_c);
}
-
+
request_s->fArg0 = (void *)(uintptr_t) options;
submitPMRequest(request_s);
return kIOReturnSuccess;
error_no_memory:
- if (request_c) releasePMRequest(request_c);
- if (request_s) releasePMRequest(request_s);
+ if (request_c) releasePMRequest(request_c);
+ if (request_s) releasePMRequest(request_s);
return kIOReturnNoMemory;
}
void IOService::handleSynchronizePowerTree( IOPMRequest * request )
{
- PM_ASSERT_IN_GATE();
- if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) &&
+ PM_ASSERT_IN_GATE();
+ if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) &&
(fCurrentPowerState == fHighestPowerState))
- {
+ {
IOOptionBits options = (uintptr_t) request->fArg0;
- startPowerChange(
- /* flags */ kIOPMSelfInitiated | kIOPMSynchronize |
+ startPowerChange(
+ /* flags */ kIOPMSelfInitiated | kIOPMSynchronize |
(options & kIOPMSyncNoChildNotify),
- /* power state */ fCurrentPowerState,
- /* domain flags */ 0,
- /* connection */ 0,
- /* parent flags */ 0);
- }
+ /* power state */ fCurrentPowerState,
+ /* domain flags */ 0,
+ /* connection */ 0,
+ /* parent flags */ 0);
+ }
}
#ifndef __LP64__
//*********************************************************************************
IOReturn IOService::powerDomainWillChangeTo(
- IOPMPowerFlags newPowerFlags,
- IOPowerConnection * whichParent )
+ IOPMPowerFlags newPowerFlags,
+ IOPowerConnection * whichParent )
{
- assert(false);
- return kIOReturnUnsupported;
+ assert(false);
+ return kIOReturnUnsupported;
}
#endif /* !__LP64__ */
void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request )
{
- IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0;
- IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
+ IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0;
+ IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
IOPMPowerChangeFlags myChangeFlags;
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
IOPMPowerStateIndex maxPowerState;
- IOPMPowerFlags combinedPowerFlags;
- bool savedParentsKnowState;
- IOReturn result = IOPMAckImplied;
+ IOPMPowerFlags combinedPowerFlags;
+ bool savedParentsKnowState;
+ IOReturn result = IOPMAckImplied;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
OUR_PMLog(kPMLogWillChange, parentPowerFlags, 0);
- if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck())
- {
- PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__);
+ if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck())
+ {
+ PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__);
goto exit_no_ack;
- }
+ }
- savedParentsKnowState = fParentsKnowState;
+ savedParentsKnowState = fParentsKnowState;
// Combine parents' output power flags.
- combinedPowerFlags = 0;
+ combinedPowerFlags = 0;
iter = getParentIterator(gIOPowerPlane);
if ( iter )
if ( fControllingDriver && !fInitialPowerChange )
{
- maxPowerState = fControllingDriver->maxCapabilityForDomainState(
- combinedPowerFlags);
+ maxPowerState = fControllingDriver->maxCapabilityForDomainState(
+ combinedPowerFlags);
+
+ if (parentChangeFlags & kIOPMDomainPowerDrop)
+ {
+ // fMaxPowerState set a limit on self-initiated power changes.
+ // Update it before a parent power drop.
+ fMaxPowerState = maxPowerState;
+ }
// Use kIOPMSynchronize below instead of kIOPMRootBroadcastFlags
// to avoid propagating the root change flags if any service must
// change power state due to root's will-change notification.
// Root does not change power state for kIOPMSynchronize.
-
+
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();
- }
- }
+ result = startPowerChange(
+ /* flags */ myChangeFlags,
+ /* power state */ maxPowerState,
+ /* domain flags */ combinedPowerFlags,
+ /* connection */ whichParent,
+ /* parent flags */ parentPowerFlags);
+ }
+
+ // If parent is dropping power, immediately update the parent's
+ // capability flags. Any future merging of parent(s) combined
+ // power flags should account for this power drop.
+
+ if (parentChangeFlags & kIOPMDomainPowerDrop)
+ {
+ setParentInfo(parentPowerFlags, whichParent, true);
+ }
+
+ // Parent is expecting an ACK from us. If we did not embark on a state
+ // transition, i.e. startPowerChange() returned IOPMAckImplied. We are
+ // still required to issue an ACK to our parent.
+
+ if (IOPMAckImplied == result)
+ {
+ IOService * parent;
+ parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
+ assert(parent);
+ if ( parent )
+ {
+ parent->acknowledgePowerChange( whichParent );
+ parent->release();
+ }
+ }
exit_no_ack:
// Drop the retain from notifyChild().
//*********************************************************************************
IOReturn IOService::powerDomainDidChangeTo(
- IOPMPowerFlags newPowerFlags,
- IOPowerConnection * whichParent )
+ IOPMPowerFlags newPowerFlags,
+ IOPowerConnection * whichParent )
{
- assert(false);
- return kIOReturnUnsupported;
+ assert(false);
+ return kIOReturnUnsupported;
}
#endif /* !__LP64__ */
void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request )
{
- IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0;
- IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
+ IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0;
+ IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
IOPMPowerChangeFlags myChangeFlags;
IOPMPowerStateIndex maxPowerState;
IOPMPowerStateIndex initialDesire = kPowerStateZero;
bool computeDesire = false;
bool desireChanged = false;
- bool savedParentsKnowState;
- IOReturn result = IOPMAckImplied;
+ bool savedParentsKnowState;
+ IOReturn result = IOPMAckImplied;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
OUR_PMLog(kPMLogDidChange, parentPowerFlags, 0);
- if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck())
- {
- PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__);
+ if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck())
+ {
+ PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__);
goto exit_no_ack;
- }
+ }
- savedParentsKnowState = fParentsKnowState;
+ savedParentsKnowState = fParentsKnowState;
setParentInfo(parentPowerFlags, whichParent, true);
if ( fControllingDriver )
- {
- maxPowerState = fControllingDriver->maxCapabilityForDomainState(
- fParentsCurrentPowerFlags);
+ {
+ maxPowerState = fControllingDriver->maxCapabilityForDomainState(
+ fParentsCurrentPowerFlags);
+
+ if ((parentChangeFlags & kIOPMDomainPowerDrop) == 0)
+ {
+ // fMaxPowerState set a limit on self-initiated power changes.
+ // Update it after a parent power rise.
+ fMaxPowerState = maxPowerState;
+ }
if (fInitialPowerChange)
{
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();
- }
- }
+ result = startPowerChange(
+ /* flags */ myChangeFlags,
+ /* power state */ maxPowerState,
+ /* domain flags */ fParentsCurrentPowerFlags,
+ /* connection */ whichParent,
+ /* parent flags */ 0);
+ }
- // If the parent registers its power driver late, then this is the
- // first opportunity to tell our parent about our desire. Or if the
+ // 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 ((!savedParentsKnowState && fParentsKnowState) || desireChanged)
- {
- PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState %d\n",
- getName(), fParentsKnowState);
- requestDomainPower( fDesiredPowerState );
- }
+ if (fControllingDriver &&
+ ((!savedParentsKnowState && fParentsKnowState) || desireChanged))
+ {
+ PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState %d\n",
+ getName(), fParentsKnowState);
+ requestDomainPower( fDesiredPowerState );
+ }
exit_no_ack:
// Drop the retain from notifyChild().
// Set our connection data for one specific parent, and then combine all the parent
// data together.
//*********************************************************************************
-
+
void IOService::setParentInfo(
- IOPMPowerFlags newPowerFlags,
- IOPowerConnection * whichParent,
- bool knowsState )
+ IOPMPowerFlags newPowerFlags,
+ IOPowerConnection * whichParent,
+ bool knowsState )
{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * conn;
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * conn;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
// set our connection data
whichParent->setParentCurrentPowerFlags(newPowerFlags);
whichParent->setParentKnowsState(knowsState);
-
+
// recompute our parent info
fParentsCurrentPowerFlags = 0;
fParentsKnowState = true;
if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep)
{
- bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList(this,
- ((oldCapability & kIOPMPreventIdleSleep) == 0));
- if(!idleCancelAllowed)
- PM_LOG2("Idle cancel was disallowed for %s\n", getName());
+ bool enablePrevention = ((oldCapability & kIOPMPreventIdleSleep) == 0);
+ bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList(
+ this, enablePrevention);
#if SUPPORT_IDLE_CANCEL
- if (idleCancelAllowed && (oldCapability & kIOPMPreventIdleSleep) == 0)
+ if (idleCancelAllowed && enablePrevention)
{
IOPMRequest * cancelRequest;
}
}
#endif
-
}
if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep)
{
-
getPMRootDomain()->updatePreventSystemSleepList(this,
((oldCapability & kIOPMPreventSystemSleep) == 0));
}
IOReturn IOService::requestPowerDomainState(
IOPMPowerFlags childRequestPowerFlags,
IOPowerConnection * childConnection,
- unsigned long specification )
+ unsigned long specification )
{
IOPMPowerStateIndex order, powerState;
- IOPMPowerFlags outputPowerFlags;
+ IOPMPowerFlags outputPowerFlags;
IOService * child;
- IOPMRequest * subRequest;
+ IOPMRequest * subRequest;
bool adjustPower = false;
if (!initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
- if (gIOPMWorkLoop->onThread() == false)
- {
- PM_LOG("%s::requestPowerDomainState\n", getName());
- return kIOReturnSuccess;
- }
+ if (gIOPMWorkLoop->onThread() == false)
+ {
+ PM_LOG("%s::requestPowerDomainState\n", getName());
+ return kIOReturnSuccess;
+ }
OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification);
- if (!isChild(childConnection, gIOPowerPlane))
- return kIOReturnNotAttached;
+ if (!isChild(childConnection, gIOPowerPlane))
+ return kIOReturnNotAttached;
if (!fControllingDriver || !fNumberOfPowerStates)
return kIOReturnNotReady;
- child = (IOService *) childConnection->getChildEntry(gIOPowerPlane);
- assert(child);
+ child = (IOService *) childConnection->getChildEntry(gIOPowerPlane);
+ assert(child);
// Remove flags from child request which we can't possibly supply
childRequestPowerFlags &= fMergedOutputPowerFlags;
// Merge in the power flags contributed by this power parent
- // at its current or impending power state.
+ // at its current or impending power state.
outputPowerFlags = fPowerStates[fCurrentPowerState].outputPowerFlags;
- if (fMachineState != kIOPM_Finished)
- {
- if (IS_POWER_DROP && !IS_ROOT_DOMAIN)
- {
+ 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:
PM_LOG1("%s: power drop cancelled in state %u by %s\n",
getName(), fMachineState, child->getName());
}
- else
- {
- // Beyond cancellation point, report the impending state.
- outputPowerFlags =
- fPowerStates[fHeadNotePowerState].outputPowerFlags;
- }
- }
- else if (IS_POWER_RISE)
- {
- // When raising power, must report the output power flags from
- // child's perspective. A child power request may arrive while
- // parent is transitioning upwards. If a request arrives after
- // setParentInfo() has already recorded the output power flags
- // for the next power state, then using the power supplied by
- // fCurrentPowerState is incorrect, and might cause the child
- // to wait when it should not.
-
- outputPowerFlags = childConnection->parentCurrentPowerFlags();
- }
+ else
+ {
+ // Beyond cancellation point, report the impending state.
+ outputPowerFlags =
+ fPowerStates[fHeadNotePowerState].outputPowerFlags;
+ }
+ }
+ else if (IS_POWER_RISE)
+ {
+ // When raising power, must report the output power flags from
+ // child's perspective. A child power request may arrive while
+ // parent is transitioning upwards. If a request arrives after
+ // setParentInfo() has already recorded the output power flags
+ // for the next power state, then using the power supplied by
+ // fCurrentPowerState is incorrect, and might cause the child
+ // to wait when it should not.
+
+ outputPowerFlags = childConnection->parentCurrentPowerFlags();
+ }
}
child->fHeadNoteDomainTargetFlags |= outputPowerFlags;
}
#endif
- // Record the child's desires on the connection.
- childConnection->setChildHasRequestedPower();
- childConnection->setDesiredDomainState( powerState );
+ // Record the child's desires on the connection.
+ childConnection->setChildHasRequestedPower();
+ childConnection->setDesiredDomainState( powerState );
- // Schedule a request to re-evaluate all children desires and
- // adjust power state. Submit a request if one wasn't pending,
- // or if the current request is part of a call tree.
+ // Schedule a request to re-evaluate all children desires and
+ // adjust power state. Submit a request if one wasn't pending,
+ // or if the current request is part of a call tree.
if (adjustPower && !fDeviceOverrideEnabled &&
(!fAdjustPowerScheduled || gIOPMRequest->getRootRequest()))
{
- subRequest = acquirePMRequest(
+ subRequest = acquirePMRequest(
this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest );
- if (subRequest)
- {
- submitPMRequest( subRequest );
- fAdjustPowerScheduled = true;
- }
+ if (subRequest)
+ {
+ submitPMRequest( subRequest );
+ fAdjustPowerScheduled = true;
+ }
}
return kIOReturnSuccess;
IOPMPowerFlags IOService::currentCapability( void )
{
- if (!initialized)
- return IOPMNotPowerManaged;
+ if (!initialized)
+ return IOPMNotPowerManaged;
return fCurrentCapabilityFlags;
}
IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
IOPMRequestTag tag )
{
- IOPMRequest * request;
+ IOPMRequest * request;
- if (!initialized)
- return kIOPMNotYetInitialized;
+ if (!initialized)
+ return kIOPMNotYetInitialized;
OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
- request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
- if (!request)
- return kIOReturnNoMemory;
+ request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
+ if (!request)
+ return kIOReturnNoMemory;
gIOPMPowerClientDevice->retain();
request->fRequestTag = tag;
request->installCompletionAction( action, target, param );
#endif
- // Prevent needless downwards power transitions by clamping power
- // until the scheduled request is executed.
+ // Prevent needless downwards power transitions by clamping power
+ // until the scheduled request is executed.
- if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates))
- {
- fTempClampPowerState = StateMax(fTempClampPowerState, ordinal);
- fTempClampCount++;
- fOverrideMaxPowerState = ordinal;
- request->fArg2 = (void *) (uintptr_t) true;
- }
+ if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates))
+ {
+ fTempClampPowerState = StateMax(fTempClampPowerState, ordinal);
+ fTempClampCount++;
+ fOverrideMaxPowerState = ordinal;
+ request->fArg2 = (void *) (uintptr_t) true;
+ }
- submitPMRequest( request );
+ submitPMRequest( request );
return IOPMNoErr;
}
}
//*********************************************************************************
-// [private] requestPowerState
+// [public for PMRD] quiescePowerTree
+//
+// For root domain to issue a request to quiesce the power tree.
+// Supplied callback invoked upon completion.
//*********************************************************************************
-IOReturn IOService::requestPowerState(
- const OSSymbol * client,
- uint32_t state )
+IOReturn IOService::quiescePowerTree(
+ void * target, IOPMCompletionAction action, void * param )
{
- IOPMRequest * request;
+ IOPMRequest * request;
- if (!client)
+ if (!initialized)
+ return kIOPMNotYetInitialized;
+ if (!target || !action)
return kIOReturnBadArgument;
- if (!initialized)
- return kIOPMNotYetInitialized;
- request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
- if (!request)
- return kIOReturnNoMemory;
+ OUR_PMLog(kPMLogQuiescePowerTree, 0, 0);
- 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
+ // Target the root node instead of root domain. This is to avoid blocking
+ // the quiesce request behind an existing root domain request in the work
+ // queue. Root parent and root domain requests in the work queue must not
+ // block the completion of the quiesce request.
+
+ request = acquirePMRequest(gIOPMRootNode, kIOPMRequestTypeQuiescePowerTree);
+ if (!request)
+ return kIOReturnNoMemory;
- // Prevent needless downwards power transitions by clamping power
- // until the scheduled request is executed.
+ request->installCompletionAction(target, action, param);
- if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates))
- {
- fTempClampPowerState = StateMax(fTempClampPowerState, state);
- fTempClampCount++;
- request->fArg2 = (void *) (uintptr_t) true;
- }
+ // 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 IOPMNoErr;
+ submitPMRequest( request );
+ return kIOReturnSuccess;
+}
+
+//*********************************************************************************
+// [private] requestPowerState
+//*********************************************************************************
+
+IOReturn IOService::requestPowerState(
+ const OSSymbol * client,
+ uint32_t state )
+{
+ IOPMRequest * request;
+
+ if (!client)
+ return kIOReturnBadArgument;
+ if (!initialized)
+ return kIOPMNotYetInitialized;
+
+ request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
+ if (!request)
+ return kIOReturnNoMemory;
+
+ client->retain();
+ request->fArg0 = (void *)(uintptr_t) state;
+ request->fArg1 = (void *) client;
+ request->fArg2 = 0;
+#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))
+ {
+ fTempClampPowerState = StateMax(fTempClampPowerState, state);
+ fTempClampCount++;
+ request->fArg2 = (void *) (uintptr_t) true;
+ }
+
+ submitPMRequest( request );
+ return IOPMNoErr;
}
//*********************************************************************************
const OSSymbol * client = (const OSSymbol *) request->fArg1;
uint32_t state = (uint32_t)(uintptr_t) request->fArg0;
- PM_ASSERT_IN_GATE();
- if (request->fArg2)
- {
- assert(fTempClampCount != 0);
- if (fTempClampCount) fTempClampCount--;
- if (!fTempClampCount) fTempClampPowerState = kPowerStateZero;
- }
+ PM_ASSERT_IN_GATE();
+ if (request->fArg2)
+ {
+ assert(fTempClampCount != 0);
+ if (fTempClampCount) fTempClampCount--;
+ if (!fTempClampCount) fTempClampPowerState = kPowerStateZero;
+ }
- if (fNumberOfPowerStates && (state >= fNumberOfPowerStates))
- state = fHighestPowerState;
+ if (fNumberOfPowerStates && (state >= fNumberOfPowerStates))
+ state = fHighestPowerState;
// The power suppression due to changePowerStateWithOverrideTo() expires
// upon the next "device" power request - changePowerStateToPriv().
fOverrideMaxPowerState = kIOPMPowerStateMax;
if ((state == kPowerStateZero) &&
- (client != gIOPMPowerClientDevice) &&
- (client != gIOPMPowerClientDriver) &&
- (client != gIOPMPowerClientChildProxy))
- removePowerClient(client);
- else
- updatePowerClient(client, state);
-
- adjustPowerState();
+ (client != gIOPMPowerClientDevice) &&
+ (client != gIOPMPowerClientDriver) &&
+ (client != gIOPMPowerClientChildProxy))
+ removePowerClient(client);
+ else
+ updatePowerClient(client, state);
+
+ adjustPowerState();
client->release();
}
IOReturn IOService::powerOverrideOnPriv( void )
{
- IOPMRequest * request;
+ IOPMRequest * request;
if (!initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
- if (gIOPMWorkLoop->inGate())
- {
- fDeviceOverrideEnabled = true;
- return IOPMNoErr;
- }
+ if (gIOPMWorkLoop->inGate())
+ {
+ fDeviceOverrideEnabled = true;
+ return IOPMNoErr;
+ }
- request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv );
- if (!request)
- return kIOReturnNoMemory;
+ request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv );
+ if (!request)
+ return kIOReturnNoMemory;
- submitPMRequest( request );
+ submitPMRequest( request );
return IOPMNoErr;
}
IOReturn IOService::powerOverrideOffPriv( void )
{
- IOPMRequest * request;
+ IOPMRequest * request;
if (!initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
- if (gIOPMWorkLoop->inGate())
- {
- fDeviceOverrideEnabled = false;
- return IOPMNoErr;
- }
+ if (gIOPMWorkLoop->inGate())
+ {
+ fDeviceOverrideEnabled = false;
+ return IOPMNoErr;
+ }
- request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv );
- if (!request)
- return kIOReturnNoMemory;
+ request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv );
+ if (!request)
+ return kIOReturnNoMemory;
- submitPMRequest( request );
+ submitPMRequest( request );
return IOPMNoErr;
}
void IOService::handlePowerOverrideChanged( IOPMRequest * request )
{
- PM_ASSERT_IN_GATE();
- if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv)
- {
- OUR_PMLog(kPMLogOverrideOn, 0, 0);
- fDeviceOverrideEnabled = true;
+ PM_ASSERT_IN_GATE();
+ if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv)
+ {
+ OUR_PMLog(kPMLogOverrideOn, 0, 0);
+ fDeviceOverrideEnabled = true;
+ }
+ else
+ {
+ OUR_PMLog(kPMLogOverrideOff, 0, 0);
+ fDeviceOverrideEnabled = false;
}
- else
- {
- OUR_PMLog(kPMLogOverrideOff, 0, 0);
- fDeviceOverrideEnabled = false;
- }
- adjustPowerState();
+ adjustPowerState();
}
//*********************************************************************************
void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly )
{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- uint32_t desiredState = kPowerStateZero;
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ uint32_t desiredState = kPowerStateZero;
uint32_t newPowerState = kPowerStateZero;
bool hasChildren = false;
- // Desired power state is always 0 without a controlling driver.
+ // Desired power state is always 0 without a controlling driver.
- if (!fNumberOfPowerStates)
- {
+ if (!fNumberOfPowerStates)
+ {
fDesiredPowerState = kPowerStateZero;
- return;
- }
+ return;
+ }
// Examine the children's desired power state.
const OSSymbol * client;
while ((client = (const OSSymbol *) iter->getNextObject()))
{
- // Ignore child and driver when override is in effect.
+ // Ignore child and driver when override is in effect.
if ((fDeviceOverrideEnabled ||
(getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)) &&
((client == gIOPMPowerClientChildren) ||
(client == gIOPMPowerClientDriver)))
continue;
- // Ignore child proxy when children are present.
+ // Ignore child proxy when children are present.
if (hasChildren && (client == gIOPMPowerClientChildProxy))
continue;
continue;
desiredState = getPowerStateForClient(client);
- assert(desiredState < fNumberOfPowerStates);
- PM_LOG1(" %u %s\n",
- desiredState, client->getCStringNoCopy());
+ assert(desiredState < fNumberOfPowerStates);
+ PM_LOG1(" %u %s\n",
+ desiredState, client->getCStringNoCopy());
newPowerState = StateMax(newPowerState, desiredState);
PM_LOG1(" temp %u, clamp %u, current %u, new %u\n",
(uint32_t) localClamp, (uint32_t) fTempClampPowerState,
- (uint32_t) fCurrentPowerState, newPowerState);
+ (uint32_t) fCurrentPowerState, newPowerState);
if (!computeOnly)
{
IOWorkLoop * IOService::getPMworkloop( void )
{
- return gIOPMWorkLoop;
+ return gIOPMWorkLoop;
}
#if NOT_YET
//*********************************************************************************
static void
-applyToPowerChildren(
+applyToPowerChildren(
IOService * service,
IOServiceApplierFunction applier,
void * context,
IOOptionBits options )
{
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
IORegistryEntry * entry;
IORegistryIterator * iter;
}
static void
-applyToPowerParent(
+applyToPowerParent(
IOService * service,
IOServiceApplierFunction applier,
void * context,
IOOptionBits options )
{
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
IORegistryEntry * entry;
IORegistryIterator * iter;
bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
{
- IOPMRequest * request;
- bool noPowerChange = true;
+ IOPMRequest * request;
+ bool noPowerChange = true;
uint32_t tickleFlags;
if (!initialized)
return true; // no power change
if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber))
- {
+ {
IOLockLock(fActivityLock);
- // Record device activity for the idle timer handler.
+ // Record device activity for the idle timer handler.
fDeviceWasActive = true;
fActivityTickleCount++;
PM_ACTION_0(actionActivityTickle);
- // Record the last tickle power state.
- // This helps to filter out redundant tickles as
- // this function may be called from the data path.
+ // Record the last tickle power state.
+ // This helps to filter out redundant tickles as
+ // this function may be called from the data path.
if ((fActivityTicklePowerState == kInvalidTicklePowerState)
|| StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber))
- {
- fActivityTicklePowerState = stateNumber;
- noPowerChange = false;
+ {
+ fActivityTicklePowerState = stateNumber;
+ noPowerChange = false;
tickleFlags = kTickleTypeActivity | kTickleTypePowerRise;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request)
- {
- request->fArg0 = (void *) stateNumber;
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
+ request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
+ if (request)
+ {
+ request->fArg0 = (void *) stateNumber;
+ request->fArg1 = (void *)(uintptr_t) tickleFlags;
request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;
- submitPMRequest(request);
- }
- }
+ submitPMRequest(request);
+ }
+ }
- IOLockUnlock(fActivityLock);
- }
+ IOLockUnlock(fActivityLock);
+ }
else if ((type == kIOPMActivityTickleTypeAdvisory) &&
((stateNumber = fDeviceUsablePowerState) != kPowerStateZero))
fAdvisoryTickled = true;
- if (fAdvisoryTicklePowerState != stateNumber)
- {
- fAdvisoryTicklePowerState = stateNumber;
- noPowerChange = false;
+ if (fAdvisoryTicklePowerState != stateNumber)
+ {
+ fAdvisoryTicklePowerState = stateNumber;
+ noPowerChange = false;
tickleFlags = kTickleTypeAdvisory | kTickleTypePowerRise;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request)
- {
- request->fArg0 = (void *) stateNumber;
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
+ request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
+ if (request)
+ {
+ request->fArg0 = (void *) stateNumber;
+ request->fArg1 = (void *)(uintptr_t) tickleFlags;
request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;
- submitPMRequest(request);
- }
- }
+ submitPMRequest(request);
+ }
+ }
- IOLockUnlock(fActivityLock);
+ IOLockUnlock(fActivityLock);
}
- // Returns false if the activityTickle might cause a transition to a
- // higher powered state, true otherwise.
+ // Returns false if the activityTickle might cause a transition to a
+ // higher powered state, true otherwise.
return noPowerChange;
}
void IOService::handleActivityTickle( IOPMRequest * request )
{
- uint32_t ticklePowerState = (uint32_t)(uintptr_t) request->fArg0;
+ uint32_t ticklePowerState = (uint32_t)(uintptr_t) request->fArg0;
uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1;
uint32_t tickleGeneration = (uint32_t)(uintptr_t) request->fArg2;
bool adjustPower = false;
-
- PM_ASSERT_IN_GATE();
+
+ PM_ASSERT_IN_GATE();
if (fResetPowerStateOnWake && (tickleGeneration != gIOPMTickleGeneration))
{
// Drivers that don't want power restored on wake will drop any
if (tickleFlags & kTickleTypeActivity)
{
IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire);
+ uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop
if (tickleFlags & kTickleTypePowerRise)
{
adjustPower = true;
}
}
- else if (deviceDesireOrder > StateOrder(fIdleTimerMinPowerState))
+ else if ((deviceDesireOrder > StateOrder(fIdleTimerMinPowerState)) &&
+ (idleTimerGeneration == fIdleTimerGeneration))
{
// Power drop due to idle timer expiration.
// Do not allow idle timer to reduce power below tickle power.
// 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)
{
}
}
- if (adjustPower)
- {
- adjustPowerState();
- }
+ if (adjustPower)
+ {
+ adjustPowerState();
+ }
}
//******************************************************************************
IOReturn IOService::setIdleTimerPeriod( unsigned long period )
{
if (!initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod);
IOReturn IOService::setIgnoreIdleTimer( bool ignore )
{
if (!initialized)
- return IOPMNotYetInitialized;
+ return IOPMNotYetInitialized;
OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0);
SInt32 IOService::nextIdleTimeout(
AbsoluteTime currentTime,
- AbsoluteTime lastActivity,
+ AbsoluteTime lastActivity,
unsigned int powerState)
{
AbsoluteTime delta;
// 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);
delay_secs = (int) fIdleTimerPeriod - delta_secs;
else
delay_secs = (int) fIdleTimerPeriod;
-
+
return (SInt32)delay_secs;
}
static const int minTimeout = 1;
AbsoluteTime uptime, deadline;
SInt32 idle_in = 0;
- boolean_t pending;
+ boolean_t pending;
- if (!initialized || !fIdleTimerPeriod)
- return;
+ if (!initialized || !fIdleTimerPeriod)
+ return;
IOLockLock(fActivityLock);
IOLockUnlock(fActivityLock);
+ fNextIdleTimerPeriod = idle_in;
+ fIdleTimerStartTime = uptime;
+
retain();
clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline);
ADD_ABSOLUTETIME(&deadline, &uptime);
{
fIdleTimerStopped = false;
fActivityTickleCount = 0;
- clock_get_uptime(&fIdleTimerStartTime);
start_PM_idle_timer();
}
else if (fHasAdvisoryDesire)
idle_timer_expired(
thread_call_param_t arg0, thread_call_param_t arg1 )
{
- IOService * me = (IOService *) arg0;
+ IOService * me = (IOService *) arg0;
- if (gIOPMWorkLoop)
- gIOPMWorkLoop->runAction(
+ if (gIOPMWorkLoop)
+ gIOPMWorkLoop->runAction(
OSMemberFunctionCast(IOWorkLoop::Action, me,
&IOService::idleTimerExpired),
me);
- me->release();
+ me->release();
}
//*********************************************************************************
void IOService::idleTimerExpired( void )
{
- IOPMRequest * request;
- bool restartTimer = true;
+ IOPMRequest * request;
+ bool restartTimer = true;
uint32_t tickleFlags;
if ( !initialized || !fIdleTimerPeriod || fIdleTimerStopped ||
fLockedFlags.PMStop )
return;
- IOLockLock(fActivityLock);
+ fIdleTimerStartTime = 0;
+
+ IOLockLock(fActivityLock);
- // Check for device activity (tickles) over last timer period.
+ // Check for device activity (tickles) over last timer period.
- if (fDeviceWasActive)
- {
- // Device was active - do not drop power, restart timer.
- fDeviceWasActive = false;
- }
- else if (!fIdleTimerIgnored)
- {
- // No device activity - drop power state by one level.
- // Decrement the cached tickle power state when possible.
- // This value may be kInvalidTicklePowerState before activityTickle()
+ if (fDeviceWasActive)
+ {
+ // Device was active - do not drop power, restart timer.
+ fDeviceWasActive = false;
+ }
+ else if (!fIdleTimerIgnored)
+ {
+ // No device activity - drop power state by one level.
+ // Decrement the cached tickle power state when possible.
+ // This value may be kInvalidTicklePowerState before activityTickle()
// is called, but the power drop request must be issued regardless.
- if ((fActivityTicklePowerState != kInvalidTicklePowerState) &&
+ if ((fActivityTicklePowerState != kInvalidTicklePowerState) &&
(fActivityTicklePowerState != kPowerStateZero))
- fActivityTicklePowerState--;
+ fActivityTicklePowerState--;
tickleFlags = kTickleTypeActivity | kTickleTypePowerDrop;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request)
- {
- request->fArg0 = (void *) kPowerStateZero; // irrelevant
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
+ 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 );
+ submitPMRequest( request );
- // Do not restart timer until after the tickle request has been
- // processed.
+ // Do not restart timer until after the tickle request has been
+ // processed.
- restartTimer = false;
- }
+ restartTimer = false;
+ }
}
if (fAdvisoryTickled)
fAdvisoryTicklePowerState = kInvalidTicklePowerState;
tickleFlags = kTickleTypeAdvisory | kTickleTypePowerDrop;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request)
- {
- request->fArg0 = (void *) kPowerStateZero; // irrelevant
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
+ 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 );
+ submitPMRequest( request );
- // Do not restart timer until after the tickle request has been
- // processed.
+ // Do not restart timer until after the tickle request has been
+ // processed.
- restartTimer = false;
- }
+ restartTimer = false;
+ }
}
- IOLockUnlock(fActivityLock);
+ IOLockUnlock(fActivityLock);
- if (restartTimer)
- start_PM_idle_timer();
+ if (restartTimer)
+ start_PM_idle_timer();
}
#ifndef __LP64__
if (!rootDomain)
return kIOReturnNotReady;
-
+
return rootDomain->getAggressiveness( type, currentLevel );
}
IOReturn IOService::systemWake( void )
{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- IOService * theChild;
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ IOService * theChild;
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
- if (connection->getReadyFlag() == false)
- {
- PM_LOG3("[%s] %s: connection not ready\n",
- getName(), __FUNCTION__);
- continue;
- }
+ if (connection->getReadyFlag() == false)
+ {
+ PM_LOG3("[%s] %s: connection not ready\n",
+ getName(), __FUNCTION__);
+ continue;
+ }
theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane);
if ( theChild )
{
- theChild->systemWake();
+ theChild->systemWake();
theChild->release();
}
}
IOReturn IOService::temperatureCriticalForZone( IOService * whichZone )
{
- IOService * theParent;
- IOService * theNub;
-
+ IOService * theParent;
+ IOService * theNub;
+
OUR_PMLog(kPMLogCriticalTemp, 0, 0);
if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT )
IOPowerConnection * parentConnection,
IOPMPowerFlags parentFlags )
{
- PM_ASSERT_IN_GATE();
- assert( fMachineState == kIOPM_Finished );
+ PM_ASSERT_IN_GATE();
+ assert( fMachineState == kIOPM_Finished );
assert( powerState < fNumberOfPowerStates );
if (powerState >= fNumberOfPowerStates)
// Reset device desire down to the clamped power state
updatePowerClient(gIOPMPowerClientDevice, powerState);
computeDesiredState(kPowerStateZero, true);
-
+
// Invalidate tickle cache so the next tickle will issue a request
IOLockLock(fActivityLock);
fDeviceWasActive = false;
if (changeFlags & kIOPMNotDone)
return IOPMAckImplied;
- // Forks to either Driver or Parent initiated power change paths.
+ // Forks to either Driver or Parent initiated power change paths.
fHeadNoteChangeFlags = changeFlags;
fHeadNotePowerState = powerState;
- fHeadNotePowerArrayEntry = &fPowerStates[ powerState ];
- fHeadNoteParentConnection = NULL;
+ fHeadNotePowerArrayEntry = &fPowerStates[ powerState ];
+ fHeadNoteParentConnection = NULL;
- if (changeFlags & kIOPMSelfInitiated)
- {
+ if (changeFlags & kIOPMSelfInitiated)
+ {
if (changeFlags & kIOPMSynchronize)
OurSyncStart();
else
OurChangeStart();
- return 0;
- }
- else
- {
- assert(changeFlags & kIOPMParentInitiated);
+ return 0;
+ }
+ else
+ {
+ assert(changeFlags & kIOPMParentInitiated);
fHeadNoteDomainFlags = domainFlags;
- fHeadNoteParentFlags = parentFlags;
+ fHeadNoteParentFlags = parentFlags;
fHeadNoteParentConnection = parentConnection;
- return ParentChangeStart();
- }
+ return ParentChangeStart();
+ }
}
//*********************************************************************************
bool IOService::notifyInterestedDrivers( void )
{
- IOPMinformee * informee;
- IOPMinformeeList * list = fInterestedDrivers;
- DriverCallParam * param;
- IOItemCount count;
+ IOPMinformee * informee;
+ IOPMinformeeList * list = fInterestedDrivers;
+ DriverCallParam * param;
+ IOItemCount count;
PM_ASSERT_IN_GATE();
assert( fDriverCallParamCount == 0 );
count = list->numberOfItems();
if (!count)
- goto done; // no interested drivers
+ goto done; // no interested drivers
// Allocate an array of interested drivers and their return values
// for the callout thread. Everything else is still "owned" by the
param = IONew(DriverCallParam, count);
if (!param)
- goto done; // no memory
+ goto done; // no memory
fDriverCallParamPtr = (void *) param;
fDriverCallParamSlots = count;
void IOService::notifyInterestedDriversDone( void )
{
- IOPMinformee * informee;
- IOItemCount count;
+ IOPMinformee * informee;
+ IOItemCount count;
DriverCallParam * param;
IOReturn result;
- PM_ASSERT_IN_GATE();
- assert( fDriverCallBusy == false );
- assert( fMachineState == kIOPM_DriverThreadCallDone );
+ PM_ASSERT_IN_GATE();
+ assert( fDriverCallBusy == false );
+ assert( fMachineState == kIOPM_DriverThreadCallDone );
- param = (DriverCallParam *) fDriverCallParamPtr;
- count = fDriverCallParamCount;
+ param = (DriverCallParam *) fDriverCallParamPtr;
+ count = fDriverCallParamCount;
- if (param && count)
- {
- for (IOItemCount i = 0; i < count; i++, param++)
- {
- informee = (IOPMinformee *) param->Target;
- result = param->Result;
+ if (param && count)
+ {
+ for (IOItemCount i = 0; i < count; i++, param++)
+ {
+ informee = (IOPMinformee *) param->Target;
+ result = param->Result;
- if ((result == IOPMAckImplied) || (result < 0))
- {
- // Interested driver return IOPMAckImplied.
+ if ((result == IOPMAckImplied) || (result < 0))
+ {
+ // Interested driver return IOPMAckImplied.
// If informee timer is zero, it must have de-registered
// interest during the thread callout. That also drops
// the pending ack count.
- if (fHeadNotePendingAcks && informee->timer)
+ if (fHeadNotePendingAcks && informee->timer)
fHeadNotePendingAcks--;
informee->timer = 0;
- }
- else if (informee->timer)
- {
+ }
+ else if (informee->timer)
+ {
assert(informee->timer == -1);
// Driver has not acked, and has returned a positive result.
result = kMinAckTimeoutTicks;
informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
- }
- // else, child has already acked or driver has removed interest,
+ }
+ // else, child has already acked or driver has removed interest,
// and head_note_pendingAcks decremented.
- // informee may have been removed from the interested drivers list,
+ // informee may have been removed from the interested drivers list,
// thus the informee must be retained across the callout.
- informee->release();
- }
+ informee->release();
+ }
- fDriverCallParamCount = 0;
+ fDriverCallParamCount = 0;
- if ( fHeadNotePendingAcks )
- {
- OUR_PMLog(kPMLogStartAckTimer, 0, 0);
- start_ack_timer();
- }
- }
+ if ( fHeadNotePendingAcks )
+ {
+ OUR_PMLog(kPMLogStartAckTimer, 0, 0);
+ start_ack_timer();
+ }
+ }
MS_POP(); // pop the machine state passed to notifyAll()
void IOService::notifyRootDomain( void )
{
- assert( fDriverCallBusy == false );
+ assert( fDriverCallBusy == false );
// Only for root domain in the will-change phase
if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState))
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 );
+ assert( fDriverCallBusy == false );
+ assert( fMachineState == kIOPM_DriverThreadCallDone );
MS_POP(); // pop notifyAll() machine state
notifyChildren();
void IOService::notifyChildren( void )
{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- OSArray * children = 0;
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ OSArray * children = 0;
IOPMrootDomain * rootDomain;
bool delayNotify = false;
-
+
if ((fHeadNotePowerState != fCurrentPowerState) &&
(IS_POWER_DROP == fIsPreChange) &&
((rootDomain = getPMRootDomain()) == this))
kIOPMTracePointWakePowerPlaneDrivers );
}
- if (fStrictTreeOrder)
- children = OSArray::withCapacity(8);
+ if (fStrictTreeOrder)
+ children = OSArray::withCapacity(8);
// Sum child power consumption in notifyChild()
fHeadNotePowerArrayEntry->staticPower = 0;
{
if ((connection = OSDynamicCast(IOPowerConnection, next)))
{
- if (connection->getReadyFlag() == false)
- {
- PM_LOG3("[%s] %s: connection not ready\n",
- getName(), __FUNCTION__);
- continue;
- }
+ if (connection->getReadyFlag() == false)
+ {
+ PM_LOG3("[%s] %s: connection not ready\n",
+ getName(), __FUNCTION__);
+ continue;
+ }
// Mechanism to postpone the did-change notification to
// certain power children to order those children last.
// Cannot be used together with strict tree ordering.
if (!fIsPreChange &&
- (connection->delayChildNotification) &&
+ connection->delayChildNotification &&
getPMRootDomain()->shouldDelayChildNotification(this))
{
if (!children)
}
}
- if (!delayNotify && children)
- children->setObject( connection );
- else
- notifyChild( connection );
- }
+ if (!delayNotify && children)
+ children->setObject( connection );
+ else
+ notifyChild( connection );
+ }
}
iter->release();
}
children->release();
children = 0;
}
- if (children)
- {
+ if (children)
+ {
assert(fNotifyChildArray == 0);
- fNotifyChildArray = children;
+ fNotifyChildArray = children;
MS_PUSH(fMachineState);
if (delayNotify)
{
- // Wait for exiting child notifications to complete,
- // before notifying the children in the array.
+ // Block until all non-delayed children have acked their
+ // notification. Then notify the remaining delayed child
+ // in the array. This is used to hold off graphics child
+ // notification while the rest of the system powers up.
+ // If a hid tickle arrives during this time, the delayed
+ // children are immediately notified and root domain will
+ // not clamp power for dark wake.
+
fMachineState = kIOPM_NotifyChildrenDelayed;
PM_LOG2("%s: %d children in delayed array\n",
getName(), children->getCount());
}
else
{
+ // Child array created to support strict notification order.
// Notify children in the array one at a time.
+
fMachineState = kIOPM_NotifyChildrenOrdered;
}
- }
+ }
}
//*********************************************************************************
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;
+ PM_ASSERT_IN_GATE();
+ assert(fNotifyChildArray);
+ assert(fMachineState == kIOPM_NotifyChildrenOrdered);
+
+ // Notify one child, wait for it to ack, then repeat for next child.
+ // This is a workaround for some drivers with multiple instances at
+ // the same branch in the power tree, but the driver is slow to power
+ // up unless the tree ordering is observed. Problem observed only on
+ // system wake, not on system sleep.
+ //
+ // We have the ability to power off in reverse child index order.
+ // That works nicely on some machines, but not on all HW configs.
+
+ if (fNotifyChildArray->getCount())
+ {
+ IOPowerConnection * connection;
+ connection = (IOPowerConnection *) fNotifyChildArray->getObject(0);
+ notifyChild( connection );
+ fNotifyChildArray->removeObject(0);
+ }
+ else
+ {
+ fNotifyChildArray->release();
+ fNotifyChildArray = 0;
MS_POP(); // pushed by notifyChildren()
- }
+ }
}
//*********************************************************************************
void IOService::notifyChildrenDelayed( void )
{
- IOPowerConnection * connection;
+ IOPowerConnection * connection;
- PM_ASSERT_IN_GATE();
- assert(fNotifyChildArray);
- assert(fMachineState == kIOPM_NotifyChildrenDelayed);
+ PM_ASSERT_IN_GATE();
+ assert(fNotifyChildArray);
+ assert(fMachineState == kIOPM_NotifyChildrenDelayed);
// Wait after all non-delayed children and interested drivers have ack'ed,
- // then notify all delayed children. When explicitly cancelled, interest
- // acks (and ack timer) may still be outstanding.
+ // then notify all delayed children. If notify delay is canceled, child
+ // acks may be outstanding with PM blocked on fHeadNotePendingAcks != 0.
+ // But the handling for either case is identical.
for (int i = 0; ; i++)
{
- connection = (IOPowerConnection *) fNotifyChildArray->getObject(i);
+ connection = (IOPowerConnection *) fNotifyChildArray->getObject(i);
if (!connection)
break;
- notifyChild( connection );
+ notifyChild( connection );
}
PM_LOG2("%s: notified delayed children\n", getName());
fNotifyChildArray->release();
fNotifyChildArray = 0;
-
+
MS_POP(); // pushed by notifyChildren()
}
IOReturn IOService::notifyAll( uint32_t nextMS )
{
- // Save the machine state to be restored by notifyInterestedDriversDone()
+ // Save the machine state to be restored by notifyInterestedDriversDone()
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
MS_PUSH(nextMS);
- fMachineState = kIOPM_DriverThreadCallDone;
- fDriverCallReason = fIsPreChange ?
- kDriverCallInformPreChange : kDriverCallInformPostChange;
+ fMachineState = kIOPM_DriverThreadCallDone;
+ fDriverCallReason = fIsPreChange ?
+ kDriverCallInformPreChange : kDriverCallInformPostChange;
- if (!notifyInterestedDrivers())
- notifyInterestedDriversDone();
+ if (!notifyInterestedDrivers())
+ notifyInterestedDriversDone();
- return IOPMWillAckLater;
+ return IOPMWillAckLater;
}
//*********************************************************************************
//*********************************************************************************
IOReturn IOService::actionDriverCalloutDone(
- OSObject * target,
- void * arg0, void * arg1,
- void * arg2, void * arg3 )
+ OSObject * target,
+ void * arg0, void * arg1,
+ void * arg2, void * arg3 )
{
IOServicePM * pwrMgt = (IOServicePM *) arg0;
void IOService::pmDriverCallout( IOService * from )
{
- assert(from);
- switch (from->fDriverCallReason)
- {
- case kDriverCallSetPowerState:
- from->driverSetPowerState();
- break;
+ assert(from);
+ switch (from->fDriverCallReason)
+ {
+ case kDriverCallSetPowerState:
+ from->driverSetPowerState();
+ break;
- case kDriverCallInformPreChange:
- case kDriverCallInformPostChange:
- from->driverInformPowerChange();
- break;
+ case kDriverCallInformPreChange:
+ case kDriverCallInformPostChange:
+ from->driverInformPowerChange();
+ break;
case kRootDomainInformPreChange:
getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState);
break;
- default:
- panic("IOService::pmDriverCallout bad machine state %x",
+ default:
+ panic("IOService::pmDriverCallout bad machine state %x",
from->fDriverCallReason);
- }
+ }
- gIOPMWorkLoop->runAction(actionDriverCalloutDone,
- /* target */ from,
- /* arg0 */ (void *) from->pwrMgt );
+ gIOPMWorkLoop->runAction(actionDriverCalloutDone,
+ /* target */ from,
+ /* arg0 */ (void *) from->pwrMgt );
}
//*********************************************************************************
void IOService::driverSetPowerState( void )
{
IOPMPowerStateIndex powerState;
- DriverCallParam * param;
+ DriverCallParam * param;
IOPMDriverCallEntry callEntry;
AbsoluteTime end;
IOReturn result;
if (assertPMDriverCall(&callEntry))
{
OUR_PMLog( kPMLogProgramHardware, (uintptr_t) this, powerState);
+ start_spindump_timer("SetState");
clock_get_uptime(&fDriverCallStartTime);
result = fControllingDriver->setPowerState( powerState, this );
clock_get_uptime(&end);
+ stop_spindump_timer();
OUR_PMLog((UInt32) -kPMLogProgramHardware, (uintptr_t) this, (UInt32) result);
deassertPMDriverCall(&callEntry);
+ // Record the most recent max power state residency timings.
+ // Use with DeviceActiveTimestamp to diagnose tickle issues.
+ if (powerState == fHighestPowerState)
+ fMaxPowerStateEntryTime = end;
+ else if (oldPowerState == fHighestPowerState)
+ fMaxPowerStateExitTime = end;
+
if (result < 0)
{
PM_LOG("%s::setPowerState(%p, %lu -> %lu) returned 0x%x\n",
- fName, this, fCurrentPowerState, powerState, result);
+ fName, OBFUSCATE(this), fCurrentPowerState, powerState, result);
}
#if LOG_SETPOWER_TIMES
SUB_ABSOLUTETIME(&end, &fDriverCallStartTime);
absolutetime_to_nanoseconds(end, &nsec);
- if (nsec > LOG_SETPOWER_TIMES)
- PM_LOG("%s::setPowerState(%p, %lu -> %lu) took %d ms\n",
- fName, this, fCurrentPowerState, powerState, NS_TO_MS(nsec));
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeSetPowerStateImmediate, // type
- fName, // who
- (uintptr_t)this, // owner unique
- NULL, // interest name
- (uint8_t)oldPowerState, // old
- (uint8_t)powerState, // new
- 0, // result
- NS_TO_US(nsec)); // usec completion time
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
+ if (nsec > LOG_SETPOWER_TIMES) {
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsDriverPSChangeSlow,
+ fName, kDriverCallSetPowerState, NS_TO_MS(nsec), 0, NULL, powerState);
+ }
}
#endif
}
void IOService::driverInformPowerChange( void )
{
- IOPMinformee * informee;
- IOService * driver;
- DriverCallParam * param;
+ IOPMinformee * informee;
+ IOService * driver;
+ DriverCallParam * param;
IOPMDriverCallEntry callEntry;
- IOPMPowerFlags powerFlags;
+ IOPMPowerFlags powerFlags;
IOPMPowerStateIndex powerState;
AbsoluteTime end;
IOReturn result;
- IOItemCount count;
+ IOItemCount count;
assert( fDriverCallBusy );
assert( fDriverCallParamPtr );
if (fDriverCallReason == kDriverCallInformPreChange)
{
OUR_PMLog(kPMLogInformDriverPreChange, (uintptr_t) this, powerState);
+ start_spindump_timer("WillChange");
clock_get_uptime(&informee->startTime);
result = driver->powerStateWillChangeTo(powerFlags, powerState, this);
clock_get_uptime(&end);
+ stop_spindump_timer();
OUR_PMLog((UInt32)-kPMLogInformDriverPreChange, (uintptr_t) this, result);
}
else
{
OUR_PMLog(kPMLogInformDriverPostChange, (uintptr_t) this, powerState);
+ start_spindump_timer("DidChange");
clock_get_uptime(&informee->startTime);
result = driver->powerStateDidChangeTo(powerFlags, powerState, this);
clock_get_uptime(&end);
+ stop_spindump_timer();
OUR_PMLog((UInt32)-kPMLogInformDriverPostChange, (uintptr_t) this, result);
}
-
+
deassertPMDriverCall(&callEntry);
#if LOG_SETPOWER_TIMES
SUB_ABSOLUTETIME(&end, &informee->startTime);
absolutetime_to_nanoseconds(end, &nsec);
- if (nsec > LOG_SETPOWER_TIMES)
- PM_LOG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) took %d ms\n",
- driver->getName(),
- (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
- driver, fName, fCurrentPowerState, powerState, NS_TO_MS(nsec));
-
- uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange)
- ? kIOPMEventTypePSWillChangeTo
- : kIOPMEventTypePSDidChangeTo;
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- logType, // type
- fName, // who
- (uintptr_t)this, // owner unique
- driver->getName(), // interest name
- (uint8_t)fCurrentPowerState, // old
- (uint8_t)fHeadNotePowerState, // new
- 0, // result
- NS_TO_US(nsec)); // usec completion time
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
+ if (nsec > LOG_SETPOWER_TIMES) {
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsDriverPSChangeSlow, driver->getName(),
+ fDriverCallReason, NS_TO_MS(nsec), 0, NULL, powerState);
+ }
}
#endif
}
IOReturn ret = IOPMAckImplied;
unsigned long childPower;
IOService * theChild;
- IOPMRequest * childRequest;
+ IOPMRequest * childRequest;
IOPMPowerChangeFlags requestArg2;
- int requestType;
+ int requestType;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
if (!theChild)
{
// Unless the child handles the notification immediately and returns
// kIOPMAckImplied, we'll be awaiting their acknowledgement later.
- fHeadNotePendingAcks++;
+ fHeadNotePendingAcks++;
theNub->setAwaitingAck(true);
requestArg2 = fHeadNoteChangeFlags;
kIOPMRequestTypePowerDomainWillChange :
kIOPMRequestTypePowerDomainDidChange;
- childRequest = acquirePMRequest( theChild, requestType );
- if (childRequest)
- {
+ childRequest = acquirePMRequest( theChild, requestType );
+ if (childRequest)
+ {
theNub->retain();
- childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags;
- childRequest->fArg1 = (void *) theNub;
- childRequest->fArg2 = (void *)(uintptr_t) requestArg2;
- theChild->submitPMRequest( childRequest );
- ret = IOPMWillAckLater;
- }
- else
- {
- ret = IOPMAckImplied;
- fHeadNotePendingAcks--;
- theNub->setAwaitingAck(false);
+ childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags;
+ childRequest->fArg1 = (void *) theNub;
+ childRequest->fArg2 = (void *)(uintptr_t) requestArg2;
+ theChild->submitPMRequest( childRequest );
+ ret = IOPMWillAckLater;
+ }
+ else
+ {
+ ret = IOPMAckImplied;
+ fHeadNotePendingAcks--;
+ theNub->setAwaitingAck(false);
childPower = theChild->currentPowerConsumption();
if ( childPower == kIOPMUnknown )
{
}
theChild->release();
- return (IOPMAckImplied == ret);
+ return (IOPMAckImplied == ret);
}
//*********************************************************************************
bool IOService::notifyControllingDriver( void )
{
- DriverCallParam * param;
+ DriverCallParam * param;
PM_ASSERT_IN_GATE();
assert( fDriverCallParamCount == 0 );
{
param = IONew(DriverCallParam, 1);
if (!param)
- return false; // no memory
+ return false; // no memory
fDriverCallParamPtr = (void *) param;
fDriverCallParamSlots = 1;
void IOService::notifyControllingDriverDone( void )
{
- DriverCallParam * param;
- IOReturn result;
+ DriverCallParam * param;
+ IOReturn result;
- PM_ASSERT_IN_GATE();
- param = (DriverCallParam *) fDriverCallParamPtr;
+ PM_ASSERT_IN_GATE();
+ param = (DriverCallParam *) fDriverCallParamPtr;
- assert( fDriverCallBusy == false );
- assert( fMachineState == kIOPM_DriverThreadCallDone );
+ assert( fDriverCallBusy == false );
+ assert( fMachineState == kIOPM_DriverThreadCallDone );
- if (param && fDriverCallParamCount)
- {
- assert(fDriverCallParamCount == 1);
-
- // the return value from setPowerState()
- result = param->Result;
+ if (param && fDriverCallParamCount)
+ {
+ assert(fDriverCallParamCount == 1);
- if ((result == IOPMAckImplied) || (result < 0))
- {
+ // the return value from setPowerState()
+ result = param->Result;
+
+ if ((result == IOPMAckImplied) || (result < 0))
+ {
fDriverTimer = 0;
- }
- else if (fDriverTimer)
- {
+ }
+ else if (fDriverTimer)
+ {
assert(fDriverTimer == -1);
// Driver has not acked, and has returned a positive result.
result = kMinAckTimeoutTicks;
fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
- }
- // else, child has already acked and driver_timer reset to 0.
+ }
+ // else, child has already acked and driver_timer reset to 0.
- fDriverCallParamCount = 0;
+ fDriverCallParamCount = 0;
- if ( fDriverTimer )
- {
- OUR_PMLog(kPMLogStartAckTimer, 0, 0);
- start_ack_timer();
- }
- }
+ if ( fDriverTimer )
+ {
+ OUR_PMLog(kPMLogStartAckTimer, 0, 0);
+ start_ack_timer();
+ }
+ }
MS_POP(); // pushed by OurChangeSetPowerState()
fIsPreChange = false;
const IOPMPSEntry * powerStatePtr;
IOPMDriverCallEntry callEntry;
uint32_t prevMachineState = fMachineState;
- bool callAction = false;
+ bool actionCalled = false;
uint64_t ts;
fMachineState = kIOPM_Finished;
}
// our power change
- if ( fHeadNoteChangeFlags & kIOPMSelfInitiated )
+ if (fHeadNoteChangeFlags & kIOPMSelfInitiated)
{
- // could our driver switch to the new state?
- if ( !( fHeadNoteChangeFlags & kIOPMNotDone) )
+ // power state changed
+ if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0)
{
trackSystemSleepPreventers(
fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
- // we changed, tell our parent
+ // we changed, tell our parent
requestDomainPower(fHeadNotePowerState);
// yes, did power raise?
OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
PM_ACTION_2(actionPowerChangeDone,
fHeadNotePowerState, fHeadNoteChangeFlags);
- callAction = true;
+ actionCalled = true;
powerStatePtr = &fPowerStates[fCurrentPowerState];
fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
}
}
- // parent's power change
- if ( fHeadNoteChangeFlags & kIOPMParentInitiated)
+ // parent-initiated power change
+ if (fHeadNoteChangeFlags & kIOPMParentInitiated)
{
if (fHeadNoteChangeFlags & kIOPMRootChangeDown)
ParentChangeRootChangeDown();
-
- if (((fHeadNoteChangeFlags & kIOPMDomainWillChange) &&
- (StateOrder(fCurrentPowerState) >= StateOrder(fHeadNotePowerState))) ||
- ((fHeadNoteChangeFlags & kIOPMDomainDidChange) &&
- (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState))))
+
+ // power state changed
+ if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0)
{
trackSystemSleepPreventers(
fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
#if PM_VARS_SUPPORT
fPMVars->myCurrentState = fCurrentPowerState;
#endif
- fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fHeadNoteDomainFlags);
OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
PM_ACTION_2(actionPowerChangeDone,
fHeadNotePowerState, fHeadNoteChangeFlags);
- callAction = true;
+ actionCalled = true;
powerStatePtr = &fPowerStates[fCurrentPowerState];
fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
fIdleTimerMinPowerState = kPowerStateZero;
}
- if (!callAction)
+ if (!actionCalled)
{
PM_ACTION_2(actionPowerChangeDone,
fHeadNotePowerState, fHeadNoteChangeFlags);
void IOService::OurChangeStart( void )
{
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState );
- // fMaxPowerState is our maximum possible power state based on the current
- // power state of our parents. If we are trying to raise power beyond the
- // maximum, send an async request for more power to all parents.
+ // fMaxPowerState is our maximum possible power state based on the current
+ // power state of our parents. If we are trying to raise power beyond the
+ // maximum, send an async request for more power to all parents.
if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState)))
{
return;
}
- // Redundant power changes skips to the end of the state machine.
+ // Redundant power changes skips to the end of the state machine.
if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState))
- {
- OurChangeFinish();
- return;
+ {
+ OurChangeFinish();
+ return;
}
fInitialPowerChange = false;
PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
- // Two separate paths, depending if power is being raised or lowered.
- // Lowering power is subject to approval by clients of this service.
+ // Two separate paths, depending if power is being raised or lowered.
+ // Lowering power is subject to approval by clients of this service.
if (IS_POWER_DROP)
{
fOutOfBandParameter = kNotifyApps;
askChangeDown(fHeadNotePowerState);
}
- else
- {
+ else
+ {
// This service is raising power and parents are able to support the
// new power state. However a parent may have already committed to
// drop power, which might force this object to temporarily drop power.
IOPMPowerStateIndex maxPowerState;
IOPMRequestDomainPowerContext context;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
assert(ourPowerState < fNumberOfPowerStates);
if (ourPowerState >= fNumberOfPowerStates)
return kIOReturnBadArgument;
// Fetch our input power flags for the requested power state.
// Parent request is stated in terms of required power flags.
- requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags;
+ requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags;
// Disregard the "previous request" for power reservation.
void IOService::OurSyncStart( void )
{
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
if (fInitialPowerChange)
return;
if (fHeadNoteChangeFlags & kIOPMNotDone)
{
- OurChangeFinish();
- return;
+ OurChangeFinish();
+ return;
}
if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown)
// [private] OurChangeTellClientsPowerDown
//
// All applications and kernel clients have acknowledged our permission to drop
-// power. Here we notify them that we will lower the power and wait for acks.
+// power. Here we notify them that we will lower the power and wait for acks.
//*********************************************************************************
void IOService::OurChangeTellClientsPowerDown( void )
if (IS_POWER_DROP)
{
rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests );
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeAppNotificationsFinished,
- NULL,
- 100,
- kIOReturnSuccess);
- rootDomain->recordAndReleasePMEvent( details );
}
else
rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests );
IOReturn IOService::ParentChangeStart( void )
{
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState );
// Root power domain has transitioned to its max power state
{
PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
- // Tell apps and kernel clients
- fInitialPowerChange = false;
+ // Tell apps and kernel clients
+ fInitialPowerChange = false;
fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown;
- tellChangeDown1(fHeadNotePowerState);
+ tellChangeDown1(fHeadNotePowerState);
return IOPMWillAckLater;
}
{
// We power up, but not all the way
fHeadNotePowerState = fDesiredPowerState;
- fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState];
+ fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState];
OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0);
}
} else {
// We don't need to change
fHeadNotePowerState = fCurrentPowerState;
- fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState];
+ fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState];
OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0);
}
}
if ( fHeadNoteChangeFlags & kIOPMDomainDidChange )
- {
+ {
if ( StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState) )
{
PM_ACTION_2(actionPowerChangeStart,
fHeadNotePowerState, &fHeadNoteChangeFlags);
// Parent did change up - start our change up
- fInitialPowerChange = false;
+ fInitialPowerChange = false;
ParentChangeTellCapabilityWillChange();
return IOPMWillAckLater;
}
// to our children.
fMachineState = kIOPM_SyncNotifyDidChange;
fDriverCallReason = kDriverCallInformPreChange;
+ fHeadNoteChangeFlags |= kIOPMNotDone;
notifyChildren();
return IOPMWillAckLater;
}
}
+ // No power state change necessary
+ fHeadNoteChangeFlags |= kIOPMNotDone;
+
all_done();
return IOPMAckImplied;
}
{
updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero);
computeDesiredState(kPowerStateZero, true);
+ requestDomainPower( fDesiredPowerState );
PM_LOG1("%s: tickle desire removed\n", fName);
}
void IOService::ParentChangeTellPriorityClientsPowerDown( void )
{
fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange;
- tellChangeDown2(fHeadNotePowerState);
+ tellChangeDown2(fHeadNotePowerState);
}
//*********************************************************************************
void IOService::ParentChangeNotifyInterestedDriversWillChange( void )
{
- notifyAll( kIOPM_ParentChangeSetPowerState );
+ notifyAll( kIOPM_ParentChangeSetPowerState );
}
//*********************************************************************************
void IOService::ParentChangeWaitForPowerSettle( void )
{
- fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;
+ fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;
startSettleTimer();
}
void IOService::ParentChangeNotifyInterestedDriversDidChange( void )
{
- notifyAll( kIOPM_ParentChangeTellCapabilityDidChange );
+ notifyAll( kIOPM_ParentChangeTellCapabilityDidChange );
}
//*********************************************************************************
//*********************************************************************************
// [private] ParentAcknowledgePowerChange
//
-// Acknowledge our power parent that our power change is done.
+// Acknowledge our power parent that our power change is done.
//*********************************************************************************
void IOService::ParentChangeAcknowledgePowerChange( void )
{
- IORegistryEntry * nub;
- IOService * parent;
+ IORegistryEntry * nub;
+ IOService * parent;
nub = fHeadNoteParentConnection;
nub->retain();
void IOService::settleTimerExpired( void )
{
- fSettleTimeUS = 0;
- gIOPMWorkQueue->signalWorkAvailable();
+ fSettleTimeUS = 0;
+ gIOPMWorkQueue->signalWorkAvailable();
}
//*********************************************************************************
static void
settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
{
- IOService * me = (IOService *) arg0;
+ IOService * me = (IOService *) arg0;
- if (gIOPMWorkLoop && gIOPMWorkQueue)
- {
- gIOPMWorkLoop->runAction(
+ if (gIOPMWorkLoop && gIOPMWorkQueue)
+ {
+ gIOPMWorkLoop->runAction(
OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired),
me);
- }
- me->release();
+ }
+ me->release();
}
//*********************************************************************************
IOPMPowerStateIndex stateIndex;
IOPMPowerStateIndex currentOrder, newOrder, i;
uint32_t settleTime = 0;
- boolean_t pending;
+ boolean_t pending;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
currentOrder = StateOrder(fCurrentPowerState);
newOrder = StateOrder(fHeadNotePowerState);
#ifndef __LP64__
void IOService::ack_timer_ticked ( void )
{
- assert(false);
+ assert(false);
}
#endif /* !__LP64__ */
bool IOService::ackTimerTick( void )
{
- IOPMinformee * nextObject;
- bool done = false;
+ IOPMinformee * nextObject;
+ bool done = false;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
switch (fMachineState) {
case kIOPM_OurChangeWaitForPowerSettle:
case kIOPM_ParentChangeWaitForPowerSettle:
PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n",
fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec));
-#if LOG_SETPOWER_TIMES
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeSetPowerStateDelayed, // type
- fName, // who
- (uintptr_t)this, // owner unique
- NULL, // interest name
- (uint8_t)getPowerState(), // old
- 0, // new
- kIOReturnTimeout, // result
- NS_TO_US(nsec)); // usec completion time
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
-#endif
-
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;
- }
+ {
+ // Unblock state machine and pretend driver has acked.
+ done = true;
+ }
} else {
// still waiting, set timer again
start_ack_timer();
OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState,
NS_TO_MS(nsec));
-#if LOG_SETPOWER_TIMES
- uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange)
- ? kIOPMEventTypePSWillChangeTo
- : kIOPMEventTypePSDidChangeTo;
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- logType, // type
- fName, // who
- (uintptr_t)this, // owner unique
- nextObject->whatObject->getName(), // interest name
- (uint8_t)fCurrentPowerState, // old
- (uint8_t)fHeadNotePowerState, // new
- kIOReturnTimeout, // result
- NS_TO_US(nsec)); // usec completion time
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
-#endif
-
// Pretend driver has acked.
fHeadNotePendingAcks--;
}
if ( fHeadNotePendingAcks == 0 )
{
// yes, we can continue
- done = true;
+ done = true;
} else {
// no, set timer again
start_ack_timer();
case kIOPM_SyncTellPriorityClientsPowerDown:
case kIOPM_SyncNotifyWillChange:
case kIOPM_TellCapabilityChangeDone:
- // apps didn't respond in time
+ // apps didn't respond in time
cleanClientResponses(true);
OUR_PMLog(kPMLogClientTardy, 0, 1);
- // tardy equates to approval
- done = true;
+ // tardy equates to approval
+ done = true;
break;
default:
PM_LOG1("%s: unexpected ack timer tick (state = %d)\n",
- getName(), fMachineState);
+ getName(), fMachineState);
break;
}
- return done;
+ return done;
}
//*********************************************************************************
{
AbsoluteTime deadline;
boolean_t pending;
+ static int timeout = -1;
- if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug) ||
- (getPMRootDomain()->sleepWakeDebugIsWdogEnabled() == false))
+ 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(WATCHDOG_TIMER_PERIOD, kSecondScale, &deadline);
+ clock_interval_to_deadline(timeout, kSecondScale, &deadline);
retain();
pending = thread_call_enter_delayed(fWatchdogTimer, deadline);
{
boolean_t pending;
- if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug) ||
- (getPMRootDomain()->sleepWakeDebugIsWdogEnabled() == false))
+ if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))
return false;
pending = thread_call_cancel(fWatchdogTimer);
void
IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
{
- IOService * me = (IOService *) arg0;
+ IOService * me = (IOService *) arg0;
gIOPMWatchDogThread = current_thread();
getPMRootDomain()->sleepWakeDebugTrig(true);
gIOPMWatchDogThread = 0;
- me->release();
+ thread_call_free(me->fWatchdogTimer);
+ me->fWatchdogTimer = 0;
- return ;
+ return ;
}
void IOService::start_ack_timer( void )
{
- start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale );
+ start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale );
}
void IOService::start_ack_timer ( UInt32 interval, UInt32 scale )
void
IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
{
- IOService * me = (IOService *) arg0;
+ IOService * me = (IOService *) arg0;
+
+ if (gIOPMWorkLoop)
+ {
+ gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
+ }
+ me->release();
+}
+
+//*********************************************************************************
+// [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);
- if (gIOPMWorkLoop)
- {
- gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
- }
- me->release();
+ 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: -
void IOService::tellSystemCapabilityChange( uint32_t nextMS )
{
- MS_PUSH( nextMS );
+ MS_PUSH( nextMS );
fMachineState = kIOPM_TellCapabilityChangeDone;
fOutOfBandMessage = kIOMessageSystemCapabilityChange;
(flag = context->responseArray->getObject(clientIndex)) &&
(flag != kOSBooleanTrue))
{
- OSNumber *clientID = copyClientIDForNotification(object, context);
-
+ 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);
+ name, 0, (30*1000), pid, object);
}
}
{
IOPMInterestContext context;
bool isRootDomain = IS_ROOT_DOMAIN;
+ uint32_t maxTimeOut = kMaxTimeRequested;
- PM_ASSERT_IN_GATE();
+ PM_ASSERT_IN_GATE();
assert( fResponseArray == NULL );
assert( fNotifyClientArray == NULL );
fResponseArray->setCapacityIncrement(8);
if (++fSerialNumber == 0)
- fSerialNumber++;
+ fSerialNumber++;
context.responseArray = fResponseArray;
context.notifyClients = 0;
switch ( fOutOfBandParameter ) {
case kNotifyApps:
applyToInterested( gIOAppPowerStateInterest,
- pmTellAppWithResponse, (void *) &context );
+ pmTellAppWithResponse, (void *) &context );
if (isRootDomain &&
(fMachineState != kIOPM_OurChangeTellClientsPowerDown) &&
context.notifyType = kNotifyCapabilityChangeApps;
context.messageType = kIOMessageSystemCapabilityChange;
applyToInterested( gIOAppPowerStateInterest,
- pmTellCapabilityAppWithResponse, (void *) &context );
+ pmTellCapabilityAppWithResponse, (void *) &context );
context.notifyType = fOutOfBandParameter;
context.messageType = messageType;
}
- context.maxTimeRequested = k30Seconds;
-
+ if(context.messageType == kIOMessageCanSystemSleep)
+ {
+ maxTimeOut = kCanSleepMaxTimeReq;
+ if(gCanSleepTimeout)
+ {
+ maxTimeOut = (gCanSleepTimeout*us_per_s);
+ }
+ }
+ context.maxTimeRequested = maxTimeOut;
applyToInterested( gIOGeneralInterest,
- pmTellClientWithResponse, (void *) &context );
+ pmTellClientWithResponse, (void *) &context );
fNotifyClientArray = context.notifyClients;
break;
case kNotifyPriority:
context.enableTracing = isRootDomain;
applyToInterested( gIOPriorityPowerStateInterest,
- pmTellClientWithResponse, (void *) &context );
+ pmTellClientWithResponse, (void *) &context );
if (isRootDomain)
{
case kNotifyCapabilityChangeApps:
applyToInterested( gIOAppPowerStateInterest,
- pmTellCapabilityAppWithResponse, (void *) &context );
+ pmTellCapabilityAppWithResponse, (void *) &context );
fNotifyClientArray = context.notifyClients;
- context.maxTimeRequested = k30Seconds;
+ if(context.messageType == kIOMessageCanSystemSleep)
+ {
+ maxTimeOut = kCanSleepMaxTimeReq;
+ if(gCanSleepTimeout)
+ {
+ maxTimeOut = (gCanSleepTimeout*us_per_s);
+ }
+ }
+ context.maxTimeRequested = maxTimeOut;
break;
case kNotifyCapabilityChangePriority:
applyToInterested( gIOPriorityPowerStateInterest,
- pmTellCapabilityClientWithResponse, (void *) &context );
+ pmTellCapabilityClientWithResponse, (void *) &context );
break;
}
OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0);
if (context.enableTracing)
getPMRootDomain()->traceDetail( context.maxTimeRequested / 1000 );
- start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
+ start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
return false;
}
OSNumber *clientID = NULL;
proc_t proc = NULL;
boolean_t proc_suspended = FALSE;
+ OSObject * waitForReply = kOSBooleanTrue;
#if LOG_APP_RESPONSE_TIMES
AbsoluteTime now;
#endif
}
}
}
-
+
if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, 0, 0))
+ !context->messageFilter(context->us, object, context, 0, &waitForReply))
{
if (kIOLogDebugPower & gIOKitDebug)
{
logClientIDForNotification(object, context, "MESG App");
}
+ if (waitForReply == kOSBooleanTrue)
+ {
#if LOG_APP_RESPONSE_TIMES
- OSNumber * num;
- clock_get_uptime(&now);
- num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
- if (num)
+ OSNumber * num;
+ clock_get_uptime(&now);
+ num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
+ if (num)
+ {
+ context->responseArray->setObject(msgIndex, num);
+ num->release();
+ }
+ else
+#endif
+ context->responseArray->setObject(msgIndex, kOSBooleanFalse);
+ }
+ else
{
- context->responseArray->setObject(msgIndex, num);
- num->release();
+ context->responseArray->setObject(msgIndex, kOSBooleanTrue);
+ if (kIOLogDebugPower & gIOKitDebug)
+ {
+ logClientIDForNotification(object, context, "App response ignored");
+ }
}
- else
-#endif
- context->responseArray->setObject(msgIndex, kOSBooleanFalse);
if (context->notifyClients)
context->notifyClients->setObject(msgIndex, object);
context->us->getName(),
getIOMessageString(context->messageType),
OBFUSCATE(object), OBFUSCATE(n->handler));
- }
+ }
return;
}
IOServicePM * pwrMgt = context->us->pwrMgt;
if (gIOKitDebug & kIOLogPower) {
- OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
- if (OSDynamicCast(IOService, object)) {
- const char *who = ((IOService *) object)->getName();
- gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
- }
+ OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
+ if (OSDynamicCast(IOService, object)) {
+ const char *who = ((IOService *) object)->getName();
+ gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
+ }
else if (notifier) {
- OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
+ OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
}
}
if ((kIOLogDebugPower & gIOKitDebug) && notifier)
if (kIOReturnSuccess == retCode)
{
if (0 == notify.returnValue) {
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
+ OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
} else {
replied = kOSBooleanFalse;
if ( notify.returnValue > context->maxTimeRequested )
} else {
// not a client of ours
// so we won't be waiting for response
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
+ OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
}
context->responseArray->setObject(msgIndex, replied);
if (clientID) {
clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue());
}
-
+
PM_LOG("%s MESG App(%u) %s, wait %u, %s\n",
context->us->getName(),
msgIndex, getIOMessageString(msgType),
context->us->getName(),
getIOMessageString(context->messageType),
OBFUSCATE(object), OBFUSCATE(n->handler));
- }
+ }
return;
}
IOServicePM * pwrMgt = context->us->pwrMgt;
if (gIOKitDebug & kIOLogPower) {
- OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
- if (OSDynamicCast(IOService, object)) {
- const char *who = ((IOService *) object)->getName();
- gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
- }
+ OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
+ if (OSDynamicCast(IOService, object)) {
+ const char *who = ((IOService *) object)->getName();
+ gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
+ }
else if (notifier) {
- OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
- }
+ OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
+ }
}
if ((kIOLogDebugPower & gIOKitDebug) && notifier)
{
if ( 0 == msgArg.maxWaitForReply )
{
// client doesn't want time to respond
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
+ OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
}
else
{
{
// not a client of ours
// so we won't be waiting for response
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
+ OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
}
context->responseArray->setObject(msgIndex, replied);
static void tellKernelClientApplier( OSObject * object, void * arg )
{
- IOPowerStateChangeNotification notify;
+ IOPowerStateChangeNotification notify;
IOPMInterestContext * context = (IOPMInterestContext *) arg;
if (context->messageFilter &&
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;
+ notify.returnValue = 0;
+ notify.stateNumber = context->stateNumber;
+ notify.stateFlags = context->stateFlags;
context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify));
}
static OSNumber * copyClientIDForNotification(
- OSObject *object,
+ OSObject *object,
IOPMInterestContext *context)
{
OSNumber *clientID = NULL;
static void logClientIDForNotification(
OSObject *object,
- IOPMInterestContext *context,
+ IOPMInterestContext *context,
const char *logString)
{
OSString *logClientID = NULL;
- OSNumber *clientID = copyClientIDForNotification(object, context);
+ OSNumber *clientID = copyClientIDForNotification(object, context);
- if (logString)
+ if (logString)
{
if (clientID)
logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue());
-
+
PM_LOG("%s %s %s, %s\n",
context->us->getName(), logString,
IOService::getIOMessageString(context->messageType),
logClientID ? logClientID->getCStringNoCopy() : "");
- if (logClientID)
+ if (logClientID)
logClientID->release();
}
-
- if (clientID)
+
+ if (clientID)
clientID->release();
return;
OSNumber * clientID = NULL;
proc_t proc = NULL;
boolean_t proc_suspended = FALSE;
-
+
if (context->us == IOService::getPMRootDomain())
{
if ((clientID = copyClientIDForNotification(object, context)))
bool IOService::checkForDone( void )
{
- int i = 0;
- OSObject * theFlag;
+ int i = 0;
+ OSObject * theFlag;
if (fResponseArray == NULL) {
return true;
}
-
+
for (i = 0; ; i++) {
theFlag = fResponseArray->getObject(i);
bool IOService::responseValid( uint32_t refcon, int pid )
{
- UInt16 serialComponent;
- UInt16 ordinalComponent;
- OSObject * theFlag;
+ UInt16 serialComponent;
+ UInt16 ordinalComponent;
+ OSObject * theFlag;
+ OSObject *object = 0;
serialComponent = (refcon >> 16) & 0xFFFF;
ordinalComponent = (refcon & 0xFFFF);
{
return false;
}
-
+
if ( fResponseArray == NULL )
{
return false;
}
-
+
theFlag = fResponseArray->getObject(ordinalComponent);
-
+
if ( theFlag == 0 )
{
return false;
}
+ if (fNotifyClientArray)
+ object = fNotifyClientArray->getObject(ordinalComponent);
+
OSNumber * num;
if ((num = OSDynamicCast(OSNumber, theFlag)))
{
#if LOG_APP_RESPONSE_TIMES
- AbsoluteTime now;
- AbsoluteTime start;
+ AbsoluteTime now;
+ AbsoluteTime start;
uint64_t nsec;
char name[128];
AbsoluteTime_to_scalar(&start) = num->unsigned64BitValue();
SUB_ABSOLUTETIME(&now, &start);
absolutetime_to_nanoseconds(now, &nsec);
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeAppResponse, // type
- name, // who
- (uintptr_t)pid, // owner unique
- NULL, // interest name
- 0, // old
- 0, // new
- 0, // result
- NS_TO_US(nsec)); // usec completion time
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
if (kIOLogDebugPower & gIOKitDebug)
{
// > 100 ms
if (nsec > LOG_APP_RESPONSE_TIMES)
{
- PM_LOG("PM response took %d ms (%d, %s)\n", NS_TO_MS(nsec),
+ 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);
- }
+ if (nsec > LOG_APP_RESPONSE_MSG_TRACER)
+ {
+ // TODO: populate the messageType argument
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsApplicationResponseSlow,
+ name, 0, NS_TO_MS(nsec), pid, object);
+ }
+ else
+ {
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsApplicationResponsePrompt,
+ name, 0, NS_TO_MS(nsec), pid, object);
}
#endif
theFlag = kOSBooleanFalse;
}
+ else if (object) {
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsApplicationResponsePrompt,
+ 0, 0, 0, pid, object);
+
+ }
- if ( kOSBooleanFalse == theFlag )
+ if ( kOSBooleanFalse == theFlag )
{
fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue);
}
-
+
return true;
}
IOReturn IOService::allowPowerChange( unsigned long refcon )
{
- IOPMRequest * request;
+ IOPMRequest * request;
if ( !initialized )
{
return kIOReturnSuccess;
}
- request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange );
- if (!request)
- return kIOReturnNoMemory;
+ request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange );
+ if (!request)
+ return kIOReturnNoMemory;
- request->fArg0 = (void *) refcon;
- request->fArg1 = (void *)(uintptr_t) proc_selfpid();
- request->fArg2 = (void *) 0;
- submitPMRequest( request );
+ request->fArg0 = (void *) refcon;
+ request->fArg1 = (void *)(uintptr_t) proc_selfpid();
+ request->fArg2 = (void *) 0;
+ submitPMRequest( request );
- return kIOReturnSuccess;
+ return kIOReturnSuccess;
}
#ifndef __LP64__
IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon )
{
- // [deprecated] public
- return kIOReturnUnsupported;
+ // [deprecated] public
+ return kIOReturnUnsupported;
}
#endif /* !__LP64__ */
IOReturn IOService::cancelPowerChange( unsigned long refcon )
{
- IOPMRequest * request;
+ IOPMRequest * request;
char name[128];
pid_t pid = proc_selfpid();
proc_name(pid, name, sizeof(name));
PM_ERROR("PM notification cancel (pid %d, %s)\n", pid, name);
- request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange );
- if (!request)
+ request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange );
+ if (!request)
{
return kIOReturnNoMemory;
}
#ifndef __LP64__
IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon )
{
- // [deprecated] public
- return kIOReturnUnsupported;
+ // [deprecated] public
+ return kIOReturnUnsupported;
}
//*********************************************************************************
unsigned long i;
uint64_t ts;
- if (!pwrMgt)
+ if (!pwrMgt)
return kIOReturnUnsupported;
if (!fNumberOfPowerStates)
return kIOReturnSuccess; // For drivers which are in power plane, but haven't called registerPowerDriver()
PM_LOCK();
- switch (action)
+ switch (action)
{
case kIOReportEnable:
- if (fReportBuf)
+ if (fReportBuf)
{
fReportClientCnt++;
break;
if (fPowerStates[i].capabilityFlags & kIOPMLowPower)
bits |= kPMReportLowPower;
- STATEREPORT_SETSTATEID(fReportBuf, i, ((bits & 0xff) << 8) |
+ STATEREPORT_SETSTATEID(fReportBuf, i, ((bits & 0xff) << 8) |
((StateOrder(fMaxPowerState) & 0xf) << 4) | (StateOrder(i) & 0xf));
}
ts = mach_absolute_time();
IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
- if (!pwrMgt)
+ if (!pwrMgt)
return kIOReturnUnsupported;
- if (!fNumberOfPowerStates)
+ if (!fNumberOfPowerStates)
return kIOReturnSuccess;
if ( !result || !dest ) return kIOReturnBadArgument;
PM_LOCK();
switch (action) {
- case kIOReportCopyChannelData:
+ case kIOReportCopyChannelData:
if ( !fReportBuf ) {
rc = kIOReturnNotOpen;
break;
}
STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result);
- dest->appendBytes(data2cpy, size2cpy);
+ dest->appendBytes(data2cpy, size2cpy);
default:
break;
//*********************************************************************************
// configureSimplePowerReport
//
-// Configures the IOSimpleReport for given channel id
+// Configures the IOSimpleReport for given channel id
//*********************************************************************************
IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, void *result )
{
IOReturn rc = kIOReturnSuccess;
- if ( !pwrMgt )
+ if ( !pwrMgt )
return kIOReturnUnsupported;
- if ( !fNumberOfPowerStates )
+ if ( !fNumberOfPowerStates )
return rc;
- switch (action)
+ switch (action)
{
case kIOReportEnable:
case kIOReportDisable:
//*********************************************************************************
// updateSimplePowerReport
//
-// Updates the IOSimpleReport for the given chanel id
+// 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
+ 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 )
+ if ( !pwrMgt )
return kIOReturnUnsupported;
if ( !result || !dest ) return kIOReturnBadArgument;
- if ( !fNumberOfPowerStates )
+ if ( !fNumberOfPowerStates )
return rc;
PM_LOCK();
switch (action) {
- case kIOReportCopyChannelData:
+ case kIOReportCopyChannelData:
SIMPLEREPORT_INIT(buf, sizeof(buf), getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower);
bits |= kPMReportLowPower;
- SIMPLEREPORT_SETVALUE(buf, ((bits & 0xff) << 8) | ((StateOrder(fMaxPowerState) & 0xf) << 4) |
+ SIMPLEREPORT_SETVALUE(buf, ((bits & 0xff) << 8) | ((StateOrder(fMaxPowerState) & 0xf) << 4) |
(StateOrder(fCurrentPowerState) & 0xf));
SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy);
}
SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result);
- dest->appendBytes(data2cpy, size2cpy);
+ dest->appendBytes(data2cpy, size2cpy);
default:
break;
//*********************************************************************************
IOReturn IOService::setPowerState(
- unsigned long powerStateOrdinal, IOService * whatDevice )
+ unsigned long powerStateOrdinal, IOService * whatDevice )
{
return IOPMNoErr;
}
void IOService::systemWillShutdown( IOOptionBits specifier )
{
- IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
- if (rootDomain)
- rootDomain->acknowledgeSystemWillShutdown( this );
+ IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
+ if (rootDomain)
+ rootDomain->acknowledgeSystemWillShutdown( this );
}
// MARK: -
IOService::acquirePMRequest( IOService * target, IOOptionBits requestType,
IOPMRequest * active )
{
- IOPMRequest * request;
+ IOPMRequest * request;
- assert(target);
+ assert(target);
- request = IOPMRequest::create();
- if (request)
- {
- request->init( target, requestType );
+ request = IOPMRequest::create();
+ if (request)
+ {
+ request->init( target, requestType );
if (active)
{
IOPMRequest * root = active->getRootRequest();
if (root) request->attachRootRequest(root);
}
}
- else
- {
+ else
+ {
PM_ERROR("%s: No memory for PM request type 0x%x\n",
target->getName(), (uint32_t) requestType);
- }
- return request;
+ }
+ return request;
}
//*********************************************************************************
void IOService::releasePMRequest( IOPMRequest * request )
{
- if (request)
- {
- request->reset();
- request->release();
- }
+ if (request)
+ {
+ request->reset();
+ request->release();
+ }
}
//*********************************************************************************
-// [private] submitPMRequest
+// [private static] submitPMRequest
//*********************************************************************************
void IOService::submitPMRequest( IOPMRequest * request )
{
- assert( request );
- assert( gIOPMReplyQueue );
- assert( gIOPMRequestQueue );
+ assert( request );
+ assert( gIOPMReplyQueue );
+ assert( gIOPMRequestQueue );
- PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
- (long)request->getType(), OBFUSCATE(request),
- OBFUSCATE(request->getTarget()), request->getTarget()->getName(),
- OBFUSCATE(request->fArg0),
+ PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
+ (long)request->getType(), OBFUSCATE(request),
+ OBFUSCATE(request->getTarget()), request->getTarget()->getName(),
+ OBFUSCATE(request->fArg0),
OBFUSCATE(request->fArg1), OBFUSCATE(request->fArg2));
- if (request->isReplyType())
- gIOPMReplyQueue->queuePMRequest( request );
- else
- gIOPMRequestQueue->queuePMRequest( request );
+ if (request->isReplyType())
+ gIOPMReplyQueue->queuePMRequest( request );
+ else
+ gIOPMRequestQueue->queuePMRequest( request );
}
-void IOService::submitPMRequest( IOPMRequest ** requests, IOItemCount count )
+void IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count )
{
- assert( requests );
- assert( count > 0 );
- assert( gIOPMRequestQueue );
+ assert( requests );
+ assert( count > 0 );
+ assert( gIOPMRequestQueue );
- for (IOItemCount i = 0; i < count; i++)
- {
- IOPMRequest * req = requests[i];
- PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
- (long)req->getType(), OBFUSCATE(req),
- OBFUSCATE(req->getTarget()), req->getTarget()->getName(),
- OBFUSCATE(req->fArg0),
+ for (IOItemCount i = 0; i < count; i++)
+ {
+ IOPMRequest * req = requests[i];
+ PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
+ (long)req->getType(), OBFUSCATE(req),
+ OBFUSCATE(req->getTarget()), req->getTarget()->getName(),
+ OBFUSCATE(req->fArg0),
OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2));
- }
+ }
- gIOPMRequestQueue->queuePMRequestChain( requests, count );
+ gIOPMRequestQueue->queuePMRequestChain( requests, count );
}
//*********************************************************************************
-// [private] servicePMRequestQueue
+// [private] actionPMRequestQueue
//
-// Called from IOPMRequestQueue::checkForWork().
+// IOPMRequestQueue::checkForWork() passing a new request to the request target.
//*********************************************************************************
-bool IOService::servicePMRequestQueue(
- IOPMRequest * request,
- IOPMRequestQueue * queue )
+bool IOService::actionPMRequestQueue(
+ IOPMRequest * request,
+ IOPMRequestQueue * queue )
{
bool more;
if (initialized)
{
- // Work queue will immediately execute the queue'd request if possible.
- // If execution blocks, the work queue will wait for a producer signal.
- // Only need to signal more when completing attached requests.
+ // Work queue will immediately execute the request if the per-service
+ // request queue is empty. Note pwrMgt is the target's IOServicePM.
more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt);
- return more;
}
+ else
+ {
+ // Calling PM without PMinit() is not allowed, fail the request.
+ // Need to signal more when completing attached requests.
- // Calling PM without PMinit() is not allowed, fail the request.
+ PM_LOG("%s: PM not initialized\n", getName());
+ PM_LOG1("[- %02x] %p [%p %s] !initialized\n",
+ request->getType(), OBFUSCATE(request),
+ OBFUSCATE(this), getName());
- PM_LOG("%s: PM not initialized\n", getName());
- fAdjustPowerScheduled = false;
- more = gIOPMFreeQueue->queuePMRequest(request);
- if (more) gIOPMWorkQueue->incrementProducerCount();
- return more;
+ more = gIOPMCompletionQueue->queuePMRequest(request);
+ if (more) gIOPMWorkQueue->incrementProducerCount();
+ }
+
+ return more;
}
//*********************************************************************************
-// [private] servicePMFreeQueue
+// [private] actionPMCompletionQueue
//
-// Called from IOPMCompletionQueue::checkForWork().
+// IOPMCompletionQueue::checkForWork() passing a completed request to the
+// request target.
//*********************************************************************************
-bool IOService::servicePMFreeQueue(
- IOPMRequest * request,
- IOPMCompletionQueue * queue )
+bool IOService::actionPMCompletionQueue(
+ IOPMRequest * request,
+ IOPMCompletionQueue * queue )
{
- bool more = request->getNextRequest();
+ bool more = (request->getNextRequest() != 0);
IOPMRequest * root = request->getRootRequest();
if (root && (root != request))
if (more)
gIOPMWorkQueue->incrementProducerCount();
- releasePMRequest( request );
- return more;
+ releasePMRequest( request );
+ return more;
}
//*********************************************************************************
-// [private] retirePMRequest
+// [private] actionPMWorkQueueRetire
//
-// Called by IOPMWorkQueue to retire a completed request.
+// IOPMWorkQueue::checkForWork() passing a retired request to the request target.
//*********************************************************************************
-bool IOService::retirePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
+bool IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * queue )
{
- assert(request && queue);
+ assert(request && queue);
- PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n",
- request->getType(), OBFUSCATE(request),
+ PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n",
+ request->getType(), OBFUSCATE(request),
OBFUSCATE(this), getName(),
- fMachineState, gIOPMBusyCount);
+ fMachineState, gIOPMBusyRequestCount);
- // Catch requests created by idleTimerExpired().
+ // Catch requests created by idleTimerExpired()
+ if (request->getType() == kIOPMRequestTypeActivityTickle)
+ {
+ uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1;
- if ((request->getType() == kIOPMRequestTypeActivityTickle) &&
- (((uintptr_t) request->fArg1) & kTickleTypePowerDrop) &&
- fIdleTimerPeriod)
- {
- restartIdleTimer();
+ if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod)
+ {
+ restartIdleTimer();
+ }
+ else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise))
+ {
+ // Invalidate any idle power drop that got queued while
+ // processing this request.
+ fIdleTimerGeneration++;
+ }
}
+
+ // When the completed request is linked, tell work queue there is
+ // more work pending.
- // If the request is linked, then Work queue has already incremented its
- // producer count.
-
- return (gIOPMFreeQueue->queuePMRequest( request ));
+ return (gIOPMCompletionQueue->queuePMRequest( request ));
}
//*********************************************************************************
bool IOService::isPMBlocked( IOPMRequest * request, int count )
{
- int reason = 0;
+ int reason = 0;
- do {
- if (kIOPM_Finished == fMachineState)
- break;
+ do {
+ if (kIOPM_Finished == fMachineState)
+ break;
- if (kIOPM_DriverThreadCallDone == fMachineState)
- {
+ if (kIOPM_DriverThreadCallDone == fMachineState)
+ {
// 5 = kDriverCallInformPreChange
// 6 = kDriverCallInformPostChange
// 7 = kDriverCallSetPowerState
// 8 = kRootDomainInformPreChange
- if (fDriverCallBusy)
+ if (fDriverCallBusy)
reason = 5 + fDriverCallReason;
- break;
- }
+ break;
+ }
- // Waiting on driver's setPowerState() timeout.
- if (fDriverTimer)
- {
- reason = 1; break;
- }
+ // Waiting on driver's setPowerState() timeout.
+ if (fDriverTimer)
+ {
+ reason = 1; break;
+ }
- // Child or interested driver acks pending.
- if (fHeadNotePendingAcks)
- {
- reason = 2; break;
- }
+ // Child or interested driver acks pending.
+ if (fHeadNotePendingAcks)
+ {
+ reason = 2; break;
+ }
- // Waiting on apps or priority power interest clients.
- if (fResponseArray)
- {
- reason = 3; break;
- }
+ // Waiting on apps or priority power interest clients.
+ if (fResponseArray)
+ {
+ reason = 3; break;
+ }
- // Waiting on settle timer expiration.
- if (fSettleTimeUS)
- {
- reason = 4; break;
- }
- } while (false);
+ // Waiting on settle timer expiration.
+ if (fSettleTimeUS)
+ {
+ reason = 4; break;
+ }
+ } while (false);
- fWaitReason = reason;
+ fWaitReason = reason;
- if (reason)
- {
- if (count)
- {
- PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n",
- request->getType(), OBFUSCATE(request),
+ 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);
- }
+ fMachineState, reason);
+ }
- return true;
- }
+ return true;
+ }
- return false;
+ return false;
}
//*********************************************************************************
-// [private] servicePMRequest
+// [private] actionPMWorkQueueInvoke
//
-// Service a request from our work queue.
+// IOPMWorkQueue::checkForWork() passing a request to the
+// request target for execution.
//*********************************************************************************
-bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
+bool IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue )
{
- bool done = false;
- int loop = 0;
+ bool done = false;
+ int loop = 0;
- assert(request && queue);
+ assert(request && queue);
- while (isPMBlocked(request, loop++) == false)
- {
- PM_LOG1("[W %02x] %p [%p %s] state %d\n",
- request->getType(), OBFUSCATE(request),
+ while (isPMBlocked(request, loop++) == false)
+ {
+ PM_LOG1("[W %02x] %p [%p %s] state %d\n",
+ request->getType(), OBFUSCATE(request),
OBFUSCATE(this), getName(), fMachineState);
- gIOPMRequest = request;
- gIOPMWorkCount++;
+ gIOPMRequest = request;
+ gIOPMWorkInvokeCount++;
- // Every PM machine states must be handled in one of the cases below.
+ // Every PM machine states must be handled in one of the cases below.
- switch ( fMachineState )
- {
- case kIOPM_Finished:
+ switch ( fMachineState )
+ {
+ case kIOPM_Finished:
start_watchdog_timer();
- executePMRequest( request );
- break;
+ executePMRequest( request );
+ break;
- case kIOPM_OurChangeTellClientsPowerDown:
+ case kIOPM_OurChangeTellClientsPowerDown:
// Root domain might self cancel due to assertions.
if (IS_ROOT_DOMAIN)
{
}
// askChangeDown() done, was it vetoed?
- if (!fDoNotPowerDown)
- {
- if (IS_ROOT_DOMAIN) {
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeAppNotificationsFinished,
- NULL,
- 0,
- 0);
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
- }
-
- // no, we can continue
- OurChangeTellClientsPowerDown();
- }
- else
- {
- if (IS_ROOT_DOMAIN) {
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeSleepDone,
- NULL,
- 1, /* reason: 1 == Ask clients succeeded */
- kIOReturnAborted); /* result */
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
- }
+ if (!fDoNotPowerDown)
+ {
+ // no, we can continue
+ OurChangeTellClientsPowerDown();
+ }
+ else
+ {
+ OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+ PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
+ // yes, rescind the warning
+ tellNoChangeDown(fHeadNotePowerState);
+ // mark the change note un-actioned
+ fHeadNoteChangeFlags |= kIOPMNotDone;
+ // and we're done
+ OurChangeFinish();
+ }
+ break;
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
- // yes, rescind the warning
- tellNoChangeDown(fHeadNotePowerState);
- // mark the change note un-actioned
- fHeadNoteChangeFlags |= kIOPMNotDone;
- // and we're done
- OurChangeFinish();
- }
- break;
-
- case kIOPM_OurChangeTellUserPMPolicyPowerDown:
+ case kIOPM_OurChangeTellUserPMPolicyPowerDown:
// PMRD: tellChangeDown/kNotifyApps done, was it cancelled?
- if (fDoNotPowerDown)
- {
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
- // yes, rescind the warning
- tellNoChangeDown(fHeadNotePowerState);
- // mark the change note un-actioned
- fHeadNoteChangeFlags |= kIOPMNotDone;
- // and we're done
- OurChangeFinish();
- }
- else
- OurChangeTellUserPMPolicyPowerDown();
- break;
-
- case kIOPM_OurChangeTellPriorityClientsPowerDown:
- // PMRD: LastCallBeforeSleep notify done
+ if (fDoNotPowerDown)
+ {
+ OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+ PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
+ // yes, rescind the warning
+ tellNoChangeDown(fHeadNotePowerState);
+ // mark the change note un-actioned
+ fHeadNoteChangeFlags |= kIOPMNotDone;
+ // and we're done
+ OurChangeFinish();
+ }
+ else
+ OurChangeTellUserPMPolicyPowerDown();
+ break;
+
+ case kIOPM_OurChangeTellPriorityClientsPowerDown:
+ // PMRD: LastCallBeforeSleep notify done
// Non-PMRD: tellChangeDown/kNotifyApps done
- if (fDoNotPowerDown)
- {
- if (IS_ROOT_DOMAIN) {
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeSleepDone,
- NULL,
- 2, /* reason: 2 == Client cancelled wake */
- kIOReturnAborted); /* result */
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
- }
- 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
- {
- if (IS_ROOT_DOMAIN) {
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeAppNotificationsFinished,
- NULL,
- 2, /* reason: 2 == TellPriorityClientsDone */
- kIOReturnSuccess); /* result */
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
- }
- // yes, we can continue
- OurChangeTellPriorityClientsPowerDown();
- }
- break;
+ if (fDoNotPowerDown)
+ {
+ OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+ PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState);
+ // no, tell clients we're back in the old state
+ tellChangeUp(fCurrentPowerState);
+ // mark the change note un-actioned
+ fHeadNoteChangeFlags |= kIOPMNotDone;
+ // and we're done
+ OurChangeFinish();
+ }
+ else
+ {
+ // yes, we can continue
+ OurChangeTellPriorityClientsPowerDown();
+ }
+ break;
- case kIOPM_OurChangeNotifyInterestedDriversWillChange:
- OurChangeNotifyInterestedDriversWillChange();
- break;
+ case kIOPM_OurChangeNotifyInterestedDriversWillChange:
+ OurChangeNotifyInterestedDriversWillChange();
+ break;
- case kIOPM_OurChangeSetPowerState:
- OurChangeSetPowerState();
- break;
+ case kIOPM_OurChangeSetPowerState:
+ OurChangeSetPowerState();
+ break;
- case kIOPM_OurChangeWaitForPowerSettle:
- OurChangeWaitForPowerSettle();
- break;
+ case kIOPM_OurChangeWaitForPowerSettle:
+ OurChangeWaitForPowerSettle();
+ break;
- case kIOPM_OurChangeNotifyInterestedDriversDidChange:
- OurChangeNotifyInterestedDriversDidChange();
- break;
+ case kIOPM_OurChangeNotifyInterestedDriversDidChange:
+ OurChangeNotifyInterestedDriversDidChange();
+ break;
case kIOPM_OurChangeTellCapabilityDidChange:
OurChangeTellCapabilityDidChange();
break;
- case kIOPM_OurChangeFinish:
- OurChangeFinish();
- break;
+ case kIOPM_OurChangeFinish:
+ OurChangeFinish();
+ break;
- case kIOPM_ParentChangeTellPriorityClientsPowerDown:
- ParentChangeTellPriorityClientsPowerDown();
- break;
+ case kIOPM_ParentChangeTellPriorityClientsPowerDown:
+ ParentChangeTellPriorityClientsPowerDown();
+ break;
- case kIOPM_ParentChangeNotifyInterestedDriversWillChange:
- ParentChangeNotifyInterestedDriversWillChange();
- break;
+ case kIOPM_ParentChangeNotifyInterestedDriversWillChange:
+ ParentChangeNotifyInterestedDriversWillChange();
+ break;
- case kIOPM_ParentChangeSetPowerState:
- ParentChangeSetPowerState();
- break;
+ case kIOPM_ParentChangeSetPowerState:
+ ParentChangeSetPowerState();
+ break;
- case kIOPM_ParentChangeWaitForPowerSettle:
- ParentChangeWaitForPowerSettle();
- break;
+ case kIOPM_ParentChangeWaitForPowerSettle:
+ ParentChangeWaitForPowerSettle();
+ break;
- case kIOPM_ParentChangeNotifyInterestedDriversDidChange:
- ParentChangeNotifyInterestedDriversDidChange();
- break;
+ case kIOPM_ParentChangeNotifyInterestedDriversDidChange:
+ ParentChangeNotifyInterestedDriversDidChange();
+ break;
case kIOPM_ParentChangeTellCapabilityDidChange:
ParentChangeTellCapabilityDidChange();
break;
- case kIOPM_ParentChangeAcknowledgePowerChange:
- ParentChangeAcknowledgePowerChange();
- break;
+ case kIOPM_ParentChangeAcknowledgePowerChange:
+ ParentChangeAcknowledgePowerChange();
+ break;
- case kIOPM_DriverThreadCallDone:
+ case kIOPM_DriverThreadCallDone:
switch (fDriverCallReason)
{
case kDriverCallInformPreChange:
panic("%s: bad call reason %x",
getName(), fDriverCallReason);
}
- break;
+ break;
- case kIOPM_NotifyChildrenOrdered:
- notifyChildrenOrdered();
- break;
+ case kIOPM_NotifyChildrenOrdered:
+ notifyChildrenOrdered();
+ break;
- case kIOPM_NotifyChildrenDelayed:
- notifyChildrenDelayed();
- break;
+ case kIOPM_NotifyChildrenDelayed:
+ notifyChildrenDelayed();
+ break;
case kIOPM_NotifyChildrenStart:
// pop notifyAll() state saved by notifyInterestedDriversDone()
&fHeadNoteChangeFlags, &cancel);
fDoNotPowerDown = cancel;
}
- if (!fDoNotPowerDown)
- {
+ if (!fDoNotPowerDown)
+ {
fMachineState = kIOPM_SyncTellPriorityClientsPowerDown;
fOutOfBandParameter = kNotifyApps;
tellChangeDown(fHeadNotePowerState);
- }
- else
- {
+ }
+ 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();
- }
+ 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)
- {
+ 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;
+ 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)
tellClientsWithResponse( fOutOfBandMessage );
break;
- default:
- panic("servicePMWorkQueue: unknown machine state %x",
+ default:
+ panic("PMWorkQueueInvoke: unknown machine state %x",
fMachineState);
- }
+ }
- gIOPMRequest = 0;
+ gIOPMRequest = 0;
- if (fMachineState == kIOPM_Finished)
- {
+ if (fMachineState == kIOPM_Finished)
+ {
stop_watchdog_timer();
- done = true;
- break;
- }
- }
+ done = true;
+ break;
+ }
+ }
- return done;
+ return done;
}
//*********************************************************************************
void IOService::executePMRequest( IOPMRequest * request )
{
- assert( kIOPM_Finished == fMachineState );
+ assert( kIOPM_Finished == fMachineState );
- switch (request->getType())
- {
- case kIOPMRequestTypePMStop:
- handlePMstop( request );
- break;
+ switch (request->getType())
+ {
+ case kIOPMRequestTypePMStop:
+ handlePMstop( request );
+ break;
- case kIOPMRequestTypeAddPowerChild1:
- addPowerChild1( request );
- break;
+ case kIOPMRequestTypeAddPowerChild1:
+ addPowerChild1( request );
+ break;
- case kIOPMRequestTypeAddPowerChild2:
- addPowerChild2( request );
- break;
+ case kIOPMRequestTypeAddPowerChild2:
+ addPowerChild2( request );
+ break;
- case kIOPMRequestTypeAddPowerChild3:
- addPowerChild3( request );
- break;
+ case kIOPMRequestTypeAddPowerChild3:
+ addPowerChild3( request );
+ break;
- case kIOPMRequestTypeRegisterPowerDriver:
- handleRegisterPowerDriver( request );
- break;
+ case kIOPMRequestTypeRegisterPowerDriver:
+ handleRegisterPowerDriver( request );
+ break;
- case kIOPMRequestTypeAdjustPowerState:
- fAdjustPowerScheduled = false;
- adjustPowerState();
- break;
+ case kIOPMRequestTypeAdjustPowerState:
+ fAdjustPowerScheduled = false;
+ adjustPowerState();
+ break;
- case kIOPMRequestTypePowerDomainWillChange:
- handlePowerDomainWillChangeTo( request );
- break;
+ case kIOPMRequestTypePowerDomainWillChange:
+ handlePowerDomainWillChangeTo( request );
+ break;
- case kIOPMRequestTypePowerDomainDidChange:
- handlePowerDomainDidChangeTo( request );
- break;
+ case kIOPMRequestTypePowerDomainDidChange:
+ handlePowerDomainDidChangeTo( request );
+ break;
- case kIOPMRequestTypeRequestPowerState:
+ case kIOPMRequestTypeRequestPowerState:
case kIOPMRequestTypeRequestPowerStateOverride:
- handleRequestPowerState( request );
- break;
+ handleRequestPowerState( request );
+ break;
- case kIOPMRequestTypePowerOverrideOnPriv:
- case kIOPMRequestTypePowerOverrideOffPriv:
- handlePowerOverrideChanged( request );
- break;
+ case kIOPMRequestTypePowerOverrideOnPriv:
+ case kIOPMRequestTypePowerOverrideOffPriv:
+ handlePowerOverrideChanged( request );
+ break;
- case kIOPMRequestTypeActivityTickle:
- handleActivityTickle( request );
- break;
+ case kIOPMRequestTypeActivityTickle:
+ handleActivityTickle( request );
+ break;
case kIOPMRequestTypeSynchronizePowerTree:
- handleSynchronizePowerTree( request );
- break;
+ handleSynchronizePowerTree( request );
+ break;
case kIOPMRequestTypeSetIdleTimerPeriod:
{
fIdleTimerPeriod = (uintptr_t) request->fArg0;
+ fNextIdleTimerPeriod = fIdleTimerPeriod;
if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0))
restartIdleTimer();
}
fIdleTimerIgnored = request->fArg0 ? 1 : 0;
break;
- default:
- panic("executePMRequest: unknown request type %x", request->getType());
- }
+ case kIOPMRequestTypeQuiescePowerTree:
+ gIOPMWorkQueue->finishQuiesceRequest(request);
+ break;
+
+ default:
+ panic("executePMRequest: unknown request type %x", request->getType());
+ }
}
//*********************************************************************************
-// [private] servicePMReplyQueue
+// [private] actionPMReplyQueue
+//
+// IOPMRequestQueue::checkForWork() passing a reply-type request to the
+// request target.
//*********************************************************************************
-bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue )
+bool IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue )
{
- bool more = false;
+ bool more = false;
- assert( request && queue );
- assert( request->isReplyType() );
+ assert( request && queue );
+ assert( request->isReplyType() );
- PM_LOG1("[A %02x] %p [%p %s] state %d\n",
- request->getType(), OBFUSCATE(request),
+ PM_LOG1("[A %02x] %p [%p %s] state %d\n",
+ request->getType(), OBFUSCATE(request),
OBFUSCATE(this), getName(), fMachineState);
- switch ( request->getType() )
- {
- case kIOPMRequestTypeAllowPowerChange:
- case kIOPMRequestTypeCancelPowerChange:
- // Check if we are expecting this response.
- if (responseValid((uint32_t)(uintptr_t) request->fArg0,
+ switch ( request->getType() )
+ {
+ case kIOPMRequestTypeAllowPowerChange:
+ case kIOPMRequestTypeCancelPowerChange:
+ // Check if we are expecting this response.
+ if (responseValid((uint32_t)(uintptr_t) request->fArg0,
(int)(uintptr_t) request->fArg1))
- {
- if (kIOPMRequestTypeCancelPowerChange == request->getType())
+ {
+ if (kIOPMRequestTypeCancelPowerChange == request->getType())
{
// Clients are not allowed to cancel when kIOPMSkipAskPowerDown
// flag is set. Only root domain will set this flag.
getPMRootDomain()->pmStatsRecordApplicationResponse(
gIOPMStatsApplicationResponseCancel,
name ? name->getCStringNoCopy() : "", 0,
- 0, (int)(uintptr_t) request->fArg1);
+ 0, (int)(uintptr_t) request->fArg1, 0);
}
}
- if (checkForDone())
- {
- stop_ack_timer();
+ if (checkForDone())
+ {
+ stop_ack_timer();
cleanClientResponses(false);
- more = true;
- }
- }
+ more = true;
+ }
+ }
// OSString containing app name in Arg2 must be released.
if (request->getType() == kIOPMRequestTypeCancelPowerChange)
{
OSObject * obj = (OSObject *) request->fArg2;
if (obj) obj->release();
}
- break;
-
- case kIOPMRequestTypeAckPowerChange:
- more = handleAcknowledgePowerChange( request );
- break;
-
- case kIOPMRequestTypeAckSetPowerState:
- if (fDriverTimer == -1)
- {
- // driver acked while setPowerState() call is in-flight.
- // take this ack, return value from setPowerState() is irrelevant.
- OUR_PMLog(kPMLogDriverAcknowledgeSet,
- (uintptr_t) this, fDriverTimer);
- fDriverTimer = 0;
- }
- else if (fDriverTimer > 0)
- {
- // expected ack, stop the timer
- stop_ack_timer();
+ break;
+
+ case kIOPMRequestTypeAckPowerChange:
+ more = handleAcknowledgePowerChange( request );
+ break;
+
+ case kIOPMRequestTypeAckSetPowerState:
+ if (fDriverTimer == -1)
+ {
+ // driver acked while setPowerState() call is in-flight.
+ // take this ack, return value from setPowerState() is irrelevant.
+ OUR_PMLog(kPMLogDriverAcknowledgeSet,
+ (uintptr_t) this, fDriverTimer);
+ fDriverTimer = 0;
+ }
+ else if (fDriverTimer > 0)
+ {
+ // expected ack, stop the timer
+ stop_ack_timer();
#if LOG_SETPOWER_TIMES
uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
- if (nsec > LOG_SETPOWER_TIMES)
- PM_LOG("%s::setPowerState(%p, %lu -> %lu) async took %d ms\n",
- fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec));
-
- PMEventDetails *details = PMEventDetails::eventDetails(
- kIOPMEventTypeSetPowerStateDelayed, // type
- fName, // who
- (uintptr_t)this, // owner unique
- NULL, // interest name
- (uint8_t)getPowerState(), // old
- (uint8_t)fHeadNotePowerState, // new
- 0, // result
- NS_TO_US(nsec)); // usec completion time
-
- getPMRootDomain()->recordAndReleasePMEvent( details );
+ if (nsec > LOG_SETPOWER_TIMES) {
+ getPMRootDomain()->pmStatsRecordApplicationResponse(
+ gIOPMStatsDriverPSChangeSlow,
+ fName, kDriverCallSetPowerState, NS_TO_MS(nsec), 0, NULL, fHeadNotePowerState);
+ }
#endif
- OUR_PMLog(kPMLogDriverAcknowledgeSet, (uintptr_t) this, fDriverTimer);
- fDriverTimer = 0;
- more = true;
- }
- else
- {
- // unexpected ack
- OUR_PMLog(kPMLogAcknowledgeErr4, (uintptr_t) this, 0);
- }
- break;
-
- case kIOPMRequestTypeInterestChanged:
- handleInterestChanged( request );
- more = true;
- break;
-
- case kIOPMRequestTypeIdleCancel:
- if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown)
+ 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_OurChangeTellPriorityClientsPowerDown)
|| (fMachineState == kIOPM_SyncTellClientsPowerDown)
|| (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown))
- {
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+ {
+ OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
PM_LOG2("%s: cancel from machine state %d\n",
getName(), fMachineState);
- fDoNotPowerDown = true;
+ fDoNotPowerDown = true;
// Stop waiting for app replys.
- if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) ||
- (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) ||
- (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown))
- cleanClientResponses(false);
- more = true;
- }
- break;
+ if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) ||
+ (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) ||
+ (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown) ||
+ (fMachineState == kIOPM_SyncTellClientsPowerDown) )
+ cleanClientResponses(false);
+ more = true;
+ }
+ break;
case kIOPMRequestTypeChildNotifyDelayCancel:
if (fMachineState == kIOPM_NotifyChildrenDelayed)
{
- PM_LOG2("%s: delay notify cancelled\n", getName());
+ PM_LOG2("%s: delay notify cancelled\n", getName());
notifyChildrenDelayed();
}
break;
- default:
- panic("servicePMReplyQueue: unknown reply type %x",
- request->getType());
- }
+ default:
+ panic("PMReplyQueue: unknown reply type %x", request->getType());
+ }
- more |= gIOPMFreeQueue->queuePMRequest(request);
+ more |= gIOPMCompletionQueue->queuePMRequest(request);
if (more)
gIOPMWorkQueue->incrementProducerCount();
- return more;
+ return more;
}
//*********************************************************************************
{
goto fail;
}
-
+
if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive())
{
goto fail;
}
continue;
}
-
+
wait = true;
break;
}
{
#define MSG_ENTRY(x) {(int) x, #x}
- static const IONamedValue msgNames[] = {
+ static const IONamedValue msgNames[] = {
MSG_ENTRY( kIOMessageCanDevicePowerOff ),
MSG_ENTRY( kIOMessageDeviceWillPowerOff ),
MSG_ENTRY( kIOMessageDeviceWillNotPowerOff ),
IOPMRequest * IOPMRequest::create( void )
{
- IOPMRequest * me = OSTypeAlloc(IOPMRequest);
- if (me && !me->init(0, kIOPMRequestTypeInvalid))
- {
- me->release();
- me = 0;
- }
- return me;
+ IOPMRequest * me = OSTypeAlloc(IOPMRequest);
+ if (me && !me->init(0, kIOPMRequestTypeInvalid))
+ {
+ me->release();
+ me = 0;
+ }
+ return me;
}
bool IOPMRequest::init( IOService * target, IOOptionBits type )
{
- if (!IOCommand::init())
- return false;
+ if (!IOCommand::init())
+ return false;
- fType = type;
- fTarget = target;
-#if NOT_READY
- fCompletionStatus = kIOReturnSuccess;
-#endif
+ fRequestType = type;
+ fTarget = target;
+
+ if (fTarget)
+ fTarget->retain();
- if (fTarget)
- fTarget->retain();
+ // Root node and root domain requests does not prevent the power tree from
+ // becoming quiescent.
- return true;
+ fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) &&
+ (fTarget != IOService::getPMRootDomain()));
+
+ return true;
}
void IOPMRequest::reset( void )
{
- assert( fWorkWaitCount == 0 );
- assert( fFreeWaitCount == 0 );
+ assert( fWorkWaitCount == 0 );
+ assert( fFreeWaitCount == 0 );
- detachNextRequest();
+ detachNextRequest();
detachRootRequest();
- fType = kIOPMRequestTypeInvalid;
-
-#if NOT_READY
- if (fCompletionAction)
- {
- fCompletionAction(fCompletionTarget, fCompletionParam, fCompletionStatus);
+ if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree))
+ {
+ // Call the completion on PM work loop context
+ fCompletionAction(fCompletionTarget, fCompletionParam);
+ fCompletionAction = 0;
}
-#endif
- if (fTarget)
- {
- fTarget->release();
- fTarget = 0;
- }
+ fRequestType = kIOPMRequestTypeInvalid;
+
+ if (fTarget)
+ {
+ fTarget->release();
+ fTarget = 0;
+ }
}
bool IOPMRequest::attachNextRequest( IOPMRequest * next )
fRequestNext->fWorkWaitCount++;
#if LOG_REQUEST_ATTACH
PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n",
- OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestNext),
- (uint32_t) fRequestNext->fType,
+ OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext),
+ fRequestNext->fRequestType,
(uint32_t) fRequestNext->fWorkWaitCount,
fTarget->getName());
#endif
fRequestNext->fWorkWaitCount--;
#if LOG_REQUEST_ATTACH
PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n",
- OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestNext),
- (uint32_t) fRequestNext->fType,
+ OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext),
+ fRequestNext->fRequestType,
(uint32_t) fRequestNext->fWorkWaitCount,
fTarget->getName());
#endif
IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction )
{
- IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
- if (me && !me->init(inOwner, inAction))
- {
- me->release();
- me = 0;
- }
- return me;
+ IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
+ if (me && !me->init(inOwner, inAction))
+ {
+ me->release();
+ me = 0;
+ }
+ return me;
}
bool IOPMRequestQueue::init( IOService * inOwner, Action inAction )
{
- if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
+ if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
return false;
- queue_init(&fQueue);
- fLock = IOLockAlloc();
- return (fLock != 0);
+ queue_init(&fQueue);
+ fLock = IOLockAlloc();
+ return (fLock != 0);
}
void IOPMRequestQueue::free( void )
{
- if (fLock)
- {
- IOLockFree(fLock);
- fLock = 0;
- }
- return IOEventSource::free();
+ if (fLock)
+ {
+ IOLockFree(fLock);
+ fLock = 0;
+ }
+ return IOEventSource::free();
}
void IOPMRequestQueue::queuePMRequest( IOPMRequest * request )
{
- assert(request);
- IOLockLock(fLock);
- queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
- IOLockUnlock(fLock);
- if (workLoop) signalWorkAvailable();
+ assert(request);
+ IOLockLock(fLock);
+ queue_enter(&fQueue, request, typeof(request), fCommandChain);
+ IOLockUnlock(fLock);
+ if (workLoop) signalWorkAvailable();
}
void
IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count )
{
- IOPMRequest * next;
+ IOPMRequest * next;
- assert(requests && count);
- IOLockLock(fLock);
- while (count--)
- {
- next = *requests;
- requests++;
- queue_enter(&fQueue, next, IOPMRequest *, fCommandChain);
- }
- IOLockUnlock(fLock);
- if (workLoop) signalWorkAvailable();
+ assert(requests && count);
+ IOLockLock(fLock);
+ while (count--)
+ {
+ next = *requests;
+ requests++;
+ queue_enter(&fQueue, next, typeof(next), fCommandChain);
+ }
+ IOLockUnlock(fLock);
+ if (workLoop) signalWorkAvailable();
}
bool IOPMRequestQueue::checkForWork( void )
{
- Action dqAction = (Action) action;
- IOPMRequest * request;
- IOService * target;
- bool more = false;
+ Action dqAction = (Action) action;
+ IOPMRequest * request;
+ IOService * target;
+ int dequeueCount = 0;
+ bool more = false;
- IOLockLock( fLock );
+ IOLockLock( fLock );
- while (!queue_empty(&fQueue))
- {
- queue_remove_first( &fQueue, request, IOPMRequest *, fCommandChain );
- IOLockUnlock( fLock );
- target = request->getTarget();
- assert(target);
- more |= (*dqAction)( target, request, this );
- IOLockLock( fLock );
- }
+ while (!queue_empty(&fQueue))
+ {
+ if (dequeueCount++ >= kMaxDequeueCount)
+ {
+ // Allow other queues a chance to work
+ more = true;
+ break;
+ }
+
+ queue_remove_first(&fQueue, request, typeof(request), fCommandChain);
+ IOLockUnlock(fLock);
+ target = request->getTarget();
+ assert(target);
+ more |= (*dqAction)( target, request, this );
+ IOLockLock( fLock );
+ }
- IOLockUnlock( fLock );
- return more;
+ IOLockUnlock( fLock );
+ return more;
}
// MARK: -
//*********************************************************************************
// IOPMWorkQueue Class
//
-// Queue of IOServicePM objects with busy IOPMRequest(s).
+// Queue of IOServicePM objects, each with a queue of IOPMRequest sharing the
+// same target.
//*********************************************************************************
OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource );
IOPMWorkQueue *
-IOPMWorkQueue::create( IOService * inOwner, Action work, Action retire )
+IOPMWorkQueue::create( IOService * inOwner, Action invoke, Action retire )
{
- IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue);
- if (me && !me->init(inOwner, work, retire))
- {
- me->release();
- me = 0;
- }
- return me;
+ IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue);
+ if (me && !me->init(inOwner, invoke, retire))
+ {
+ me->release();
+ me = 0;
+ }
+ return me;
}
-bool IOPMWorkQueue::init( IOService * inOwner, Action work, Action retire )
+bool IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire )
{
- if (!work || !retire ||
- !IOEventSource::init(inOwner, (IOEventSourceAction)0))
- return false;
+ if (!invoke || !retire ||
+ !IOEventSource::init(inOwner, (IOEventSourceAction)0))
+ return false;
- queue_init(&fWorkQueue);
+ queue_init(&fWorkQueue);
- fWorkAction = work;
- fRetireAction = retire;
+ fInvokeAction = invoke;
+ fRetireAction = retire;
fConsumerCount = fProducerCount = 0;
- return true;
+ return true;
}
bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt )
{
- bool more = false;
- bool empty;
+ queue_head_t * requestQueue;
+ bool more = false;
+ bool empty;
- assert( request );
+ assert( request );
assert( pwrMgt );
- assert( onThread() );
+ assert( onThread() );
assert( queue_next(&request->fCommandChain) ==
queue_prev(&request->fCommandChain) );
- gIOPMBusyCount++;
+ gIOPMBusyRequestCount++;
+
+ if (request->isQuiesceType())
+ {
+ if ((request->getTarget() == gIOPMRootNode) && !fQuiesceStartTime)
+ {
+ // Attach new quiesce request to all quiesce blockers in the queue
+ fQuiesceStartTime = mach_absolute_time();
+ attachQuiesceRequest(request);
+ fQuiesceRequest = request;
+ }
+ }
+ else if (fQuiesceRequest && request->isQuiesceBlocker())
+ {
+ // Attach the new quiesce blocker to the blocked quiesce request
+ request->attachNextRequest(fQuiesceRequest);
+ }
// Add new request to the tail of the per-service request queue.
// Then immediately check the request queue to minimize latency
// if the queue was empty.
- empty = queue_empty(&pwrMgt->RequestHead);
- queue_enter(&pwrMgt->RequestHead, request, IOPMRequest *, fCommandChain);
+ requestQueue = &pwrMgt->RequestHead;
+ empty = queue_empty(requestQueue);
+ queue_enter(requestQueue, request, typeof(request), fCommandChain);
if (empty)
{
- more = checkRequestQueue(&pwrMgt->RequestHead, &empty);
+ more = checkRequestQueue(requestQueue, &empty);
if (!empty)
{
- // New Request is blocked, add IOServicePM to work queue.
+ // Request just added is blocked, add its target IOServicePM
+ // to the work queue.
assert( queue_next(&pwrMgt->WorkChain) ==
queue_prev(&pwrMgt->WorkChain) );
- queue_enter(&fWorkQueue, pwrMgt, IOServicePM *, WorkChain);
+ queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain);
fQueueLength++;
PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n",
fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt));
return more;
}
-bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty )
+bool IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty )
{
- IOPMRequest * request;
- IOService * target;
+ IOPMRequest * request;
+ IOService * target;
bool more = false;
- bool done = false;
+ bool done = false;
- assert(!queue_empty(queue));
+ assert(!queue_empty(requestQueue));
do {
- request = (IOPMRequest *) queue_first(queue);
- if (request->isWorkBlocked())
- break; // cannot start, blocked on attached request
+ request = (typeof(request)) queue_first(requestQueue);
+ if (request->isWorkBlocked())
+ break; // request dispatch blocked on attached request
+
+ target = request->getTarget();
+ 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
- target = request->getTarget();
- done = (*fWorkAction)( target, request, this );
- if (!done)
- break; // work started, blocked on PM state machine
+ assert(gIOPMBusyRequestCount > 0);
+ if (gIOPMBusyRequestCount)
+ gIOPMBusyRequestCount--;
- assert(gIOPMBusyCount > 0);
- if (gIOPMBusyCount)
- gIOPMBusyCount--;
+ if (request == fQuiesceRequest)
+ {
+ fQuiesceRequest = 0;
+ }
- queue_remove_first(queue, request, IOPMRequest *, fCommandChain);
+ queue_remove_first(requestQueue, request, typeof(request), fCommandChain);
more |= (*fRetireAction)( target, request, this );
- done = queue_empty(queue);
+ done = queue_empty(requestQueue);
} while (!done);
*empty = done;
if (more)
{
- // Retired request blocks another request, since the
- // blocked request may reside in the work queue, we
- // must bump the producer count to avoid work stall.
+ // Retired a request that may unblock a previously visited request
+ // that is still waiting on the work queue. Must trigger another
+ // queue check.
fProducerCount++;
}
bool IOPMWorkQueue::checkForWork( void )
{
- IOServicePM * entry;
- IOServicePM * next;
- bool more = false;
+ IOServicePM * entry;
+ IOServicePM * next;
+ bool more = false;
bool empty;
#if WORK_QUEUE_STATS
fStatCheckForWork++;
#endif
- // Each producer signal triggers a full iteration over
- // all IOServicePM entries in the work queue.
+ // Iterate over all IOServicePM entries in the work queue,
+ // and check each entry's request queue.
while (fConsumerCount != fProducerCount)
{
fConsumerCount = fProducerCount;
-#if WORK_QUEUE_STATS
+#if WORK_QUEUE_STATS
if (queue_empty(&fWorkQueue))
{
fStatQueueEmpty++;
break;
}
fStatScanEntries++;
- uint32_t cachedWorkCount = gIOPMWorkCount;
+ uint32_t cachedWorkCount = gIOPMWorkInvokeCount;
#endif
- entry = (IOServicePM *) queue_first(&fWorkQueue);
+ __IGNORE_WCASTALIGN(entry = (typeof(entry)) queue_first(&fWorkQueue));
while (!queue_end(&fWorkQueue, (queue_entry_t) entry))
{
more |= checkRequestQueue(&entry->RequestHead, &empty);
// Get next entry, points to head if current entry is last.
- next = (IOServicePM *) queue_next(&entry->WorkChain);
+ __IGNORE_WCASTALIGN(next = (typeof(next)) queue_next(&entry->WorkChain));
- // if request queue is empty, remove IOServicePM from queue.
+ // if request queue is empty, remove IOServicePM from work queue.
if (empty)
{
assert(fQueueLength);
if (fQueueLength) fQueueLength--;
PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n",
fQueueLength, entry->Name, OBFUSCATE(entry));
- queue_remove(&fWorkQueue, entry, IOServicePM *, WorkChain);
+ queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain);
}
entry = next;
}
#if WORK_QUEUE_STATS
- if (cachedWorkCount == gIOPMWorkCount)
+ if (cachedWorkCount == gIOPMWorkInvokeCount)
fStatNoWorkDone++;
#endif
}
void IOPMWorkQueue::signalWorkAvailable( void )
{
fProducerCount++;
- IOEventSource::signalWorkAvailable();
+ IOEventSource::signalWorkAvailable();
}
void IOPMWorkQueue::incrementProducerCount( void )
fProducerCount++;
}
+void IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest )
+{
+ IOServicePM * entry;
+ IOPMRequest * request;
+
+ if (queue_empty(&fWorkQueue))
+ {
+ return;
+ }
+
+ queue_iterate(&fWorkQueue, entry, typeof(entry), WorkChain)
+ {
+ queue_iterate(&entry->RequestHead, request, typeof(request), fCommandChain)
+ {
+ // Attach the quiesce request to any request in the queue that
+ // is not linked to a next request. These requests will block
+ // the quiesce request.
+
+ if (request->isQuiesceBlocker())
+ {
+ request->attachNextRequest(quiesceRequest);
+ }
+ }
+ }
+}
+
+void IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest )
+{
+ if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) &&
+ (fQuiesceStartTime != 0))
+ {
+ fInvokeAction = 0;
+ fQuiesceFinishTime = mach_absolute_time();
+ }
+}
+
// MARK: -
// MARK: IOPMCompletionQueue
IOPMCompletionQueue *
IOPMCompletionQueue::create( IOService * inOwner, Action inAction )
{
- IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue);
- if (me && !me->init(inOwner, inAction))
- {
- me->release();
- me = 0;
- }
- return me;
+ IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue);
+ if (me && !me->init(inOwner, inAction))
+ {
+ me->release();
+ me = 0;
+ }
+ return me;
}
bool IOPMCompletionQueue::init( IOService * inOwner, Action inAction )
{
- if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
+ if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
return false;
- queue_init(&fQueue);
- return true;
+ queue_init(&fQueue);
+ return true;
}
bool IOPMCompletionQueue::queuePMRequest( IOPMRequest * request )
{
bool more;
- assert(request);
+ assert(request);
// unblock dependent request
more = request->detachNextRequest();
- queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
+ queue_enter(&fQueue, request, typeof(request), fCommandChain);
return more;
}
bool IOPMCompletionQueue::checkForWork( void )
{
- Action dqAction = (Action) action;
- IOPMRequest * request;
- IOPMRequest * next;
- IOService * target;
- bool more = false;
+ Action dqAction = (Action) action;
+ IOPMRequest * request;
+ IOPMRequest * next;
+ IOService * target;
+ bool more = false;
- request = (IOPMRequest *) queue_first(&fQueue);
+ request = (typeof(request)) queue_first(&fQueue);
while (!queue_end(&fQueue, (queue_entry_t) request))
{
- next = (IOPMRequest *) queue_next(&request->fCommandChain);
- if (!request->isFreeBlocked())
+ next = (typeof(next)) queue_next(&request->fCommandChain);
+ if (!request->isFreeBlocked())
{
- queue_remove(&fQueue, request, IOPMRequest *, fCommandChain);
+ queue_remove(&fQueue, request, typeof(request), fCommandChain);
target = request->getTarget();
assert(target);
more |= (*dqAction)( target, request, this );
IOReturn IOServicePM::gatedSerialize( OSSerialize * s ) const
{
- OSDictionary * dict;
- bool ok = false;
+ OSDictionary * dict;
+ bool ok = false;
int powerClamp = -1;
- int dictSize = 5;
+ int dictSize = 6;
- if (IdleTimerPeriod)
- dictSize += 4;
+ if (IdleTimerPeriod)
+ dictSize += 4;
if (PMActions.parameter & kPMActionsFlagLimitPower)
{
else
dict = OSDictionary::withCapacity(dictSize);
- if (dict)
- {
+ if (dict)
+ {
setPMProperty(dict, "CurrentPowerState", CurrentPowerState);
+ setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags);
if (NumberOfPowerStates)
setPMProperty(dict, "MaxPowerState", NumberOfPowerStates-1);
if (DesiredPowerState != CurrentPowerState)
if (powerClamp >= 0)
setPMProperty(dict, "PowerClamp", powerClamp);
- if (IdleTimerPeriod)
- {
+ if (IdleTimerPeriod)
+ {
AbsoluteTime now;
AbsoluteTime delta;
uint64_t nsecs;
clock_get_uptime(&now);
- // The idle timer period in milliseconds.
- setPMProperty(dict, "IdleTimerPeriod", IdleTimerPeriod * 1000ULL);
+ // The idle timer period in milliseconds
+ setPMProperty(dict, "IdleTimerPeriod", NextIdleTimerPeriod * 1000ULL);
- // The number of activity tickles recorded since device idle
+ // Number of tickles since the last idle timer expiration
setPMProperty(dict, "ActivityTickles", ActivityTickleCount);
if (AbsoluteTime_to_scalar(&DeviceActiveTimestamp))
{
- // The number of milliseconds since the last activity tickle.
+ // Milliseconds since the last activity tickle
delta = now;
SUB_ABSOLUTETIME(&delta, &DeviceActiveTimestamp);
absolutetime_to_nanoseconds(delta, &nsecs);
setPMProperty(dict, "TimeSinceLastTickle", NS_TO_MS(nsecs));
}
- if (AbsoluteTime_to_scalar(&IdleTimerStartTime))
+ if (!IdleTimerStopped && AbsoluteTime_to_scalar(&IdleTimerStartTime))
{
- // The number of milliseconds since the last device idle.
+ // Idle timer elapsed time in milliseconds
delta = now;
SUB_ABSOLUTETIME(&delta, &IdleTimerStartTime);
absolutetime_to_nanoseconds(delta, &nsecs);
- setPMProperty(dict, "TimeSinceDeviceIdle", NS_TO_MS(nsecs));
+ setPMProperty(dict, "IdleTimerElapsedTime", NS_TO_MS(nsecs));
}
- }
+ }
#if WORK_QUEUE_STATS
if (gIOPMRootNode == Owner)
dict->removeObject(gIOPMPowerClientAdvisoryTickle);
}
- ok = dict->serialize(s);
- dict->release();
- }
+ ok = dict->serialize(s);
+ dict->release();
+ }
- return (ok ? kIOReturnSuccess : kIOReturnNoMemory);
+ return (ok ? kIOReturnSuccess : kIOReturnNoMemory);
}
bool IOServicePM::serialize( OSSerialize * s ) const
ret = gatedSerialize(s);
}
else if (gIOPMWorkLoop)
- {
- ret = gIOPMWorkLoop->runAction(
+ {
+ ret = gIOPMWorkLoop->runAction(
OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize),
(OSObject *) this, (void *) s);
- }
+ }
return (kIOReturnSuccess == ret);
}
IOTimeStampConstant(code, name, (uintptr_t) regId, param1, param2);
}
-PMEventDetails* PMEventDetails::eventDetails(uint32_t type,
- const char *ownerName,
- uintptr_t ownerUnique,
- const char *interestName,
- uint8_t oldState,
- uint8_t newState,
- uint32_t result,
- uint32_t elapsedTimeUS) {
-
- PMEventDetails *myself;
- myself = new PMEventDetails;
-
- if(myself) {
- myself->eventType = type;
- myself->ownerName = ownerName;
- myself->ownerUnique = ownerUnique;
- myself->interestName = interestName;
- myself->oldState = oldState;
- myself->newState = newState;
- myself->result = result;
- myself->elapsedTimeUS = elapsedTimeUS;
-
- myself->eventClassifier = kIOPMEventClassDriverEvent;
- }
-
- return myself;
-}
-
-
-PMEventDetails* PMEventDetails::eventDetails(uint32_t type,
- const char *uuid,
- uint32_t reason,
- uint32_t result) {
-
- PMEventDetails *myself;
- myself = new PMEventDetails;
-
- if(myself) {
- myself->eventType = type;
- myself->uuid = uuid;
- myself->reason = reason;
- myself->result = result;
-
- myself->eventClassifier = kIOPMEventClassSystemEvent;
- }
-
- return myself;
-}
-
projects / apple / xnu.git / blobdiff